binaryparse 0.1.6 → 0.2.0

data/lib/blocker.rb

@@ -6,10 +6,11 @@
 # (BinaryBlocker::PackedNumberEncoder) and date fields 
 # (BinaryBlocker::PackedDateEncoder) 
 
-# Todo
-# Allow nil/blanks by default
+begin
+  require 'uconv'
+rescue LoadError
+end
 
-require 'uconv'
 require 'date'
 require 'time'
 
@@ -221,20 +222,44 @@ module BinaryBlocker
   # here. 
   class GroupEncoder < Encoder
     class << self
+      def attributes
+        @attributes
+      end
+      
+      def attributes=(a)
+        @attributes=a
+      end
+      
+      def lookup
+        @lookup
+      end
+      
+      def lookup=(l)
+        @lookup=l
+      end
+
+      def klasses
+        @klasses
+      end
+      
+      def klasses=(k)
+        @klasses = k
+      end
+            
       def inherited(obj)
         obj.instance_eval do
-          @klasses = BinaryBlocker.klasses.clone
-          @attributes = []
-          @lookup = {}
+          self.klasses = self.klasses || BinaryBlocker.klasses.clone
+          self.attributes = self.attributes || []
+          self.lookup = self.lookup || {}
         end
         super
       end
 
       # One and only one (this is the easiest :-)
       def has_one(sym, klass, *opts) 
-        klass = @klasses[klass] if @klasses[klass]
-        @lookup[sym] = @attributes.size
-        @attributes << lambda { klass.new(*opts) }
+        klass = self.klasses[klass] if self.klasses[klass]
+        self.lookup[sym] = self.attributes.size
+        self.attributes << lambda { klass.new(*opts) }
       end
       
       def include_klasses(klasses, *opts)
@@ -250,31 +275,31 @@ module BinaryBlocker
       
       def has_one_of(sym, klasses, *opts)
         klasses = include_klasses(klasses, *opts) 
-        @lookup[sym] = @attributes.size 
-        @attributes << lambda { OneOfEncoder.new(klasses, *opts) }
+        self.lookup[sym] = self.attributes.size 
+        self.attributes << lambda { OneOfEncoder.new(klasses, *opts) }
       end
 
       def has_counted_array(sym, count_type, klasses, *opts)
         klasses = include_klasses(klasses, *opts)
-        @lookup[sym] = @attributes.size 
-        @attributes << lambda { CountedArrayEncoder.new(count_type, klasses, *opts) }
+        self.lookup[sym] = self.attributes.size 
+        self.attributes << lambda { CountedArrayEncoder.new(count_type, klasses, *opts) }
       end
       
       def has_fixed_array(sym, count, klasses, *opts)
         klasses = include_klasses(klasses, *opts)
-        @lookup[sym] = @attributes.size 
-        @attributes << lambda { FixedArrayEncoder.new(count, klasses, *opts) }
+        self.lookup[sym] = self.attributes.size 
+        self.attributes << lambda { FixedArrayEncoder.new(count, klasses, *opts) }
       end
 
       def has_bit_field(sym, type, bit_info, *opts)
-        @lookup[sym] = @attributes.size
-        @attributes << lambda { BitFieldEncoder.new(type, bit_info, *opts) }
+        self.lookup[sym] = self.attributes.size
+        self.attributes << lambda { BitFieldEncoder.new(type, bit_info, *opts) }
       end
           
        def has_list_of(sym, klasses, *opts)
         klasses = include_klasses(klasses, *opts)
-        @lookup[sym] = @attributes.size 
-        @attributes << lambda { ListOfEncoder.new(klasses, *opts) }
+        self.lookup[sym] = self.attributes.size 
+        self.attributes << lambda { ListOfEncoder.new(klasses, *opts) }
       end
       
       def register_klass(sym, klass)
@@ -285,14 +310,6 @@ module BinaryBlocker
       def clear_registered_klasses
         @klasses = {}
       end
-      
-      def attributes
-        @attributes
-      end
-      
-      def lookup
-        @lookup
-      end
     end
     
     def initialize(*opts)
@@ -302,7 +319,9 @@ module BinaryBlocker
     end 
     
     def block
