divine 0.0.2 → 0.0.3

data/lib/divine/code_generators/ruby.rb

@@ -1,6 +1,12 @@
 module Divine
 
   class RubyHelperMethods < BabelHelperMethods
+    def get_header_comment
+      get_header_comment_text.map do |s|
+        "# #{s}"
+      end.join("\n")
+    end
+    
     def ruby_base_class_template_str
       %q{
   class BabelBase<%= toplevel_class %>
@@ -29,6 +35,24 @@ module Divine
       (data.getbyte << 24) | read_int24(data)
     end
 
+    def read_sint32(data)
+      max = (2** (32 - 1)) - 1
+      num = (data.getbyte << 24) | read_int24(data)
+      if num > max
+        return num - 2** 32
+      end
+      return num
+    end
+
+    def read_sint64(data)
+      max = (2** (64 - 1)) - 1
+      num = (read_int32(data) << 32) | (read_int32(data) & 0xFFFFFFFF);
+      if num > max
+        return num - 2** 64
+      end
+      return num
+    end
+
     def read_bool(data)
       read_int8(data) == 1
     end
@@ -107,6 +131,26 @@ module Divine
       write_int24( v & 0xFFFFFF, out)
     end
 
+    def write_sint32(v, out)
+      v = v.to_i
+      max = (2** (32 - 1)) - 1
+      min = (2** (32 - 1) ) - (2** 32)
+      raise_error "Too large Sint32 number: #{v} , Max = #{max}" if v > max # Max  2.147.483.647
+      raise_error "Too small sInt32 number: #{v} , Min = #{min}" if v < min # Min -2.147.483.648
+      write_int8( v >> 24 & 0xFF, out)
+      write_int24( v & 0xFFFFFF, out)
+    end
+
+    def write_sint64(v, out)
+      v = v.to_i
+      max = (2** (64 - 1)) - 1
+      min = (2** (64 - 1) ) - (2** 64)
+      raise_error "Too large Sint32 number: #{v} , Max = #{max}" if v > max # Max  2.147.483.647
+      raise_error "Too small sInt32 number: #{v} , Min = #{min}" if v < min # Min -2.147.483.648
+      write_int32( v >> 32 & 0xFFFFFFFF, out)
+      write_int32( v & 0xFFFFFFFF, out)
+    end
+
     def write_bool(v, out)
       write_int8(v ? 1 : 0, out)
     end
@@ -236,50 +280,99 @@ module Divine
     }
     end
 
-    def ruby_class_template_str
-      %q{
-  class <%= c.name %> < BabelBase
-  <% unless c.fields.empty? %>
-      attr_accessor <%= c.fields.map { |x| ":#{x.name}" }.join(', ') %>
-
-      def initialize()
-          super
-  <% c.fields.each do |f| %>
-          @<%= f.name %> ||= <%= this.ruby_get_empty_declaration(f) %>
-  <% end %>
-      end
-  <% end %>
-
-      def serialize_internal(out)
-        print "+"
-        <% c.simple_fields.each do |f| %>
-        write_<%= f.type %>(<%= f.name %>, out)
-        <% end %>
-        <% c.complex_fields.each do |f| %>
-  <%= this.ruby_serialize_complex f %>
-        <% end %>
-      end
-
-      def deserialize(data)
-        print "-"
-        <% c.simple_fields.each do |f| %>
-        @<%= f.name %> = read_<%= f.type %>(data)
-        <% end %>
-        <% c.complex_fields.each do |f| %>
-  <%= this.ruby_deserialize_complex f %>
-        <% end %>
-      end
-  end
-    }
+    def ruby_class_template(sh)
+      code = [
+        "class #{sh.name} < BabelBase",
+        :indent,
+        "",
+        
+        # PROPERTIES
+        if sh.field_names.size > 0
+          "attr_accessor :struct_version, #{sh.field_names.map {|n| ":#{n}" }.join(', ')}"
+        else
+          "attr_accessor :struct_version"
+        end, "",
+
+
+        # INITIALIZE
+        "def initialize()",
+        :indent,
+        "super",
+        "@struct_version ||= #{sh.latest_version}",
+        sh.field_names.map do |fn|
+          "@#{fn} ||= #{ruby_get_empty_declaration(sh.field(fn).first)}"
+        end,
+        :deindent,
+        "end", "",
+  
+        # SERiALIZE INTERNAL
+        "def serialize_internal(out)",
+        :indent,
+        "write_int8(@struct_version, out)",
+        sh.structs.map do |s|
+          [
+            "if @struct_version == #{s.version}",
+            :indent,
+            s.simple_fields.map do |f|
+              "write_#{f.type}(#{f.name}, out)"
+            end,
+            s.complex_fields.map do |f|
+              [
+                "", "# Serialize #{f.type} '#{f.name}'",
+                ruby_serialize_internal(f.name,  f.referenced_types)
+              ]
+            end,
+            "return",
+            :deindent,
+            "end", ""
+          ]
+        end, "",
+        "raise \"Unsupported version #\{@struct_version\} for type '#{sh.name}'\"",
+        :deindent,
+        "end", "",
+        
+        # DESERIALIZE
+        "def deserialize(data)",
+        :indent,
+        "@struct_version = read_int8(data)",
+        sh.structs.map do |s|
+          [
+            "if @struct_version == #{s.version}",
+            :indent,
+            s.simple_fields.map do |f|
+                "@#{f.name} = read_#{f.type}(data)"
+            end,
+            s.complex_fields.map do |f|
+              [
+                "", "# Read #{f.type} '#{f.name}'",
+                ruby_deserialize_internal("@#{f.name}",  f.referenced_types)
+              ]
+            end,
+            "return",
+            :deindent,
+            "end"
+          ]
+        end, "",
+        "raise \"Unsupported version #\{@struct_version\} for type '#{sh.name}'\"",
+        :deindent,
+        "end", "",
+        
+        
+        # END OF CLASS
+        :deindent,
+        "end"        
+        ]
+      format_src(0, 3, code)
     end
 
