bindata 1.4.5 → 1.5.0

data/{ChangeLog → ChangeLog.rdoc}

@@ -1,5 +1,15 @@
 = BinData Changelog
 
+== Version 1.5.0 (2013-05-21)
+
+* Moved to github.
+* Updated to Ruby 2.0
+* Arrays now accept BinData object factories for :type (feature request by
+  Matt Dainty).
+* Dynamically generated BinData objects can use the :name parameter to
+  register themselves.
+* Remove functionality that has been deprecated for two years.
+
 == Version 1.4.5 (2012-07-24)
 
 * Added the :pad_front option for padding to occur at the front of a String.
@@ -22,7 +32,7 @@
 
 == Version 1.4.2 (2011-08-06)
 
-* =~ now works for strings.
+* \=~ now works for strings.
 
 == Version 1.4.1 (2011-06-20)
 

data/{NEWS → NEWS.rdoc}

@@ -1,3 +1,9 @@
+= 1.5.0
+
+Finally moved the source code to github.
+
+Deprecated functionality has been removed to cleanup the codebase.
+
 = 1.4.4
 
 == Deprecations
@@ -31,7 +37,7 @@ It should be changed to:
       uint8 :initial_value => :initial_element_value
     end
 
-See http://bindata.rubyforge.org/#extending_existing_types for details.
+See http://bindata.rubyforge.org/manual.html#extending_existing_types for details.
 
 = 1.3.0
 

data/README.md

