struct_packing 0.0.2 → 0.0.3

data/History.txt

@@ -2,3 +2,17 @@
 
 * 1 major enhancement:
   * Initial release
+
+=== 0.0.2 2013-02-17
+
+* 3 major enhancement:
+  * Support array type.
+  * Use jeweler for gem build.
+  * A lot of BUG FIX.
+
+=== 0.0.2 2013-03-02
+
+* 2 major enhancement:
+  * Support struct.
+  * Support hash-style field access.
+  * Some BUG FIX.

data/Rakefile

@@ -48,6 +48,7 @@ Rake::RDocTask.new do |rdoc|
 
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title = "struct_packing #{version}"
-  rdoc.rdoc_files.include('README*')
+  rdoc.main = "README.rdoc"
+  rdoc.rdoc_files.include('*.rdoc')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/struct_packing.rb

@@ -11,7 +11,7 @@ $:.unshift(File.dirname(__FILE__)) unless
 # and the class and instances can packing or unpacking by these methods.
 module StructPacking
   # Gem version.
-  VERSION = '0.0.1'
+  VERSION = '0.0.3'
 end
 
 require 'struct_packing/base'

data/lib/struct_packing/base.rb

@@ -10,30 +10,36 @@ module StructPacking
     
     def self.included(base)
       base.extend ClassMethods
+      base.attr_mapped_struct
+      
+      base.instance_eval { @selfclass = base }
+      base.instance_eval { def selfclass ; @selfclass ; end }
+    end
+    
+    protected
+
+    # get self class or eign class.
+    def selfclass
+      if defined?(self.class.selfclass)
+        self.class.selfclass
+      else
+        eign = (class << self; self ; end)
+        eign.selfclass
+      end
     end
-  
-    public
     
     # Get structure format string used in packing this object.
     #
     # This method work as just wrapper to same name class-method. 
     def internal_format
-      self.class.internal_format
-    end
-
-    # Get field name list of this class.
-    def field_names
-      self.class.field_names
-    end
-
-    # Get field type list of this class.
-    def field_types
-      self.class.field_types
+      selfclass.send(:internal_format)
     end
+    
+    public
 
-    # Get Ruby's pack tenplate string for this class.
+    # Get Ruby's pack template string for this class.
     def pack_template
-      self.class.pack_template
+      selfclass.pack_template
     end
     
     # Common extending methods for Packable and Unpackable.
@@ -42,49 +48,101 @@ module StructPacking
     module ClassMethods
       
       private
-
-      # TODO temporary initializer for @@struct_internal_format
-      def check_vardef
-        if not self.class_variable_defined?(:@@struct_internal_format)
-          class_eval("@@struct_internal_format = ''")
+      
+      def self.extended(base)
+        base.class_eval do
+          begin
+            @struct_field_getter = superclass.class_eval { @struct_field_getter }
+          rescue
+            @struct_field_getter = nil
+          end
+          begin
+            @struct_field_setter = superclass.class_eval { @struct_field_setter }
+          rescue
+            @struct_field_setter = nil
+          end
+          begin
+            @struct_internal_format = superclass.class_eval { @struct_internal_format }
+            if @struct_internal_format == nil
+              @struct_internal_format = ""
+            end
+          rescue
+            @struct_internal_format = ""
+          end
         end
       end
       
-      public
+      protected
 
       # Get internal structure format used to pack a object of this class.
       def internal_format
-        check_vardef # TODO Find more good way!
-        
-        Util.internal_format_from( self.class_variable_get(:@@struct_internal_format) )
+        Util.internal_format_from( @struct_internal_format)
       end
+  
+      public
       
       # Set structure format for this class by string.
       def byte_format=(text)
-        check_vardef # TODO Find more good way!
-        
-        self.class_variable_set(:@@struct_internal_format, text)
+        @struct_internal_format = text
 
         true
       end
 
-      # Get field name list of this class.
-      def field_names
-        internal_format.keys
+      public
+      
+      # Get Ruby's pack template string for this class.
+      def pack_template
+        if self.to_s =~ /^.*<(.*):0x.*/
+          clsname = $1
+        else
+          clsname = self.to_s
+        end
+        
+        Util.pack_template_from( @struct_internal_format, clsname )
       end
-
-      # Get field type list of this class.
-      def field_types
-        internal_format.values
+    
+      # Call getter procedure to get field of target object.
+      def get_field_value(obj, name)
+        begin
+          @struct_field_getter.call(obj, name)
+        rescue
+          0
+        end
+      end
+            
+      # Call setter procedure to set value to the field of target object.
+      def set_field_value(obj, name, value)
+        begin
+          @struct_field_setter.call(obj, name, value)
+        rescue
+        end
       end
 