+
     def ruby_get_empty_declaration(field)
       case field.type
       when :list, :binary, :short_binary
         "[]"
       when :map
         "{}"
-      when :int8, :int16, :int32
+      when :int8, :int16, :int32, :sint32, :sint64
         "0"
       when :string, :ip_number
         "\"\""
@@ -288,15 +381,6 @@ module Divine
       end
     end
 
-    def ruby_serialize_complex(field)
-      types = field.referenced_types
-      as = [
-            "# Serialize #{field.type} '#{field.name}'",
-            ruby_serialize_internal(field.name, types)
-           ]
-      format_src(6, 3, as)
-    end
-
     def ruby_serialize_internal(var, types)
       if types.respond_to? :first
         case types.first
@@ -338,15 +422,6 @@ module Divine
       end
     end
 
-    def ruby_deserialize_complex(field)
-      types = field.referenced_types
-      as = [
-            "# Deserialize #{field.type} '#{field.name}'",
-            ruby_deserialize_internal("@#{field.name}", types)
-           ]
-      format_src(6, 3, as)
-    end
-
     def ruby_deserialize_internal(var, types)
       if types.respond_to? :first
         case types.first
@@ -406,21 +481,19 @@ module Divine
     @debug = true
   
     def generate_code(structs, opts)
-      pp opts
       base_template = Erubis::Eruby.new(ruby_base_class_template_str)
-      class_template = Erubis::Eruby.new(ruby_class_template_str)
       keys = structs.keys.sort
       src = keys.map do |k|
         ss = structs[k]
-        # TODO: Should we merge different versions and deduce deprecated methods, warn for incompatible changes, etc?
-        raise "Duplicate definitions of struct #{k}" if ss.size > 1
-        class_template.result( c: ss.first, this: self )
+        # Check different aspects the the structs
+        vss = sanity_check(ss)
+        ruby_class_template(StructHandler.new(vss))
       end
     
       # User defined super class?
       toplevel = opts[:parent_class] || nil
       toplevel = " < #{toplevel}" if toplevel 
-      return [{file: opts[:file], src: "#{ruby_get_begin_module(opts)}#{base_template.result({ toplevel_class: toplevel })}\n\n#{src.join("\n\n")}#{ruby_get_end_module(opts)}"}]
+      return [{file: opts[:file], src: "#{get_header_comment}\n#{ruby_get_begin_module(opts)}#{base_template.result({ toplevel_class: toplevel, this: self })}\n\n#{src.join("\n\n")}#{ruby_get_end_module(opts)}"}]
     end
   
     def ruby_get_begin_module(opts)

data/lib/divine/dsl.rb

@@ -2,7 +2,8 @@ module Divine
   $all_structs = {}
 
   class StructDefinition
-    def initialize(type, args)
+    def initialize(owner, type, args)
+      @owner = owner
       @type = type
       @args = args
     end
@@ -14,12 +15,20 @@ module Divine
     def type
       @type
     end
+    
+    def version 
+      @owner.version
+    end
+    
+    def to_s
+      "#{@owner.name}: #{self.type} #{self.name} (#{self.class.name}, #{@args.inspect})"
+    end
   end
 
   class SimpleDefinition < StructDefinition
     def simple?; true; end
     def referenced_types
-      @type
+      [@type]
     end
   end
 
@@ -39,6 +48,12 @@ module Divine
     end
   end
 
+  class SInteger64Definition < SimpleDefinition
+  end
+
+  class SInteger32Definition < SimpleDefinition
+  end 
+
   class Integer32Definition < SimpleDefinition
   end
 
