bindata 2.4.15 → 2.5.1

data/test/string_test.rb

@@ -298,15 +298,15 @@ end
 describe BinData::String, "warnings" do
   it "warns if has :asserted_value but no :length" do
     obj = BinData::String.new(asserted_value: "ABC")
-    obj.must_warn "obj does not have a :read_length parameter - returning empty string" do
+    _ {
       _ { obj.read("abcde") }.must_raise BinData::ValidityError
-    end
+    }.must_warn "obj does not have a :read_length parameter - returning empty string"
   end
 
   it "warns if has :value but no :read_length" do
     obj = BinData::String.new(value: "ABC")
-    obj.must_warn "obj does not have a :read_length parameter - returning empty string" do
+    _ {
       obj.read("abcde")
-    end
+    }.must_warn "obj does not have a :read_length parameter - returning empty string"
   end
 end

data/test/stringz_test.rb

@@ -76,6 +76,14 @@ end
 describe BinData::Stringz, "with max_length" do
   let(:obj) { BinData::Stringz.new(max_length: 5) }
 
+  it "fails if max_length is less that 1" do
+    obj = BinData::Stringz.new(max_length: 0)
+
+    _{ obj.read "abc\0" }.must_raise ArgumentError
+    _{ obj.to_binary_s }.must_raise ArgumentError
+    _{ obj.num_bytes }.must_raise ArgumentError
+  end
+
   it "reads less than max_length" do
     io = StringIO.new("abc\0xyz")
     obj.read(io)

data/test/struct_test.rb

@@ -45,24 +45,65 @@ describe BinData::Struct, "with anonymous fields" do
     params = { fields: [
                             [:int8, :a, {initial_value: 5}],
                             [:int8, nil],
-                            [:int8, '', {value: :a}]
+                            [:int8, '', {value: :a}],
+                            [:int8, :b]
                           ] }
     BinData::Struct.new(params)
   }
 
   it "only shows non anonymous fields" do
-    _(obj.field_names).must_equal [:a]
+    _(obj.field_names).must_equal [:a, :b]
   end
 
   it "does not include anonymous fields in snapshot" do
-    obj.a = 5
-    _(obj.snapshot).must_equal({a: 5})
+    obj.a = 6
+    _(obj.snapshot).must_equal({a: 6, b: 0})
   end
 
   it "writes anonymous fields" do
-    obj.read("\001\002\003")
+    obj.read("\001\002\003\004")
     obj.a.clear
-    _(obj.to_binary_s).must_equal_binary "\005\002\005"
+    _(obj.to_binary_s).must_equal_binary "\005\002\005\004"
+  end
+
+  it "does not include anonymous fields in each_pair" do
+    _(obj.each_pair.count).must_equal 2
+  end
+
+  it "includes anonymous fields in each_pair when specified" do
+    _(obj.each_pair(true).count).must_equal 4
+  end
+
+  it "clears" do
+    obj.b = 3
+    refute obj.clear?
+
+    obj.clear
+    assert obj.clear?
+  end
+end
+
+describe BinData::Struct, "with onlyif fields" do
+  let(:obj) {
+    params = { fields: [
+                            [:int8, :a, {initial_value: 2}],
+                            [:int8, :b, {onlyif: -> { a.odd? }}]
+                          ] }
+    BinData::Struct.new(params)
+  }
+
+  it "#fieldnames includes all fields" do
+    _(obj.field_names).must_equal [:a, :b]
+  end
+
+  it "#snapshot checks for onlyif" do
+    _(obj.snapshot.keys).must_equal [:a]
+  end
+
+  it "includes fields when required" do
+    refute obj.b?
+    obj.a = 3
+    assert obj.b?
   end
 end
 
@@ -140,10 +181,16 @@ describe BinData::Struct, "with multiple fields" do
     _(obj[:a]).must_equal 1
   end
 
-  it "handles not existing elements" do
+  it "handles nonexistent elements" do
     _(obj[:does_not_exist]).must_be_nil
   end
 
