slow_blink 0.0.6 → 0.0.7

data/lib/slow_blink/namespace.rb

@@ -1,143 +0,0 @@
-# @license
-#   
-#   Copyright (c) 2016 Cameron Harper
-#     
-#   Permission is hereby granted, free of charge, to any person obtaining a copy of
-#   this software and associated documentation files (the "Software"), to deal in
-#   the Software without restriction, including without limitation the rights to
-#   use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-#   the Software, and to permit persons to whom the Software is furnished to do so,
-#   subject to the following conditions:
-#   
-#   The above copyright notice and this permission notice shall be included in all
-#   copies or substantial portions of the Software.
-# 
-#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-#   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-#   FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-#   COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-#   IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-#   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
-module SlowBlink
-
-    class Namespace
-
-        include Annotatable
-
-        # @return [Hash<Definition>]
-        attr_reader :definitions
-
-        # @return [Array<Group>]
-        attr_reader :groups
-
-        # @return [String]
-        attr_reader :name
-
-        # @return [Array<IncrementalAnnotation>]
-        attr_reader :incrAnnotations
-
-        # @!method self.parse(input, **opts)
-        #
-        #   @api private
-        #
-        #   @param input [String] Blink Schema
-        #   @param opts [Hash] options
-        #   @option opts [String] :fileName filename to append to error message strings
-        #   @return [Namespace]
-
-        # @param filename [nil,String]
-        # @param name [nil,String]
-        # @param defs [Array<Definition,Group>]
-        def initialize(filename, name, defs)
-
-            @filename = filename
-            @annotes = {}
-            @incrAnnotations = []
-            @groups = []
-            @definitions = {}
-            @name = name
-            @schema = nil
-            
-            error = false
-            
-            # populate table of definitions
-            # gather list of groups and incrAnnotations
-            # set namespace reference in each def
-            defs.each do |d|
-                if d.is_a? IncrementalAnnotation
-                    @incrAnnotations << d
-                else
-                    if @definitions[d.nameWithID.name]
-                        Log.error "#{d.location}: error: definitions must have unique names ('#{d.nameWithID.name}' first appears at #{definitions[d.nameWithID.name].location})"
-                        error = true
-                    else
-                        @definitions[d.nameWithID.name] = d
-                        if d.is_a? Group
-                            @groups << d
-                        end
-                        d.namespace = self           
-                    end                    
-                end
-            end
-
-            if error
-                raise ParseError
-            end
-            
-        end
-
-        # @api private
-        #
-        # @param namespace [Namespace]
-        def merge!(namespace)
-            @incrAnnotations.concat(namespace.incrAnnotations)
-            namespace.definitions.each do |d|
-                if @definitions[d.nameWithID.name]
-                    Log.error "#{d.location}: error: definitions must have unique names ('#{d.nameWithID.name}' first appears at #{definitions[d.nameWithID.name].location})"
-                    raise ParseError
-                else
-                    @definitions[d.nameWithID.name] = d
-                    if d.is_a? Group
-                        @groups << d
-                    end                        
-                end                    
-            end                
-        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=[])            
-            errors = 0
-            @definitions.each do |name, d|
-                if !d.link(schema, stack.dup << self)
-                    errors += 1
-                end                    
-            end
-            errors == 0    
-        end
-
-        # @param name [String] unqualified name
-        # @return [Definition,Group]
-        def resolve(name)
-            @definitions[name]
-        end
-
-        # @param name [String]
-        # @return [Group,nil]
-        def group(name)
-            @groups.detect{|g|g.nameWithID.name == name}
-        end
-
-    end    
-
-end
-
-
-

data/lib/slow_blink/sequence.rb

