bindata 1.1.0 → 1.2.0

data/lib/bindata/stringz.rb

@@ -27,7 +27,7 @@ module BinData
   #                        byte.
   class Stringz < BinData::BasePrimitive
 
-    register(self.name, self)
+    register_self
 
     optional_parameters :max_length
 

data/lib/bindata/struct.rb

@@ -47,20 +47,26 @@ module BinData
   #                      calls to #read, #write, #num_bytes or #snapshot.
   class Struct < BinData::Base
 
-    register(self.name, self)
+    register_self
+
+    mandatory_parameter :fields
+    optional_parameters :endian, :hide
 
     # These reserved words may not be used as field names
-    RESERVED = (::Hash.instance_methods.collect { |meth| meth.to_s } + 
-                %w{alias and begin break case class def defined do else elsif
-                   end ensure false for if in module next nil not or redo
-                   rescue retry return self super then true undef unless until
-                   when while yield} +
-                %w{array element index value} ).uniq
+    RESERVED = Hash[*
+                 (::Hash.instance_methods.collect { |meth| meth.to_s } + 
+                  %w{alias and begin break case class def defined do else elsif
+                     end ensure false for if in module next nil not or redo
+                     rescue retry return self super then true undef unless until
+                     when while yield} +
+                  %w{array element index value} ).
+                  uniq.collect { |key| [key, true] }.flatten
+               ]
 
     # A hash that can be accessed via attributes.
     class Snapshot < Hash #:nodoc:
       def respond_to?(symbol, include_private = false)
-        has_key?(symbol.to_s) || super(symbol, include_private)
+        has_key?(symbol.to_s) || super
       end
 
       def method_missing(symbol, *args)
@@ -101,10 +107,10 @@ module BinData
 
       def sanitize_hide(params, sanitizer)
         if params.needs_sanitizing?(:hide) and params.has_parameter?(:fields)
-          field_names = sanitized_field_names(params[:fields])
+          field_names  = sanitized_field_names(params[:fields])
           hfield_names = hidden_field_names(params[:hide])
 
-          params[:hide]   = (hfield_names & field_names)
+          params[:hide] = (hfield_names & field_names)
         end
       end
 
@@ -117,11 +123,10 @@ module BinData
       end
 
       def ensure_field_names_are_valid(field_names)
-        instance_methods = self.instance_methods.collect { |meth| meth.to_s }
         reserved_names = RESERVED
 
         field_names.each do |name|
-          if instance_methods.include?(name)
+          if self.class.method_defined?(name)
             raise NameError.new("Rename field '#{name}' in #{self}, " +
                                 "as it shadows an existing method.", name)
           end
@@ -137,11 +142,8 @@ module BinData
       end
     end
 
-    mandatory_parameter :fields
-    optional_parameters :endian, :hide
-
-    def initialize(params = {}, parent = nil)
-      super(params, parent)
+    def initialize(parameters = {}, parent = nil)
+      super
 
       @field_names = get_parameter(:fields).field_names
       @field_objs  = []
@@ -152,7 +154,7 @@ module BinData
     end
 
     def clear? #:nodoc:
-      @field_objs.inject(true) { |all_clear, f| all_clear and (f.nil? or f.clear?) }
+      @field_objs.all? { |f| f.nil? or f.clear? }
     end
 
     # Returns a list of the names of all fields accessible through this
@@ -168,8 +170,7 @@ module BinData
     end
 
     def respond_to?(symbol, include_private = false) #:nodoc:
-      super(symbol, include_private) ||
-        field_names(true).include?(symbol.to_s.chomp("="))
+      field_names(true).include?(symbol.to_s.chomp("=")) || super
     end
 
     def method_missing(symbol, *args, &block) #:nodoc:

data/lib/bindata/trace.rb

@@ -10,6 +10,14 @@ module BinData
     def trace(msg)
       @trace_io.puts(msg)
     end
+
+    def trace_obj(obj_name, val)
+      if val.length > 30
+        val = val.slice(0 .. 30) + "..."
+      end
+
+      trace "#{obj_name} => #{val}"
+    end
   end
 
   # Turn on trace information when reading a BinData object.

data/lib/bindata/wrapper.rb

@@ -1,4 +1,5 @@
 require 'bindata/base'
+require 'bindata/dsl'
 
 module BinData
   # A Wrapper allows the creation of new BinData types that
@@ -19,85 +20,28 @@ module BinData
   #   arr.snapshot #=> [3, 3, 3, 3 ,3]
   #   
   class Wrapper < BinData::Base
+    include DSLMixin
 
