slow_blink 0.0.3 → 0.0.4

data/lib/slow_blink/message/integer.rb

@@ -19,199 +19,150 @@
 
 module SlowBlink::Message
 
-    module INTEGER
+    class INTEGER
 
-        module CLASS
-
-            def name
-                @name
-            end
-
-            def opt?
-                @opt
-            end
-
-            def in_range?(value)
-                @type.class::RANGE.cover? value
-            end
+        def self.name
+            @name
+        end
 
+        def self.opt?
+            @opt
         end
 
-        module INSTANCE
+        def self.in_range?(value)
+            @type.class::RANGE.cover? value
+        end
 
-            def set(value)
-                if value
-                    if value.kind_of? Integer
-                        if self.class.in_range?(value)
-                            @value = value.to_i
-                        else
-                            raise Error.new "value out of range"
-                        end
+        def set(value)
+            if value
+                if value.kind_of? Integer
+                    if self.class.in_range?(value)
+                        @value = value.to_i
                     else
-                        raise Error.new "value must be an integer"
+                        raise Error.new "value out of range"
                     end
-                elsif self.class.opt?
-                    @value = nil
                 else
-                    raise Error.new "value unacceptable"
+                    raise Error.new "value must be an integer"
                 end
+            elsif self.class.opt?
+                @value = nil
+            else
+                raise Error.new "value unacceptable"
             end
-            
-            def get
-                @value
-            end
+        end
+        
+        def get
+            @value
+        end
 
-            # @param value [Integer, nil]
-            def initialize(value)
-                if value
-                    set(value)
-                else
-                    @value = nil
-                end
+        # @param value [Integer, nil]
+        def initialize(value)
+            if value
+                set(value)
+            else
+                @value = nil
             end
         end
+
         
     end
 
-    module U8
+    class U8 < INTEGER
 
-        module CLASS    
-            include SlowBlink::Message::INTEGER::CLASS
-            def from_compact!(input)
-                self.new(input.getU8!)
-            end
+    
+        def self.from_compact!(input)
+            self.new(input.getU8!)
         end
 
-        module INSTANCE
-            include SlowBlink::Message::INTEGER::INSTANCE
-            def to_compact(out)
-                out.putU8(@value)
-            end
+        def to_compact(out)
+            out.putU8(@value)
         end
         
+        
     end
 
-    module U16
+    class U16 < INTEGER
 
-        module CLASS
-            include SlowBlink::Message::INTEGER::CLASS
-            def from_compact!(input)
-                self.new(input.getU16!)
-            end
+        def self.from_compact!(input)
+            self.new(input.getU16!)
         end
-
-        module INSTANCE
-            include SlowBlink::Message::INTEGER::INSTANCE
-            def to_compact(out)
-                out.putU16(@value)
-            end
+    
+        def to_compact(out)
+            out.putU16(@value)
         end
+        
     end
 
-    module U32
+    class U32 < INTEGER
 
-        module CLASS            
-            include SlowBlink::Message::INTEGER::CLASS
-            def from_compact!(input)
-                self.new(input.getU32!)
-            end
+        def self.from_compact!(input)
+            self.new(input.getU32!)
         end
 
-        module INSTANCE
-            include SlowBlink::Message::INTEGER::INSTANCE
-            def to_compact(out)
-                out.putU32(@value)
-            end
+        def to_compact(out)
+            out.putU32(@value)
         end
         
     end
 
-    module U64
+    class U64 < INTEGER
 
-        module CLASS
-            include SlowBlink::Message::INTEGER::CLASS
-            def from_compact!(input)
-                self.new(input.getU64!)
-            end
+        def self.from_compact!(input)
+            self.new(input.getU64!)
         end
-
-        module INSTANCE
-            include SlowBlink::Message::INTEGER::INSTANCE
-            def to_compact(out)
-                out.putU64(@value)
-            end
+    
+        def to_compact(out)
+            out.putU64(@value)
         end
         
     end
 
-    module I8
+    class I8 < INTEGER
 
-        module CLASS
-            include SlowBlink::Message::INTEGER::CLASS
-            def from_compact!(input)
-                self.new(input.getI8!)
-            end
+        def self.from_compact!(input)
+            self.new(input.getI8!)
         end
-
-        module INSTANCE
-            include SlowBlink::Message::INTEGER::INSTANCE
-            def to_compact(out)
-                out.putI8(@value)
-            end
+    
+        def to_compact(out)
+            out.putI8(@value)
         end
         
     end
 
