bindata 1.5.1 → 1.6.0

data/lib/bindata/int.rb

@@ -157,10 +157,8 @@ module BinData
   end
 
   # Create classes on demand
-  class << self
-    alias_method :const_missing_without_int, :const_missing
-    def const_missing_with_int(name)
-      name = name.to_s
+  module IntFactory
+    def const_missing(name)
       mappings = {
         /^Uint(\d+)be$/ => [:big, :unsigned],
         /^Uint(\d+)le$/ => [:little, :unsigned],
@@ -169,7 +167,7 @@ module BinData
       }
 
       mappings.each_pair do |regex, args|
-        if regex =~ name
+        if regex =~ name.to_s
           nbits = $1.to_i
           if (nbits % 8).zero?
             return Int.define_class(nbits, *args)
@@ -177,8 +175,8 @@ module BinData
         end
       end
 
-      const_missing_without_int(name)
+      super
     end
-    alias_method :const_missing, :const_missing_with_int
   end
+  BinData.extend IntFactory
 end

data/lib/bindata/name.rb

@@ -0,0 +1,28 @@
+module BinData
+  # == Parameters
+  #
+  # Parameters may be provided at initialisation to control the behaviour of
+  # an object.  These parameters are:
+  #
+  # <tt>:name</tt>:: The name that this object can be referred to may be
+  #                  set explicitly.  This is only useful when dynamically
+  #                  generating types.
+  #                  <code><pre>
+  #                    BinData::Struct.new(:name => :my_struct, :fields => ...)
+  #                    array = BinData::Array.new(:type => :my_struct)
+  #                  </pre></code>
+  module RegisterNamePlugin
+
+    def self.included(base) #:nodoc:
+      # The registered name may be provided explicitly.
+      base.optional_parameter :name
+    end
+
+    def initialize_shared_instance
+      if has_parameter?(:name)
+        RegisteredClasses.register(get_parameter(:name), self)
+      end
+      super
+    end
+  end
+end

data/lib/bindata/offset.rb

@@ -15,77 +15,66 @@ module BinData
   #                           position before reading.  This is like
   #                           <tt>:check_offset</tt>, except that it will
   #                           adjust the IO offset instead of raising an error.
-  module CheckOrAdjustOffsetMixin
+  module CheckOrAdjustOffsetPlugin
 
     def self.included(base) #:nodoc:
       base.optional_parameters :check_offset, :adjust_offset
       base.mutually_exclusive_parameters :check_offset, :adjust_offset
     end
 
-    # Ideally these two methods should be protected,
-    # but Ruby 1.9.2 requires them to be public.
-    # see http://redmine.ruby-lang.org/issues/show/2375
-
-    def do_read_with_check_offset(io) #:nodoc:
-      check_offset(io)
-      do_read_without_check_offset(io)
+    def initialize_shared_instance
+      extend CheckOffsetMixin  if has_parameter?(:check_offset)
+      extend AdjustOffsetMixin if has_parameter?(:adjust_offset)
+      super
     end
 
-    def do_read_with_adjust_offset(io) #:nodoc:
-      adjust_offset(io)
-      do_read_without_adjust_offset(io)
-    end
+    module CheckOffsetMixin
+      def do_read(io) #:nodoc:
+        check_offset(io)
+        super(io)
+      end
 
-    #---------------
-    private
+      #---------------
+      private
 
-    # To be called from BinData::Base#initialize.
-    #
-    # Monkey patches #do_read to check or adjust the stream offset
-    # as appropriate.
-    def add_methods_for_check_or_adjust_offset
-      if has_parameter?(:check_offset)
-        class << self
-          alias_method :do_read_without_check_offset, :do_read
-          alias_method :do_read, :do_read_with_check_offset
-        end
-      end
-      if has_parameter?(:adjust_offset)
-        class << self
-          alias_method :do_read_without_adjust_offset, :do_read
-          alias_method :do_read, :do_read_with_adjust_offset
+      def check_offset(io)
+        actual_offset = io.offset
+        expected = eval_parameter(:check_offset, :offset => actual_offset)
+
+        if not expected
+          raise ValidityError, "offset not as expected for #{debug_name}"
+        elsif actual_offset != expected and expected != true
+          raise ValidityError,
+                "offset is '#{actual_offset}' but " +
+                "expected '#{expected}' for #{debug_name}"
         end
       end
     end
 
-    def check_offset(io)
-      actual_offset = io.offset
-      expected = eval_parameter(:check_offset, :offset => actual_offset)
-
-      if not expected
-        raise ValidityError, "offset not as expected for #{debug_name}"
-      elsif actual_offset != expected and expected != true
-        raise ValidityError,
-              "offset is '#{actual_offset}' but " +
-              "expected '#{expected}' for #{debug_name}"
+    module AdjustOffsetMixin
+      def do_read(io) #:nodoc:
+        adjust_offset(io)
+        super(io)
       end
-    end
 