+  it "ignores setting nonexistent elements" do
+    snap = obj.snapshot
+    obj[:does_not_exist] = 3
+    _(obj.snapshot).must_equal snap
+  end
+
   it "writes elements dynamically" do
     obj[:a] = 2
     _(obj.a).must_equal 2
@@ -225,6 +272,20 @@ describe BinData::Struct, "with multiple fields" do
       obj.snapshot.each_pair { |k, v| keys << k }
       _(keys).must_equal [:a, :b]
     end
+
+    it "accesses field" do
+      _(obj.snapshot[:a]).must_equal 1
+    end
+
+    it "fails on unknown method call" do
+      _ { obj.snapshot.does_not_exist }.must_raise NoMethodError
+    end
+
+    it "will not set attribute with nil value" do
+      refute obj.snapshot.key?(:foo)
+      obj.snapshot[:foo] = nil
+      refute obj.snapshot.key?(:foo)
+    end
   end
 end
 
@@ -402,30 +463,44 @@ describe BinData::Struct, "with byte_align" do
   let(:obj) {
     params = { fields: [[:int8, :a],
                         [:int8, :b, byte_align: 5],
-                        [:bit2, :c],
+                        [:bit2, :c, onlyif: -> { a == 1}],
                         [:int8, :d, byte_align: 3]] }
     BinData::Struct.new(params)
   }
 
   it "has #num_bytes" do
+    _(obj.num_bytes).must_equal 7
+  end
+
+  it "has #num_bytes with onlyif" do
+    obj.a = 1
     _(obj.num_bytes).must_equal 10
   end
 
-  it "reads" do
+  it "reads with onlyif" do
     obj.read("\x01\x00\x00\x00\x00\x02\xc0\x00\x00\x04")
     _(obj.snapshot).must_equal({ a: 1, b: 2, c: 3, d: 4 })
   end
 
-  it "writes" do
+  it "reads without onlyif" do
+    obj.read("\x00\x00\x00\x00\x00\x02\x04")
+    _(obj.snapshot).must_equal({ a: 0, b: 2, d: 4 })
+  end
+
+  it "writes with onlyif" do
     obj.assign(a: 1, b: 2, c: 3, d: 4)
     _(obj.to_binary_s).must_equal_binary "\x01\x00\x00\x00\x00\x02\xc0\x00\x00\x04"
   end
 
+  it "writes without onlyif" do
+    obj.assign(a: 0, b: 2, c: 3, d: 4)
+    _(obj.to_binary_s).must_equal_binary "\x00\x00\x00\x00\x00\x02\x04"
+  end
+
   it "has correct offsets" do
     _(obj.a.rel_offset).must_equal 0
     _(obj.b.rel_offset).must_equal 5
-    _(obj.c.rel_offset).must_equal 6
-    _(obj.d.rel_offset).must_equal 9
+    _(obj.d.rel_offset).must_equal 6
   end
 end
 

data/test/system_test.rb

@@ -229,6 +229,19 @@ describe "Tracing"  do
 
     _(io.value).must_equal "obj => \"000000000011111111112222222222...\n"
   end
+
+  it "can be nested" do
+    obj = BinData::String.new(read_length: 5)
+
+    io = StringIO.new
+    BinData::trace_reading(io) {
+      BinData::trace_reading(io) {
+        obj.read("12345")
+      }
+    }
+
+    _(io.value).must_equal "obj => \"12345\"\n"
+  end
 end
 
 describe "Forward referencing with Primitive" do
@@ -381,7 +394,7 @@ describe BinData::Record, "encoding" do
   end
 
   it "returns binary encoded data despite Encoding.default_internal" do
-    w, $-w = $-w, false
+    w, $-w = $-w, nil
     before_enc = Encoding.default_internal
 
     begin
@@ -394,3 +407,108 @@ describe BinData::Record, "encoding" do
     end
   end
 end