-    class << self
-
-      def inherited(subclass) #:nodoc:
-        # Register the names of all subclasses of this class.
-        register(subclass.name, subclass)
-      end
-
-      def endian(endian = nil)
-        @endian ||= default_endian
-        if [:little, :big].include?(endian)
-          @endian = endian
-        elsif endian != nil
-          raise ArgumentError,
-                  "unknown value for endian '#{endian}' in #{self}", caller(1)
-        end
-        @endian
-      end
-
-      def wrapped(*args)
-        @wrapped ||= default_wrapped
-        if args.length == 2
-          type, params = *args
-          ensure_type_exists(type)
-
-          if wrapped != nil
-            raise SyntaxError, "#{self} can only wrap one type", caller(2)
-          end
-          @wrapped = [type, params]
-        end
-        @wrapped
-      end
-
-      def method_missing(symbol, *args) #:nodoc:
-        type = symbol
-        params = args.length == 0 ? {} : args[0]
-
-        wrapped(type, params)
-      end
+    register_subclasses
+    dsl_parser :only_one_field, :no_fieldnames
 
+    class << self
       def sanitize_parameters!(params, sanitizer) #:nodoc:
-        raise "Nothing to wrap" if wrapped.nil?
+        raise "no wrapped type was specified in #{self}" if field.nil?
 
-        wrapped_type, wrapped_params = wrapped
-        wrapped_params = wrapped_params.dup
+        wrapped_type = field.type
+        wrapped_params = field.params.dup
 
         params.move_unknown_parameters_to(wrapped_params)
 
         params[:wrapped] = sanitizer.create_sanitized_object_prototype(wrapped_type, wrapped_params, endian)
       end
-
-      #-------------
-      private
-
-      def parent_wrapper
-        ancestors[1..-1].find { |cls|
-          cls.ancestors[1..-1].include?(BinData::Wrapper)
-        }
-      end
-
-      def default_endian
-        wrap = parent_wrapper
-        wrap ? wrap.endian : nil
-      end
-
-      def default_wrapped
-        wrap = parent_wrapper
-        wrap ? wrap.wrapped : nil
-      end
-
-      def ensure_type_exists(type)
-        unless RegisteredClasses.is_registered?(type, endian)
-          raise TypeError, "unknown type '#{type}' for #{self}", caller(3)
-        end
-      end
     end
 
-    def initialize(params = {}, parent = nil)
-      super(params, parent)
+    mandatory_parameter :wrapped
+
+    def initialize(parameters = {}, parent = nil)
+      super
 
       prototype = get_parameter(:wrapped)
       @wrapped = prototype.instantiate(self)
@@ -112,7 +56,7 @@ module BinData
     end
 
     def respond_to?(symbol, include_private = false) #:nodoc:
-      super || wrapped.respond_to?(symbol, include_private)
+      wrapped.respond_to?(symbol, include_private) || super
     end
 
     def method_missing(symbol, *args, &block) #:nodoc:

data/manual.haml

@@ -1,5 +1,5 @@
 !!!
-%html{ :xmlns => "http://www.w3.org/1999/xhtml" }
+%html{ :xmlns => "http://www.w3.org/1999/xhtml", "xml:lang" => "en", :lang => "en" }
   %head
     %meta{ :content => "text/html; charset=iso-8859-1", "http-equiv" => "Content-Type" }
     %title
@@ -307,5 +307,5 @@
     #main_frame
       #main_content
         :maruku
-          #{File.read("README")}
+          #{File.read("manual.md")}
 

data/spec/array_spec.rb

@@ -15,7 +15,7 @@ describe BinData::Array, "when instantiating" do
 
   it "should fail if a given type is unknown" do
     args = {:type => :does_not_exist, :initial_length => 3}
-    lambda { BinData::Array.new(args) }.should raise_error(BinData::UnknownTypeError)
+    lambda { BinData::Array.new(args) }.should raise_error(BinData::UnRegisteredTypeError)
   end
 
   it "should not allow both :initial_length and :read_until" do

data/spec/base_primitive_spec.rb

@@ -36,7 +36,7 @@ describe BinData::BasePrimitive do
   end
 
   it "should conform to rule 2 for returning a value" do
-    io = BinData::IO.new([42].pack("V"))
+    io = ExampleSingle.io_with_value(42)
     data = ExampleSingle.new(:value => 5)
     data.expose_methods_for_testing
     data.do_read(io)
@@ -218,14 +218,14 @@ describe BinData::BasePrimitive, "with :value" do
   end
 
   it "should change during reading" do
-    io = BinData::IO.new([56].pack("V"))
+    io = ExampleSingle.io_with_value(56)
     @data.do_read(io)
     @data.value.should == 56
     @data.done_read
   end
 
   it "should not change after reading" do
-    io = BinData::IO.new([56].pack("V"))
+    io = ExampleSingle.io_with_value(56)
     @data.read(io)
     @data.value.should == 5
   end
@@ -238,7 +238,7 @@ end
 
 describe BinData::BasePrimitive, "with :check_value" do
   before(:each) do
-    @io = BinData::IO.new([34].pack("V"))
+    @io = ExampleSingle.io_with_value(34)
   end
 
   it "should succeed when check_value is non boolean and correct" do

data/spec/base_spec.rb

@@ -184,7 +184,7 @@ describe BinData::Base, "with :check_offset" do
   end
 
   before(:each) do
-    @io = BinData::IO.create_string_io("12345678901234567890")
+    @io = StringIO.new("12345678901234567890")
   end
 
   it "should fail if offset is incorrect" do
