slow_blink 0.0.4 → 0.0.5

data/lib/slow_blink/message/model.rb

@@ -19,99 +19,113 @@
 
 module SlowBlink
 
+    # This module is concerned with generating models from Schema that are optimised for encoding/decoding and enforcing constraints
     module Message
 
-        class Error < Exception
+        class Error < StandardError
         end
 
         class Model
 
+            # the maximum level of nesting in messages able to be decoded by models
+            DEFAULT_MAX_RECURSION = 100
+
             # @api user
             #
             # Create a Model from a {Schema}
             #
             # @param schema [SlowBlink::Schema]
-            def initialize(schema)
+            # @param opts [Hash]
+            #
+            # @option opts [Symbol] :maxRecursion
+            #
+            def initialize(schema, **opts)
+
                 @schema = schema
-                @taggedGroups = {}                
-                schema.tagged.each do |id, g|
-                    @taggedGroups[id] = _model_group(false, g)                    
-                end                
+                @taggedGroups = {}
+                @groups = {}
+                @maxRecursion = opts[:maxRecursion]||DEFAULT_MAX_RECURSION
+                maxRecursion = @maxRecursion
+
+                # define the extension object
+                groups = @groups
                 taggedGroups = @taggedGroups
-                @top = Class.new(DynamicGroup) do
+                permitted = schema.tagged.keys
+                @extensionObject = Class.new(DynamicGroup) do
+                    @maxRecursion = maxRecursion
+                    @extensionObject = self
                     @opt = false
-                    @groups = taggedGroups
-                    @permitted = taggedGroups.keys                    
-                end                
+                    @groups = groups
+                    @taggedGroups = taggedGroups
+                    @permitted = permitted                        
+                end
+                extensionObject = @extensionObject
+                
+                schema.groups.each do |name, g|
+                    this = self
+                    @groups[name] = Class.new(Group) do
+                        @extensionObject = extensionObject
+                        @maxRecursion = maxRecursion
+                        @name = g.nameWithID.name
+                        @id = g.nameWithID.id
+                        @fields = {}
+                        g.fields.each do |f|
+                            @fields[f.nameWithID.name] = this._model_field(f)
+                        end                   
+                    end
+                    if g.nameWithID.id
+                        @taggedGroups[g.nameWithID.id] = @groups[name]
+                    end
+                end
+
+
             end
 
             # @api user
             #
             # Initialise a message model instance with a compact form string
             #
-            # @note return value will be an *anonymous* *subclass* *instance* of {DynamicGroup}
+            # @note return value will be an *anonymous* *subclass* *instance* of {Group}
             #
-            # @param [String] Blink Protocol compact form
-            # @return [DynamicGroup] group instance
+            # @param input [String] Blink Protocol compact form
+            # @return [Group] group instance
             #
             def decode_compact(input)
-                @top.from_compact!(input.dup)
-            end
-
-            # @api user
-            #
-            # Create an instance of a group subclass
-            #
-            # @note return value will be an *anonymous* *subclass* *instance* of {DynamicGroup} or {StaticGroup}
-            #
-            # @overload group(name, data)
-            #           
-            #   @param name [String] name of group
-            #   @param data [Hash] bulk initialisation data
-            #   @return [StaticGroup,DynamicGroup] group instance
-            #
-            # @overload group(name)
-            #   
-            #   @param name [String] name of group
-            #   @yield [Group] group instance to initalise
-            #   @return [StaticGroup,DynamicGroup] group instance            
-            #
-            def group(name, data=nil, &block)
-                group = @top.groups.values.detect{|g|g.name == name}
-                if group                    
-                    top = @top.new(group.new(data))
-                    if block
-                        self.instance_exec(top, &block)
-                        # validate optional constraint here
+                stack = []
+                inputSize = input.size
+                buf = input.getBinary!
+                if buf.size > 0
+                    id = buf.getU64!
+                    groupClass = @taggedGroups[id]
+                    begin
+                        if groupClass                        
+                            group = groupClass.from_compact!(buf, stack)                        
+                        else
+                            raise Error.new "W2: Group id #{group.id} is unknown"
+                        end
+                    rescue Error => ex
+                        puts ex
+                        puts "encountered at offset #{inputSize - input.size}"
+                        puts stack.last.name
+                        raise
                     end