-    module I16
-        module CLASS
-            include SlowBlink::Message::INTEGER::CLASS
-            def from_compact!(input)
-                self.new(input.getI16!)
-            end
+    class I16 < INTEGER
+        
+        def self.from_compact!(input)
+            self.new(input.getI16!)
         end
-
-        module INSTANCE
-            include SlowBlink::Message::INTEGER::INSTANCE
-            def to_compact(out)
-                out.putI16(@value)
-            end
+    
+        def to_compact(out)
+            out.putI16(@value)
         end
         
     end
 
-    module I32
+    class I32 < INTEGER
 
-        module CLASS
-            include SlowBlink::Message::INTEGER::CLASS
-            def from_compact!(input)
-                self.new(input.getI32!)
-            end
+        def self.from_compact!(input)
+            self.new(input.getI32!)
         end
-
-        module INSTANCE
-            include INTEGER::INSTANCE
-            def to_compact(out)
-                out.putI32(@value)
-            end
+    
+        def to_compact(out)
+            out.putI32(@value)
         end
         
     end
 
-    module I64
+    class I64 < INTEGER
 
-        module CLASS
-            include SlowBlink::Message::INTEGER::CLASS
-            def from_compact!(input)
-                self.new(input.getI64!)
-            end
+        def self.from_compact!(input)
+            self.new(input.getI64!)
         end
-            
-        module INSTANCE
-            include SlowBlink::Message::INTEGER::INSTANCE
-            def to_compact(out)
-                out.putI64(@value)
-            end
+    
+        def to_compact(out)
+            out.putI64(@value)
         end
+        
     end
 
 end

data/lib/slow_blink/message/model.rb

@@ -26,110 +26,115 @@ module SlowBlink
 
         class Model
 
-            # @param nameOrID [String,Integer] name or id of top-level group
-            # @return [Class] anonymous class extending {DynamicGroup::CLASS} and including {DynamicGroup::INSTANCE}            
-            def [](nameOrID)
-                if nameOrID.kind_of? Integer
-                    @top.new(@top.groups.values.detect{|g|g.name == nameOrID})
-                else
-                    @top.new(@top.groups[nameOrID])
-                end                    
-            end
-
-            attr_reader :top
-
-            # Initialise a message model from a schema
+            # @api user
+            #
+            # Create a Model from a {Schema}
             #
-            # @param schema [Schema]
-            # @param opts [Hash]
-            def initialize(schema, **opts)
+            # @param schema [SlowBlink::Schema]
+            def initialize(schema)
                 @schema = schema
-                @groups = {}                
+                @taggedGroups = {}                
                 schema.tagged.each do |id, g|
-                    @groups[id] = _model_group(false, g)                    
+                    @taggedGroups[id] = _model_group(false, g)                    
                 end                
-                groups = @groups
-                @top = Class.new do
+                taggedGroups = @taggedGroups
+                @top = Class.new(DynamicGroup) do
                     @opt = false
-                    @groups = groups
-                    @permitted = groups.keys
-                    extend DynamicGroup::CLASS
-                    include DynamicGroup::INSTANCE
+                    @groups = taggedGroups
+                    @permitted = taggedGroups.keys                    
                 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}
+            #
+            # @param [String] Blink Protocol compact form
+            # @return [DynamicGroup] group instance
+            #
             def decode_compact(input)
                 @top.from_compact!(input.dup)
             end
 
-            def encode_compact(input)
-                @top.from_compact!(input)
-            end
-
-            def group(name, &block)
+            # @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(nil))
-                    top.instance_exec(top, &block)
+                    top = @top.new(group.new(data))
+                    if block
+                        self.instance_exec(top, &block)
+                        # validate optional constraint here
+                    end
                     top
                 else
                     raise
                 end
             end
 
-            def new(&block)
-                if block.nil?
-                    raise                    
-                end
-                result = self.instance_exec(&block)
-            end    
-
-            # @private
+            # @api private
             #
             # Create a model for a Group
             #
             # @param opt [true,false] this group is allowed to be optional
             # @param group [SlowBlink::Group] group definition
-            # @return [Class] anonymous class extending {StaticGroup::CLASS} and including {StaticGroup::INSTANCE}            
+            # @return [Class] anonymous subclass of {StaticGroup}
             def _model_group(opt, group)
                 this = self