-      # Get Ruby's pack tenplate string for this class.
-      def pack_template
-        check_vardef # TODO Find more good way!
-
-        Util.pack_template_from( self.class_variable_get(:@@struct_internal_format) )
+      # Set gettter procedure.
+      def set_field_getter(&block)
+        @struct_field_getter = block
+      end
+      
+      # Set settter procedure.
+      def set_field_setter(&block)
+        @struct_field_setter = block
+      end
+      
+      # Declare this struct as accessible by hash-style-access(access by [] operator).
+      def hash_mapped_struct
+        set_field_getter {|obj, name| obj[name.to_sym] }
+        set_field_setter {|obj, name, value| obj[name.to_sym] = value }
+      end
+      
+      # Declare this struct as accessible by attr-style-access(access by {name}= operator).
+      # This is default behavior.
+      def attr_mapped_struct
+        set_field_getter {|obj, name| obj.send(name) }
+        set_field_setter {|obj, name, value| obj.send("#{name}=", value) }
       end
 
+      alias :define_struct :byte_format=
+      
     end
   end
   

data/lib/struct_packing/packable.rb

@@ -23,25 +23,45 @@ module StructPacking
     include Base
     
     def self.included(base)
-      base.send("include", Base)
+      base.send(:include, Base)
     end
     
-    public
+    def value_or_zero(&block)
+      begin
+        instance_eval &block
+      rescue
+        0
+      end
+    end
+    
+    protected
+    
+    def struct_values
+      internal_format.collect do |name, type|
+        if type =~ /^struct\s*\w*\s*(?:\s*\[(\d+)\s*\])?\s*$/
+          arynum = $1
+          if $1 == nil
+            value_or_zero { send(:selfclass).get_field_value(self, name).struct_values }
+          else
+            (0..(arynum.to_i-1)).each.collect do |i|
+              value_or_zero { send(:selfclass).get_field_value(self, name)[i].struct_values }
+            end
+          end
+        else
+          value_or_zero { send(:selfclass).get_field_value(self, name) }
+        end
+      end
+    end
 
+    public
+  
     # Pack this object to byte array.
     #
     # If attribute defined in byte_format, 
     # but object has no attr_getter, treat as the attribute is zero.
     def pack()
-      values = field_names.collect do |n|
-        begin
-          instance_eval { send(n) }
-        rescue NoMethodError
-          0
-        end
-      end
+      values = struct_values
       values.flatten!
-
       values.pack( pack_template )
     end
       

data/lib/struct_packing/unpackable.rb

@@ -12,7 +12,7 @@ module StructPacking
     private
 
     def self.included(base)
-      base.send("include", Base)
+      base.send(:include, Base)
       base.extend ClassMethods
     end
   
@@ -37,32 +37,92 @@ module StructPacking
       
       alias :from_data :unpack
 
+      protected
+      
+      
+      # Instantiate and initialize object by value-array.
+      def from_values(values)
+        obj = self.new
+        set_values_from_values_to_object(values, obj)
+      end
+      
       private
 
       def set_values_from_byte_to_object(bytes, obj)
-        
         values = bytes.unpack( pack_template )
+        set_values_from_values_to_object(values, obj)
+      end
+     
+      # Get field name list of this class.
+      def field_names
+        internal_format.keys
+      end
 
+      def set_values_from_values_to_object(values, obj)
+        
         field_names.zip(gather_array_field(values) ).each do |name,value|
           begin
-            obj.instance_eval {
-              send("#{name}=", value)
-            }
+            obj.send(:selfclass).set_field_value(obj, name, value)
           rescue NoMethodError
           end
         end
         obj
       end
-      
-      def gather_array_field(values)
-        field_types.collect do |name|
-          if name =~ /.*\[\w*(\d+)\w*\]\w*/
+     
+      def gather_array_field(value_array)
+        values = value_array.dup
+        
+        internal_format.collect do |name, type|
+
+          if type =~ /^struct\s*(\w*)\s*(?:\s*\[(\d+)\s*\])?\s*$/
+            struct_name = $1
+            arylen = $2
+            cls = Util.find_hier_mod(self, struct_name)
+            if arylen == nil
+              obj = cls.from_values( values[0, cls.send(:num_of_value)] )
+              values = values[cls.send(:num_of_value), values.length]
+            else
+              obj = []
+              
+              arylen.to_i.times do 
+                obj.push( cls.from_values( values[0, cls.send(:num_of_value)] ) )
+                values = values[cls.send(:num_of_value), values.length]
+              end
+            end
+            
+            obj
+          elsif type =~ /.*\[\w*(\d+)\w*\]\w*/
             [0..$1.to_i].to_a.collect { values.shift }
           else
             values.shift
           end
         end
       end