@@ -0,0 +1,54 @@
+# What is BinData?
+
+Do you ever find yourself writing code like this?
+
+```ruby
+io = File.open(...)
+len = io.read(2).unpack("v")
+name = io.read(len)
+width, height = io.read(8).unpack("VV")
+puts "Rectangle #{name} is #{width} x #{height}"
+```
+
+It’s ugly, violates DRY and feels like you’re writing Perl, not Ruby.
+
+There is a better way. Here’s how you’d write the above using BinData.
+
+```ruby
+class Rectangle < BinData::Record
+  endian :little
+  uint16 :len
+  string :name, :read_length => :len
+  uint32 :width
+  uint32 :height
+end
+
+io = File.open(...)
+r  = Rectangle.read(io)
+puts "Rectangle #{r.name} is #{r.width} x #{r.height}"
+```
+
+BinData makes it easy to create new data types. It supports all the common
+primitive datatypes that are found in structured binary data formats. Support
+for dependent and variable length fields is built in. 
+
+# Installation
+
+    $ sudo gem install bindata
+
+-or-
+
+    $ sudo ruby setup.rb
+
+# Documentation
+
+[http://bindata.rubyforge.org/manual.html](http://bindata.rubyforge.org/manual.html)
+
+-or-
+
+    $ rake manual
+
+# Contact
+
+If you have any queries / bug reports / suggestions, please contact me
+(Dion Mendel) via email at dion@lostrealm.com

data/lib/bindata.rb

@@ -1,5 +1,5 @@
 # BinData -- Binary data manipulator.
-# Copyright (c) 2007 - 2012 Dion Mendel.
+# Copyright (c) 2007 - 2013 Dion Mendel.
 
 require 'bindata/array'
 require 'bindata/bits'
@@ -15,7 +15,6 @@ require 'bindata/string'
 require 'bindata/stringz'
 require 'bindata/struct'
 require 'bindata/trace'
-require 'bindata/wrapper'
 require 'bindata/alignment'
 require 'bindata/deprecated'
 
@@ -24,13 +23,13 @@ require 'bindata/deprecated'
 # A declarative way to read and write structured binary data.
 # 
 # A full reference manual is available online at
-# http://bindata.rubyforge.org.
+# http://bindata.rubyforge.org/manual.html
 #
 # == License
 #
 # BinData is released under the same license as Ruby.
 #
-# Copyright (c) 2007 - 2012 Dion Mendel.
+# Copyright (c) 2007 - 2013 Dion Mendel.
 module BinData
-  VERSION = "1.4.5"
+  VERSION = "1.5.0"
 end

data/lib/bindata/base.rb

@@ -82,6 +82,9 @@ module BinData
     # Register all subclasses of this class.
     register_subclasses
 
+    # The registered name may be provided explicitly.
+    optional_parameter :name
+
     # Creates a new data object.
     #
     # Args are optional, but if present, must be in the following order.
@@ -93,12 +96,27 @@ module BinData
     #
     # +parent+ is the parent data object (e.g. struct, array, choice) this
     # object resides under.
+    #
+    # == Parameters
+    #
+    # Parameters may be provided at initialisation to control the behaviour of
+    # an object.  These params 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>
+    #
     def initialize(*args)
       value, parameters, parent = extract_args(args)
 
       @params = SanitizedParameters.sanitize(parameters, self.class)
       @parent = parent
 
+      register_prototype
       add_methods_for_check_or_adjust_offset
 
       initialize_shared_instance
@@ -111,7 +129,7 @@ module BinData
 
     # Creates a new data object based on this instance.
     #
-    # All parameters will be be duplicated.  Use this method 
+    # All parameters will be be duplicated.  Use this method
     # when creating multiple objects with the same parameters.
     def new(value = nil, parent = nil)
       obj = clone
@@ -265,6 +283,12 @@ module BinData
       self.class.arg_extractor.extract(self.class, the_args)
     end
 
+    def register_prototype
+      if has_parameter?(:name)
+        RegisteredClasses.register(get_parameter(:name), self)
+      end
+    end
+
     def furthest_ancestor
       if parent.nil?
         self
@@ -275,6 +299,14 @@ module BinData
       end
     end
 
+    def binary_string(str)
+      if str.respond_to?(:force_encoding)
+        str.dup.force_encoding(Encoding::BINARY)
+      else
+        str.dup
+      end
+    end
+
     ###########################################################################
     # To be implemented by subclasses
 

data/lib/bindata/deprecated.rb

@@ -18,15 +18,27 @@ end
 module BinData
   class Base
 
-    alias_method :initialize_without_deprecation, :initialize
-    def initialize_with_deprecation(*args)
+    # Don't override initialize.  If you are defining a new kind of datatype
+    # (list, array, choice etc) then put your initialization code in
+    # #initialize_instance.  This is because BinData objects can be initialized
+    # as prototypes and your initialization code may not be called.
+    #
+    # If you're subclassing BinData::Record, you are definitely doing the wrong
+    # thing.  Read the documentation on how to use BinData.
+    # http://bindata.rubyforge.org/manual.html#records
+    alias_method :initialize_without_warning, :initialize
+    def initialize_with_warning(*args)
       owner = method(:initialize).owner
       if owner != BinData::Base
-        fail "implementing #initialize on #{owner} is not allowed.\nEither downgrade to BinData 1.2.2, or rename #initialize to #initialize_instance."
+        msg = "Don't override #initialize on #{owner}."
+        if %w(BinData::Base BinData::BasePrimitive).include? self.class.superclass.name
+          msg += "\nrename #initialize to #initialize_instance."
+        end
+        fail msg
       end
-      initialize_without_deprecation(*args)
+      initialize_without_warning(*args)
     end
-    alias_method :initialize, :initialize_with_deprecation
+    alias_method :initialize, :initialize_with_warning
 
     def initialize_instance(*args)
       unless args.empty?
@@ -34,55 +46,5 @@ module BinData
       end
     end
 
-    class << self
-      def register_self
-        warn "#{caller[0]} `register_self' is no longer needed as of BinData 1.3.2.  You can delete this line"
-      end
-
-      def register(name, class_to_register)
-        warn "#{caller[0]} `register' is no longer needed as of BinData 1.3.2.  You can delete this line"
-      end
-    end
-
-    def _do_read(io)
-      warn "#{caller[0]} `_do_read(io)' is deprecated as of BinData 1.3.0.  Replace with `do_read(io)'"
-      do_read(io)
-    end
-
-    def _do_write(io)
-      warn "#{caller[0]} `_do_write(io)' is deprecated as of BinData 1.3.0.  Replace with `do_write(io)'"
-      do_write(io)
-    end
-
-    def _do_num_bytes
-      warn "#{caller[0]} `_do_num_bytes' is deprecated as of BinData 1.3.0.  Replace with `do_num_bytes'"
-      do_num_bytes
-    end
-
-    def _assign(val)
-      warn "#{caller[0]} `_assign(val)' is deprecated as of BinData 1.3.0.  Replace with `assign(val)'"
-      assign(val)
-    end
-
-    def _snapshot
-      warn "#{caller[0]} `_snapshot' is deprecated as of BinData 1.3.0.  Replace with `snapshot'"
-      snapshot
-    end
-  end
-
-  class SingleValue
-    class << self
-      def inherited(subclass) #:nodoc:
-        fail "BinData::SingleValue is deprecated.  Downgrade to BinData 0.11.1.\nYou will need to make changes to your code before you can use BinData >= 1.0.0"
-      end
-    end
-  end
-
-  class MultiValue
-    class << self
-      def inherited(subclass) #:nodoc:
-        fail "BinData::MultiValue is deprecated.  Downgrade to BinData 0.11.1.\nYou will need to make changes to your code before you can use BinData >= 1.0.0"
-      end
-    end
   end
 end

data/lib/bindata/dsl.rb

@@ -90,8 +90,6 @@ module BinData
           to_choice_params
         when :primitive
           to_struct_params
-        when :wrapper
-          raise "Wrapper is deprecated"
         else
           raise "unknown parser type #{@parser_type}"
         end
@@ -122,8 +120,6 @@ module BinData
           [:multiple_fields, :all_or_none_fieldnames, :sanitize_fields, :fieldnames_are_values]
         when :primitive
           [:multiple_fields, :optional_fieldnames, :sanitize_fields]
-        when :wrapper
-          [:only_one_field, :no_fieldnames]
         else
           raise "unknown parser type #{parser_type}"
         end

data/lib/bindata/io.rb

@@ -7,7 +7,7 @@ module BinData
 
     # Creates a StringIO around +str+.
     def self.create_string_io(str = "")
-      if RUBY_VERSION >= "1.9"
+      if str.respond_to?(:force_encoding)
         str = str.dup.force_encoding(Encoding::BINARY)
       end
       StringIO.new(str)
@@ -19,7 +19,7 @@ module BinData
     # +io+ is a string it will be automatically wrapped in an StringIO object.
     #
     # The IO can handle bitstreams in either big or little endian format.
-    # 
+    #
     #      M  byte1   L      M  byte2   L
     #      S 76543210 S      S fedcba98 S
     #      B          B      B          B

data/lib/bindata/params.rb

@@ -123,7 +123,7 @@ module BinData
       def self.invalid_parameter_names
         unless defined? @invalid_names
           all_names = LazyEvaluator.instance_methods(true) + Kernel.methods
-          allowed_names = ["type", :type] # ruby 1.8 vs 1.9
+          allowed_names = ["name", "type", :name, :type] # ruby 1.8 vs 1.9
           invalid_names = (all_names - allowed_names).uniq
           @invalid_names = Hash[*invalid_names.collect { |key| [key.to_sym, true] }.flatten]
         end

data/lib/bindata/primitive.rb

@@ -16,11 +16,11 @@ module BinData
   #    class PascalString < BinData::Primitive
   #      uint8  :len,  :value => lambda { data.length }
   #      string :data, :read_length => :len
-  #    
+  #
   #      def get
   #        self.data
   #      end
-  #    
+  #
   #      def set(v)
   #        self.data = v
   #      end

data/lib/bindata/sanitize.rb

@@ -10,8 +10,18 @@ module BinData
       endian = endian.endian if endian.respond_to? :endian
       obj_params ||= {}
 
-      @obj_class  = RegisteredClasses.lookup(obj_type, endian)
-      @obj_params = SanitizedParameters.new(obj_params, @obj_class, endian)
+      if BinData::Base === obj_type
+        obj_class = obj_type
+      else
+        obj_class = RegisteredClasses.lookup(obj_type, endian)
+      end
+
+      if BinData::Base === obj_class
+        @factory = obj_class
+      else
+        @obj_class  = obj_class
+        @obj_params = SanitizedParameters.new(obj_params, @obj_class, endian)
+      end
     end
 
     def instantiate(value = nil, parent = nil)

data/lib/bindata/string.rb

@@ -76,24 +76,17 @@ module BinData
       private
 
       def sanitized_pad_byte(byte)
-        result = byte.is_a?(Integer) ? byte.chr : byte_string(byte.to_s.dup)
-        if result.length > 1
+        result = byte.is_a?(Integer) ? byte.chr : byte.to_s
+        len = result.respond_to?(:bytesize) ? result.bytesize : result.length
+        if len > 1
           raise ArgumentError, ":pad_byte must not contain more than 1 byte"
         end
         result
       end
-
-      def byte_string(str)
-        if RUBY_VERSION >= "1.9"
-          str.force_encoding(Encoding::BINARY) 
-        else
-          str
-        end
-      end
     end
 
     def assign(val)
-      super(byte_string(val.dup))
+      super(binary_string(val))
     end
 
     def snapshot
@@ -110,16 +103,8 @@ module BinData
     #---------------
     private
 
-    def byte_string(str)
-      if RUBY_VERSION >= "1.9"
-        str.force_encoding(Encoding::BINARY) 
-      else
-        str
-      end
-    end
-
     def clamp_to_length(str)
-      str = byte_string(str)
+      str = binary_string(str)
 
       len = eval_parameter(:length) || str.length
       if str.length == len

data/lib/bindata/stringz.rb

@@ -29,8 +29,7 @@ module BinData
     optional_parameters :max_length
 
     def assign(val)
-      val = val.dup.force_encoding(Encoding::BINARY) if RUBY_VERSION >= "1.9"
-      super(val)
+      super(binary_string(val))
     end
 
     def snapshot
@@ -67,8 +66,7 @@ module BinData
     end
 
     def trim_and_zero_terminate(str)
-      str.force_encoding(Encoding::BINARY) if RUBY_VERSION >= "1.9"
-
+      str = binary_string(str)
       str = truncate_after_first_zero_byte(str)
       str = trim_to(str, eval_parameter(:max_length))
       append_zero_byte_if_needed(str)

data/lib/bindata/struct.rb

@@ -163,7 +163,7 @@ module BinData
     end
 
     def snapshot
-      snapshot = Snapshot.new(field_names)
+      snapshot = Snapshot.new
       field_names.each do |name|
         obj = find_obj_for_name(name)
         snapshot[name] = obj.snapshot if include_obj(obj)
@@ -303,7 +303,7 @@ module BinData
       elsif val.nil?
         {}
       else
-        hash = Snapshot.new(field_names)
+        hash = Snapshot.new
         val.each_pair { |k,v| hash[k] = v }
         hash
       end
@@ -330,18 +330,20 @@ module BinData
       not obj.has_parameter?(:onlyif) or obj.eval_parameter(:onlyif)
     end
 
-    # A hash that can be accessed via attributes.
-    class Snapshot < ::Hash #:nodoc:
-      def initialize(order = [])
-        @order = order.compact
-      end
-
-      if RUBY_VERSION <= "1.9"
+    if RUBY_VERSION <= "1.9"
+      module OrderedHash #:nodoc:
         def keys
+          @order ||= []
           k = super
           @order & k
         end
 
+        def []=(key, value)
+          @order ||= []
+          @order << key
+          super(key, value)
+        end
+
         def each
           keys.each do |k|
             yield [k, self[k]]
@@ -354,6 +356,11 @@ module BinData
           end
         end
       end
+    end
+
+    # A hash that can be accessed via attributes.
+    class Snapshot < ::Hash #:nodoc:
+      include OrderedHash if RUBY_VERSION <= "1.9"
 
       def has_key?(key)
         super(key.to_s)

data/manual.haml

@@ -354,6 +354,11 @@
                       Extending existing Types
                     .acc-section
                       .acc-content
+                  %li
+                    %a{ :href => "#dynamically_creating_types" }
+                      Dynamically creating Types
+                    .acc-section
+                      .acc-content
                   %li
                     %a{ :href => "#skipping_over_unused_data" }
                       Skipping over unused data

data/manual.md

@@ -40,13 +40,17 @@ manipulating.
 It supports all the common datatypes that are found in structured binary
 data. Support for dependent and variable length fields is built in. 
 
-Last updated: 2012-07-24
+Last updated: 2013-05-21
+
+## Source code
+
+[BinData](http://github.com/dmendel/bindata) is hosted on Github.
 
 ## License
 
 BinData is released under the same license as Ruby.
 
-Copyright © 2007 - 2012 [Dion Mendel](mailto:dion@lostrealm.com)
+Copyright © 2007 - 2013 [Dion Mendel](mailto:dion@lostrealm.com)
 
 ## Donate
 
@@ -57,13 +61,14 @@ Want to donate?  My favourite local charity is
 
 # Installation
 
-You can install BinData via rubygems.
+You can install BinData via rubygems (recommended).
 
     gem install bindata
 
-Alternatively, visit the 
-[download](http://rubyforge.org/frs/?group_id=3252) page and download
-BinData as a tar file.
+or as source package.
+
+    git clone http://github.com/dmendel/bindata.git
+    cd bindata && ruby setup.rb
 
 ---------------------------------------------------------------------------
 
@@ -1357,6 +1362,20 @@ We can also use the block form syntax:
     end
 {:ruby}
 
+## Dynamically creating Types
+
+Sometimes the format of a record is not known until runtime.  You can use the
+`BinData::Struct` class to dynamically create a new type.  To be able to reuse
+this type, you can give it a name.
+
+    # Dynamically create my_new_type
+    BinData::Struct.new(:name => :my_new_type,
+                        :fields => [ [:int8, :a], [:int8, :b] ])
+
+    # Create an array of these types
+    array = BinData::Array.new(:type => :my_new_type)
+{:ruby}
+
 ## Skipping over unused data
 
 Some structures contain binary data that is irrelevant to your purposes.  
@@ -1559,7 +1578,7 @@ decided by the `protocol` field.
 Modelling this structure can be difficult when the nesting is recursive, e.g.
 IP tunneling.  Here is an example of the simplest possible recursive TLV structure,
 a [list that can contains atoms or other
-lists](http://bindata.rubyforge.org/svn/trunk/examples/list.rb).
+lists](http://github.com/dmendel/bindata/blob/master/examples/list.rb).
 
 ---------------------------------------------------------------------------
 

data/spec/array_spec.rb

@@ -30,6 +30,12 @@ describe BinData::Array, "when instantiating" do
     args = {:initial_length => 3, :read_until => lambda { false } }
     expect { BinData::Array.new(args) }.to raise_error(ArgumentError)
   end
+
+  it "accepts BinData::Base as :type" do
+    obj = BinData::Int8.new(:initial_value => 5)
+    array = BinData::Array.new(:type => obj, :initial_length => 1)
+    array.should == [5]
+  end
 end
 
 describe BinData::Array, "with no elements" do

data/spec/deprecated_spec.rb

@@ -4,24 +4,6 @@ require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
 require File.expand_path(File.join(File.dirname(__FILE__), "example"))
 require 'bindata'
 
-describe BinData::SingleValue, "when defining" do
-  it "fails when inheriting from deprecated SingleValue" do
-    expect {
-      class SubclassSingleValue < BinData::SingleValue
-      end
-    }.to raise_error
-  end
-end
-
-describe BinData::MultiValue, "when defining" do
-  it "fails inheriting from deprecated MultiValue" do
-    expect {
-      class SubclassMultiValue < BinData::MultiValue
-      end
-    }.to raise_error
-  end
-end
-
 describe BinData::Base, "when defining" do
   it "fails if #initialize is overridden" do
     class BaseWithInitialize < BinData::Base
@@ -46,75 +28,4 @@ describe BinData::Base, "when defining" do
       BaseWithInitializeInstance.new
     }.not_to raise_error
   end
-
-  it "handles deprecated #register_self method" do
-    expect {
-      class DeprecatedRegisterSelfBase < BinData::Base
-        register_self
-      end
-    }.not_to raise_error
-  end
-
-  it "handles deprecated #register method" do
-    expect {
-      class DeprecatedRegisterBase < BinData::Base
-        register(self.name, self)
-      end
-    }.not_to raise_error
-  end
-
-  it "handles deprecated #register method for subclasses" do
-    expect {
-      class DeprecatedSuperBase < BinData::Base
-        def self.inherited(subclass)
-          register(subclass.name, subclass)                                                                                                                                      
-        end                                                                                                                                                                      
-      end
-
-      class DeprecatedSubBase < DeprecatedSuperBase
-      end
-    }.not_to raise_error
-  end
-
-  it "handles deprecated #register method with custom calling" do
-    expect {
-      class DeprecatedCustomBase < BinData::Base
-        register(name, Object)
-      end
-    }.not_to raise_error
-  end
-end
-
-describe BinData::Base do
-  class DeprecatedBase < BinData::Base
-  end
-
-  subject { DeprecatedBase.new }
-  let(:io)  { "abcde" }
-
-  it "forwards _do_read to do_read" do
-    subject.should_receive(:do_read).with(io)
-    subject._do_read(io)
-  end
-
-  it "forwards _do_write to do_write" do
-    subject.should_receive(:do_write).with(io)
-    subject._do_write(io)
-  end
-
-  it "forwards _do_num_bytes to do_num_bytes" do
-    subject.should_receive(:do_num_bytes)
-    subject._do_num_bytes
-  end
-
-  it "forwards _assign to assign" do
-    val = 3
-    subject.should_receive(:assign).with(val)
-    subject._assign(val)
-  end
-
-  it "forwards _snapshot to snapshot" do
-    subject.should_receive(:snapshot)
-    subject._snapshot
-  end
 end

data/spec/int_spec.rb

@@ -129,7 +129,7 @@ shared_examples "All Integers" do
   end
 
   def int_to_binary_str(val)
-    str = ""
+    str = binary("")
     v = val & ((1 << (@nbytes * 8)) - 1)
     @nbytes.times do
       str.concat(v & 0xff)

data/spec/spec_common.rb

@@ -49,3 +49,10 @@ def raise_error_on_line(exception, line, &block)
   end
 end
 
+def binary(str)
+  if str.respond_to?(:force_encoding)
+    str.dup.force_encoding(Encoding::BINARY)
+  else
+    str
+  end
+end

data/spec/string_spec.rb

@@ -269,7 +269,7 @@ describe BinData::String, "with Ruby 1.9 encodings" do
     end
 
     subject { UTF8String.new }
-    let(:binary_str) { "\xC3\x85\xC3\x84\xC3\x96" }
+    let(:binary_str) { binary("\xC3\x85\xC3\x84\xC3\x96") }
     let(:utf8_str) { binary_str.dup.force_encoding('UTF-8') }
 
     it "stores assigned values as binary" do

data/spec/struct_spec.rb

@@ -338,3 +338,13 @@ describe BinData::Struct, "with nested endian" do
     subject.d.should   == 4
   end
 end
+
+describe BinData::Struct, "with dynamically named types" do
+  it "instantiates" do
+    dyn = BinData::Struct.new(:name => :my_struct, :fields => [[:int8, :a, {:initial_value => 3}]])
+
+    obj = BinData::Struct.new(:fields => [[:my_struct, :v]])
+
+    obj.v.a.should == 3
+  end
+end

data/tasks/pkg.rake

@@ -9,12 +9,12 @@ begin
     s.summary = 'A declarative way to read and write binary file formats'
     s.author = 'Dion Mendel'
     s.email = 'dion@lostrealm.com'
-    s.homepage = 'http://bindata.rubyforge.org'
+    s.homepage = 'http://github.com/dmendel/bindata'
     s.rubyforge_project = 'bindata'
     s.require_path = 'lib'
     s.has_rdoc = true
-    s.extra_rdoc_files = ['NEWS']
-    s.rdoc_options << '--main' << 'NEWS'
+    s.extra_rdoc_files = ['NEWS.rdoc']
+    s.rdoc_options << '--main' << 'NEWS.rdoc'
     s.files = PKG_FILES
     s.add_development_dependency('rspec', [">= 2.10.0"])
     s.add_development_dependency('haml')

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bindata
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 3
   prerelease: 
   segments: 
   - 1
-  - 4
   - 5
-  version: 1.4.5
+  - 0
+  version: 1.5.0
 platform: ruby
 authors: 
 - Dion Mendel
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-24 00:00:00 Z
+date: 2013-05-21 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -89,14 +89,14 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- NEWS
+- NEWS.rdoc
 files: 
-- ChangeLog
-- NEWS
+- NEWS.rdoc
 - COPYING
+- README.md
 - BSDL
-- README
 - Rakefile
+- ChangeLog.rdoc
 - INSTALL
 - examples/ip_address.rb
 - examples/list.rb
@@ -124,7 +124,6 @@ files:
 - spec/string_spec.rb
 - spec/base_spec.rb
 - spec/registry_spec.rb
-- spec/wrapper_spec.rb
 - spec/skip_spec.rb
 - spec/float_spec.rb
 - lib/bindata/count_bytes_remaining.rb
@@ -144,7 +143,6 @@ files:
 - lib/bindata/base_primitive.rb
 - lib/bindata/struct.rb
 - lib/bindata/bits.rb
-- lib/bindata/wrapper.rb
 - lib/bindata/offset.rb
 - lib/bindata/record.rb
 - lib/bindata/dsl.rb
@@ -161,13 +159,13 @@ files:
 - setup.rb
 - manual.haml
 - manual.md
-homepage: http://bindata.rubyforge.org
+homepage: http://github.com/dmendel/bindata
 licenses: []
 
 post_install_message: 
 rdoc_options: 
 - --main
-- NEWS
+- NEWS.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 

data/README

@@ -1,50 +0,0 @@
-= What is BinData?
-
-Do you ever find yourself writing code like this?
-
-  io = File.open(...)
-  len = io.read(2).unpack("v")
-  name = io.read(len)
-  width, height = io.read(8).unpack("VV")
-  puts "Rectangle #{name} is #{width} x #{height}"
-
-It’s ugly, violates DRY and feels like you’re writing Perl, not Ruby.
-
-There is a better way. Here’s how you’d write the above using BinData.
-
-  class Rectangle < BinData::Record
-    endian :little
-    uint16 :len
-    string :name, :read_length => :len
-    uint32 :width
-    uint32 :height
-  end
-
-  io = File.open(...)
-  r  = Rectangle.read(io)
-  puts "Rectangle #{r.name} is #{r.width} x #{r.height}"
-
-BinData makes it easy to create new data types. It supports all the common
-primitive datatypes that are found in structured binary data formats. Support
-for dependent and variable length fields is built in. 
-
-= Installation
-
-  $ sudo gem install bindata
-
-  -or-
-
-  $ sudo ruby setup.rb
-
-= Documentation
-
-  http://bindata.rubyforge.org/
-
-  -or-
-
-  $ rake manual
-
-= Contact
-
-If you have any queries / bug reports / suggestions, please contact me
-(Dion Mendel) via email at dion@lostrealm.com

data/lib/bindata/wrapper.rb

@@ -1,121 +0,0 @@
-require 'bindata/base'
-require 'bindata/dsl'
-
-module BinData
-  class SanitizedParameters < Hash
-    def move_unknown_parameters_to(dest)
-      unused_keys = keys - @the_class.accepted_parameters.all
-      unused_keys.each do |key|
-        dest[key] = delete(key)
-      end
-    end
-  end
-
-  # A Wrapper allows the creation of new BinData types that
-  # provide default parameters.
-  #
-  #   require 'bindata'
-  #
-  #   class Uint8Array < BinData::Wrapper
-  #     default_parameter :initial_element_value => 0
-  #
-  #     array :initial_length => 2 do
-  #       uint8 :initial_value => :initial_element_value
-  #     end
-  #   end
-  #
-  #   arr = Uint8Array.new
-  #   arr.snapshot #=> [0, 0]
-  #
-  #   arr = Uint8Array.new(:initial_length => 5, :initial_element_value => 3)
-  #   arr.snapshot #=> [3, 3, 3, 3 ,3]
-  #   
-  class Wrapper < BinData::Base
-    include DSLMixin
-
-    unregister_self
-    dsl_parser :wrapper
-
-    class << self
-      def sanitize_parameters!(params) #:nodoc:
-        raise "no wrapped type was specified in #{self}" if fields[0].nil?
-
-        wrapped_type = fields[0].type
-        wrapped_params = fields[0].params.dup
-
-        params.move_unknown_parameters_to(wrapped_params)
-
-        params.endian = endian unless endian.nil?
-        params[:wrapped] = params.create_sanitized_object_prototype(wrapped_type, wrapped_params)
-
-        wrapped_class = params[:wrapped].instance_variable_get(:@obj_class)
-        warn "BinData::Wrapper is deprecated as of BinData 1.3.2.  #{self} should derive from #{wrapped_class}\n   See http://bindata.rubyforge.org/#extending_existing_types"
-      end
-    end
-
-    mandatory_parameter :wrapped
-
-    def initialize_instance
-      prototype = get_parameter(:wrapped)
-      @wrapped = prototype.instantiate(nil, self)
-    end
-
-    def clear #:nodoc:
-      @wrapped.clear
-    end
-
-    def clear? #:nodoc:
-      @wrapped.clear?
-    end
-
-    def assign(val)
-      @wrapped.assign(val)
-    end
-
-    def snapshot
-      @wrapped.snapshot
-    end
-
-    def respond_to?(symbol, include_private = false) #:nodoc:
-      @wrapped.respond_to?(symbol, include_private) || super
-    end
-
-    def method_missing(symbol, *args, &block) #:nodoc:
-      @wrapped.__send__(symbol, *args, &block)
-    end
-
-    def do_read(io) #:nodoc:
-      @wrapped.do_read(io)
-    end
-
-    def do_write(io) #:nodoc
-      @wrapped.do_write(io)
-    end
-
-    def do_num_bytes #:nodoc:
-      @wrapped.do_num_bytes
-    end
-
-    #---------------
-    private
-
-    def extract_args(args)
-      klass = wrapped_class
-      if klass
-        klass.arg_extractor.extract(klass, args)
-      else
-        super
-      end
-    end
-
-    def wrapped_class
-      return nil if self.class.fields[0].nil?
-
-      begin
-        RegisteredClasses.lookup(self.class.fields[0].type, self.class.endian)
-      rescue BinData::UnRegisteredTypeError
-        nil
-      end
-    end
-  end
-end

data/spec/wrapper_spec.rb

@@ -1,185 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_common"))
-require 'bindata'
-
-describe BinData::Wrapper do
-  it "is not registered" do
-    expect {
-      BinData::RegisteredClasses.lookup("Wrapper")
-    }.to raise_error(BinData::UnRegisteredTypeError)
-  end
-end
-
-describe BinData::Wrapper, "with errors" do
-  it "does not wrap more than one type" do
-    lambda {
-      class WrappedMultipleTypes < BinData::Wrapper
-        uint8
-        uint8
-      end
-    }.should raise_error_on_line(SyntaxError, 3) { |err|
-      err.message.should == "attempting to wrap more than one type in #{WrappedMultipleTypes}"
-    }
-  end
-
-  it "fails if wrapped type has a name" do
-    lambda {
-      class WrappedWithName < BinData::Wrapper
-        uint8 :a
-      end
-    }.should raise_error_on_line(SyntaxError, 2) { |err|
-      err.message.should == "field must not have a name in #{WrappedWithName}"
-    }
-  end
-
-  it "fails if no types to wrap" do
-    class WrappedNoTypes < BinData::Wrapper
-    end
-
-    lambda {
-      WrappedNoTypes.new
-    }.should raise_error(RuntimeError) { |err|
-      err.message.should == "no wrapped type was specified in #{WrappedNoTypes}"
-    }
-  end
-end
-
-describe BinData::Wrapper, "around a Primitive" do
-  class WrappedPrimitive < BinData::Wrapper
-    default_parameter :a => 3
-
-    uint8 :initial_value => :a
-  end
-
-  it "accesses custom parameter" do
-    subject = WrappedPrimitive.new
-    subject.assign(3)
-    subject.should == 3
-  end
-
-  it "overrides custom default parameter" do
-    subject = WrappedPrimitive.new(:a => 5)
-    subject.should == 5
-  end
-
-  it "overrides parameter" do
-    subject = WrappedPrimitive.new(:initial_value => 7)
-    subject.should == 7
-  end
-
-  it "clears" do
-    subject = WrappedPrimitive.new
-    subject.assign(3)
-    subject.should_not be_clear
-
-    subject.clear
-    subject.should be_clear
-  end
-
-  it "reads" do
-    subject = WrappedPrimitive.new
-    subject.assign(3)
-    str = subject.to_binary_s
-
-    WrappedPrimitive.read(str).should == 3
-  end
-
-  it "respond_to and forward messages to the wrapped object" do
-    subject = WrappedPrimitive.new
-    subject.assign(5)
-
-    subject.should respond_to(:to_int)
-    subject.to_int.should == 5
-  end
-end
-
-describe BinData::Wrapper, "around an Array" do
-  class WrappedIntArray < BinData::Wrapper
-    endian :big
-    default_parameter :initial_element_value => 0
-    array do
-      uint16 :initial_value => :initial_element_value
-    end
-  end
-
-  it "forwards parameters" do
-    subject = WrappedIntArray.new(:initial_length => 7)
-    subject.length.should == 7
-  end
-
-  it "overrides default parameters" do
-    subject = WrappedIntArray.new(:initial_length => 3, :initial_element_value => 5)
-    subject.to_binary_s.should == "\x00\x05\x00\x05\x00\x05"
-  end
-end
-
-describe BinData::Wrapper, "around a Choice" do
-  class WrappedChoice < BinData::Wrapper
-    endian :big
-    choice :choices => { 'a' => :uint8, 'b' => :uint16 }
-  end
-
-  it "forwards parameters" do
-    subject = WrappedChoice.new(:selection => 'b')
-    subject.num_bytes.should == 2
-  end
-end
-
-describe BinData::Wrapper, "inside a Record" do
-  class WrappedUint32le < BinData::Wrapper
-    uint32le
-  end
-
-  class RecordWithWrapped < BinData::Record
-    wrapped_uint32le :a, :onlyif => false, :value => 1
-    wrapped_uint32le :b, :onlyif => true,  :value => 2
-  end
-
-  it "handles onlyif" do
-    subject = RecordWithWrapped.new
-    subject.should == {'b' => 2}
-  end
-end
-
-describe BinData::Wrapper, "around a Record" do
-  class RecordToBeWrapped < BinData::Record
-    default_parameter :arg => 3
-    uint8 :a, :initial_value => :arg
-    uint8 :b
-  end
-
-  class WrappedRecord < BinData::Wrapper
-    record_to_be_wrapped
-  end
-
-  it "forwards parameters" do
-    subject = WrappedRecord.new(:arg => 5)
-    subject.a.should == 5
-  end
-
-  it "assigns value" do
-    subject = WrappedRecord.new(:b => 5)
-    subject.b.should == 5
-  end
-
-  it "assigns value and forward parameters" do
-    subject = WrappedRecord.new({:b => 5}, :arg => 7)
-    subject.a.should == 7
-    subject.b.should == 5
-  end
-end
-
-describe BinData::Wrapper, "derived classes" do
-  class ParentDerivedWrapper < BinData::Wrapper
-    uint32le
-  end
-
-  class ChildDerivedWrapper < ParentDerivedWrapper
-  end
-
-  it "wraps" do
-    a = ChildDerivedWrapper.new
-    a.num_bytes.should == 4
-  end
-end