@@ -222,7 +222,7 @@ describe BinData::Base, "with :adjust_offset" do
   end
 
   before(:each) do
-    @io = BinData::IO.create_string_io("12345678901234567890")
+    @io = StringIO.new("12345678901234567890")
   end
 
   it "should be mutually exclusive with :check_offset" do
@@ -288,17 +288,30 @@ describe BinData::Base, "as black box" do
     obj.to_s.should == obj.snapshot.to_s
   end
 
+  it "should pretty print object as snapshot" do
+    class PPBase < BaseStub
+      def snapshot; [1, 2, 3]; end
+    end
+    obj = SnapshotBase.new
+    actual_io = StringIO.new
+    expected_io = StringIO.new
+
+    require 'pp'
+    PP.pp(obj, actual_io)
+    PP.pp(obj.snapshot, expected_io)
+
+    actual_io.value.should == expected_io.value
+  end
+
   it "should write the same as to_binary_s" do
     class WriteToSBase < BaseStub
       def _do_write(io) io.writebytes("abc"); end
     end
 
     obj = WriteToSBase.new
-    io = BinData::IO.create_string_io
+    io = StringIO.new
     obj.write(io)
-    io.rewind
-    written = io.read
-    obj.to_binary_s.should == written
+    io.value.should == obj.to_binary_s
   end
 end
 

data/spec/bits_spec.rb

@@ -116,7 +116,11 @@ share_examples_for "All bitfields" do
     mid = (min_value + max_value) / 2
     hi  = max_value - 1
 
-    [lo, mid, hi].find_all { |v| (min_value .. max_value).include?(v) }
+    [lo, mid, hi].select { |val| value_within_range?(val) }
+  end
+
+  def value_within_range?(val)
+    (min_value .. max_value).include?(val)
   end
 end
 

data/spec/choice_spec.rb

@@ -20,12 +20,12 @@ describe BinData::Choice, "when instantiating" do
 
   it "should fail if a given type is unknown" do
     args = {:choices => [:does_not_exist], :selection => 0}
-    lambda { BinData::Choice.new(args) }.should raise_error(BinData::UnknownTypeError)
+    lambda { BinData::Choice.new(args) }.should raise_error(BinData::UnRegisteredTypeError)
   end
 
   it "should fail if a given type is unknown" do
     args = {:choices => {0 => :does_not_exist}, :selection => 0}
-    lambda { BinData::Choice.new(args) }.should raise_error(BinData::UnknownTypeError)
+    lambda { BinData::Choice.new(args) }.should raise_error(BinData::UnRegisteredTypeError)
   end
 
   it "should fail if :choices Hash has a symbol as key" do
@@ -50,6 +50,17 @@ share_examples_for "Choice initialized with array or hash" do
     @data.selection.should == 3
   end
 
+  it "should not be able to directly change the current selection" do
+    lambda {
+      @data.selection = 3
+    }.should raise_error(NoMethodError)
+  end
+
+  it "should forward #snapshot" do
+    @chooser.choice = 3
+    @data.snapshot.should == 30
+  end
+
   it "should be able to change the choice" do
     @chooser.choice = 3
 

data/spec/deprecated_spec.rb

@@ -21,3 +21,34 @@ describe BinData::MultiValue, "when defining" do
     }.should raise_error
   end
 end
+
+describe BinData::Base, "when defining" do
+  it "should handle deprecated #register method" do
+    lambda {
+      class DeprecatedRegisterBase < BinData::Base
+        register(self.name, self)
+      end
+    }.should_not raise_error
+  end
+
+  it "should handle deprecated #register method for subclasses" do
+    lambda {
+      class DeprecatedSuperBase < BinData::Base
+        def self.inherited(subclass)
+          register(subclass.name, subclass)                                                                                                                                      
+        end                                                                                                                                                                      
+      end
+
+      class DeprecatedSubBase < DeprecatedSuperBase
+      end
+    }.should_not raise_error
+  end
+
+  it "should handle deprecated #register method with custom calling" do
+    lambda {
+      class DeprecatedCustomBase < BinData::Base
+        register(name, Object)
+      end
+    }.should_not raise_error
+  end
+end

data/spec/example.rb

@@ -1,7 +1,11 @@
 require 'bindata/base_primitive'
 
 class ExampleSingle < BinData::BasePrimitive
-  register(self.name, self)
+  register_self
+
+  def self.io_with_value(val)
+    BinData::IO.new([val].pack("V"))
+  end
 
   private
 

data/spec/io_spec.rb

@@ -106,8 +106,7 @@ describe BinData::IO do
     io = BinData::IO.new(stream)
     io.writebytes("abcd")
 
-    stream.rewind
-    stream.read.should == "abcd"
+    stream.value.should == "abcd"
   end
 
   it "should flush" do
@@ -116,8 +115,7 @@ describe BinData::IO do
     io.writebytes("abcd")
     io.flush
 
-    stream.rewind
-    stream.read.should == "abcd"
+    stream.value.should == "abcd"
   end
 
 end