slow_blink 0.0.6 → 0.0.7

data/lib/slow_blink/static_group.rb

@@ -0,0 +1,37 @@
+module SlowBlink
+    class StaticGroup < Type
+
+        # @return [String]
+        def name
+            @group.name
+        end
+        
+        # @return [Integer,nil]
+        def id
+            @group.id
+        end
+
+        # @return [Array<Field>]
+        def fields
+            @group.fields
+        end
+
+        # @return [Group]
+        def superGroup
+            @group.superGroup
+        end
+
+        # @return [Array<Groups>]
+        def ancestors
+            @group.ancestors            
+        end
+
+        # @private
+        def initialize(attr)
+            super(attr)
+            @group = attr[:group]
+            @table = attr[:table]
+        end
+         
+    end
+end

data/lib/slow_blink/string.rb

@@ -29,11 +29,10 @@ module SlowBlink
         # @return [nil] no maximum size
         attr_reader :size
 
-        # @param size [Integer] maximum size
-        # @param location [String]    
-        def initialize(size, location)
-            @size = size
-            super(location)
+        # @private
+        def initialize(attr)
+            super(attr)
+            @size = attr[:size]            
         end
 
     end

data/lib/slow_blink/sym.rb

@@ -22,8 +22,6 @@
 module SlowBlink
     class Sym
 
-        include Annotatable
-
         # @macro location
         attr_reader :location
 
@@ -31,32 +29,14 @@ module SlowBlink
         attr_reader :name
 
         # @return [Integer]
-        attr_reader :val
-
-        # @api private
-        def val=(value)
-            @val = value.to_i
-        end
-
-        # @param name [String]
-        # @param val [nil,Integer] explicit value
-        # @param location [String]
-        def initialize(name, val, location)
-            @name = name
-            @val = val
-            @annotes = {}
-            @location = location
-            @implicit = (val ? false : true)
-        end
-
-        # @api private
-        # Resolve references, enforce constraints, and detect cycles
-        #
-        # @param schema [Schema] schema this definition belongs to
-        # @param stack [nil, Array] objects that depend on this object
-        # @return [true,false] linked?
-        def link(schema, stack=[])
-            @schema = schema
+        attr_reader :value
+
+        # @private
+        def initialize(attr)
+            @name = attr[:name].to_s
+            @value = attr[:value]
+            @location = attr[:loc]
+            @implicit = attr[:implicit]
         end
         
     end

data/lib/slow_blink/type.rb

@@ -24,34 +24,25 @@ module SlowBlink
 
     class Type
 
-        include Annotatable
-
         # @macro location
         attr_reader :location
 
+        # @return [true] this type is sequence (repeating) type
+        def sequence?
+            @sequence
+        end
+
         def self.===(other)
             self == other                
         end
 
-        # @param location [String]
-        def initialize(location)
-            @schema = nil
-            @annotes = {}
-            @location = location
+        # @private
+        def initialize(attr)
+            @location = attr[:loc].freeze
+            @sequence = attr[:sequence]
+            @ns = attr[:ns].freeze
         end
 
-        # @api private
-        #
-        # Resolve references, enforce constraints, and detect cycles
-        #
-        # @param schema [Schema] schema this definition belongs to
-        # @param ns [Namespace] namespace this definition belongs to
-        # @param stack [nil, Array] objects that depend on this object
-        # @return [true,false] linked?
-        def link(schema, ns, stack=[])
-            @schema = schema
-        end
-    
     end
     
 end

data/lib/slow_blink/version.rb

@@ -21,5 +21,5 @@
 
 
 module SlowBlink
-    VERSION = '0.0.6'.freeze
+    VERSION = '0.0.7'.freeze
 end

data/lib/slow_blink.rb

@@ -21,3 +21,4 @@
 
 require 'slow_blink/schema'
 require 'slow_blink/message/model'
+require 'slow_blink/generate_c/model'

data/test/tc_compact_encoder.rb

@@ -7,369 +7,336 @@ class TestCompactEncoder < Test::Unit::TestCase
 
     def test_putU8
         input = 0x7f
