bindata 1.6.0 → 1.8.0

data/lib/bindata/primitive.rb

@@ -89,6 +89,12 @@ module BinData
       end
     end
 
+    def assign(val)
+      super(val)
+      set(_value)
+      @value = get
+    end
+
     def debug_name_of(child) #:nodoc:
       debug_name + "-internal-"
     end

data/lib/bindata/record.rb

@@ -3,42 +3,6 @@ require 'bindata/sanitize'
 require 'bindata/struct'
 
 module BinData
-  # Extracts args for Records.
-  #
-  # Foo.new(:bar => "baz) is ambiguous as to whether :bar is a value or parameter.
-  #
-  # BaseArgExtractor always assumes :bar is parameter.  This extractor correctly
-  # identifies it as value or parameter.
-  class RecordArgExtractor
-    class << self
-      def extract(the_class, the_args)
-        value, parameters, parent = BaseArgExtractor.extract(the_class, the_args)
-
-        if parameters_is_value?(the_class, value, parameters)
-          value = parameters
-          parameters = {}
-        end
-
-        [value, parameters, parent]
-      end
-
-      def parameters_is_value?(the_class, value, parameters)
-        if value.nil? and parameters.length > 0
-          field_names_in_parameters?(the_class, parameters)
-        else
-          false
-        end
-      end
-
-      def field_names_in_parameters?(the_class, parameters)
-        field_names = the_class.fields.field_names
-        param_keys = parameters.keys
-
-        (field_names & param_keys).length > 0
-      end
-    end
-  end
-
   # A Record is a declarative wrapper around Struct.
   #
   #    require 'bindata'
@@ -68,7 +32,7 @@ module BinData
     class << self
 
       def arg_extractor
-        RecordArgExtractor
+        MultiFieldArgExtractor
       end
 
       def sanitize_parameters!(params) #:nodoc:

data/lib/bindata/registry.rb

@@ -18,28 +18,29 @@ module BinData
     def register(name, class_to_register)
       return if class_to_register.nil?
 
-      formatted_name = lookup_key(name)
+      formatted_name = underscore_name(name)
       warn_if_name_is_already_registered(formatted_name, class_to_register)
 
       @registry[formatted_name] = class_to_register
     end
 
     def unregister(name)
-      formatted_name = lookup_key(name)
-      @registry.delete(formatted_name)
+      @registry.delete(underscore_name(name))
     end
 
     def lookup(name, endian = nil)
-      key = lookup_key(name, endian)
-      try_registering_key(key) unless @registry.has_key?(key)
-
+      key = normalize_name(name, endian)
       @registry[key] || raise(UnRegisteredTypeError, name.to_s)
     end
 
     def normalize_name(name, endian = nil)
-      if lookup(name, endian)
-        lookup_key(name, endian)
-      end
+      name = underscore_name(name)
+      return name if is_registered?(name)
+
+      name = name_with_endian(name, endian)
+      return name if is_registered?(name)
+
+      name
     end
 
     # Convert CamelCase +name+ to underscore style.
@@ -54,25 +55,28 @@ module BinData
     #---------------
     private
 
-    def lookup_key(name, endian = nil)
-      name = underscore_name(name)
+    def name_with_endian(name, endian)
+      return name if endian.nil?
 
-      result = name
-      if endian != nil
-        if /^u?int\d+$/ =~ name
-          result = name + ((endian == :little) ? "le" : "be")
-        elsif /^(float|double)$/ =~ name
-          result = name + ((endian == :little) ? "_le" : "_be")
-        end
+      suffix = (endian == :little) ? "le" : "be"
+      if /^u?int\d+$/ =~ name
+        name + suffix
+      else
+        name + "_" + suffix
       end
-      result
     end
 
-    def try_registering_key(key)
-      if /^u?int\d+(le|be)$/ =~ key or /^bit\d+(le)?$/ =~ key
-        class_name = key.gsub(/(?:^|_)(.)/) { $1.upcase }
+    def is_registered?(name)
+      register_dynamic_class(name) unless @registry.has_key?(name)
+
+      @registry.has_key?(name)
+    end
+
+    def register_dynamic_class(name)
+      if /^u?int\d+(le|be)$/ =~ name or /^bit\d+(le)?$/ =~ name
+        class_name = name.gsub(/(?:^|_)(.)/) { $1.upcase }
         begin
-          register(key, BinData::const_get(class_name))
+          BinData::const_get(class_name)
         rescue NameError
         end
       end

data/lib/bindata/version.rb

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

data/lib/bindata/virtual.rb

@@ -1,4 +1,4 @@
-require "bindata/base_primitive"
+require "bindata/base"
 
 module BinData
   # A virtual field is one that is neither read, written nor occupies space.
@@ -17,31 +17,37 @@ module BinData
   #   obj.a #=> "abcde"
   #   obj.c.offset #=> 10
   #
-  class Virtual < BinData::BasePrimitive
-
-    default_parameter :onlyif => false
+  #   obj = A.read("abcdeABCDE") #=> BinData::ValidityError: assertion failed for obj.c
+  #
+  # == Parameters
+  #
+  # Parameters may be provided at initialisation to control the behaviour of
+  # an object.  These params include those for BinData::Base as well as:
+  #
+  # [<tt>:assert</tt>]    Raise an error when reading or assigning if the value
+  #                       of this evaluated parameter is false.
+  #
+  class Virtual < BinData::Base
 
-    class << self
-      def sanitize_parameters!(params) #:nodoc:
-        if params.has_parameter?(:asserted_value)
-          fail ":asserted_value can not be used on virtual field"
-        end
-      end
-    end
+    optional_parameter :assert
 
-    #---------------
-    private
+    def clear?; true; end
+    def snapshot; nil; end
+    def do_num_bytes; 0; end
+    def do_write(io); end
 
-    def value_to_binary_string(val)
-      ""
+    def assign(val)
+      assert!
     end
 
-    def read_and_return_value(io)
-      ""
+    def do_read(io)
+      assert!
     end
 
-    def sensible_default
-      ""
+    def assert!
+      if has_parameter?(:assert) and not eval_parameter(:assert)
+        raise ValidityError, "assertion failed for #{debug_name}"
+      end
     end
   end
 end

data/test/buffer_test.rb