-    def adjust_offset(io)
-      actual_offset = io.offset
-      expected = eval_parameter(:adjust_offset)
-      if actual_offset != expected
-        begin
-          seek = expected - actual_offset
-          io.seekbytes(seek)
-          warn "adjusting stream position by #{seek} bytes" if $VERBOSE
-        rescue
-          raise ValidityError,
-                "offset is '#{actual_offset}' but couldn't seek to " +
-                "expected '#{expected}' for #{debug_name}"
+      #---------------
+      private
+
+      def adjust_offset(io)
+        actual_offset = io.offset
+        expected = eval_parameter(:adjust_offset)
+        if actual_offset != expected
+          begin
+            seek = expected - actual_offset
+            io.seekbytes(seek)
+            warn "adjusting stream position by #{seek} bytes" if $VERBOSE
+          rescue
+            raise ValidityError,
+                  "offset is '#{actual_offset}' but couldn't seek to " +
+                  "expected '#{expected}' for #{debug_name}"
+          end
         end
       end
     end
   end
 end
-

data/lib/bindata/params.rb

@@ -1,53 +1,45 @@
 require 'bindata/lazy'
 
 module BinData
-  module AcceptedParametersMixin
-    def self.included(base) #:nodoc:
-      base.extend ClassMethods
+  module AcceptedParametersPlugin
+    # Mandatory parameters must be present when instantiating a data object.
+    def mandatory_parameters(*args)
+      accepted_parameters.mandatory(*args)
     end
 
-    # Class methods to mix in to BinData::Base
-    module ClassMethods
-      # Mandatory parameters must be present when instantiating a data object.
-      def mandatory_parameters(*args)
-        accepted_parameters.mandatory(*args)
-      end
-
-      # Optional parameters may be present when instantiating a data object.
-      def optional_parameters(*args)
-        accepted_parameters.optional(*args)
-      end
+    # Optional parameters may be present when instantiating a data object.
+    def optional_parameters(*args)
+      accepted_parameters.optional(*args)
+    end
 
-      # Default parameters can be overridden when instantiating a data object.
-      def default_parameters(*args)
-        accepted_parameters.default(*args)
-      end
+    # Default parameters can be overridden when instantiating a data object.
+    def default_parameters(*args)
+      accepted_parameters.default(*args)
+    end
 
-      # Mutually exclusive parameters may not all be present when
-      # instantiating a data object.
-      def mutually_exclusive_parameters(*args)
-        accepted_parameters.mutually_exclusive(*args)
-      end
+    # Mutually exclusive parameters may not all be present when
+    # instantiating a data object.
+    def mutually_exclusive_parameters(*args)
+      accepted_parameters.mutually_exclusive(*args)
+    end
 
-      alias_method :mandatory_parameter, :mandatory_parameters
-      alias_method :optional_parameter, :optional_parameters
-      alias_method :default_parameter, :default_parameters
+    alias_method :mandatory_parameter, :mandatory_parameters
+    alias_method :optional_parameter, :optional_parameters
+    alias_method :default_parameter, :default_parameters
 
-      def accepted_parameters #:nodoc:
-        unless defined? @accepted_parameters
-          ancestor_params = superclass.respond_to?(:accepted_parameters) ?
-                              superclass.accepted_parameters : nil
-          @accepted_parameters = AcceptedParameters.new(ancestor_params)
-        end
-        @accepted_parameters
+    def accepted_parameters #:nodoc:
+      unless defined? @accepted_parameters
+        ancestor_params = superclass.respond_to?(:accepted_parameters) ?
+                            superclass.accepted_parameters : nil
+        @accepted_parameters = AcceptedParameters.new(ancestor_params)
       end
+      @accepted_parameters
     end
 
     # BinData objects accept parameters when initializing.  AcceptedParameters
     # allow a BinData class to declaratively identify accepted parameters as
     # mandatory, optional, default or mutually exclusive.
     class AcceptedParameters
-
       def initialize(ancestor_parameters = nil)
         if ancestor_parameters
           @mandatory = ancestor_parameters.mandatory.dup
@@ -89,10 +81,13 @@ module BinData
       end
 
       def mutually_exclusive(*args)
-        arg1, arg2 = args
-        if arg1 != nil && arg2 != nil
-          @mutually_exclusive.push([arg1.to_sym, arg2.to_sym])
-          @mutually_exclusive.uniq!
+        arg1 = args.shift
+        while not args.empty?
+          args.each do |arg2|
+            @mutually_exclusive.push([arg1.to_sym, arg2.to_sym])
+            @mutually_exclusive.uniq!
+          end
+          arg1 = args.shift
         end
         @mutually_exclusive
       end

data/lib/bindata/struct.rb

@@ -113,12 +113,7 @@ module BinData
       end
 
       def hidden_field_names(hidden)
-        (hidden || []).collect do |h|
-          unless Symbol === h
-            warn "Hidden field '#{h}' should be provided as a symbol.  Using strings is deprecated"
-          end
-          h.to_sym
-        end
+        (hidden || []).collect { |h| h.to_sym }
       end
 
       def ensure_field_names_are_valid(field_names)
@@ -143,6 +138,7 @@ module BinData
 
     def initialize_shared_instance
       @field_names = get_parameter(:fields).field_names.freeze
+      super
     end
 
     def initialize_instance

data/lib/bindata/trace.rb