-                    top
                 else
-                    raise
+                    raise Error.new "W1: Top level group cannot be null "                    
                 end
             end
 
-            # @api private
+            # @api user
             #
-            # Create a model for a Group
+            # Get a group model
             #
-            # @param opt [true,false] this group is allowed to be optional
-            # @param group [SlowBlink::Group] group definition
-            # @return [Class] anonymous subclass of {StaticGroup}
-            def _model_group(opt, group)
-                this = self
-                Class.new(StaticGroup) do
-                    @implements = group.class
-                    @name = group.nameWithID.name
-                    @id = group.nameWithID.id
-                    @opt = opt
-                    @fields = group.fields.inject([]) do |fields, f|
-                        fields << this._model_field(f)                        
-                    end
-                    
-                end            
+            # @param name [String] name of group (may be qualified)
+            # @return [Class] {DynamicGroup} or {Group}
+            # @return [nil] group not defined
+            #
+            def group(name)
+                @groups[name]            
             end
 
-
             # @api private
             #
             # Create a model for a Field
@@ -121,11 +135,10 @@ module SlowBlink
             def _model_field(field)
                 this = self
                 Class.new(Field) do
-                    @implements = field.class
                     @opt = field.opt?
                     @name = field.nameWithID.name
                     @id = field.nameWithID.id
-                    @type = this._model_type(field)
+                    @type = this._model_type(field.type, field.opt?)
                 end                
             end
 
@@ -133,50 +146,71 @@ module SlowBlink
             #
             # Create a model for a type
             #
-            # @param field [SlowBlink::Field] field definition (containing type)
-            # @return [Class] anonymous subclass
-            def _model_type(field)
-                type = field.type
-                name = field.nameWithID.name    
+            # @param type [SlowBlink::Type] type definition
+            # @param opt  [true,false] parent definition may allow this type to be optional
+            #
+            #            
+            def _model_type(type, opt)
+                this = self
+                extensionObject = @extensionObject
+                maxRecursion = @maxRecursion
                 case type.class
                 when SlowBlink::OBJECT
                     groups = @groups
-                    permitted = @schema.tagged.keys
-                    klass = Class.new(DynamicGroup) do
-                        @implements = type.class
-                        @opt = field.opt?                        
+                    taggedGroups = @taggedGroups
+                    permitted = @taggedGroups.keys
+                    Class.new(DynamicGroup) do
+                        @extensionObject = extensionObject
+                        @maxRecursion = maxRecursion
+                        @opt = opt
                         @groups = groups
+                        @taggedGroups = taggedGroups
                         @permitted = permitted                        
-                    end                               
+                    end                     
                 when SlowBlink::REF
-                    if type.ref.kind_of? Group
+                    if type.ref.kind_of? SlowBlink::Group
                         if type.dynamic?
+                            taggedGroups = @taggedGroups
                             groups = @groups
-                            permitted = @schema.tagged.keys
+                            permitted = @taggedGroups.keys
                             @schema.tagged.each do |id, g|
                                 if g.group_kind_of?(type)
                                     permitted << id
                                 end
                             end
                             Class.new(DynamicGroup) do
-                                @implements = type.class
-                                @name = name
-                                @opt = field.opt?
+                                @extensionObject = extensionObject
+                                @maxRecursion = maxRecursion
+                                @opt = opt
+                                @taggedGroups = taggedGroups
                                 @groups = groups
                                 @permitted = permitted
                             end                               
                         else