@@ -1,57 +0,0 @@
-# @license
-#   
-#   Copyright (c) 2016 Cameron Harper
-#     
-#   Permission is hereby granted, free of charge, to any person obtaining a copy of
-#   this software and associated documentation files (the "Software"), to deal in
-#   the Software without restriction, including without limitation the rights to
-#   use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-#   the Software, and to permit persons to whom the Software is furnished to do so,
-#   subject to the following conditions:
-#   
-#   The above copyright notice and this permission notice shall be included in all
-#   copies or substantial portions of the Software.
-# 
-#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-#   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-#   FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-#   COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-#   IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-#   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
-module SlowBlink
-
-    # Blink Specification 3.12
-    class SEQUENCE < Type
-
-        # @return [Type]
-        attr_reader :type
-
-        # @param type [Type] repeating type
-        # @param location [String]    
-        def initialize(type, location)
-            @type = type
-            super(location)
-        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=[])            
-            if stack.detect{|sf| sf.is_a? SEQUENCE}
-                Log.error "#{@location}: error: a sequence type specifier must not specify a sequence as the item type"
-                false
-            else
-                @type.link(schema, ns, stack << self)            
-            end                    
-        end
-           
-    end
-
-end

data/test/tc_field.rb

@@ -1,94 +0,0 @@
-require "test/unit"
-require 'slow_blink'
-
-class TestField < Test::Unit::TestCase
-
-    include SlowBlink
-
-    def test_optional
-        input = "Test -> u8 one?"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(true, schema.ns[nil].group("Test").field("one").opt?)        
-    end
-
-    def test_not_optional
-        input = "Test -> u8 one"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(false, schema.ns[nil].group("Test").field("one").opt?)        
-    end
-
-    def test_with_id
-        input = "Test -> u8 one/42"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(42, schema.ns[nil].group("Test").field("one").nameWithID.id)
-    end
-
-    def test_with_hexid
-        input = "Test -> u8 one/0x2a"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(42, schema.ns[nil].group("Test").field("one").nameWithID.id)
-    end
-
-    def test_without_id
-        input = "Test -> u8 one"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(nil, schema.ns[nil].group("Test").field("one").nameWithID.id)
-    end
-
-    def test_reference
-        input = "Ref = u8 Test -> Ref one"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_true(schema.ns[nil].group("Test").field("one").type.is_a? REF)
-        assert_true(schema.ns[nil].group("Test").field("one").type.ref.is_a? U8)
-    end
-
-    def test_duplicate_name
-        input = "Ref = u8 Test -> Ref one, Ref one"
-        
-        assert_raise do
-            Schema.new(SchemaBuffer.new(input))
-        end
-    end
-
-    def test_field_direct_cycle
-        input =  <<-eos
-            test ->
-                test field
-        eos
-        assert_raise do
-            Schema.new(SchemaBuffer.new(input))
-        end    
-    end
-
-    def test_field_direct_dynamic_cycle
-        input =  <<-eos
-            test ->
-                test * field
-        eos
-        
-        Schema.new(SchemaBuffer.new(input))
-        
-    end
-
-    def test_field_indirect_cycle
-        input =  <<-eos
-            intermediate = test
-            test ->
-                intermediate field
-        eos
-        assert_raise do
-            Schema.new(SchemaBuffer.new(input))
-        end    
-    end
-
-    def test_field_indirect_dynamic_cycle
-        input =  <<-eos
-            intermediate = test *
-            test ->
-                intermediate field
-        eos
-        
-        Schema.new(SchemaBuffer.new(input))
-    end
-
-end

data/test/tc_group.rb