@@ -84,6 +99,8 @@ module Divine
 
 
   $available_types = {
+    sint64: SInteger64Definition,
+    sint32: SInteger32Definition,
     int32: Integer32Definition,
     int24: Integer24Definition,
     int16: Integer16Definition,
@@ -102,10 +119,10 @@ module Divine
     # Name = name of the struct
     # Version = struct version (not currently used)
     # Fields = All defined fields
-    attr_reader :name, :version, :fields
+    attr_reader :name, :properties, :fields
 
-    def initialize(name, version)
-      @version = version
+    def initialize(name, ps)
+      @properties = ps
       @name = name.to_sym
       @fields = []
       unless @name == :_inline_
@@ -114,35 +131,76 @@ module Divine
       end
     end
 
+    #
+    # Get the version of the struct 
+    #
+    def version
+      if properties && properties[:version]
+        properties[:version].to_i
+      else
+        1
+      end
+    rescue => e
+      raise "Failed to get version number from '#{name}': #{properties.inspect}\n#{e}"
+    end
+    
+    #
+    # Is the struct freezed? I.e. no changes are allowed
+    #
+    def freezed?
+      nil != freeze_signature
+    end
+    
+    #
+    # Get the freeze signature
+    #
+    def freeze_signature
+      if properties && properties[:freeze]
+        properties[:freeze]
+      else
+        nil
+      end
+    end
+
     #
     # Get all simple fields, i.e. basic types like string, etc
     #
     def simple_fields
-        fields.select(&:simple?)
+      fields.select(&:simple?)
     end
 
     #
     # Get all complex fields, i.e. lists and hashmaps
     #
     def complex_fields
-        fields.reject(&:simple?)
+      fields.reject(&:simple?)
+    end
+
+    #
+    # Get named field
+    #
+    def get_field(name)
+      fields.each do |f|
+        return f if f.name == name
+      end
+      return nil
     end
 
     def method_missing(m, *args, &block)
-      puts "... #{m}"
+      #puts "... #{m} #{args.inspect}"
       type = $available_types[m]
       if type
         if block_given?
-          puts ".... recursive definition"
-          builder = StructBuilder.new(:_inline_, version)
+          #puts ".... recursive definition"
+          builder = StructBuilder.new(:_inline_, args)
           Docile.dsl_eval(builder, &block)
           args << builder
         end
         if @name == :_inline_
           # Pad the _inline_ name to anonymous inner types
-          @fields << type.new(m, [@name] + args)
+          @fields << type.new(self, m, [@name] + args)
         else
-          @fields << type.new(m, args)
+          @fields << type.new(self, m, args)
         end
         #puts "... adding #{m} to #{name}, got #{fields} ..."
       else

data/lib/divine/version.rb

@@ -1,3 +1,3 @@
 module Divine
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/test/basic_complex_test/js_test/js_testBasic.js

@@ -18,7 +18,7 @@ var read = deserialize();
 
 
 var testBasic_deser = new TestBasic();
-testBasic_deser.deserialize(new BabelDataReader(read));
+testBasic_deser.deserialize(new DivineDataReader(read));
 
 assert.equal(testBasic_ser.i8, testBasic_deser.i8);
 assert.equal(testBasic_ser.i16, testBasic_deser.i16);

data/test/basic_complex_test/js_test/js_testComplex.js

@@ -16,7 +16,7 @@ serialize(ca);
 var read = deserialize();
 
 var testComplex_deser = new TestComplex();
-testComplex_deser.deserialize(new BabelDataReader(read));
+testComplex_deser.deserialize(new DivineDataReader(read));
 
 compare_list(testComplex_ser.list1, testComplex_deser.list1);
 compare_list(testComplex_ser.list2, testComplex_deser.list2);

data/test/basic_complex_test/ruby_test/ruby_test.rb

@@ -24,12 +24,12 @@ class TestBabelTestBasic < MiniTest::Unit::TestCase
     testbasic_deser = BabelTest::TestBasic.new
     testbasic_deser.deserialize res
 
-    assert testbasic_ser.i8 == testbasic_deser.i8
-    assert testbasic_ser.i16 == testbasic_deser.i16
-    assert testbasic_ser.i32 == testbasic_deser.i32
-    assert testbasic_ser.str == testbasic_deser.str
-    assert testbasic_ser.ip == testbasic_deser.ip
-    assert testbasic_ser.guid == testbasic_deser.guid
+    assert_equal testbasic_ser.i8 , testbasic_deser.i8
+    assert_equal testbasic_ser.i16 , testbasic_deser.i16
+    assert_equal testbasic_ser.i32 , testbasic_deser.i32
+    assert_equal testbasic_ser.str , testbasic_deser.str
+    assert_equal testbasic_ser.ip , testbasic_deser.ip
+    assert_equal testbasic_ser.guid , testbasic_deser.guid
   end
 
   def test_complex
@@ -48,11 +48,11 @@ class TestBabelTestBasic < MiniTest::Unit::TestCase
     testcomplex_deser = BabelTest::TestComplex.new
     testcomplex_deser.deserialize res
 
-    assert testcomplex_ser.list1.sort == testcomplex_deser.list1.sort
-    assert testcomplex_ser.list2.sort == testcomplex_deser.list2.sort
-    assert testcomplex_ser.map1 == testcomplex_deser.map1
+    assert_equal testcomplex_ser.list1, testcomplex_deser.list1
+    assert_equal testcomplex_ser.list2, testcomplex_deser.list2
+    assert_equal testcomplex_ser.map1, testcomplex_deser.map1
     testcomplex_ser.map2.keys.each do |k|
-      assert testcomplex_ser.map2[k].length == testcomplex_deser.map2[k].length
+      assert_equal testcomplex_ser.map2[k].length, testcomplex_deser.map2[k].length
     end
   end