-                            _model_group(field.opt?, type.ref)
+                            Class.new(StaticGroup) do
+                                @extensionObject = extensionObject
+                                @maxRecursion = maxRecursion
+                                @name = type.ref.nameWithID.name
+                                @id = nil
+                                @opt = opt
+                                @fields = {}
+                                type.ref.fields.each do |f|
+                                    @fields[f.nameWithID.name] = this._model_field(f)
+                                end                                                            
+                            end                                                   
                         end
                     else
-                        _model_type(opt, type.ref)
+                        _model_type(type.ref)
                     end
-                else                        
+                when SlowBlink::SEQUENCE
+                    Class.new(SEQUENCE) do
+                        @maxRecursion = maxRecursion
+                        @type = this._model_type(type.type, false)
+                    end                    
+                else
                     Class.new(SlowBlink::Message.const_get(type.class.name.split('::').last)) do
-                        klass = 
-                        @opt = field.opt?
-                        @name = name
-                        @type = type                        
+                        @opt = opt
+                        @type = type                                        
                     end                    
                 end
             end
@@ -187,6 +221,7 @@ module SlowBlink
 
 end
 
+require "slow_blink/message/ext_compact_encoder"
 require "slow_blink/message/field"
 require "slow_blink/message/integer"
 require "slow_blink/message/string"
@@ -200,4 +235,5 @@ require "slow_blink/message/group"
 require "slow_blink/message/time"
 require "slow_blink/message/time_of_day"
 require "slow_blink/message/date"
+require "slow_blink/message/decimal"
 

data/lib/slow_blink/message/sequence.rb

@@ -20,56 +20,71 @@
 module SlowBlink::Message
 
     class SEQUENCE
+
+        # @return the type that repeats in this SEQUENCE
+        def self.type
+            @type
+        end
             
-        def self.from_compact!(input)
+        def self.from_compact!(input, stack)
+
+            if stack.size < @maxRecursion
+                stack << self
+            else
+                raise Error.new "stack limit"
+            end
+        
             value = []
             size = input.getU32!
             if size
                 while out.size < size do
-                    value << @type.from_compact!(input)
+                    value << @type.from_compact!(input, stack)
                 end
                 self.new(value)
             else
-                self.new
+                nil
             end
-        end
 
-        # @param v [Array,nil]
-        def set(value)
-            if value
-                if value.kind_of? Array
-                    @value = v
-                else
-                    raise Error.new "bad type"
-                end
-            elsif self.class.opt?
-                @value = nil
-            else
-                raise Error.new "value unacceptable"
-            end
+            stack.pop
+            
         end
 
+        # @return [Array]
         def get
             @value
         end
 
+        # Set value of a SEQUENCE
+        #
         # @param value [Array]
-        def initialize(value)
-            if value
-                set(value)
+        # @raise [TypeError]
+        # @raise [RangeError]
+        #
+        def set(value)
+            @value = []
+            if value.kind_of? Array
+                value.each do |v|
+                    if v.kind_of? self.class.type
+                        @value << v
+                    else
+                        @value << self.class.type.new(v)
+                    end
+                end
             else
-                @value = nil
+                raise TypeError.new "expecting an array"
             end
         end
 
+        # @note calls {#set}(value)
+        def initialize(value)       
+            set(value)            
+        end
+
         def to_compact(out)
-            if @value                
-                @value.inject(out.putU32(@value.size)) do |out, v|
-                    out << v.to_compact
-                end
-            else
-                out.putU32(nil)
-            end                
+            out.putU32(@value.size)
+            @value.each do |value|                                
+                value.to_compact(out)
+            end            
         end
 
     end

data/lib/slow_blink/message/string.rb

@@ -21,15 +21,7 @@ module SlowBlink::Message
 
     class STRING
 
-        def self.name
-            @name
-        end
-
-        def self.opt?
-            @opt
-        end
-
-        def self.from_compact!(input)
+        def self.from_compact!(input, stack)
             value = input.getString!
             if value
                 if !@type.size or value.size <= @type.size
@@ -37,52 +29,46 @@ module SlowBlink::Message
                 else
                     raise Error.new "W7: String value exceeds maximum size"
                 end