+      
+      def num_of_value
+        
+        nums = internal_format.collect do |name, type|
+          if type =~ /^struct\s*(\w*)\s*(?:\s*\[(\d+)\s*\])?\s*$/
+            struct_name = $1
+            arylen = $2
+            cls = Util.find_hier_mod(self, struct_name)
+            
+            if arylen == nil
+              cls.num_of_value
+            else
+              cls.num_of_value * arylen.to_i
+            end
+          else
+            1
+          end
+        end
+        
+        nums.inject(0) do |sum, num|
+          sum + num
+        end
+            
+      end
+      
     end
     
     public

data/lib/struct_packing/util.rb

@@ -7,16 +7,37 @@ module StructPacking
   class Util
 
     private
+    
+    def self.struct_template(type, arraylen, mod=nil)
+      type =~ /struct\s*(\w*)\s*/
 
-    def self.parse_ctype_decl(decl)
-      decl =~ /^\s*(unsigned|signed)?\s*(ascii|utf8|byte|char|short|(?:u?int)(?:(?:8|16|32|64)_t)?|(?:big|little)?(?:16|32)|(?:big|little)?\s*(?:float|double)?|long(?:\s*long))\s*(?:\[\s*(\d+)\s*\])?\s*$/
+      if arraylen != ""
+        find_hier_mod(mod, $1).pack_template * arraylen.to_i
+      else
+        find_hier_mod(mod, $1).pack_template
+      end
+      
+    end
+
+    def self.parse_ctype_decl(decl, mod=nil)
+      decl =~ /^\s*(unsigned|signed)?\s*(ascii|utf8|byte|char|short|(?:u?int)(?:(?:8|16|32|64)_t)?|(?:big|little)?(?:16|32)|(?:big|little)?\s*(?:float|double)?|long(?:\s*long)|struct\s*\w*)\s*([\s\*]*)\s*(?:\[\s*(\d+)\s*\])?\s*$/
+
+      sign = !("unsigned" == $1) #sign modifier
+      type = $2
+      ptr = $3
+      arraylen = $4
 
-      sign = !("unsigned" == $1)
-      template = template_of(sign, $2)
-      if $3 != nil and $3 == "1"
-        template += $3
+      if arraylen == nil or arraylen == "1"
+        arraylen = ""
+      end
+      
+      if ptr != nil and ptr != "" #pointer operator
+        'P' + arraylen
+      elsif "struct" == type[0..5]
+        struct_template(type, arraylen, mod)
+      else
+        template_of(sign, type) + arraylen
       end
-      template
     end
 
     def self.template_of(sign, type)
@@ -82,15 +103,33 @@ module StructPacking
       end      
     end
 
-    def self.types_to_template(types)
-      types.collect {|t| parse_ctype_decl(t)}.join
+    def self.types_to_template(types, mod=nil)
+      types.collect {|t| parse_ctype_decl(t,mod)}.join
     end
 
+    
+    def self.find_hier_mod(context_mod, sym)
+      nesthier = context_mod.to_s.split("::")
+    
+      parent = Kernel
+      mods = nesthier.collect {|m| x = parent.const_get(m); parent = x; x }
+      mods.unshift Kernel
+    
+      finded = mods.reverse.collect {|m| m.const_defined?(sym) ? m.const_get(sym) : nil }
+      targetmod = finded.select {|f| f != nil }.first
+    
+      if targetmod == nil
+        raise NameError
+      end
+      targetmod
+    end
+  
+    
     public
     # Parse declaration string into pack template.
-    def self.pack_template_from(text)
+    def self.pack_template_from(text,mod=nil)
       internal = internal_format_from(text)
-      types_to_template(internal.values)
+      types_to_template(internal.values,mod)
     end
 
     # Parse declaration string into internal format.