@@ -25,14 +25,12 @@ module BinData
   # This is useful for debugging a BinData declaration.
   def trace_reading(io = STDERR, &block)
     @tracer = Tracer.new(io)
-    BasePrimitive.turn_on_tracing
-    Choice.turn_on_tracing
+    [BasePrimitive, Choice].each { |traced| traced.turn_on_tracing }
     if block_given?
       begin
         block.call
       ensure
-        BasePrimitive.turn_off_tracing
-        Choice.turn_off_tracing
+        [BasePrimitive, Choice].each { |traced| traced.turn_off_tracing }
         @tracer = nil
       end
     end
@@ -47,18 +45,19 @@ module BinData
   class BasePrimitive < BinData::Base
     class << self
       def turn_on_tracing
-        alias_method :hook_after_do_read, :trace_value
+        alias_method :do_read_without_hook, :do_read
+        alias_method :do_read, :do_read_with_hook
       end
 
       def turn_off_tracing
-        alias_method :hook_after_do_read, :null_method
+        alias_method :do_read, :do_read_without_hook
       end
     end
 
-    #---------------
-    private
-
-    def null_method; end
+    def do_read_with_hook(io)
+      do_read_without_hook(io)
+      trace_value
+    end
 
     def trace_value
       BinData::trace_message do |tracer|
@@ -71,18 +70,19 @@ module BinData
   class Choice < BinData::Base
     class << self
       def turn_on_tracing
-        alias_method :hook_before_do_read, :trace_selection
+        alias_method :do_read_without_hook, :do_read
+        alias_method :do_read, :do_read_with_hook
       end
 
       def turn_off_tracing
-        alias_method :hook_before_do_read, :null_method
+        alias_method :do_read, :do_read_without_hook
       end
     end
 
-    #---------------
-    private
-
-    def null_method; end
+    def do_read_with_hook(io)
+      trace_selection
+      do_read_without_hook(io)
+    end
 
     def trace_selection
       BinData::trace_message do |tracer|

data/lib/bindata/version.rb

@@ -1,3 +1,3 @@
 module BinData
-  VERSION = "1.5.1"
+  VERSION = "1.6.0"
 end

data/lib/bindata/virtual.rb

@@ -15,7 +15,7 @@ module BinData
   #
   #   obj = A.read("abcdeabcde")
   #   obj.a #=> "abcde"
-  #   obj.b.offset #=> 10
+  #   obj.c.offset #=> 10
   #
   class Virtual < BinData::BasePrimitive
 
@@ -23,8 +23,8 @@ module BinData
 
     class << self
       def sanitize_parameters!(params) #:nodoc:
-        if params.has_parameter?(:assert_value)
-          fail ":assert_value can not be used on virtual field"
+        if params.has_parameter?(:asserted_value)
+          fail ":asserted_value can not be used on virtual field"
         end
       end
     end

data/{spec/alignment_spec.rb → test/alignment_test.rb}

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata'
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
 
 describe BinData::ResumeByteAlignment do
   class ResumeAlignmentRecord < BinData::Record
@@ -10,29 +9,29 @@ describe BinData::ResumeByteAlignment do
     bit4 :b
   end
 
-  subject { ResumeAlignmentRecord.new }
+  let(:obj) { ResumeAlignmentRecord.new }
 
   it "resets read alignment" do
-    subject.read "\x12\x34"
+    obj.read "\x12\x34"
 
-    subject.a.should == 1
-    subject.b.should == 3
+    obj.a.must_equal 1
+    obj.b.must_equal 3
   end
 
   it "resets write alignment" do
-    subject.assign(:a => 2, :b => 7)
+    obj.assign(:a => 2, :b => 7)
 
-    subject.to_binary_s.should == "\x20\x70"
+    obj.to_binary_s.must_equal "\x20\x70"
   end
 end
 
 describe BinData::BitAligned do
   it "does not apply to BinData::Primitives" do
-    expect {
+    lambda {
       class BitAlignedPrimitive < BinData::Primitive
         bit_aligned
       end
-    }.to raise_error
+    }.must_raise RuntimeError
   end
 
   class BitString < BinData::String
@@ -45,17 +44,19 @@ describe BinData::BitAligned do
     bit4 :afterward
   end
 
-  subject { BitAlignedRecord.new }
+  let(:obj) { BitAlignedRecord.new }
 
-  its(:num_bytes) { should == 3 }
+  it "#num_bytes as expected" do
+    obj.num_bytes.must_equal 3
+  end
 
   it "reads as expected" do
-    subject.read("\x56\x36\x42")
-    subject.should == {"preamble" => 5, "str" => "cd", "afterward" => 2}
+    obj.read("\x56\x36\x42")
+    obj.snapshot.must_equal({"preamble" => 5, "str" => "cd", "afterward" => 2})
   end
 
   it "writes as expected" do
-    subject.assign(:preamble => 5, :str => "ab", :afterward => 1)
-    subject.to_binary_s.should == "\x56\x16\x21"
+    obj.assign(:preamble => 5, :str => "ab", :afterward => 1)
+    obj.to_binary_s.must_equal "\x56\x16\x21"
   end
 end