@@ -0,0 +1,144 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "common"))
+
+describe BinData::Buffer, "when instantiating" do
+  describe "with no mandatory parameters supplied" do
+    it "raises an error" do
+      args = {}
+      lambda { BinData::Buffer.new(args) }.must_raise ArgumentError
+    end
+  end
+
+  describe "with some but not all mandatory parameters supplied" do
+    it "raises an error" do
+      args = {:length => 3}
+      lambda { BinData::Buffer.new(args) }.must_raise ArgumentError
+    end
+  end
+
+  it "fails if a given type is unknown" do
+    args = {:type => :does_not_exist, :length => 3}
+    lambda { BinData::Buffer.new(args) }.must_raise BinData::UnRegisteredTypeError
+  end
+
+  it "accepts BinData::Base as :type" do
+    obj = BinData::Int8.new(:initial_value => 5)
+    array = BinData::Buffer.new(:type => obj, :length => 3)
+    array.must_equal 5
+  end
+end
+
+describe BinData::Buffer, "subclassed with a single type" do
+  class IntBuffer < BinData::Buffer
+    endian :big
+    default_parameter :length => 5
+
+    uint16
+  end
+
+  it "behaves as type" do
+    obj = IntBuffer.new(3)
+    obj.must_equal 3
+  end
+
+  it "reads data" do
+    obj = IntBuffer.read "\001\002\003\004\005"
+    obj.must_equal 0x0102
+  end
+
+  it "writes data" do
+    obj = IntBuffer.new(3)
+    obj.to_binary_s.must_equal "\000\003\000\000\000"
+  end
+
+  it "has total num_bytes" do
+    obj = IntBuffer.new
+    obj.num_bytes.must_equal 5
+  end
+end
+
+describe BinData::Buffer, "subclassed with multiple types" do
+  class TupleBuffer < BinData::Buffer
+    endian :big
+    default_parameter :length => 5
+
+    uint16 :a
+    uint16 :b
+  end
+
+  it "behaves as type" do
+    obj = TupleBuffer.new(:a => 1, :b => 2)
+    obj.a.must_equal 1
+    obj.b.must_equal 2
+  end
+
+  it "has total num_bytes" do
+    obj = TupleBuffer.new
+    obj.num_bytes.must_equal 5
+  end
+
+  it "reads data" do
+    obj = TupleBuffer.read "\001\002\003\004\005"
+    obj.a.must_equal 0x0102
+    obj.b.must_equal 0x0304
+  end
+
+  it "writes data" do
+    obj = TupleBuffer.new(:a => 1, :b => 2)
+    obj.to_binary_s.must_equal "\000\001\000\002\000"
+  end
+end
+
+describe BinData::Buffer, "inside a Record" do
+  class BufferRecord < BinData::Record
+    endian :little
+
+    uint16 :buffer_length, :value => lambda { 2 * list.length + 1 }
+    buffer :list, :length => :buffer_length do
+      array :type => :int16, :read_until => :eof
+    end
+    string :footer, :length => 2, :asserted_value => "ZZ"
+  end
+
+  it "reads" do
+    obj = BufferRecord.read "\007\000\004\000\005\000\006\000\000ZZ"
+    obj.list.must_equal [4, 5, 6]
+  end
+
+  it "writes" do
+    obj = BufferRecord.new(:list => [1, 2, 3, 4, 5])
+    obj.to_binary_s.must_equal "\013\000\001\000\002\000\003\000\004\000\005\000\000ZZ"
+  end
+end
+
+describe BinData::Buffer, "nested buffers" do
+  class NestedBufferRecord < BinData::Record
+    buffer :a, :length => 10 do
+      buffer :aa, :length => 5 do
+        string :read_length => 5
+      end
+      buffer :bb, :length => 20 do
+        string :read_length => 5
+      end
+    end
+    string :b, :read_length => 5
+  end
+
+  it "restricts large nested buffer" do
+    obj = NestedBufferRecord.read "abcdefghijklmnopqrst"
+    obj.a.aa.must_equal "abcde"
+    obj.a.bb.must_equal "fghij"
+    obj.b.must_equal "klmno"
+  end
+
+  it "restricts oversize writes" do
+    obj = NestedBufferRecord.new
+    obj.a.aa = "abcdefghij"
+    obj.a.bb = "ABCDEFGHIJ"
+    obj.b = "12345"
+
+    obj.to_binary_s.must_equal "abcdeABCDE12345"
+  end
+end
+

data/test/common.rb

@@ -30,7 +30,7 @@ end
 
 class ExampleSingle < BinData::BasePrimitive
   def self.io_with_value(val)
-    BinData::IO.new([val].pack("V"))
+    StringIO.new([val].pack("V"))
   end
 
   private

data/test/io_test.rb

@@ -2,63 +2,43 @@
 
 require File.expand_path(File.join(File.dirname(__FILE__), "common"))
 
-describe BinData::IO, "reading from non seekable stream" do
+describe BinData::IO::Read, "reading from non seekable stream" do
   before do
     @rd, @wr = IO::pipe
-    if fork
-      # parent
-      @wr.close
-      @io = BinData::IO.new(@rd)
-    else
-      # child
-      begin
-        @rd.close
-        @wr.write "a" * 5000
-        @wr.write "b" * 5000
-        @wr.close
-      rescue Exception
-        # ignore it
-      ensure
-        exit!
-      end
-    end
+    @io = BinData::IO::Read.new(@rd)
+    @wr.write "a" * 2000
+    @wr.write "b" * 2000
+    @wr.close
   end
 
   after do
     @rd.close
