slow_blink 0.0.6 → 0.0.7

data/lib/slow_blink/message/model.rb

@@ -19,6 +19,7 @@
 #   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
 
     # This module is concerned with generating models from Schema that are optimised for encoding/decoding and enforcing constraints
@@ -112,63 +113,45 @@ module SlowBlink
                 @maxRecursion = opts[:maxRecursion]||DEFAULT_MAX_RECURSION
                 maxRecursion = @maxRecursion
 
-                # define the extension object
-                groups = @groups
+                # any of the groups
+                
                 taggedGroups = @taggedGroups
-                permitted = schema.tagged.keys
-                @extensionObject = Class.new(DynamicGroup) do
+                
+                @anyTaggedGroup = Class.new(DynamicGroup) do
                     @maxRecursion = maxRecursion
-                    @extensionObject = self
-                    @opt = false
-                    @groups = groups
+                    @anyTaggedGroup = self
                     @taggedGroups = taggedGroups
-                    @permitted = permitted                        
+                    @permittedID = schema.groups.map{|g|g.id}.select{|g|g}
                 end
-                extensionObject = @extensionObject
+                    
+                anyTaggedGroup = @anyTaggedGroup
                 
-                schema.groups.each do |name, g|
-                    fields = {}
-                    g.fields.each do |f|
-                        fields[f.nameWithID.name] = _model_field(f)
-                    end                    
-                    @groups[name] = Class.new(Group) do
-                        @extensionObject = extensionObject
+                # create an anon class for each group defined in schema                
+                schema.groups.each do |g|
+                    fields = g.fields.map{|f| _model_field(f)}
+                    @groups[g.name] = Class.new(Group) do
                         @maxRecursion = maxRecursion
-                        @name = g.nameWithID.name
-                        @id = g.nameWithID.id
-                        @fields = fields                    
+                        @anyTaggedGroup = anyTaggedGroup                        
+                        @name = g.name
+                        @id = g.id
+                        @fields = fields
                     end
-                    if g.nameWithID.id
-                        @taggedGroups[g.nameWithID.id] = @groups[name]
+                    if g.id
+                        @taggedGroups[g.id] = @groups[g.name]
                     end
                 end
 
-
             end
 
             # @api user
             #
             # Initialise a {Group} from a compact form string
-            # @param input [String] Blink Protocol compact form
+            # @param input [StringIO] Blink Protocol compact form
             # @return [Group] anonymous subclass instance of Group
             # @raise [WeakError,StrongError]
             # @raise [RecursionLimit]
-            # @raise []
             def decode_compact(input)
-                stack = []
-                inputSize = input.size
-                buf = input.getBinary!
-                if buf.size > 0
-                    id = buf.getU64!
-                    groupClass = @taggedGroups[id]                    
-                    if groupClass                        
-                        group = groupClass.from_compact!(buf, stack)                        
-                    else
-                        raise WeakError2.new "W2: Group id #{group.id} is unknown"
-                    end                    
-                else
-                    raise WeakError1.new "W1: Top level group cannot be null"
-                end
+                @anyTaggedGroup.from_compact(input, []).get
             end
 
             # @api user
@@ -179,11 +162,10 @@ module SlowBlink
             # @return [Group] anonymous subclass of Group
             # @raise [RangeError] unknown group
             def group(name)
-                group = @groups[name]
-                if group
-                    group
-                else
+                if (group = @groups[name]).nil?
                     raise RangeError.new "group '#{name}' is unknown"
+                else
+                    group
                 end                
             end
 
@@ -194,89 +176,47 @@ module SlowBlink
                 # @param field [SlowBlink::Field] field definition
                 # @return [Class] anonymous subclass of {Field}
                 def _model_field(field)
-                    type = _model_type(field.type, field.opt?)
+
+                    type = _model_type(field.type)
                     Class.new(Field) do
-                        @opt = field.opt?
-                        @name = field.nameWithID.name
-                        @id = field.nameWithID.id
+                        @optional = field.optional?
+                        @name = field.name
+                        @id = field.id
                         @type = type