@@ -1,114 +0,0 @@
-require "test/unit"
-require 'slow_blink'
-
-class TestGroup < Test::Unit::TestCase
-
-    include SlowBlink
-
-    def test_empty_group_without_id
-        input = "Test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal("Test", schema.ns[nil].group("Test").nameWithID.name)
-        assert_equal(nil, schema.ns[nil].group("Test").nameWithID.id)
-        assert_equal([], schema.ns[nil].group("Test").fields)
-        assert_equal({}, schema.tagged)        
-    end
-
-    def test_empty_group_with_id
-        input = "Test/0"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal("Test", schema.ns[nil].group("Test").nameWithID.name)
-        assert_equal(0, schema.ns[nil].group("Test").nameWithID.id)
-        assert_equal([], schema.ns[nil].group("Test").fields)
-        assert_equal({0 => schema.ns[nil].group("Test")}, schema.tagged)
-    end
-
-    def test_empty_group_with_hexid
-        input = "Test/0x2a"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal("Test", schema.ns[nil].group("Test").nameWithID.name)
-        assert_equal(42, schema.ns[nil].group("Test").nameWithID.id)
-        assert_equal([], schema.ns[nil].group("Test").fields)
-        assert_equal({42 => schema.ns[nil].group("Test")}, schema.tagged)
-    end
-
-    def test_group_of_one_field
-        input = "Test -> u8 one"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(1, schema.ns[nil].group("Test").fields.size)
-    end
-
-    def test_group_of_many_field
-        input = "Test -> u8 one, u8 two, u8 three"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(3, schema.ns[nil].group("Test").fields.size)        
-    end
-
-    def test_with_supergroup
-        input = "Test : Super Super -> u8 one, u16 two, u32 three"        
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(3, schema.ns[nil].group("Test").fields.size)
-        assert_true(schema.ns[nil].group("Test").group_kind_of? schema.ns[nil].group("Super"))
-        assert_true(schema.ns[nil].group("Test").field("one") != nil)
-        assert_true(schema.ns[nil].group("Test").field("two") != nil)
-        assert_true(schema.ns[nil].group("Test").field("three") != nil)
-    end
-
-    def test_without_supergroup
-        input = "Test Super -> u8 one, u16 two, u32 three"        
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(0, schema.ns[nil].group("Test").fields.size)
-        assert_true(!schema.ns[nil].group("Test").group_kind_of?(schema.ns[nil].group("Super")))
-        assert_true(schema.ns[nil].group("Test").field("one") == nil)
-        assert_true(schema.ns[nil].group("Test").field("two") == nil)
-        assert_true(schema.ns[nil].group("Test").field("three") == nil)
-    end
-
-    def test_with_multiple_supergroup
-
-        input = "Test : Super Super : SuperSuper SuperSuper -> u8 one, u16 two, u32 three"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(3, schema.ns[nil].group("Test").fields.size)
-        assert_true(schema.ns[nil].group("Test").group_kind_of? schema.ns[nil].group("Super"))
-        assert_true(schema.ns[nil].group("Test").group_kind_of? schema.ns[nil].group("SuperSuper"))
-        assert_true(schema.ns[nil].group("Test").field("one") != nil)
-        assert_true(schema.ns[nil].group("Test").field("two") != nil)
-        assert_true(schema.ns[nil].group("Test").field("three") != nil)
-    end
-
-    def test_with_mixed_supergroup
-        input = "Test : Super -> u32 three Super -> u8 one, u16 two"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(3, schema.ns[nil].group("Test").fields.size)
-        assert_true(schema.ns[nil].group("Test").group_kind_of? schema.ns[nil].group("Super"))
-        assert_true(schema.ns[nil].group("Test").field("one") != nil)
-        assert_true(schema.ns[nil].group("Test").field("two") != nil)
-        assert_true(schema.ns[nil].group("Test").field("three") != nil)
-    end
-
-    def test_supergroup_not_group
-        input = "Test : Thing Thing = u8"
-        assert_raise do
-            Schema.new(SchemaBuffer.new(input))
-        end
-    end
-
-    def test_supergroup_unresolved
-        input = "Test : Thing"
-        assert_raise do
-            Schema.new(SchemaBuffer.new(input))
-        end
-    end
-
-    def test_supergroup_dynamic_reference
-        input =  <<-eos
-            Super
-            Intermediate = Super *
-            Test : Intermediate
-        eos
-        assert_raise do
-            Schema.new(SchemaBuffer.new(input))
-        end        
-    end
-
-end

data/test/tc_incr_annote.rb

@@ -1,22 +0,0 @@
-require "test/unit"
-require 'slow_blink'
-
-class TestIncrAnnote < Test::Unit::TestCase
-
-    include SlowBlink
-
-    def test_schema
-
-        raw =  <<-eos
-            Thing
-            AnotherThing ->
-                string Greeting
-
-            schema <- @test="test"
-        eos
-
-        schema = Schema.new(SchemaBuffer.new(raw))
-
-    end
-
-end

data/test/tc_namespace.rb