+
+describe BinData::Record, "buffer num_bytes" do
+  class BufferNumBytesRecord < BinData::Record
+    buffer :b, length: 10 do
+      int8 :a
+      count_bytes_remaining :nbytes
+    end
+  end
+
+  it "counts bytes remaining in the buffer" do
+    obj = BufferNumBytesRecord.read "12345678901234567890"
+    _(obj.b.nbytes).must_equal 9
+  end
+
+  it "counts bytes remaining in the buffer with short streams" do
+    obj = BufferNumBytesRecord.read "12345"
+    _(obj.b.nbytes).must_equal 4
+  end
+
+  it "assumes buffer is full with non-seekable short streams" do
+    rd, wr = IO::pipe
+    io = BinData::IO::Read.new(rd)
+    wr.write "12345"
+    wr.close
+
+    obj = BufferNumBytesRecord.read(io)
+    _(obj.b.nbytes).must_equal 9
+    rd.close
+  end
+end
+
+describe BinData::Buffer, "with seek_abs" do
+  class BufferSkipRecord < BinData::Record
+    endian :little
+    mandatory_parameter :seek_offset
+
+    uint8
+    buffer :buf, length: 5 do
+      uint8
+      uint8
+      skip to_abs_offset: :seek_offset
+      uint8 :a
+    end
+    uint8
+  end
+
+  let(:str) { "\001\002\003\004\005\006\007" }
+
+  ## TODO: enable this if we decide to allow backwards seeking
+  #backwards_seeking = false
+  #
+  #it "won't seek backwards before buffer" do
+  #  skip unless backwards_seeking
+  #  _ { BufferSkipRecord.new(seek_offset: 0).read(str) }.must_raise(IOError)
+  #end
+  #
+  #it "seeks backwards to start of buffer" do
+  #  skip unless backwards_seeking
+  #  obj = BufferSkipRecord.new(seek_offset: 1).read(str)
+  #  _(obj.buf.a).must_equal 2
+  #end
+  #
+  #it "seeks backwards inside buffer" do
+  #  skip unless backwards_seeking
+  #  obj = BufferSkipRecord.new(seek_offset: 2).read(str)
+  #  _(obj.buf.a).must_equal 3
+  #end
+
+  it "seeks forwards inside buffer" do
+    obj = BufferSkipRecord.new(seek_offset: 4).read(str)
+    _(obj.buf.a).must_equal 5
+  end
+
+  it "seeks to end of buffer" do
+    obj = BufferSkipRecord.new(seek_offset: 5).read(str)
+    _(obj.buf.a).must_equal 6
+  end
+
+  it "won't seek after buffer" do
+    _ { BufferSkipRecord.new(seek_offset: 6).read(str) }.must_raise(IOError)
+  end
+end
+
+
+describe BinData::Record, "buffered readahead" do
+  class BufferedReadaheadRecord < BinData::Record
+    buffer :a, length: 5 do
+      skip do
+        string read_length: 1, assert: "X"
+      end
+      string :b, read_length: 1
+    end
+    string :c, read_length: 1
+  end
+
+  it "reads ahead inside the buffer" do
+    obj = BufferedReadaheadRecord.read "12X4567890"
+    _(obj.a.b).must_equal "X"
+    _(obj.c).must_equal "6"
+  end
+
+  it "doesn't readahead outside the buffer" do
+    _ { BufferedReadaheadRecord.read "123456X890" }.must_raise IOError
+  end
+end

data/test/test_helper.rb

@@ -1,7 +1,9 @@
 require 'rubygems'
 
-require 'coveralls'
-Coveralls.wear!
+require 'simplecov'
+SimpleCov.start do
+  enable_coverage :branch
+end
 
 require 'minitest/autorun'
 require 'stringio'
@@ -30,32 +32,45 @@ module Kernel
   def value_read_from_written
     self.class.read(self.to_binary_s)
   end
+end
 
-  def must_equal_binary(expected)
-    must_equal expected.dup.force_encoding(Encoding::BINARY)
+module Minitest::Assertions
+  def assert_equals_binary(expected, actual)
+    assert_equal expected.dup.force_encoding(Encoding::BINARY), actual
   end
 