-                    end                
+                        @sequence = field.type.sequence?                        
+                    end
                 end
 
                 # Create a model for a type
                 #
                 # @param type [SlowBlink::Type] type definition
                 # @param opt  [true,false] parent definition may allow this type to be optional
-                def _model_type(type, opt)
-                    extensionObject = @extensionObject
+                def _model_type(type)
+                    anyTaggedGroup = @anyTaggedGroup
                     maxRecursion = @maxRecursion
+
                     case type.class
                     when SlowBlink::OBJECT
-                        groups = @groups
+                        @anyTaggedGroup                    
+                    when SlowBlink::DynamicGroup
                         taggedGroups = @taggedGroups
-                        permitted = @taggedGroups.keys
                         Class.new(DynamicGroup) do
-                            @extensionObject = extensionObject
+                            @anyTaggedGroup = anyTaggedGroup
                             @maxRecursion = maxRecursion
-                            @opt = opt
-                            @groups = groups
                             @taggedGroups = taggedGroups
-                            @permitted = permitted                        
-                        end                     
-                    when SlowBlink::REF
-                        if type.ref.kind_of? SlowBlink::Group
-                            if type.dynamic?
-                                taggedGroups = @taggedGroups
-                                groups = @groups
-                                permitted = @taggedGroups.keys
-                                @schema.tagged.each do |id, g|
-                                    if g.group_kind_of?(type)
-                                        permitted << id
-                                    end
-                                end
-                                Class.new(DynamicGroup) do
-                                    @extensionObject = extensionObject
-                                    @maxRecursion = maxRecursion
-                                    @opt = opt
-                                    @taggedGroups = taggedGroups
-                                    @groups = groups
-                                    @permitted = permitted
-                                end                               
-                            else
-                                fields = {}
-                                type.ref.fields.each do |f|
-                                    fields[f.nameWithID.name] = _model_field(f)
-                                end                                                            
-                                Class.new(StaticGroup) do
-                                    @extensionObject = extensionObject
-                                    @maxRecursion = maxRecursion
-                                    @name = type.ref.nameWithID.name
-                                    @id = nil
-                                    @opt = opt
-                                    @fields = fields                                
-                                end                                                   
-                            end
-                        else
-                            _model_type(type.ref, false)
-                        end
-                    when SlowBlink::SEQUENCE
-                        t = _model_type(type.type, false)
-                        Class.new(SEQUENCE) do
-                            @maxRecursion = maxRecursion
-                            @type = t
-                        end
-                    when SlowBlink::ENUMERATION
-                        symbols = {}
-                        type.symbols.each do |n,v|
-                            symbols[n] = v.val
+                            @permittedID = type.groups.map{|g|g.id}
                         end
-                        Class.new(ENUMERATION) do
-                            @symbols = symbols
-                        end                        
-                    else
+                    when SlowBlink::StaticGroup
+                        fields = type.fields.map{|f| _model_field(f)}
+                        Class.new(StaticGroup) do
+                            @maxRecursion = maxRecursion                 
+                            @name = type.name
+                            @id = type.id
+                            @fields = fields                          
+                        end                                                                           
+                    else                    
                         Class.new(SlowBlink::Message.const_get(type.class.name.split('::').last)) do
-                            @opt = opt
-                            @type = type                                        
+                            @type = type                                       
                         end                    
                     end
                 end
@@ -287,6 +227,7 @@ module SlowBlink
 
 end
 
+require "stringio"
 require "slow_blink/message/ext_compact_encoder"
 require "slow_blink/message/field"
 require "slow_blink/message/integer"
@@ -294,9 +235,8 @@ require "slow_blink/message/string"
 require "slow_blink/message/binary"
 require "slow_blink/message/fixed"
 require "slow_blink/message/boolean"
-require "slow_blink/message/enumeration"
+require "slow_blink/message/enum"
 require "slow_blink/message/floating_point"