-      @value.inject("") { |a,b| a + b.block }
+      @value.inject("") do |a,b|
+        a + b.block 
+      end
     end
     
     def deblock(io)
@@ -408,6 +427,7 @@ module BinaryBlocker
       
       initialize_data(*opts)
     end
+    
   end
   BinaryBlocker.register_klass(:string, FixedStringEncoder)
   
@@ -572,7 +592,11 @@ module BinaryBlocker
     end
     
     def internal_block(val)
-      val.block if val
+      if val
+        val.block
+      else
+        @classes.first.block
+      end
     end
     
     def internal_deblock(io)

data/test/test_blocker.rb

@@ -440,6 +440,43 @@ class TestBlocker < Test::Unit::TestCase
     assert_nil(t2.t)
   end
   
+  class BBPackNumRecord < BinaryBlocker::Blocker
+    has_one :p, :packed, :length => 2
+  end
+  
+  def test_null_packed
+    t = BBPackNumRecord.new
+    assert(buf = t.block)
+
+    t2 = BBPackNumRecord.new(buf)
+    assert(t2)
+    assert_equal(0, t2.p)
+  end
+  
+  def test_big_packed
+    t = BBPackNumRecord.new
+    t.p = 200
+    assert(buf = t.block)
+    assert_equal(1, buf.size)
+
+    t2 = BBPackNumRecord.new(buf)
+    assert(t2)
+    assert(t2.p < 100)
+  end
+  
+  class Filler < BinaryBlocker::Blocker
+    has_one :f, :uint8
+  end
+  
+  class NullFillerTest < BinaryBlocker::Blocker
+    has_fixed_array :fooboo, 3, [Filler]
+  end
+  
+  def test_null_filler
+    t = NullFillerTest.new
+    assert(buf = t.block)
+  end
+  
   class BBSpaceString < BinaryBlocker::Blocker
     has_one :name, :sstring, :length => 10 
     has_one :last, :string, :length => 5
@@ -451,4 +488,14 @@ class TestBlocker < Test::Unit::TestCase
     assert(ss)
     assert_equal("Name", ss.name)
   end  
+  
+  class BBSubClass < BBSpaceString
+  end
+  
+  def test_subclass
+    buf = "Name      Last "
+    ss = BBSubClass.new(buf)
+    assert(ss)
+    #assert_equal("Name", ss.name)
+  end  
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: binaryparse
 version: !ruby/object:Gem::Version 
-  version: 0.1.6
-date: 2006-09-14 00:00:00 -04:00
+  version: 0.2.0
+date: 2006-09-30 00:00:00 -04: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
@@ -15,7 +15,7 @@ description: Binaryparse is a simple Ruby DSL to parse semi-complicated binary s
 autorequire: binaryparse
 default_executable: 
 bindir: bin
-has_rdoc: false
+has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
   - - ">"
@@ -29,16 +29,12 @@ post_install_message:
 authors: 
 - Patrick Hurley
 files: 
-- binaryparse.gemspec
-- examples
-- lib
-- test
+- test/test_blocker.rb
+- lib/buffered_io.rb
+- lib/blocker.rb
 - examples/cmasqls.rb
-- examples/readme.txt
 - examples/voter.rb
-- lib/blocker.rb
-- lib/buffered_io.rb
-- test/test_blocker.rb
+- examples/readme.txt
 test_files: []
 
 rdoc_options: []

data/binaryparse.gemspec

@@ -1,19 +0,0 @@
-require 'rubygems'
-
-spec = Gem::Specification.new do |s|
-  s.name = "binaryparse"
-  s.version = "0.1.6"
-  s.author = "Patrick Hurley"
-  s.email = "phurley@gmail.com"
-  s.homepage = "http://binaryparse.rubyforge.org/"
-  s.platform = Gem::Platform::RUBY
-  s.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."
-  s.description = "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."
-  s.files = Dir["**/*"]
-  s.autorequire = "binaryparse"
-end
-
-if  __FILE__ == $PROGRAM_NAME
-  Gem::manage_gems
-  Gem::Builder.new(spec).build
-end