@@ -1,8 +0,0 @@
-require "test/unit"
-require 'slow_blink'
-
-class TestNamespace < Test::Unit::TestCase
-
-    include SlowBlink
-
-end

data/test/tc_types.rb

@@ -1,218 +0,0 @@
-require "test/unit"
-require 'slow_blink'
-
-class TestTypes < Test::Unit::TestCase
-
-    include SlowBlink
-
-    def test_bool
-        input = "test -> bool test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(BOOLEAN, schema.ns[nil].group("test").field("test").type.class)
-    end
-
-    def test_u8
-        input = "test -> u8 test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(U8, schema.ns[nil].group("test").field("test").type.class)
-    end
-
-    def test_u16
-        input = "test -> u16 test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(U16, schema.ns[nil].group("test").field("test").type.class)
-    end
-
-    def test_u32
-        input = "test -> u32 test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(U32, schema.ns[nil].group("test").field("test").type.class)
-    end
-
-    def test_u64
-        input = "test -> u64 test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(U64, schema.ns[nil].group("test").field("test").type.class)
-    end
-
-    def test_i8
-        input = "test -> i8 test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(I8, schema.ns[nil].group("test").field("test").type.class)
-    end
-
-    def test_i16
-        input = "test -> i16 test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(I16, schema.ns[nil].group("test").field("test").type.class)
-    end
-
-    def test_i32
-        input = "test -> i32 test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(I32, schema.ns[nil].group("test").field("test").type.class)
-    end
-
-    def test_i64
-        input = "test -> i64 test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(I64, schema.ns[nil].group("test").field("test").type.class)
-    end
-
-    def test_f64
-        input = "test -> f64 test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(FLOATING_POINT, schema.ns[nil].group("test").field("test").type.class)
-    end
-
-    def test_string_without_size
-        input = "test -> string test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(STRING, schema.ns[nil].group("test").field("test").type.class)
-        assert_equal(nil, schema.ns[nil].group("test").field("test").type.size)        
-    end
-
-    def test_string_with_size
-        input = "test -> string (42) test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(STRING, schema.ns[nil].group("test").field("test").type.class)
-        assert_equal(42, schema.ns[nil].group("test").field("test").type.size)       
-    end
-    
-    def test_binary_without_size
-        input = "test -> binary test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(BINARY, schema.ns[nil].group("test").field("test").type.class)
-        assert_equal(nil, schema.ns[nil].group("test").field("test").type.size)        
-    end
-
-    def test_binary_with_size
-        input = "test -> binary (42) test "
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(BINARY, schema.ns[nil].group("test").field("test").type.class)        
-        assert_equal(42, schema.ns[nil].group("test").field("test").type.size)
-    end
-
-    def test_fixed
-        input = "test -> fixed (42) test "
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(FIXED, schema.ns[nil].group("test").field("test").type.class)        
-        assert_equal(42, schema.ns[nil].group("test").field("test").type.size)
-    end
-
-    def test_enum
-        input = "colour = | blue"
-        schema = Schema.new(SchemaBuffer.new(input))
-    end
-
-    def test_enum_many
-        input = "colour = blue | white | red/5"
-        schema = Schema.new(SchemaBuffer.new(input))
-    end
-
-    def test_ref_enum
-        input = "colour = | blue test -> colour test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(REF, schema.ns[nil].group("test").field("test").type.class)
-        assert_equal(ENUMERATION, schema.ns[nil].group("test").field("test").type.ref.class)
-        assert_equal("blue", schema.ns[nil].group("test").field("test").type.ref.symbol("blue").name)
-        assert_equal(0, schema.ns[nil].group("test").field("test").type.ref.symbol("blue").val)        
-    end
-
-    def test_ref_enum_many
-        input = "colour = blue | white | red/5 | orange test -> colour test"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal(REF, schema.ns[nil].group("test").field("test").type.class)
-        assert_equal(ENUMERATION, schema.ns[nil].group("test").field("test").type.ref.class)
-        assert_equal("blue", schema.ns[nil].group("test").field("test").type.ref.symbol("blue").name)
-        assert_equal(0, schema.ns[nil].group("test").field("test").type.ref.symbol("blue").val)        
-        assert_equal("white", schema.ns[nil].group("test").field("test").type.ref.symbol("white").name)
-        assert_equal(1, schema.ns[nil].group("test").field("test").type.ref.symbol("white").val)        
-        assert_equal("red", schema.ns[nil].group("test").field("test").type.ref.symbol("red").name)
-        assert_equal(5, schema.ns[nil].group("test").field("test").type.ref.symbol("red").val)        
-        assert_equal("orange", schema.ns[nil].group("test").field("test").type.ref.symbol("orange").name)
-        assert_equal(6, schema.ns[nil].group("test").field("test").type.ref.symbol("orange").val)        
-    end
-
-    def test_static_group
-        input = "static -> u8 one, u16 two test -> static one, string two"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal("one", schema.ns[nil].group("test").field("one").nameWithID.name)
-        assert_equal(REF, schema.ns[nil].group("test").field("one").type.class)
-        assert_equal(false, schema.ns[nil].group("test").field("one").type.dynamic?)
-        assert_equal("two", schema.ns[nil].group("test").field("two").nameWithID.name)
-        assert_equal(STRING, schema.ns[nil].group("test").field("two").type.class)
-        assert_equal("one", schema.ns[nil].group("test").field("one").type.ref.field("one").nameWithID.name)
-        assert_equal(U8, schema.ns[nil].group("test").field("one").type.ref.field("one").type.class)
-        assert_equal("two", schema.ns[nil].group("test").field("one").type.ref.field("two").nameWithID.name)
-        assert_equal(U16, schema.ns[nil].group("test").field("one").type.ref.field("two").type.class)        
-    end
-
-    def test_dynamic_group
-        input = "dynamic -> u8 one, u16 two test -> dynamic * one, string two"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal("one", schema.ns[nil].group("test").field("one").nameWithID.name)
-        assert_equal(REF, schema.ns[nil].group("test").field("one").type.class)
-        assert_equal(true, schema.ns[nil].group("test").field("one").type.dynamic?)
-        assert_equal("two", schema.ns[nil].group("test").field("two").nameWithID.name)
-        assert_equal(STRING, schema.ns[nil].group("test").field("two").type.class)
-        assert_equal("one", schema.ns[nil].group("test").field("one").type.ref.field("one").nameWithID.name)
-        assert_equal(U8, schema.ns[nil].group("test").field("one").type.ref.field("one").type.class)
-        assert_equal("two", schema.ns[nil].group("test").field("one").type.ref.field("two").nameWithID.name)
-        assert_equal(U16, schema.ns[nil].group("test").field("one").type.ref.field("two").type.class)        
-    end
-
-    def test_dynamic_not_group
-        input = "thing = u8 one test -> thing * one, string two"
-        assert_raise do
-           Schema.new(SchemaBuffer.new(input))
-        end
-    end
-
-    def test_any_group
-        input = "dynamic -> u8 one, u16 two test -> object one, string two"
-        schema = Schema.new(SchemaBuffer.new(input))
-        assert_equal("one", schema.ns[nil].group("test").field("one").nameWithID.name)
-        assert_equal(OBJECT, schema.ns[nil].group("test").field("one").type.class)        
-    end
-
-    def test_type_direct_reference_cycle
-        input =  <<-eos
-            thing = thingref
-            thingref = thing
-        eos
-        assert_raise do
-           Schema.new(SchemaBuffer.new(input))
-        end        
-    end
-
-    def test_type_inderect_reference_cycle
-        input =  <<-eos
-            thing = intermediate
-            intermediate = thingref
-            thingref = thing
-        eos
-        assert_raise do
-           Schema.new(SchemaBuffer.new(input))
-        end        
-    end
-
-    def test_sequence_sequence
-        input = "test -> i32 [] test"
-        Schema.new(SchemaBuffer.new(input))        
-    end
-
-    def test_sequence_sequence_direct
-        input =  <<-eos
-            intermediate = u32 []
-            test ->
-                intermediate [] test            
-        eos
-
-        assert_raise do
-            Schema.new(SchemaBuffer.new(input))
-        end
-        
-    end
-
-end