-                klass = Class.new do
+                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
-                    extend StaticGroup::CLASS
-                    include StaticGroup::INSTANCE
+                    
                 end            
             end
 
 
-            # @private
+            # @api private
             #
             # Create a model for a Field
             #
             # @param field [SlowBlink::Field] field definition
-            # @return [Class] anonymous class extending {Field::CLASS} and including {Field::INSTANCE}            
+            # @return [Class] anonymous subclass of {Field}
             def _model_field(field)
                 this = self
-                klass = Class.new do
+                Class.new(Field) do
+                    @implements = field.class
                     @opt = field.opt?
                     @name = field.nameWithID.name
                     @id = field.nameWithID.id
                     @type = this._model_type(field)
-                    include Field::INSTANCE
-                    extend Field::CLASS
                 end                
             end
 
-            # @private
+            # @api private
             #
             # Create a model for a type
             #
             # @param field [SlowBlink::Field] field definition (containing type)
-            # @return [Class] anonymous class extending {Field::CLASS} and including {Field::INSTANCE}      
+            # @return [Class] anonymous subclass
             def _model_type(field)
                 type = field.type
                 name = field.nameWithID.name    
@@ -137,13 +142,11 @@ module SlowBlink
                 when SlowBlink::OBJECT
                     groups = @groups
                     permitted = @schema.tagged.keys
-                    klass = Class.new do
-                        @opt = field.opt?
-                        
+                    klass = Class.new(DynamicGroup) do
+                        @implements = type.class
+                        @opt = field.opt?                        
                         @groups = groups
-                        @permitted = permitted
-                        extend DynamicGroup::CLASS
-                        include DynamicGroup::INSTANCE
+                        @permitted = permitted                        
                     end                               
                 when SlowBlink::REF
                     if type.ref.kind_of? Group
@@ -155,13 +158,12 @@ module SlowBlink
                                     permitted << id
                                 end
                             end
-                            klass = Class.new do
+                            Class.new(DynamicGroup) do
+                                @implements = type.class
                                 @name = name
                                 @opt = field.opt?
                                 @groups = groups
                                 @permitted = permitted
-                                extend DynamicGroup::CLASS
-                                include DynamicGroup::INSTANCE
                             end                               
                         else
                             _model_group(field.opt?, type.ref)
@@ -170,12 +172,11 @@ module SlowBlink
                         _model_type(opt, type.ref)
                     end
                 else                        
-                    return Class.new do
+                    Class.new(SlowBlink::Message.const_get(type.class.name.split('::').last)) do
+                        klass = 
                         @opt = field.opt?
                         @name = name
-                        @type = type
-                        extend SlowBlink::Message.const_get(type.class.name.split('::').last + "::CLASS")
-                        include SlowBlink::Message.const_get(type.class.name.split('::').last + "::INSTANCE")
+                        @type = type                        
                     end                    
                 end
             end

data/lib/slow_blink/message/sequence.rb

@@ -19,65 +19,57 @@
 
 module SlowBlink::Message
 
-    module SEQUENCE
-
-        module CLASS
-        
-            def from_compact!(input)
-                value = []
-                size = input.getU32!
-                if size
-                    while out.size < size do
-                        value << @type.from_compact!(input)
-                    end
-                    self.new(value)
-                else
-                    self.new
+    class SEQUENCE
+            
+        def self.from_compact!(input)
+            value = []
+            size = input.getU32!
+            if size
+                while out.size < size do
+                    value << @type.from_compact!(input)
                 end
+                self.new(value)
+            else
+                self.new
             end
-
         end
 
-        module INSTANCE
-
-            # @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
+        # @param v [Array,nil]
+        def set(value)
+            if value
+                if value.kind_of? Array
+                    @value = v
                 else
-                    raise Error.new "value unacceptable"
+                    raise Error.new "bad type"
                 end
+            elsif self.class.opt?
+                @value = nil
+            else
+                raise Error.new "value unacceptable"
             end
+        end
 
-            def get
-                @value
-            end
-
-            # @param value [Array]
-            def initialize(value)
-                if value
-                    set(value)
-                else
-                    @value = nil
-                end
-            end
+        def get
+            @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                
+        # @param value [Array]
+        def initialize(value)
+            if value
+                set(value)
+            else
+                @value = nil
             end
+        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                
         end
 
     end