-require "slow_blink/message/sequence"
 require "slow_blink/message/group"
 require "slow_blink/message/time"
 require "slow_blink/message/time_of_day"

data/lib/slow_blink/message/string.rb

@@ -25,16 +25,15 @@ module SlowBlink::Message
     class STRING
 
         # @private
-        def self.from_compact!(input, stack)
-            value = input.getString!
-            if value
+        def self.from_compact(input, stack)
+            if value = input.getString
                 if !@type.size or value.size <= @type.size
                     self.new(value)
                 else
                     raise WeakError7.new "W7: String value exceeds maximum size"
                 end
             else
-                value
+                nil
             end               
         end
 

data/lib/slow_blink/message/time.rb

@@ -18,6 +18,7 @@
 #   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.
+
 require 'time'
 
 module SlowBlink::Message
@@ -26,12 +27,11 @@ module SlowBlink::Message
     class MILLI_TIME
 
         # @private
-        def self.from_compact!(input, stack)
-            value = input.getI64!
-            if value
+        def self.from_compact(input, stack)
+            if value = input.getI64
                 self.new(value)
             else
-                value
+                nil
             end
         end
 
@@ -51,7 +51,7 @@ module SlowBlink::Message
         # @raise [ArgumentError]
         def set(value)            
             if value.kind_of? Time or value.kind_of? DateTime or value.kind_of? Date
-                @value = time.to_datetime
+                @value = value.to_datetime
             elsif value.kind_of? String
                 @value = DateTime.parse(value)
             elsif value.kind_of? Integer

data/lib/slow_blink/message/time_of_day.rb

@@ -25,9 +25,8 @@ module SlowBlink::Message
     class TIME_OF_DAY_MILLI
 
         # @private
-        def self.from_compact!(input, stack)
-            value = input.getU32!
-            if value
+        def self.from_compact(input, stack)
+            if value = input.getU32
                 self.new(value)
             else
                 value
@@ -54,12 +53,7 @@ module SlowBlink::Message
 
         # @note calls {#set}(value)
         def initialize(value)
-            @opt = self.class.opt?
-            if value
-                set(value)
-            else
-                @value = nil
-            end
+            set(value)
         end
 
         # @private
@@ -73,9 +67,8 @@ module SlowBlink::Message
     class TIME_OF_DAY_NANO
 
         # @private
-        def self.from_compact!(input, stack)
-            value = input.getU64!
-            if value
+        def self.from_compact(input, stack)
+            if value = input.getU64
                 self.new(value)
             else
                 value

data/lib/slow_blink/ref.rb

@@ -22,88 +22,39 @@
 
 module SlowBlink
 
+    # A REF is a type that points to a Group or a Definition
+    # by a reference string.
+    #
+    #
     class REF < Type
 
-        # @return referenced object
+        # @return [String]
         attr_reader :ref
 
-        # @return [true] dynamic group reference
-        # @return [false] static reference
+        # @return [true,false]
         def dynamic?
             @dynamic
         end
 
-        # Either this reference is dynamic or an intermediate reference is dynamic
-        #
-        # @return [true,false]
-        def dynamic_reference?
-            @dynamic or @dynamic_reference                           
-        end
-
-        # @return [String]
-        attr_reader :qname
-
-        # @param qname [String] 
-        # @param dynamic [true,false]
-        # @param location [String]    
-        def initialize(qname, dynamic, location)
-            @qname = qname
-            if qname.split(":").size == 1
-                @namespace = nil
-                @name = qname                
-            else                
-                @namespace = qname.split(":").first
-                @name = qname.split(":").last
-            end
-            @dynamic = dynamic
-            @ref = nil
-            @dynamic_reference = false
-            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 @schema.nil?
-                if @namespace
-                    ref = schema.resolve(@namespace, @name)                    
-                else
-                    ref = ns.resolve(@name) or schema.resolve(@namespace, @name)
-                end
-                if ref and ref.link(schema, stack << self)
-                    # follow reference
-                    loop do
-                        if ref.kind_of? Definition
-                            if ref.type.kind_of? REF
-                                if ref.type.dynamic?
-                                    @dynamic_reference = true
-                                end
-                                ref = ref.type.ref                                
-                                next
-                            else
-                                ref = ref.type
-                            end
-                        end
-                        break
-                    end
-                                
-                    if @dynamic and !ref.kind_of? Group
-                        Log.error "#{@location}: error: a dynamic reference must resolve to a group that has an identifier"
-                    else
-                        @ref = ref
-                        @schema = schema
+        # @return [Group, Definition]
+        def resolve
+            result = nil
+            if @table
+                if (result = @table[@ref]).nil?                    
+                    if @ns and @ref.split("::").size == 1
+                        result = @table[@ns + "::" + @ref]
                     end
