binaryparse 0.2.7 → 0.3.3

data/lib/blocker.rb

@@ -325,7 +325,7 @@ module BinaryBlocker
         if o.respond_to? :to_hash
           o.keys.each do |key|
             if pos = @lookup[key.to_sym]
-              unless @value[pos].key_value?
+              unless @value[pos].respond_to?(:key_value?) && @value[pos].key_value?
                 @value[pos].value = o[key]
               end
             end
@@ -333,6 +333,19 @@ module BinaryBlocker
         end
       end                
     end 
+   
+    alias :orig_clone :clone
+    def clone
+      new_me = orig_clone
+      new_val = self.class.attributes.map { |a| a.call }
+      new_val.each_with_index do |v,i|
+        v.value = @value[i].value
+      end
+      new_me.instance_eval do
+        @value = new_val
+      end
+      new_me
+    end
     
     def block
       @value.inject("") do |a,b|
@@ -377,7 +390,9 @@ module BinaryBlocker
     end
     
     def value=(val)
-      raise "Now what?"
+      @lookup.keys.each do |key|
+        @value[@lookup[key]].value = val.send(key)
+      end
     end    
     
     def valid?
@@ -456,7 +471,15 @@ module BinaryBlocker
     
   end
   BinaryBlocker.register_klass(:string, FixedStringEncoder)
-  
+ 
+  class ByteStringEncoder < FixedStringEncoder
+	  def initialize(*opts)
+		  super
+		  @format = "a#{@length}"
+		end
+	end
+  BinaryBlocker.register_klass(:bytes, ByteStringEncoder)
+
   class SpacedStringEncoder < SimpleEncoder
     def initialize(*opts)
       @value = ''
@@ -794,6 +817,35 @@ module BinaryBlocker
       end 
     end
     
+    def to_h
+      result = []
+			@value.each do |value|
+        value = value.to_h if value.respond_to? :to_h
+				result << value
+      end    
+      result
+    end
+        
+	  def clone
+		  result = orig_clone
+		end
+
+		def size
+			@count
+		end
+
+		def value
+			self
+		end
+
+		def value=(newval)
+			raise RangeError.new("Array size mismatch") unless newval.size == @count
+      @count.times do |i|			
+				@value[i] = newval[i]
+			end
+			newval
+		end
+
     def [](offset)
       raise RangeError.new("Access (#{offset}) out of range (#{@count})") unless (0...@count) === offset
       @value[offset]
@@ -813,7 +865,11 @@ module BinaryBlocker
       @value = []
       initialize_data(*opts)
     end
-    
+
+    def value=(other)
+      @value = other.value.clone
+    end
+        
     def internal_block(val)
       val.inject("") { |r, o| r + o.block }
     end

data/test/test_blocker.rb

@@ -518,4 +518,64 @@ class TestBlocker < Test::Unit::TestCase
     assert_equal(now, b2.now)
   end
 
+  def test_clone
+    bb = BBTest1.new
+    bb.foo = 32
+    bb.bar = 24
+    
+    assert_equal(32, bb.foo)
+    assert_equal(24, bb.bar)
+    
+    b2 = bb.clone
+    assert_equal(32, b2.foo)
+    assert_equal(24, b2.bar)
+    
+    b2.foo = 42
+    assert_equal(42, b2.foo)
+    assert_equal(32, bb.foo)
+  end
+
+  def test_clone_some_more
+    bb = BBList.new
+    bb.header = 13
+    bb.footer = 42
+    
+    ia = ItemA.new
+    ib = ItemB.new
+    ib.name = 'widget B'
+    bb.items << ia << ib
+
+    b2 = bb.clone
+    assert(13, b2.header)
+    b2.header = 21
+    assert(21, b2.header)
+    assert(13, bb.header)    
+  end
+
+  class Nested < BinaryBlocker::Blocker
+    has_one :name, :string, :length => 20
+  end
+
+  class Parent < BinaryBlocker::Blocker
+    has_one :rtype, :string, :length => 10
+    has_one :nest, Nested
+    has_one :footer, :string, :length => 10
+  end
+
+  def test_clone_has_one
+    p = Parent.new
+    p.rtype = 'foo'
+    p.nest.name = 'bar'
+    p.footer = 'end'
+
+    assert_equal('foo', p.rtype)
+    assert_equal('bar', p.nest.name)
+    assert_equal('end', p.footer)
+
+    p2 = p.clone
+    assert_equal('foo', p2.rtype)
+    assert_equal('bar', p2.nest.name)
+    assert_equal('end', p2.footer)
+
+  end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: binaryparse
 version: !ruby/object:Gem::Version 
-  version: 0.2.7
-date: 2006-12-13 00:00:00 -05:00
+  version: 0.3.3
+date: 2006-12-20 00:00:00 -05:00
 summary: Binaryparse is a simple Ruby DSL to parse semi-complicated binary structures. This includes structures dynamic in length, which cannot be handled by DL::Struct or BitStructEx.
 require_paths: 
 - lib