-        output = "".putU8(input)
-        assert_equal("\x7f", output)
+        output = String.new.putU8(input)
+        assert_equal("\x7f".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putU8_big
         input = 0x80
-        output = "".putU8(input)
-        assert_equal("\x80\x02", output)
+        output = String.new.putU8(input)
+        assert_equal("\x80\x02".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putU8_tooBig
         input = 0x100
         assert_raise RangeError do
-            "".putU8(input)
+            String.new.putU8(input)
         end
     end
 
     def test_putU8_null
         input = nil
-        output = "".putU8(input)
-        assert_equal("\xc0", output)
+        output = String.new.putU8(input)
+        assert_equal("\xc0".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putU16_small
         input = 0xff
-        output = "".putU16(input)
-        assert_equal("\xbf\x03", output)
+        output = String.new.putU16(input)
+        assert_equal("\xbf\x03".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putU16
         input = 0xffff
-        output = "".putU16(input)
-        assert_equal("\xC2\xff\xff", output)
+        output = String.new.putU16(input)
+        assert_equal("\xC2\xff\xff".force_encoding("ASCII-8BIT"), output)
     end
 
     # Blink Specification 3.1
     def test_putU8_64unsigned
         input = 64
-        output = "".putU8(input)
-        assert_equal("\x40", output)
+        output = String.new.putU8(input)
+        assert_equal("\x40".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putU16_16383
         input = 16383
-        output = "".putU16(input)
-        assert_equal("\xBf\xff", output)
+        output = String.new.putU16(input)
+        assert_equal("\xBf\xff".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putI16_16383
         input = 16383
-        output = "".putI16(input)
-        assert_equal("\xC2\xff\x3f", output)
+        output = String.new.putI16(input)
+        assert_equal("\xC2\xff\x3f".force_encoding("ASCII-8BIT"), output)
     end
 
     # Blink Specification 3.1
     def test_putI8_64signed
         input = 64
-        output = "".putI8(input)
-        assert_equal("\x80\x01", output)
+        output = String.new.putI8(input)
+        assert_equal("\x80\x01".force_encoding("ASCII-8BIT"), output)
     end
 
     # Blink Specification 3.1
     def test_putU16_4711unsigned
         input = 4711
-        output = "".putU16(input)
-        assert_equal("\xa7\x49", output)
+        output = String.new.putU16(input)
+        assert_equal("\xa7\x49".force_encoding("ASCII-8BIT"), output)
     end
 
     # Blink Specification 3.1
     def test_putU32_4294967295unsigned
         input = 4294967295
-        output = "".putU32(input)
-        assert_equal("\xc4\xff\xff\xff\xff", output)
+        output = String.new.putU32(input)
+        assert_equal("\xc4\xff\xff\xff\xff".force_encoding("ASCII-8BIT"), output)
     end
 
     # Blink Specification 3.1
     def test_putI8_minus64
         input = -64
-        output = "".putI8(input)
-        assert_equal("\x40", output)
+        output = String.new.putI8(input)
+        assert_equal("\x40".force_encoding("ASCII-8BIT"), output)
     end
 
     # Blink Specification 3.1
     def test_putI16_minus4711
         input = -4711
-        output = "".putI16(input)
-        assert_equal("\x99\xb6", output)
+        output = String.new.putI16(input)
+        assert_equal("\x99\xb6".force_encoding("ASCII-8BIT"), output)
     end
 
     # Blink Specification 3.1
     def test_putI32_minus2147483648
         input = -2147483648
-        output = "".putI32(input)
-        assert_equal("\xc4\x00\x00\x00\x80", output)
+        output = String.new.putI32(input)
+        assert_equal("\xc4\x00\x00\x00\x80".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putFixed
         input = "hello world"
-        output = "".putFixed(input)
-        assert_equal("hello world", output)
-    end
-
-    def test_putFixedOptional
-        input = "hello world"
-        output = "".putFixedOptional(input)
-        assert_equal("\x01hello world", output)
-    end
-
-    def test_putFixedOptional_null
-        input = nil
-        output = "".putFixedOptional(input)
-        assert_equal("\xc0", output)
+        output = String.new.putFixed(input)
+        assert_equal("hello world".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putString
         input = "hello world"
-        output = "".putString(input)
-        assert_equal("\x0bhello world", output)
+        output = String.new.putString(input)
+        assert_equal("\x0bhello world".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putString_null
         input = nil
-        output = "".putString(input)
-        assert_equal("\xc0", output)
+        output = String.new.putString(input)
+        assert_equal("\xc0".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putBinary
         input = "hello world"
-        output = "".putBinary(input)
-        assert_equal("\x0bhello world", output)
+        output = String.new.putBinary(input)
+        assert_equal("\x0bhello world".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putBinary_null
         input = nil
-        output = "".putBinary(input)
-        assert_equal("\xc0", output)
+        output = String.new.putBinary(input)
+        assert_equal("\xc0".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putBool_true
         input = true
-        output = "".putBool(input)
-        assert_equal("\x01", output)
+        output = String.new.putBool(input)
+        assert_equal("\x01".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putBool_false
         input = false
-        output = "".putBool(input)
-        assert_equal("\x00", output)
+        output = String.new.putBool(input)
+        assert_equal("\x00".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putBool_null
         input = nil
-        output = "".putBool(input)
-        assert_equal("\xc0", output)
+        output = String.new.putBool(input)
+        assert_equal("\xc0".force_encoding("ASCII-8BIT"), output)
     end
 
     def test_putF64
         input = nil
-        output = "".putF64(input)
-        assert_equal("\xc0", output)
+        output = String.new.putF64(input)
+        assert_equal("\xc0".force_encoding("ASCII-8BIT"), output)
     end
 
     # Blink Specification 3.1
     def test_getU8_64unsigned
-        input = "\x40"
-        output = input.getU8!
+        input = StringIO.new("\x40")
+        output = input.getU8
         assert_equal(64, output)
-        assert_equal(0, input.size)
+        
     end
 
     # Blink Specification 3.1
     def test_getI8_64signed
-        input = "\x80\x01"
-        output = input.getI8!
+        input = StringIO.new("\x80\x01")
+        output = input.getI8
         assert_equal(64, output)
-        assert_equal(0, input.size)
+        
     end
 
     # Blink Specification 3.1
     def test_getU16_4711unsigned
-        input = "\xa7\x49"
-        output = input.getU16!
+        input = StringIO.new("\xa7\x49")
+        output = input.getU16
         assert_equal(4711, output)
-        assert_equal(0, input.size)
+        
     end
 
     # Blink Specification 3.1
     def test_getU32_4294967295unsigned
-        input = "\xc4\xff\xff\xff\xff"
-        output = input.getU32!
+        input = StringIO.new("\xc4\xff\xff\xff\xff")
+        output = input.getU32
         assert_equal(4294967295, output)
-        assert_equal(0, input.size)
+        
     end
 
     # Blink Specification 3.1
     def test_getI8_minus64
-        input = "\x40"
-        output = input.getI8!
+        input = StringIO.new("\x40")
+        output = input.getI8
         assert_equal(-64, output)
-        assert_equal(0, input.size)
+        
     end
 
     # Blink Specification 3.1
     def test_getI16_minus4711
-        input = "\x99\xb6"
-        output = input.getI16!
+        input = StringIO.new("\x99\xb6")
+        output = input.getI16
         assert_equal(-4711, output)
-        assert_equal(0, input.size)
+        
     end
 
     # Blink Specification 3.1
     def test_getI32_minus2147483648
-        input = "\xc4\x00\x00\x00\x80"
-        output = input.getI32!
+        input = StringIO.new("\xc4\x00\x00\x00\x80")
+        output = input.getI32
         assert_equal(-2147483648, output)
-        assert_equal(0, input.size)
+        
     end
 
     def test_getBool_true
-        input = "\x01"
-        output = input.getBool!
+        input = StringIO.new("\x01")
+        output = input.getBool
         assert_equal(true, output)
-        assert_equal(0, input.size)
+        
     end
 
     def test_getBool_false
-        input = "\x00"
-        output = input.getBool!
+        input = StringIO.new("\x00")
+        output = input.getBool
         assert_equal(false, output)
-        assert_equal(0, input.size)
+        
     end
 
     def test_getBool_other
-        input = "\x02"
+        input = StringIO.new("\x02")
         assert_raise Message::WeakError11 do
-            input.getBool!
+            input.getBool
         end
-        assert_equal(0, input.size)
+        
     end
 
     def test_getString
-        input = "\x0bhello world"
-        output = input.getString!
+        input = StringIO.new("\x0bhello world")
+        output = input.getString
         assert_equal("hello world", output)
-        assert_equal(0, input.size)
+        
     end
     
     def test_getString_null
-        input = "\xc0"
-        output = input.getString!
+        input = StringIO.new("\xc0")
+        output = input.getString
         assert_equal(nil, output)
-        assert_equal(0, input.size)
+        
     end
 
     def test_getString_eof
-        input = "\x01"
+        input = StringIO.new("\x01")
         assert_raise Message::StrongError1 do
-            input.getString!
+            input.getString
         end
     end
 
     def test_getBinary
-        input = "\x0bhello world"
-        output = input.getBinary!
+        input = StringIO.new("\x0bhello world")
+        output = input.getBinary
         assert_equal("hello world", output)
-        assert_equal(0, input.size)
+        
     end
 
     def test_getBinary_null
-        input = "\xc0"
-        output = input.getBinary!
+        input = StringIO.new("\xc0")
+        output = input.getBinary
         assert_equal(nil, output)
-        assert_equal(0, input.size)
+        
     end
 
     def test_getBinary_eof
-        input = "\x01"
+        input = StringIO.new("\x01")
         assert_raise Message::StrongError1 do
-            input.getBinary!
+            input.getBinary
         end
     end
     
     def test_getFixed
-        input = "hello world"
-        output = input.getFixed!("hello world".size)
+        input = StringIO.new("hello world")
+        output = input.getFixed("hello world".size)
         assert_equal("hello world", output)
-        assert_equal(0, input.size)
+        
     end
 
     def test_getFixed_eof
-        input = ""
-        assert_raise Message::StrongError1 do
-            input.getFixed!(1)
-        end
-    end
-
-    def test_getFixedOptional
-        input = "\x01hello world"
-        output = input.getFixedOptional!("hello world".size)
-        assert_equal("hello world", output)
-        assert_equal(0, input.size)
-    end
-
-    def test_getFixedOptional_null
-        input = "\xc0"
-        output = input.getFixedOptional!("hello world".size)
-        assert_equal(nil, output)
-        assert_equal(0, input.size)
-    end
-
-    def test_getFixedOptional_eof
-        input = "\x01"
+        input = StringIO.new
         assert_raise Message::StrongError1 do
-            input.getFixedOptional!(1)
+            input.getFixed(1)
         end
     end
 
     def test_getI64_max
-        input = "\xC8\xff\xff\xff\xff\xff\xff\xff\x7f"
+        input = StringIO.new("\xC8\xff\xff\xff\xff\xff\xff\xff\x7f")
         expected = 9223372036854775807
-        assert_equal(expected, input.getI64!)
+        assert_equal(expected, input.getI64)
     end
 
     def test_putI64_max
-        expected = "\xC8\xff\xff\xff\xff\xff\xff\xff\x7f"
+        expected = "\xC8\xff\xff\xff\xff\xff\xff\xff\x7f".force_encoding("ASCII-8BIT")
         input = 9223372036854775807
-        assert_equal(expected, "".putI64(input))
+        assert_equal(expected, String.new.putI64(input))
     end
 
     def test_getI64_min
-        input = "\xC8\x00\x00\x00\x00\x00\x00\x00\x80"
+        input = StringIO.new("\xC8\x00\x00\x00\x00\x00\x00\x00\x80")
         expected = -9223372036854775808
-        assert_equal(expected, input.getI64!)
+        assert_equal(expected, input.getI64)
     end
 
     def test_putI64_min
-        expected = "\xC8\x00\x00\x00\x00\x00\x00\x00\x80"
+        expected = "\xC8\x00\x00\x00\x00\x00\x00\x00\x80".force_encoding("ASCII-8BIT")
         input = -9223372036854775808
-        assert_equal(expected, "".putI64(input))
+        assert_equal(expected, String.new.putI64(input))
     end
 
     def test_getI32_max
-        input = "\xC4\xff\xff\xff\x7f"
+        input = StringIO.new("\xC4\xff\xff\xff\x7f")
         expected = 2147483647
-        assert_equal(expected, input.getI32!)
+        assert_equal(expected, input.getI32)
     end
 
     def test_getI32_min
-        input = "\xC4\x00\x00\x00\x80"
+        input = StringIO.new("\xC4\x00\x00\x00\x80")
         expected = -2147483648
-        assert_equal(expected, input.getI32!)
+        assert_equal(expected, input.getI32)
     end
 
     def test_getI16_max
-        input = "\xC2\xff\x7f"
+        input = StringIO.new("\xC2\xff\x7f")
         expected = 32767
-        assert_equal(expected, input.getI32!)
+        assert_equal(expected, input.getI32)
     end
 
     def test_getI16_min
-        input = "\xC2\x00\x80"
+        input = StringIO.new("\xC2\x00\x80")
         expected = -32768
-        assert_equal(expected, input.getI32!)
+        assert_equal(expected, input.getI32)
     end
     
 end

data/test/tc_inputs.rb

@@ -16,16 +16,14 @@ testClass = Class.new(Test::Unit::TestCase) do
         next if filename == ".." or filename == "."
 
         test_name = "test_#{filename.sub(".blink", "")}"
-        inputs[test_name.to_sym] = {:fileName => filename, :buffer => File.new("#{root}/#{filename}", "r").read}
+        inputs[test_name.to_sym] = "#{root}/#{filename}"
 
         define_method( test_name ) do
 
-            output = nil
-
             # run and intercept stderr output
             err = capture_stderr do
 
-                schema = SlowBlink::Schema.new(SlowBlink::SchemaBuffer.new(inputs[__method__][:buffer], filename: inputs[__method__][:fileName]))
+                SlowBlink::Schema.read(inputs[__method__])
 
             end