-                else                    
-                    Log.error "#{@location}: error: unresolved reference ('#{@qname}' is not defined as a group, type, or enum)"
                 end                
             end
-            @schema
+            result
+        end                    
+
+        # @private
+        def initialize(attr)
+            super(attr)
+            @ref = attr[:ref].freeze
+            @dynamic = attr[:dynamic]            
+            @table = attr[:table]
         end
         
     end

data/lib/slow_blink/schema.rb

@@ -20,7 +20,6 @@
 #   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 
-# SlowBlink namespace
 module SlowBlink
 
     # @!macro location
@@ -50,124 +49,104 @@ module SlowBlink
 
         # @api user
         #
-        # @return [Hash<Group>] groups indexed by qualified name
-        attr_reader :groups
+        # @return [Array<Group>] groups
+        def groups
+            @defs.values.select do |d|
+                d.is_a? Group
+            end
+        end
 
-        attr_reader :tagged
-        
-        # @return [Array<Namespace>]
-        attr_reader :ns
+        # @api user
+        #
+        # @return [Array<Definition,Group>] definitions
+        def definitions
+            @defs.values
+        end
 
         # @api user
         #
-        # Create a Schema from one or more SchemaBuffers that are evaluated
-        # in the order they appear.
+        # Create a Schema from one or more Blink Protocol schemas
         #
-        # @param buffer [Array<SchemaBuffer>]
+        # @param buffer [Array<SchemaBuffer,String>]
         def initialize(*buffer)
 
+            namespace = []
+
             if buffer.size > 0
-                namespace = []
                 buffer.each do |b|
-                    namespace << Namespace.parse(b.buffer, filename: b.filename)                    
+                    if buffer.kind_of? String
+                        namespace << SlowBlink.parse_file_buffer(buffer)
+                    else
+                        namespace << SlowBlink.parse_file_buffer(b.buffer, filename: b.filename)
+                    end
                 end
             else
                 raise ArgumentError.new "at least one buffer required"
             end
 
-            @ns = {}
-            @tagged = {}
-            
-            error = false          
-
-            # gather and merge namespaces
-            namespace.each do |ns|
-                if @ns[ns.name]
-                    begin
-                        @ns[ns.name].merge!(ns)
-                    rescue
-                        raise ParseError
+            @defs = {}
+
+            # create groups and definitions
+            namespace.each do |ns|    
+                ns[:defs].select{|d|d[:class] != :IncrementalAnnotation}.each do |d|
+                    key = d[:name][:name].dup
+                    if ns[:name]
+                        key.prepend "#{ns[:name]}::"
                     end
-                else
-                    @ns[ns.name] = ns
-                end
+                    if @defs[key]
+                        raise ParseError.new "#{d[:loc]}: duplicate definition: '#{key}' first defined at '#{@defs[key].location}'"
+                    else
+                        @defs[key] = SlowBlink.const_get(d[:class]).new(d.merge({:ns=>ns[:name], :table=>@defs}))
+                    end
+                end                
             end
 
