sdl-ng 0.0.1

data/lib/sdl/exporters.rb

@@ -0,0 +1,9 @@
+require_relative 'exporters/xml_mapping'
+require_relative 'exporters/exporter'
+require_relative 'exporters/schema_exporter'
+require_relative 'exporters/service_exporter'
+require_relative 'exporters/xsd_schema_exporter'
+require_relative 'exporters/xml_service_exporter'
+require_relative 'exporters/rdf_mapping'
+require_relative 'exporters/rdf_exporter'
+require_relative 'exporters/markdown_service_exporter'

data/lib/sdl/exporters/exporter.rb

@@ -0,0 +1,19 @@
+module SDL
+  module Exporters
+    class Exporter
+      attr :compendium
+      attr :options
+
+      def initialize(compendium, options = {})
+        @compendium = compendium
+        @options = options
+      end
+
+      def export_to_file(path, content)
+        File.open(path, 'w') do |f|
+          f.write(content)
+        end
+      end
+    end
+  end
+end

data/lib/sdl/exporters/markdown_service_exporter.rb

@@ -0,0 +1,5 @@
+class SDL::Exporters::MarkdownServiceExporter < SDL::Exporters::ServiceExporter
+  def export_service(service)
+    "Not implemented yet"
+  end
+end

data/lib/sdl/exporters/rdf_exporter.rb

@@ -0,0 +1,34 @@
+require 'rdf'
+require 'rdf/rdfxml'
+
+module SDL
+  module Exporters
+    class RDFExporter < ServiceExporter
+      @@s = RDF::Vocabulary.new('http://www.open-service-compendium.org/')
+
+      def export_service(service)
+        graph = RDF::Graph.new
+
+        service.facts.each do |fact|
+          graph << [RDF::URI.new(service.uri), @@s["has_#{fact.class.local_name.underscore}"], RDF::URI.new(fact.uri)]
+
+          expand_properties(fact, graph)
+        end
+
+        graph.dump(:rdf)
+      end
+
+      def expand_properties(type_instance, graph)
+        type_instance.property_values.each do |property, value|
+          [value].flatten.each do |v|
+            graph << [RDF::URI.new(type_instance.uri), @@s["#{property.name.underscore}"], v.rdf_object] unless v.nil?
+          end
+
+          if property.type < SDL::Base::Type
+            [value].flatten.each do |v| expand_properties(v, graph) end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sdl/exporters/rdf_mapping.rb

@@ -0,0 +1,48 @@
+require 'rdf'
+require 'active_support/inflector'
+
+[String, Fixnum, Nokogiri::XML::Element].each do |klass|
+  klass.class_eval do
+    def rdf_object
+      RDF::Literal.new(self)
+    end
+  end
+end
+
+module SDL
+  module Base
+    class Fact
+      class << self
+        def uri
+          "http://www.open-service-compendium.org/types/#{@local_name}"
+        end
+      end
+
+      def uri
+        "#{service.uri}/#{self.class.local_name.underscore}-#{hash}"
+      end
+    end
+
+    class Type
+      class << self
+        def uri
+          "http://www.open-service-compendium.org/types/#{@local_name}"
+        end
+      end
+
+      def uri
+        self.class.uri + '/' + hash.to_s
+      end
+
+      def rdf_object
+        RDF::URI.new(uri)
+      end
+    end
+
+    class Service
+      def uri
+        "http://www.open-service-compendium.org/services/#{@symbolic_name}"
+      end
+    end
+  end
+end

data/lib/sdl/exporters/schema_exporter.rb

@@ -0,0 +1,9 @@
+module SDL
+  module Exporters
+    class SchemaExporter < Exporter
+      def export_schema_to_file(path)
+        export_to_file path, export_schema
+      end
+    end
+  end
+end

data/lib/sdl/exporters/service_exporter.rb

@@ -0,0 +1,9 @@
+module SDL
+  module Exporters
+    class ServiceExporter < Exporter
+      def export_service_to_file(service, path)
+        export_to_file path, export_service(service)
+      end
+    end
+  end
+end

data/lib/sdl/exporters/xml_mapping.rb

@@ -0,0 +1,51 @@
+module SDL
+  module Base
+    class Property
+      def xsd_element_name
+        if multi?
+          @name.singularize
+        else
+          @name
+        end
+      end
+    end
+
+    class Type
+      class << self
+        def xsd_element_name
+          local_name.camelize(:lower)
+        end
+
+        def xsd_type_name
+          local_name
+        end
+
+        def xsd_type_qname
+          'sdl:' + xsd_type_name
+        end
+      end
+    end
+
+    class Fact
+      class << self
+        def xsd_type_name
+          "#{local_name}Fact"
+        end
+      end
+    end
+  end
+
+  module Types
+    module SDLType
+      module ClassMethods
+        def xml_type
+          if self < SDL::Base::Type
+            wrapped_type.xsd_type_name
+          else
+            'ns:string'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sdl/exporters/xml_service_exporter.rb

@@ -0,0 +1,37 @@
+module SDL
+  module Exporters
+    class XMLServiceExporter < ServiceExporter
+      def export_service(service)
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.service('xmlns' => 'http://www.open-service-compendium.org') do
+            service.facts.each do |fact|
+              xml.send(fact.class.xsd_element_name + '_') do
+                serialize_type_instance fact, xml
+              end
+            end
+          end
+        end
+
+        builder.to_xml
+      end
+
+      def serialize_type_instance(type_instance, xml)
+        type_instance.property_values.each do |property, value|
+          [value].flatten.each do |v|
+            if v.class < SDL::Base::Type
+              xml.send(property.xsd_element_name + '_', (!value.is_a?(Array) && value.identifier) ? {'identifier' => value.identifier.to_s} : {}) do
+                v.annotations.each do |annotation|
+                  xml.annotation annotation
+                end
+                xml.documentation v.documentation if (!value.is_a?(Array) && value.identifier)
+                serialize_type_instance(v, xml)
+              end
+            else
+              xml.send(property.xsd_element_name + '_', v)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sdl/exporters/xsd_schema_exporter.rb

@@ -0,0 +1,94 @@
+require 'active_support/inflector'
+require 'nokogiri'
+
+module SDL
+  module Exporters
+    ##
+    # The XSD schema exporter creates an XML Schema Definition for consuming service descriptions using the XML provided
+    # by the XMLServiceExporter.
+    #
+    # The schema consists of the following main components:
+    #   - The definition of the root node, i.e., a service. The service contains an arbitrary number of elements of
+    #     service fact types.
+    #   - The definition of service fact classes and SDL types
+    #   - The definition of a type base, containing annotations and documentation
+    class XSDSchemaExporter < SchemaExporter
+      def export_schema
+        export_schema_xml.to_xml
+      end
+
+      def export_schema_xml
+        Nokogiri::XML::Builder.new do |xml|
+          xml['ns'].schema('xmlns' => 'http://www.open-service-compendium.org', 'targetNamespace' => 'http://www.open-service-compendium.org', 'xmlns:ns' => 'http://www.w3.org/2001/XMLSchema', 'elementFormDefault' => 'qualified') do
+            xml['ns'].element :name => 'service' do
+              document(xml, I18n.t('sdl.xml.service_root'))
+              xml['ns'].complexType do
+                xml['ns'].choice :maxOccurs => 'unbounded' do
+                  @compendium.fact_classes.each do |fact_class|
+                    xml['ns'].element :name => fact_class.xsd_element_name, :type => fact_class.xsd_type_name do
+                      document(xml, fact_class.documentation)
+                    end
+                  end
+                end
+              end
+            end
+
+            xml['ns'].complexType :name => 'SDLTypeBase' do
+              document(xml, I18n.t('sdl.xml.typebase'))
+              xml['ns'].choice do
+                xml['ns'].element :name => 'documentation', :minOccurs => 0, :maxOccurs => 'unbounded', :type => 'ns:string' do
+                  document(xml, I18n.t('sdl.xml.documentation'))
+                end
+                xml['ns'].element :name => 'annotation', :minOccurs => 0, :maxOccurs => 'unbounded', :type => 'ns:string' do
+                  document(xml, I18n.t('sdl.xml.annotation'))
+                end
+              end
+              xml['ns'].attribute :name => 'identifier' do
+                document(xml, I18n.t('sdl.xml.identifier'))
+              end
+            end
+
+            (@compendium.fact_classes + @compendium.types).each do |fact_class|
+              xml['ns'].complexType :name => fact_class.xsd_type_name do
+                document(xml, fact_class.documentation)
+                xml['ns'].complexContent do
+                  xml['ns'].extension :base => fact_class.is_sub? ? fact_class.superclass.xsd_type_name : 'SDLTypeBase' do
+                    unless fact_class.properties.empty?
+                      xml['ns'].sequence do
+                        fact_class.properties.each do |property|
+                          extend_property(property, xml) do
+                            document(xml, property.documentation)
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # Creates an xml element corresponding to the SDL property
+      def extend_property(property, xml)
+        if property.multi?
+          xml['ns'].element :name => property.name.singularize, :type => property.type.xml_type, :minOccurs => 0, :maxOccurs => 'unbounded' do
+            yield
+          end
+        else
+          xml['ns'].element :name => property.name, :type => property.type.xml_type, :minOccurs => 0 do
+            yield
+          end
+        end
+      end
+
+      # Shortcut for adding an XSD documentation annotation
+      def document(xml, documentation)
+        xml['ns'].annotation do
+          xml['ns'].documentation documentation
+        end
+      end
+    end
+  end
+end

data/lib/sdl/receivers.rb

@@ -0,0 +1,22 @@
+require_relative 'receivers/type_instance_receiver'
+require_relative 'receivers/type_receiver'
+require_relative 'receivers/fact_receiver'
+require_relative 'receivers/service_receiver'
+
+
+module SDL
+  module Receivers
+    #
+    def self.set_value(type_class, type_instance, *property_values, compendium)
+      property_values.zip(type_class.properties(true)).each do |value, property|
+        if(value.is_a?(Hash))
+          TypeInstanceReceiver.new(type_instance, compendium).send(value.keys.first.to_s, value.values.first)
+        else
+          raise "Specified value '#{value}' for non-existing property." unless property
+
+          TypeInstanceReceiver.new(type_instance, compendium).send(property.name, value)
+        end
+      end
+    end
+  end
+end

data/lib/sdl/receivers/fact_receiver.rb

@@ -0,0 +1,15 @@
+module SDL
+  module Receivers
+    class FactReceiver < TypeReceiver
+      def base_class
+        SDL::Base::Fact
+      end
+
+      def register_sdltype(type)
+        false
+      end
+
+      alias :subfact :subtype
+    end
+  end
+end

data/lib/sdl/receivers/service_receiver.rb

@@ -0,0 +1,63 @@
+require 'verbs'
+
+require_relative '../base/service'
+
+module SDL
+  module Receivers
+    class ServiceReceiver
+      include ActiveSupport::Inflector
+
+      attr :service
+      attr :compendium
+
+      def initialize(sym, compendium)
+        @service = SDL::Base::Service.new(sym.to_s)
+        @compendium = compendium
+
+        compendium.fact_classes.each do |fact_class|
+          define_singleton_method("is_#{fact_class.local_name.underscore.verb.conjugate(:tense => :past, :person => :third, :plurality => :singular, :aspect => :perfective)}") do |*args, &block|
+            add_fact fact_class, *args, &block
+          end
+
+          define_singleton_method("has_#{fact_class.local_name.underscore}") do |*args, &block|
+            add_fact fact_class, *args, &block
+          end
+
+          define_singleton_method("#{fact_class.local_name.underscore}") do |*args, &block|
+            add_fact fact_class, *args, &block
+          end
+        end
+      end
+
+      private
+        def add_fact(fact_class, *property_values, &block)
+          fact_instance = fact_class.new
+          fact_instance.service = @service
+
+          SDL::Receivers.set_value(fact_class, fact_instance, *property_values, @compendium)
+
+          if block_given?
+            SDL::Receivers::TypeInstanceReceiver.new(fact_instance, @compendium).instance_eval &block
+          end
+
+          @service.facts << fact_instance
+        end
+
+        ##
+        # Catches calls to methods named similarily to possible predefined type instances
+        def method_missing(name, *args)
+          possible_type_instances = @compendium.type_instances.map{|k, v| v[name]}.select{|v| v != nil}
+
+          unless possible_type_instances.nil? || possible_type_instances.empty?
+            if possible_type_instances.length > 1
+              raise Exception.new("Multiple possibilities for #{name} in #{caller[0]}")
+            else
+              possible_type_instances[0]
+            end
+          else
+            raise Exception.new("I do not know what to do with '#{name}' in #{caller[0]}")
+          end
+        end
+    end
+  end
+end

data/lib/sdl/receivers/type_instance_receiver.rb

@@ -0,0 +1,86 @@
+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
+
+              instance.send "#{property.name}=", value
+            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
+                else
+                  new_list_item = property.type.new
+
+                  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
+            end
+          end
+        end
+      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}
+
+        # ... 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}
+
+        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
+  end
+end