-  def must_raise_on_line(exp, line, msg = nil)
-    ex = self.must_raise exp
-    (ex.message).must_equal msg if msg
+  def assert_raises_on_line(exp, line, msg = nil, &block)
+    ex = assert_raises(exp, &block)
+    assert_equal(msg, ex.message) if msg
+
+    line_num_regex = /(.*):(\d+)(:in.*)$/
+
+    filename = line_num_regex.match(ex.backtrace[0])[1]
 
-    idx = ex.backtrace.find_index { |bt| /:in `must_raise_on_line'$/ =~ bt }
+    filtered = ex.backtrace.grep(/^#{Regexp.escape(filename)}/)
+    top = filtered.grep(Regexp.new(Regexp.escape("in <top (required)>")))
 
-    line_num_regex = /.*:(\d+)(:.*|$)/
-    err_line = line_num_regex.match(ex.backtrace[0])[1].to_i
-    ref_line = line_num_regex.match(ex.backtrace[idx + 1])[1].to_i
+    err_line = line_num_regex.match(filtered[0])[2].to_i
+    ref_line = line_num_regex.match(top[0])[2].to_i - 1
 
-    (err_line - ref_line).must_equal line
+    assert_equal((err_line - ref_line), line)
   end
 
-  def must_warn(msg, &block)
+  def assert_warns(msg, &block)
     result = ""
     callable = proc { |str|
       result = str
     }
-    self.stub(:warn, callable) do
+    Kernel.stub(:warn, callable) do
       block.call
     end
-    (result).must_equal msg
+
+    assert_equal msg, result
   end
 end
+
+module Minitest::Expectations
+  infect_an_assertion :assert_equals_binary, :must_equal_binary
+  infect_an_assertion :assert_raises_on_line, :must_raise_on_line, :block
+  infect_an_assertion :assert_warns, :must_warn, :block
+end

data/test/warnings_test.rb

@@ -15,6 +15,18 @@ describe BinData::Base, "when defining" do
     }.must_raise RuntimeError
   end
 
+  it "fails if #initialize is overridden on BasePrimitive" do
+    class BasePrimitiveWithInitialize < BinData::String
+      def initialize(params = {}, parent = nil)
+        super
+      end
+    end
+
+    _ {
+      BasePrimitiveWithInitialize.new
+    }.must_raise RuntimeError
+  end
+
   it "handles if #initialize is naively renamed to #initialize_instance" do
     class BaseWithInitializeInstance < BinData::Base
       def initialize_instance(params = {}, parent = nil)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bindata
 version: !ruby/object:Gem::Version
-  version: 2.4.15
+  version: 2.5.1
 platform: ruby
 authors:
 - Dion Mendel
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-07 00:00:00.000000000 Z
+date: 1980-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -31,9 +31,6 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: 5.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 5.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -41,11 +38,8 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: 5.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 5.12.0
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -65,7 +59,7 @@ description: |
   data is, and BinData works out *how* to read and write data in this
   format.  It is an easier ( and more readable ) alternative to
   ruby's #pack and #unpack methods.
-email: bindata@dm9.info
+email: bindata@dmau.org
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -101,18 +95,25 @@ files:
 - lib/bindata/io.rb
 - lib/bindata/lazy.rb
 - lib/bindata/name.rb
-- lib/bindata/offset.rb
 - lib/bindata/params.rb
 - lib/bindata/primitive.rb
 - lib/bindata/record.rb
 - lib/bindata/registry.rb
 - lib/bindata/rest.rb
 - lib/bindata/sanitize.rb
+- lib/bindata/section.rb
 - lib/bindata/skip.rb
 - lib/bindata/string.rb
 - lib/bindata/stringz.rb
 - lib/bindata/struct.rb
 - lib/bindata/trace.rb
+- lib/bindata/transform/brotli.rb
+- lib/bindata/transform/lz4.rb
+- lib/bindata/transform/lzma.rb
+- lib/bindata/transform/xor.rb
+- lib/bindata/transform/xz.rb
+- lib/bindata/transform/zlib.rb
+- lib/bindata/transform/zstd.rb
 - lib/bindata/uint8_array.rb
 - lib/bindata/version.rb
 - lib/bindata/virtual.rb
@@ -130,12 +131,12 @@ files:
 - test/int_test.rb
 - test/io_test.rb
 - test/lazy_test.rb
-- test/offset_test.rb
 - test/params_test.rb
 - test/primitive_test.rb
 - test/record_test.rb
 - test/registry_test.rb
 - test/rest_test.rb
+- test/section_test.rb
 - test/skip_test.rb
 - test/string_test.rb
 - test/stringz_test.rb
@@ -148,8 +149,9 @@ files:
 homepage: https://github.com/dmendel/bindata
 licenses:
 - BSD-2-Clause
-metadata: {}
-post_install_message: 
+metadata:
+  changelog_uri: https://github.com/dmendel/bindata/blob/master/ChangeLog.rdoc
+post_install_message:
 rdoc_options:
 - "--main"
 - NEWS.rdoc
@@ -159,15 +161,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key: 
+rubygems_version: 3.3.27
+signing_key:
 specification_version: 4
 summary: A declarative way to read and write binary file formats
 test_files: []

data/lib/bindata/offset.rb

@@ -1,94 +0,0 @@
-module BinData
-  # WARNING: THIS IS UNSUPPORTED!!
-  #
-  # This was a (failed) experimental feature that allowed seeking within the
-  # input stream.  It remains here for backwards compatability for the few
-  # people that used it.
-  #
-  # The official way to skip around the stream is to use BinData::Skip with
-  # the `:to_abs_offset` parameter.
-  #
-  # == Parameters
-  #
-  # Parameters may be provided at initialisation to control the behaviour of
-  # an object.  These parameters are:
-  #
-  # [<tt>:check_offset</tt>]  Raise an error if the current IO offset doesn't
-  #                           meet this criteria.  A boolean return indicates
-  #                           success or failure.  Any other return is compared
-  #                           to the current offset.  The variable +offset+
-  #                           is made available to any lambda assigned to
-  #                           this parameter.  This parameter is only checked
-  #                           before reading.
-  # [<tt>:adjust_offset</tt>] Ensures that the current IO offset is at this
-  #                           position before reading.  This is like
-  #                           <tt>:check_offset</tt>, except that it will
-  #                           adjust the IO offset instead of raising an error.
-  module CheckOrAdjustOffsetPlugin
-
-    def self.included(base) #:nodoc:
-      base.optional_parameters :check_offset, :adjust_offset
-      base.mutually_exclusive_parameters :check_offset, :adjust_offset
-    end
-
-    def initialize_shared_instance
-      extend CheckOffsetMixin  if has_parameter?(:check_offset)
-      extend AdjustOffsetMixin if has_parameter?(:adjust_offset)
-      super
-    end
-
-    module CheckOffsetMixin
-      def do_read(io) #:nodoc:
-        check_offset(io)
-        super(io)
-      end
-
-      #---------------
-      private
-
-      def check_offset(io)
-        actual_offset = io.offset
-        expected = eval_parameter(:check_offset, offset: actual_offset)
-
-        if !expected
-          raise ValidityError, "offset not as expected for #{debug_name}"
-        elsif actual_offset != expected && expected != true
-          raise ValidityError,
-                "offset is '#{actual_offset}' but " +
-                "expected '#{expected}' for #{debug_name}"
-        end
-      end
-    end
-
-    module AdjustOffsetMixin
-      def do_read(io) #:nodoc:
-        adjust_offset(io)
-        super(io)
-      end
-
-      #---------------
-      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
-
-  # Add these offset options to Base
-  class Base
-    include CheckOrAdjustOffsetPlugin
-  end
-end