-            elsif @opt
-                self.new(nil)
             else
-                raise Error.new "W5: Value cannot be null"
-            end
+                value
+            end               
         end
 
+        # @return [Integer,nil] maximum size of string in bytes
         def self.size
             @type.size
         end
 
+        # @return [String]
         def get
             @value
         end
 
+        # Set a string value
+        # @param value [String]
+        # @raise [TypeError]
+        # @raise [RangeError] value is larger than {::size}
         def set(value)
-            if value
-                if value.kind_of? String
-                    if !self.class.size or value.size <= self.class.size
-                        @value = value
-                    else
-                        raise Error.new "string cannot be larger than #{self.class.size} bytes"
-                    end
+            if value.kind_of? String 
+                if !self.class.size or value.size <= self.class.size
+                    @value = value.to_s
                 else
-                    raise Error.new "expecting a string type"
+                    raise RangeError.new "String instance cannot be larger than #{self.class.size} bytes"
                 end
-            elsif self.class.opt?
-                @value = nil
             else
-                raise Error.new "string cannot be null"
-            end
+                raise TypeError.new "expecting a String instance"
+            end            
         end
 
+        # @note calls {#set}(value)
         def initialize(value)
-            @value = nil
-            if value
-                set(value)
-            end
+            set(value)
         end
 
         def to_compact(out)
             out.putString(@value)
         end
 
-        
-        
     end
 
 end

data/lib/slow_blink/message/time.rb

@@ -17,46 +17,84 @@
 # 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::Message
+require 'time'
 
+module SlowBlink::Message
 
     class MILLI_TIME
 
-        def self.from_compact!(input)
-            self.new(input.getI64!)
-        end
-
-        def set(value)
+        def self.from_compact!(input, stack)
+            value = input.getI64!
             if value
-                raise
-            elsif self.class.opt?
-                @value = nil
+                self.new(value)
             else
-                raise 
+                value
             end
         end
 
+        # @return [DateTime]
         def get
             @value
         end
 
-        def initialize(value)
-            if value
-                set(value)
+        # @overload set(value)
+        #   Set a millisecond time value
+        #   @param value [Time,DateTime,Date]
+        # @overload set(value)
+        #   @param value [String] time in ISO 8601
+        # @overload set(value)
+        #   @param value [String] time in milliseconds since UNIX epoch
+        # @raise [TypeError]
+        # @raise [ArgumentError]
+        def set(value)            
+            if value.kind_of? Time or value.kind_of? DateTime or value.kind_of? Date
+                @value = time.to_datetime
+            elsif value.kind_of? String
+                @value = DateTime.parse(value)
+            elsif value.kind_of? Integer
+                @value = DateTime.new(value)
             else
-                @value = nil
-            end
+                raise TypeError
+            end                        
         end
 
-        def to_compact(out)
-            out.putI64(@value)
+        # @note calls {#set}(value)
+        def initialize(value)
+            set(value)            
         end
 
+        def to_compact(out)
+            out.putI64(@value.strftime('%Q'))            
+        end
     
     end
 
     class NANO_TIME < MILLI_TIME
         
+        def to_compact(out)
+            out.putI64(@value.strftime('%N'))
+        end
+
+        # @overload set(value)
+        #   Set a nanosecond resolution time value
+        #   @param value [Time,DateTime,Date]
+        # @overload set(value)
+        #   @param value [String] time in ISO 8601
+        # @overload set(value)
+        #   @param value [Integer] time in nanoseconds since UNIX epoch
+        # @raise [TypeError]
+        # @raise [ArgumentError]
+        def set(value)            
+            if value.kind_of? Time or value.kind_of? DateTime or value.kind_of? Date
+                @value = time.to_datetime
+            elsif value.kind_of? String
+                @value = DateTime.parse(value)
+            elsif value.kind_of? Integer
+                @value = DateTime.new(value)
+            else
+                raise TypeError
+            end                        
+        end
         
     end