-            # apply incremental annotation in order of input
-            namespace.each do |ns|
-                ns.incrAnnotations.each do |a|
-                    a.apply(self, ns)
-                end
-            end
-            
-            # gather tagged groups and detect duplicates
-            @ns.each do |name, ns|
-                ns.groups.each do |g|
-                    if g.nameWithID.id
-                        if @tagged[g.nameWithID.id]
-                            Log.error "error: groups that have identifiers must have unique identifiers ('#{@g.nameWithID.id}' was first assigned to '#{@tagged[g.nameWithID.id].nameWithID.name}' at #{@tagged[g.nameWithID.id].location}"
-                            error = true
-                        else
-                            @tagged[g.nameWithID.id] = g
+            # test that reference definitions resolve and detect circular references
+            @defs.values.each do |d|
+                if d.is_a? Definition and d.type.is_a? REF
+                    ptr = d.type.resolve
+                    if ptr        
+                        stack = [d]
+                        while ptr and ptr.is_a? Definition and ptr.type.is_a? REF do
+                            if stack.include? ptr
+                                raise ParseError.new "#{d.type.location}: '#{d.name}' resolves to a circular reference"
+                            else
+                                ptr = ptr.type.resolve
+                            end
                         end
+                    else
+                        raise ParseError.new "#{d.type.location}: '#{d.name}' does not resolve"
                     end
                 end
             end
 
-            # resolve all references
-            @ns.each do |name, ns|
-                if !ns.link(self)
-                    error = true
-                end
-            end
-
-            # create list of all groups with qualified names
-            @groups = {}
-            @ns.each do |name, ns|
-                ns.groups.each do |g|
-                    if name
-                        @groups[g.nameWithID.name.prepend "#{name}:"] = g
+            # test that groups resolve and meet constraints
+            tagged = {}
+            @defs.values.each do |d|                
+                if d.is_a? Group
+                    d.superGroup
+                    d.fields
+                    if d.id and tagged[d.id]
+                        raise ParseError.new "#{d.type.location}: duplicate tag"
                     else
-                        @groups[g.nameWithID.name] = g
-                    end                
+                        tagged[d.id] = d
+                    end                    
                 end
             end
 
-            if error
-                raise ParseError
-            end
-            
         end
 
-        # Resolve a name to a definition in any namespace
-        #
-        # @param namespace [String,nil]
-        # @param name [String]
-        # @return [Definition,Group]
-        def resolve(namespace, name)
-            if @ns[namespace]
-                @ns[namespace].resolve(name)
-            else
-                nil
-            end               
-        end
-    
     end    
 
 end
 
 require 'slow_blink/parse_error'
-require 'slow_blink/log'
 require 'slow_blink/schema_buffer'
-require 'slow_blink/annotatable'
-require 'slow_blink/namespace'
 require 'slow_blink/version'
-require 'slow_blink/annotation'
-require 'slow_blink/incremental_annotation'
-require 'slow_blink/group'
 require 'slow_blink/field'
-require 'slow_blink/definition'
 require 'slow_blink/type'
+require 'slow_blink/static_group'
+require 'slow_blink/dynamic_group'
 require 'slow_blink/integer'
 require 'slow_blink/decimal'
 require 'slow_blink/floating_point'
@@ -177,13 +156,13 @@ require 'slow_blink/fixed'
 require 'slow_blink/date'
 require 'slow_blink/time_of_day'
 require 'slow_blink/time'
-require 'slow_blink/sequence'
 require 'slow_blink/ref'
+require 'slow_blink/group'
 require 'slow_blink/object'
 require 'slow_blink/boolean'
-require 'slow_blink/enumeration'
+require 'slow_blink/enum'
 require 'slow_blink/sym'
-require 'slow_blink/name_with_id'
+require 'slow_blink/definition'
 require 'slow_blink/ext_schema_parser'
 
 

data/lib/slow_blink/schema_buffer.rb

@@ -22,10 +22,7 @@
 
 module SlowBlink
 
-    # Use schema buffer when you want to deal with schemas in-memory
-    # rather than loading from files.
-    #
-    # It combines the schema string with an optional filename string.
+    # Use SchemaBuffer when you want to deal named in-memory schemas
     #
     # e.g:
     #