data/struct_packing.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "struct_packing"
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["TOKITA Hiroshi"]
-  s.date = "2013-02-16"
+  s.date = "2013-03-02"
   s.description = "* Read/Write ruby object to byte array with C-like struct declarations."
   s.email = ["tokita.hiroshi@gmail.com"]
   s.extra_rdoc_files = [

data/test/struct_packing/test_base.rb

@@ -13,7 +13,7 @@ class TestBase < Test::Unit::TestCase
   
   def test_null_internal_format
     obj = ClassIncludeOnly.new
-    assert_equal({}, obj.internal_format())
+    assert_equal({}, obj.send(:internal_format) )
   end
   
 
@@ -23,7 +23,7 @@ class TestBase < Test::Unit::TestCase
   end
   
   def test_single_int_internal_format
-    assert_equal("int" , SingleIntStruct.internal_format[:hoge])
+    assert_equal("int" , SingleIntStruct.send(:internal_format)[:hoge])
   end
 
   class MultiFieldStruct
@@ -32,17 +32,45 @@ class TestBase < Test::Unit::TestCase
   end
 
   def test_multi_field_internal_format
-    assert_equal("int" , MultiFieldStruct.internal_format[:fuga])
-    assert_equal("char" , MultiFieldStruct.internal_format[:piyo])
+    assert_equal("int" , MultiFieldStruct.send(:internal_format)[:fuga])
+    assert_equal("char" , MultiFieldStruct.send(:internal_format)[:piyo])
+  end
+  
+  def test_class_macro
+    eval <<-EOF
+      class TestClassMacro
+        include StructPacking::Base
+        define_struct "int foo;"
+      end
+    EOF
+    
+    assert_equal({:foo=>"int"}, TestClassMacro.send(:internal_format) )
   end
 
-=begin
+  class NotModifiableFormat
+    include StructPacking::Base
+    self.byte_format = "int xxx;"
+  end
+  
   def test_internal_format_not_modifiable
-    assert_equal(4, (SingleIntStruct.internal_format[:hoge])[:size])
-    (SingleIntStruct.internal_format[:hoge])[:size] = 8
-    assert_equal(8, (SingleIntStruct.internal_format[:hoge])[:size])
-    assert_equal({:type=>"int", :start=>0, :size=>4} , SingleIntStruct.internal_format[:hoge])
+    assert_equal("int", NotModifiableFormat.send(:internal_format)[:xxx])
+    SingleIntStruct.send(:internal_format)[:xxx] = "byte"
+    assert_equal("int", (NotModifiableFormat.send(:internal_format)[:xxx]))
+  end
+  
+  class InnerModuleClass
+    include StructPacking::Base
+    self.byte_format = "int inner; char mod;"
+  end
+  
+  class InnerModuleTest
+    include StructPacking::Base
+    self.byte_format =  "struct InnerModuleClass imc;"
   end
-=end 
+  
+  def test_inner_struct_class
+    assert_equal("ic", InnerModuleTest.pack_template)
+  end
+  
   
 end

data/test/struct_packing/test_packable.rb

@@ -22,6 +22,7 @@ class TestPackable < Test::Unit::TestCase
   end
 
   class ClsInt < ClsIntNoAttr
+    include TEST_MOD
     attr_accessor :packtestint
   end
 
@@ -42,6 +43,7 @@ class TestPackable < Test::Unit::TestCase
   end
 
   class ClsChar < ClsCharNoAttr
+    include TEST_MOD
     attr_accessor :packtestchar
   end
 
@@ -85,5 +87,59 @@ class TestPackable < Test::Unit::TestCase
     
     assert_equal([1, 0, 0, 0, 2, 0, 0, 0, 8].pack("C*"), ba)
   end
+  
+  class ClsNested < OpenStruct
+    include TEST_MOD
+    self.byte_format = "int ho; char ge;"
+  end
+  
+  class ClsNesting < OpenStruct
+    include TEST_MOD
+    self.byte_format = "struct ClsNested nst;"
+  end
+
+  def test_struct
+    obj = ClsNesting.new
+    nst = ClsNested.new
+    obj.nst = nst
+    obj.nst.ho = 1
+    obj.nst.ge = 10
+
+    assert_equal([1,0,0,0, 10].pack("C*"), obj.pack )
+  end
+  
+  class ClsArray < OpenStruct
+    include TEST_MOD
+    self.byte_format = "struct ClsNested ary[2];"
+  end
+  
+  def test_struct_array
+    obj = ClsArray.new
+
+    nst1 = ClsNested.new
+    nst1.ho = 1
+    nst1.ge = 10
+    nst2 = ClsNested.new
+    nst2.ho = 2
+    nst2.ge = 20
+    obj.ary = [nst1, nst2]
+    
+    assert_equal([1,0,0,0,10,2,0,0,0,20].pack("C*"), obj.pack )
+  end
+  
+  class HashMapped < Hash
+    include TEST_MOD
+    define_struct "int hashhoge; char hashfuga;"
+    hash_mapped_struct
+  end
+
+  def test_hash_struct
+    obj = HashMapped.new
 
+    obj[:hashhoge] = 1
+    obj[:hashfuga] = 2
+    
+    assert_equal([1,0,0,0,2].pack("C*"), obj.pack)
+  end
+  
 end

data/test/struct_packing/test_unpackable.rb

@@ -24,6 +24,7 @@ class TestUnpackable < Test::Unit::TestCase
   end
 
   class ClsInt < ClsIntNoAttr
+    include TEST_MOD
     attr_accessor :packtestint
   end
 
@@ -45,6 +46,7 @@ class TestUnpackable < Test::Unit::TestCase
   end
 
   class ClsChar < ClsCharNoAttr
+    include TEST_MOD
     attr_accessor :packtestchar
   end
 
@@ -83,5 +85,50 @@ class TestUnpackable < Test::Unit::TestCase
     assert_equal(2, ud.fuga)
     assert_equal([8], ud.piyo)
   end
+  
+  class ClsNested < OpenStruct
+    include TEST_MOD
+    self.byte_format = "int ho; char ge;"
+  end
+  
+  class ClsNesting < OpenStruct
+    include TEST_MOD
+    self.byte_format = "struct ClsNested nst;"
+  end
+
+  def test_struct
+    obj = ClsNesting.from_data([1,0,0,0, 10].pack("C*"))
+    assert_equal(1, obj.nst.ho)
+    assert_equal(10, obj.nst.ge)
+  end
+  
+  class ClsArray < OpenStruct
+    include TEST_MOD
+    self.byte_format = "struct ClsNested ary[2];"
+  end
+  
+  def test_struct_array
+    obj = ClsArray.from_data([1,0,0,0,10,2,0,0,0,20].pack("C*"))
+
+    assert_equal(1, obj.ary[0].ho)
+    assert_equal(10, obj.ary[0].ge)
+    assert_equal(2, obj.ary[1].ho)
+    assert_equal(20, obj.ary[1].ge)
+    
+  end
+  
+  class HashMapped < Hash
+    include TEST_MOD
+    define_struct "int hashhoge; char hashfuga;"
+    hash_mapped_struct
+  end
+
+  def test_hash_struct
+    obj = HashMapped.from_data([1,0,0,0,2].pack("C*") )
 
+    
+    assert_equal(1, obj[:hashhoge])
+    assert_equal(2, obj[:hashfuga])
+  end
+  
 end

data/test/struct_packing/test_util.rb

@@ -2,6 +2,12 @@ require File.dirname(__FILE__) + '/../test_helper.rb'
 
 require 'ostruct'
 
+
+class Hoge
+  include StructPacking::Packable
+  define_struct "int ho; char ge;"
+end
+
 class TestUtil < Test::Unit::TestCase
 
   def setup
@@ -11,7 +17,44 @@ class TestUtil < Test::Unit::TestCase
     tpl = StructPacking::Util.types_to_template(["int", "char"])
 
     assert_equal("ic", tpl)
+  end
+  
+  def test_array_type
+    tpl = StructPacking::Util.types_to_template(["int", "char"])
 
+    assert_equal("ic", tpl)
   end
   
+
+  def test_pointer
+    tpl = StructPacking::Util.types_to_template(["int*", "char*[4]"])
+
+    assert_equal("PP4", tpl)
+  end
+  
+  def test_struct
+    tpl = StructPacking::Util.types_to_template(["struct Hoge"])
+
+    assert_equal("ic", tpl)
+  end
+  
+
+  def test_struct_array
+    tpl = StructPacking::Util.types_to_template(["struct Hoge[4]"])
+
+    assert_equal("icicicic", tpl)
+  end
+  
+  class TestInnerClass
+    include StructPacking::Packable
+    define_struct "int fu; char ga;"
+  end
+  
+  def test_inner_module
+    tpl = StructPacking::Util.types_to_template(["struct TestInnerClass[4]"], self.class)
+
+    assert_equal("icicicic", tpl)
+  end
+  
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: struct_packing
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-16 00:00:00.000000000 Z
+date: 2013-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
@@ -127,7 +127,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -258042995
+      hash: -170055565
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: