sdl-ng 0.0.4 → 0.0.5

data/lib/sdl/receivers/type_instance_receiver.rb

@@ -1,90 +1,84 @@
-require 'active_support/inflector'
-
-module SDL
-  module Receivers
-    ##
-    # Receiver for setting the properties of Type instances
-    class TypeInstanceReceiver
-      attr_accessor :instance
-
-      attr_accessor :compendium
-
-      ##
-      # When initialized for a fact or type instance, the receiver creates singleton methods on itself for all
-      # properties.
-      def initialize(instance, compendium)
-        @instance = instance
-        @compendium = compendium
-
-        instance.class.properties(true).each do |property|
-          if property.single?
-            # Single valued properties are set by their name
-            define_singleton_method property.name do |value = nil, &block|
-              if value.is_a? Symbol
-                value = compendium.type_instances[property.type][value] || raise("Could not find instance :#{value.to_s} in predefined #{property.type.name} types")
-              end
+##
+# Receiver for setting the properties of Type instances
+class SDL::Receivers::TypeInstanceReceiver
+  attr_accessor :instance
+
+  attr_accessor :compendium
+
+  ##
+  # When initialized for a fact or type instance, the receiver creates singleton methods on itself for all
+  # properties.
+  def initialize(instance, compendium)
+    @instance = instance
+    @compendium = compendium
+
+    instance.class.properties(true).each do |property|
+      if property.single?
+        # Single valued properties are set by their name
+        define_singleton_method property.name do |value = nil, &block|
+          if value.is_a? Symbol
+            value = compendium.type_instances[property.type][value] || raise("Could not find instance :#{value.to_s} in predefined #{property.type.name} types")
+          end
 
-              begin
-                instance.send "#{property.name}=", value
-              rescue RuntimeError => e
-                raise RuntimeError, "Cannot set property '#{property.name}' of Type #{@instance.class.name}: #{e}", e.backtrace
+          begin
+            instance.send "#{property.name}=", value
+          rescue RuntimeError => e
+            raise RuntimeError, "Cannot set property '#{property.name}' of Type #{@instance.class.name}: #{e}", e.backtrace
+          end
+        end
+      else
+        # Multi-valued properties are added to by their singular name
+        define_singleton_method property.name.singularize do |*property_values, &block|
+          existing_list = instance.send "#{property.name}"
+
+          unless property_values.empty?
+            # If there is just one parameter for a multi-valued property setter
+            if property_values.length == 1
+              # It could be a symbol, which would resolve to a predefined type instance of the same name
+              if property_values[0].is_a?(Symbol)
+                predefined_value = compendium.type_instances[property.type][property_values[0]]
+
+                raise "Could not find instance :#{property_values[0]} in predefined #{property.type.name} types" unless predefined_value
+
+                existing_list << compendium.type_instances[property.type][property_values[0]]
+              # Or better: it could already be an instance of the type - e.g. when using the implemented #method_mssing
+              elsif property_values[0].is_a? property.type
+                existing_list << property_values[0]
               end
-            end
-          else
-            # Multi-valued properties are added to by their singular name
-            define_singleton_method property.name.singularize do |*property_values, &block|
-              existing_list = instance.send "#{property.name}"
-
-              unless property_values.empty?
-                # If there is just one parameter for a multi-valued property setter
-                if property_values.length == 1
-                  # It could be a symbol, which would resolve to a predefined type instance of the same name
-                  if property_values[0].is_a?(Symbol)
-                    predefined_value = compendium.type_instances[property.type][property_values[0]]
+            else
+              new_list_item = property.type.new
 
-                    raise "Could not find instance :#{property_values[0]} in predefined #{property.type.name} types" unless predefined_value
+              SDL::Receivers.set_value(property.type, new_list_item, *property_values, @compendium)
 
-                    existing_list << compendium.type_instances[property.type][property_values[0]]
-                  # Or better: it could already be an instance of the type - e.g. when using the implemented #method_mssing
-                  elsif property_values[0].is_a? property.type
-                    existing_list << property_values[0]
-                  end
-                else
-                  new_list_item = property.type.new
+              self.class.new(new_list_item, @compendium).instance_exec(&block) unless block.nil?
 
-                  SDL::Receivers.set_value(property.type, new_list_item, *property_values, @compendium)
-
-                  self.class.new(new_list_item, @compendium).instance_exec(&block) unless block.nil?
-
-                  existing_list << new_list_item
-                end
-              end
+              existing_list << new_list_item
             end
           end
         end
       end
+    end
+  end
 
-      def annotation(value)
-        @instance.annotations << value
-      end
+  def annotation(value)
+    @instance.annotations << value
+  end
 
-      ##
-      # Catches calls to methods named similarily to possible predefined type instances
-      def method_missing(name, *args)
-        # Possible type instances are all types of properties of properties of this instance ...
-        possible_type_classes = @instance.class.properties.map(&:type).map(&:properties).flatten.map(&:type).select{|type| type.wrapped_type < SDL::Base::Type}
+  ##
+  # Catches calls to methods named similarily to possible predefined type instances
+  def method_missing(name, *args)
+    # Possible type instances are all types of properties of properties of this instance ...
+    possible_type_classes = @instance.class.properties.map(&:type).map(&:properties).flatten.map(&:type).select{|type| type.wrapped_type < SDL::Base::Type}
 
-        # ... and the types of multi-value instances
-        possible_type_classes.concat(@instance.class.properties.find_all{|p| p.multi?}.map(&:type))
+    # ... and the types of multi-value instances
+    possible_type_classes.concat(@instance.class.properties.find_all{|p| p.multi?}.map(&:type))
 
-        possible_type_instances = @compendium.type_instances.select{|k, v| possible_type_classes.include?(k)}.map{|k, v| v[name]}.select{|v| v != nil}
+    possible_type_instances = @compendium.type_instances.select{|k, v| possible_type_classes.include?(k)}.map{|k, v| v[name]}.select{|v| v != nil}
 
-        unless possible_type_instances.nil? || possible_type_instances.empty?
-          possible_type_instances[0]
-        else
-          raise Exception.new("I do not know what to do with '#{name}' in #{caller[0]}")
-        end
-      end
+    unless possible_type_instances.nil? || possible_type_instances.empty?
+      possible_type_instances[0]
+    else
+      raise Exception.new("I do not know what to do with '#{name}' in #{caller[0]}")
     end
   end
 end

data/lib/sdl/receivers/type_receiver.rb

@@ -1,96 +1,92 @@
-module SDL
-  module Receivers
-    class TypeReceiver
-      include ActiveSupport::Inflector
+class SDL::Receivers::TypeReceiver
+  include ActiveSupport::Inflector
 
-      attr :klass
-      attr :subclasses
-      attr :compendium
+  attr :klass
+  attr :subclasses
+  attr :compendium
 
-      def initialize(sym, compendium, superklass = nil)
-        @compendium = compendium
-        @klass = Class.new(superklass || base_class)
-        @klass.local_name = sym.to_s.camelize
+  def initialize(sym, compendium, superklass = nil)
+    @compendium = compendium
+    @klass = Class.new(superklass || base_class)
+    @klass.local_name = sym.to_s.camelize
 
-        @subclasses = [@klass]
+    @subclasses = [@klass]
 
-        register_sdltype(@klass)
-      end
+    register_sdltype(@klass)
+  end
 
-      def base_class
-        SDL::Base::Type
-      end
+  def base_class
+    SDL::Base::Type
+  end
 
-      def register_sdltype(klass)
-        klass.class_eval do
-          include SDL::Types::SDLType
+  def register_sdltype(klass)
+    klass.class_eval do
+      include SDL::Types::SDLType
 
-          wraps self
-          codes local_name.underscore.to_sym
-        end
-      end
+      wraps self
+      codes local_name.underscore.to_sym
+    end
+  end
 
-      def subtype(sym, &definition)
-        receiver = self.class.new(sym, @compendium, @klass)
-        receiver.instance_eval(&definition) if block_given?
+  def subtype(sym, &definition)
+    receiver = self.class.new(sym, @compendium, @klass)
+    receiver.instance_eval(&definition) if block_given?
 
-        @subclasses.concat(receiver.subclasses)
-      end
+    @subclasses.concat(receiver.subclasses)
+  end
 
-      ##
-      # Define a list of a type, which is defined in the block.
-      def list(name, &block)
-        list_type = @compendium.type name.to_s.singularize.to_sym, &block
+  ##
+  # Define a list of a type, which is defined in the block.
+  def list(name, &block)
+    list_type = @compendium.type name.to_s.singularize.to_sym, &block
 
-        add_property name.to_sym, list_type, true
-      end
+    add_property name.to_sym, list_type, true
+  end
 
-      def method_missing(name, *args, &block)
-        sym = args[0] || name.to_sym
+  def method_missing(name, *args, &block)
+    sym = args[0] || name.to_sym
 
-        if name =~ /list_of_/
-          multi = true
-          type = @compendium.sdltype_codes[name.to_s.gsub('list_of_', '').singularize.to_sym]
-        else
-          multi = false
-          type = @compendium.sdltype_codes[name.to_sym]
-        end
+    if name =~ /list_of_/
+      multi = true
+      type = @compendium.sdltype_codes[name.to_s.gsub('list_of_', '').singularize.to_sym]
+    else
+      multi = false
+      type = @compendium.sdltype_codes[name.to_sym]
+    end
 
-        if type
-          add_property sym, type, multi
-        else
-          super(name, *args, &block)
-        end
-      end
+    if type
+      add_property sym, type, multi
+    else
+      super(name, *args, &block)
+    end
+  end
 
-      private
-        ##
-        # Adds accessors to set the property to the target class.
-        def add_property(sym, type, multi)
-          unless multi
-            @klass.class_eval do
-              attr_reader sym
-
-              # Setter
-              define_method "#{sym}=" do |value|
-                if type < SDL::Types::SDLSimpleType
-                  instance_variable_set "@#{sym}".to_s, type.new(value)
-                else
-                  instance_variable_set "@#{sym}".to_s, value
-                end
-              end
-            end
-          else
-            # Define accessor method for lists
-            @klass.class_eval do
-              define_method sym do
-                eval "@#{sym} ||= []"
-              end
+  private
+    ##
+    # Adds accessors to set the property to the target class.
+    def add_property(sym, type, multi)
+      unless multi
+        @klass.class_eval do
+          attr_reader sym
+
+          # Setter
+          define_method "#{sym}=" do |value|
+            if type < SDL::Types::SDLSimpleType
+              instance_variable_set "@#{sym}".to_s, type.new(value)
+            else
+              instance_variable_set "@#{sym}".to_s, value
             end
           end
-
-          @klass.properties << SDL::Base::Property.new(sym, type, @klass, multi)
         end
+      else
+        # Define accessor method for lists
+        @klass.class_eval do
+          define_method sym do
+            eval "@#{sym} ||= []"
+          end
+        end
+      end
+
+      @klass.properties << SDL::Base::Property.new(sym, type, @klass, multi)
     end
-  end
 end

data/lib/sdl/types.rb

@@ -1,12 +1,3 @@
-require_relative 'types/sdl_type'
-require_relative 'types/sdl_simple_type'
-require_relative 'types/sdl_string'
-require_relative 'types/sdl_description'
-require_relative 'types/sdl_number'
-require_relative 'types/sdl_duration'
-require_relative 'types/sdl_url'
-require_relative 'types/sdl_datetime'
-
 module SDL
   ##
   # This module contains the SDL type system.
@@ -15,5 +6,20 @@ module SDL
   # * When setting a property, its new value is checked for type compatibility to the wrapped Ruby class
   # * When exporting a service description, the wrapper is used to determine the serialization format
   module Types
+    extend ActiveSupport::Autoload
+
+    # Required, as these types register Receiver methods for their usage in property definitions.
+    eager_autoload do
+      autoload :SDLType
+      autoload :SDLSimpleType
+      autoload :SDLDatetime
+      autoload :SDLDescription
+      autoload :SDLDuration
+      autoload :SDLNumber
+      autoload :SDLString
+      autoload :SDLUrl
+    end
+
+    eager_load!
   end
 end

data/lib/sdl/types/sdl_datetime.rb

@@ -1,10 +1,6 @@
-module SDL
-  module Types
-    class SDLDatetime < SDLSimpleType
-      include SDLType
+class SDL::Types::SDLDatetime < SDL::Types::SDLSimpleType
+  include SDL::Types::SDLType
 
-      wraps Time
-      codes :datetime
-    end
-  end
+  wraps Time
+  codes :datetime
 end

data/lib/sdl/types/sdl_description.rb

@@ -1,14 +1,10 @@
-module SDL
-  module Types
-    class SDLDescription < SDLSimpleType
-      include SDLType
+class SDL::Types::SDLDescription < SDL::Types::SDLSimpleType
+  include SDL::Types::SDLType
 
-      wraps String
-      codes :description
+  wraps String
+  codes :description
 
-      def from_nilclass(nilvalue)
-        @value = ""
-      end
-    end
+  def from_nilclass(nilvalue)
+    @value = ""
   end
 end

data/lib/sdl/types/sdl_duration.rb

@@ -1,12 +1,8 @@
 require 'active_support/duration'
 
-module SDL
-  module Types
-    class SDLDuration < SDLSimpleType
-      include SDLType
+class SDL::Types::SDLDuration < SDL::Types::SDLSimpleType
+  include SDL::Types::SDLType
 
-      wraps ActiveSupport::Duration
-      codes :duration
-    end
-  end
+  wraps ActiveSupport::Duration
+  codes :duration
 end

data/lib/sdl/types/sdl_number.rb

@@ -1,10 +1,6 @@
-module SDL
-  module Types
-    class SDLNumber < SDLSimpleType
-      include SDLType
+class SDL::Types::SDLNumber < SDL::Types::SDLSimpleType
+  include SDL::Types::SDLType
 
-      wraps Numeric
-      codes :number, :int, :integer
-    end
-  end
+  wraps Numeric
+  codes :number, :int, :integer
 end

data/lib/sdl/types/sdl_simple_type.rb

@@ -5,6 +5,19 @@
 class SDL::Types::SDLSimpleType
   include SDL::Types::SDLType
 
+  ##
+  # Array of all SDLSimpleTypes. Used by the ServiceCompendium.
+  def self.sdl_types
+    @@sdl_types ||= []
+  end
+
+  ##
+  # Every descendant of SDLSimpleType registers it with this class, so that all ServiceCompendiums
+  # recognize the codes of descendants.
+  def self.inherited(subclass)
+    sdl_types << subclass
+  end
+
   # The SDL value type value, possibly converted to the wrapped ruby type, e.g., an URI object created from an
   # "http://" String
   attr_reader :value
@@ -44,12 +57,6 @@ class SDL::Types::SDLSimpleType
     @value.to_s
   end
 
-  ##
-  # Designates this SDLType to be a default type, i.e., to be loaded by all ServiceCompendiums automatically
-  def self.inherited(subclass)
-    SDL::Base::ServiceCompendium.default_sdltypes << subclass
-  end
-
   private
     def conversion_method_name(value)
       value.class.name.demodulize.camelize.downcase