-    Process.wait
   end
 
-  it "always has an offset of 0" do
+  it "has correct offset" do
     @io.readbytes(10)
-    @io.offset.must_equal 0
+    @io.offset.must_equal 10
   end
 
   it "seeks correctly" do
-    @io.seekbytes(4999)
+    @io.seekbytes(1999)
     @io.readbytes(5).must_equal "abbbb"
   end
 
-  it "returns zero for num bytes remaining" do
-    @io.num_bytes_remaining.must_equal 0
+  it "#num_bytes_remaining raises IOError" do
+    lambda {
+      @io.num_bytes_remaining
+    }.must_raise IOError
   end
 end
 
-describe BinData::IO, "when reading" do
+describe BinData::IO::Read, "when reading" do
   let(:stream) { StringIO.new "abcdefghij" }
-  let(:io) { BinData::IO.new(stream) }
-
-  it "wraps strings in StringIO" do
-    io.raw_io.class.must_equal StringIO
-  end
+  let(:io) { BinData::IO::Read.new(stream) }
 
-  it "does not wrap IO objects" do
-    io.raw_io.must_equal stream
-  end
-
-  it "raises error when io is BinData::IO" do
+  it "raises error when io is BinData::IO::Read" do
     lambda {
-      BinData::IO.new(BinData::IO.new(""))
+      BinData::IO::Read.new(BinData::IO::Read.new(""))
     }.must_raise ArgumentError
   end
 
@@ -100,17 +80,69 @@ describe BinData::IO, "when reading" do
   end
 end
 
-describe BinData::IO, "when writing" do
-  let(:stream) { StringIO.new }
-  let(:io) { BinData::IO.new(stream) }
+describe BinData::IO::Read, "#with_buffer" do
+  let(:stream) { StringIO.new "abcdefghijklmnopqrst" }
+  let(:io) { BinData::IO::Read.new(stream) }
+
+  it "consumes entire buffer on short reads" do
+    io.with_buffer(10) do
+      io.readbytes(4).must_equal "abcd"
+    end
+    io.offset.must_equal(10)
+  end
+
+  it "consumes entire buffer on read_all_bytes" do
+    io.with_buffer(10) do
+      io.read_all_bytes.must_equal "abcdefghij"
+    end
+    io.offset.must_equal(10)
+  end
+
+  it "restricts large reads" do
+    io.with_buffer(10) do
+      lambda {
+        io.readbytes(15)
+      }.must_raise IOError
+    end
+  end
+
+  it "is nestable" do
+    io.with_buffer(10) do
+      io.readbytes(2).must_equal "ab"
+      io.with_buffer(5) do
+        io.read_all_bytes.must_equal "cdefg"
+      end
+      io.offset.must_equal(2 + 5)
+    end
+    io.offset.must_equal(10)
+  end
+
+  it "restricts large nested buffers" do
+    io.with_buffer(10) do
+      io.readbytes(2).must_equal "ab"
+      io.with_buffer(20) do
+        io.read_all_bytes.must_equal "cdefghij"
+        io.offset.must_equal(10)
+      end
+    end
+    io.offset.must_equal(10)
+  end
 
-  it "does not wrap IO objects" do
-    io.raw_io.must_equal stream
+  it "restricts large seeks" do
+    io.with_buffer(10) do
+      io.seekbytes(15)
+    end
+    io.offset.must_equal(10)
   end
+end
+
+describe BinData::IO::Write, "when writing" do
+  let(:stream) { StringIO.new }
+  let(:io) { BinData::IO::Write.new(stream) }
 
   it "raises error when io is BinData::IO" do
     lambda {
-      BinData::IO.new(BinData::IO.new(""))
+      BinData::IO::Write.new(BinData::IO::Write.new(""))
     }.must_raise ArgumentError
   end
 
@@ -128,11 +160,43 @@ describe BinData::IO, "when writing" do
   end
 end
 
-describe BinData::IO, "reading bits in big endian" do
+describe BinData::IO::Write, "#with_buffer" do
+  let(:stream) { StringIO.new }
+  let(:io) { BinData::IO::Write.new(stream) }
+
+  it "pads entire buffer on short reads" do
+    io.with_buffer(10) do
+      io.writebytes "abcde"
+    end
+
+    stream.value.must_equal "abcde\0\0\0\0\0"
+  end
+
+  it "discards excess on large writes" do
+    io.with_buffer(5) do
+      io.writebytes "abcdefghij"
+    end
+
+    stream.value.must_equal "abcde"
+  end
+
+  it "is nestable" do
+    io.with_buffer(10) do
+      io.with_buffer(5) do
+        io.writebytes "abc"
+      end
+      io.writebytes "de"
+    end
+
+    stream.value.must_equal "abc\0\0de\0\0\0"
+  end
+end
+
+describe BinData::IO::Read, "reading bits in big endian" do
   let(:b1) { 0b1111_1010 }
   let(:b2) { 0b1100_1110 }
   let(:b3) { 0b0110_1010 }
-  let(:io) { BinData::IO.new([b1, b2, b3].pack("CCC")) }
+  let(:io) { BinData::IO::Read.new([b1, b2, b3].pack("CCC")) }
 
   it "reads a bitfield less than 1 byte" do
     io.readbits(3, :big).must_equal 0b111
@@ -174,11 +238,11 @@ describe BinData::IO, "reading bits in big endian" do
   end
 end
 
-describe BinData::IO, "reading bits in little endian" do
+describe BinData::IO::Read, "reading bits in little endian" do
   let(:b1) { 0b1111_1010 }
   let(:b2) { 0b1100_1110 }
   let(:b3) { 0b0110_1010 }
-  let(:io) { BinData::IO.new([b1, b2, b3].pack("CCC")) }
+  let(:io) { BinData::IO::Read.new([b1, b2, b3].pack("CCC")) }
 
   it "reads a bitfield less than 1 byte" do
     io.readbits(3, :little).must_equal 0b010
@@ -223,7 +287,7 @@ end
 class BitWriterHelper
   def initialize
     @stringio = BinData::IO.create_string_io
-    @io = BinData::IO.new(@stringio)
+    @io = BinData::IO::Write.new(@stringio)
   end
 
   def writebits(val, nbits, endian)
@@ -241,7 +305,7 @@ class BitWriterHelper
   end
 end
 
-describe BinData::IO, "writing bits in big endian" do
+describe BinData::IO::Write, "writing bits in big endian" do
   let(:io) { BitWriterHelper.new }
 
   it "writes a bitfield less than 1 byte" do
@@ -286,7 +350,7 @@ describe BinData::IO, "writing bits in big endian" do
   end
 end
 
-describe BinData::IO, "writing bits in little endian" do
+describe BinData::IO::Write, "writing bits in little endian" do
   let(:io) { BitWriterHelper.new }
 
   it "writes a bitfield less than 1 byte" do
@@ -331,17 +395,19 @@ describe BinData::IO, "writing bits in little endian" do
   end
 end
 
-describe BinData::IO, "with changing endian" do
+describe BinData::IO::Read, "with changing endian" do
   it "does not mix different endianess when reading" do
     b1 = 0b0110_1010
     b2 = 0b1110_0010
     str = [b1, b2].pack("CC")
-    io = BinData::IO.new(str)
+    io = BinData::IO::Read.new(str)
 
     io.readbits(3, :big).must_equal 0b011
     io.readbits(4, :little).must_equal 0b0010
   end
+end
 
+describe BinData::IO::Write, "with changing endian" do
   it "does not mix different endianess when writing" do
     io = BitWriterHelper.new
     io.writebits(0b110, 3, :big)