enterprisifier 0.0.1

data/lib/enterprisifier/marshalling/schema_composition.rb

@@ -0,0 +1,170 @@
+require 'enterprisifier/marshalling/namespace'
+
+module Enterprisifier
+  module Marshalling
+    module SchemaComposition
+      mattr_accessor :schema_elements
+      self.schema_elements = {}
+
+      def self.included(base)
+        super
+        base.instance_eval do
+          include InstanceMethods
+          extend ClassMethods
+        end
+        self.schema_elements[base.base_name] = base
+      end
+
+      module TypeDefSetting
+
+        def reify_self
+          @type.reify(reified) if @type
+        end
+
+      private
+        #
+        # @todo - this shit sucks bad
+        def set_type_def(type_def)
+          if type_def.is_a?(String)
+            @name = type_def
+            type_or_ref = nil
+          elsif type_def.is_a?(Hash)
+            @name = type_def.keys.first
+            type_or_ref = type_def.values.last
+          else
+            type_or_ref = type_def
+          end
+
+          if type_or_ref && type_or_ref.respond_to?(:is_referable?) && type_or_ref.is_referable?
+            @reference = type_or_ref
+          elsif type_or_ref
+            @type = type_or_ref
+          end
+        end
+
+      end # InstanceMethods
+
+      module InstanceMethods
+
+        def initialize(*args)
+          yield(self) if block_given?
+        end
+
+        def namespace
+          if @parent
+            @parent.namespace
+          else
+            self.class.namespace
+          end
+        end
+
+        def evaluate(block)
+          instance_eval(&block) if block
+        end
+
+        def reify(reifiable)
+          composition.each do |comp|
+            Array(instance_variable_get("@#{comp.to_s.underscore.pluralize}")).each {|c| c.reify(reifiable) }
+          end
+        end
+
+        def definition_changed(change_name, def_i)
+          return nil unless respond_to?(:reified, true)
+          def_i.reify(reified)
+        end
+
+      end # InstanceMethods
+
+      module ClassMethods
+
+        def self.extended(base)
+          base.class_eval <<-EOM
+            attr_accessor :parent
+            class_inheritable_accessor :instance
+            class_inheritable_array :composition
+            write_inheritable_array :composition, []
+
+            class << self
+              private :new
+              delegate :reify, :to => :instance
+            end
+
+            def self.#{base.base_name.to_s.underscore}(*args, &block)
+              self.instance = build(*args, &block)
+            end
+          EOM
+        end
+
+        def is_referable?
+          false
+        end
+
+        def build(*args, &block)
+          new(*args).tap do |i|
+            i.evaluate(block)
+            i.reify_self if i.respond_to?(:reify_self, true)
+          end
+        end
+
+        def build_with_parent(parent, *args, &block)
+          new(*args) do |i|
+            i.parent = parent
+            i
+          end.tap do |i|
+            i.evaluate(block)
+            i.reify_self if i.respond_to?(:reify_self, true)
+          end
+        end
+
+        def base_name
+          name.demodulize.to_sym
+        end
+
+        def namespace(ns_settings = nil)
+          if ns_settings
+            @namespace = Enterprisifier::Marshalling::Namespace.new(*(ns_settings.to_a.first))
+          else
+            @namespace
+          end
+        end
+
+        def macros(*args)
+          options = args.extract_options!
+          args.each do |m|
+            class_eval <<-EOM
+            def #{m}(val = nil)
+              return @#{m} unless val
+              #{if options[:allow_multiple]
+                  "(@#{m.to_s.pluralize} ||= []) << val"
+                else
+                  "@#{m.to_s.pluralize} = val"
+                end}
+            end
+            EOM
+          end
+        end
+
+        def composed_of(*schema_elements)
+          write_inheritable_array :composition, schema_elements
+          schema_elements.each do |se|
+            class_eval <<-EOM
+              attr_accessor #{se.to_s.underscore.pluralize.inspect}
+
+              def #{se.to_s.underscore}(*args, &block)
+                builder = ::Enterprisifier::Marshalling::SchemaComposition.schema_elements[#{se.inspect}]
+                builder.build_with_parent(self, *args, &block).tap do |def_i|
+                  (self.#{se.to_s.underscore.pluralize} ||= []) << def_i
+                  definition_changed(#{se.to_s.underscore.to_sym.inspect}, def_i) if respond_to?(:definition_changed, true)
+                end
+              end
+
+              class << self
+                delegate #{se.to_s.underscore.inspect}, :to => :instance
+              end
+            EOM
+          end
+        end
+      end # ClassMethods
+    end   # SchemaComposition
+  end     # Marshalling
+end       # Enterprisifier

data/lib/enterprisifier/marshalling/xsd/schema/attribute.rb

@@ -0,0 +1,48 @@
+require 'enterprisifier/marshalling/schema_composition'
+require 'enterprisifier/marshalling/xsd/schema/simple_type'
+
+module Enterprisifier
+  module Marshalling
+    module XSD
+      module Schema
+        class Attribute
+          include Enterprisifier::Marshalling::SchemaComposition
+          include Enterprisifier::Marshalling::SchemaComposition::TypeDefSetting
+          composed_of :SimpleType
+          macros :default, :fixed, :form, :use
+          attr_reader :name
+
+          class InstantiatableAttribute
+            delegate :attribute_name, :to => "self.class"
+            delegate :attribute_namespace, :to => "self.class"
+            class << self
+              attr_accessor :attribute_name, :attribute_namespace
+            end
+
+          end # InstantiatableAttribute
+
+          def initialize(type_def = nil)
+            super
+            set_type_def(type_def)
+          end
+
+          def reify(reifiable)
+            super
+            reifiable.has_attribute(namespace, name, reified)
+          end
+
+          #
+          # @todo - uuuugly
+          def reified
+            return @reference.reified if @reference && @reference.respond_to?(:reified)
+            @reified ||= Class.new(InstantiatableAttribute).tap do |inst|
+              inst.attribute_name = name
+              inst.attribute_namespace = namespace
+            end
+          end
+
+        end   # Attribute
+      end     # Schema
+    end       # XSD
+  end         # Marshalling
+end           # Enterprisifier

data/lib/enterprisifier/marshalling/xsd/schema/choice.rb

@@ -0,0 +1,18 @@
+require 'enterprisifier/marshalling/schema_composition'
+require 'enterprisifier/marshalling/xsd/schema/element'
+require 'enterprisifier/marshalling/xsd/schema/group'
+require 'enterprisifier/marshalling/xsd/schema/sequence'
+
+module Enterprisifier
+  module Marshalling
+    module XSD
+      module Schema
+        class Choice
+          include Enterprisifier::Marshalling::SchemaComposition
+          composed_of :Element, :Group, :Choice, :Sequence
+
+        end # Choice
+      end   # Schema
+    end     # XSD
+  end       # Marshalling
+end         # Enterprisifier

data/lib/enterprisifier/marshalling/xsd/schema/complex_content.rb

@@ -0,0 +1,18 @@
+require 'enterprisifier/marshalling/schema_composition'
+require 'enterprisifier/marshalling/xsd/schema/restriction'
+require 'enterprisifier/marshalling/xsd/schema/extension'
+
+module Enterprisifier
+  module Marshalling
+    module XSD
+      module Schema
+        class ComplexContent
+          include Enterprisifier::Marshalling::SchemaComposition
+          composed_of :Restriction, :Extension
+          macros :mixed
+
+        end # ComplexContent
+      end   # Schema
+    end     # XSD
+  end       # Marshalling
+end         # Enterprisifier

data/lib/enterprisifier/marshalling/xsd/schema/complex_type.rb

@@ -0,0 +1,28 @@
+require 'enterprisifier/marshalling/schema_composition'
+require 'enterprisifier/marshalling/xsd/schema/simple_content'
+require 'enterprisifier/marshalling/xsd/schema/complex_content'
+require 'enterprisifier/marshalling/xsd/schema/group'
+require 'enterprisifier/marshalling/xsd/schema/choice'
+require 'enterprisifier/marshalling/xsd/schema/sequence'
+require 'enterprisifier/marshalling/xsd/schema/attribute'
+
+module Enterprisifier
+  module Marshalling
+    module XSD
+      module Schema
+        class ComplexType
+          include Enterprisifier::Marshalling::SchemaComposition
+          composed_of :SimpleContent, :ComplexContent, :Group, :Choice, :Sequence, :Attribute
+          macros :abstract, :mixed, :block, :final
+          attr_reader :name
+
+          def initialize(name = nil)
+            super
+            @name = name
+          end
+
+        end   # ComplexType
+      end     # Schema
+    end       # XSD
+  end         # Marshalling
+end           # Enterprisifier

data/lib/enterprisifier/marshalling/xsd/schema/element.rb

@@ -0,0 +1,92 @@
+require 'enterprisifier/marshalling/builder'
+require 'enterprisifier/marshalling/instantiatable_element'
+require 'enterprisifier/marshalling/schema_composition'
+require 'enterprisifier/marshalling/xsd/schema/simple_type'
+require 'enterprisifier/marshalling/xsd/schema/complex_type'
+require 'observer'
+
+module Enterprisifier
+  module Marshalling
+    module XSD
+      module Schema
+        class Element
+          include Enterprisifier::Marshalling::SchemaComposition
+          include Enterprisifier::Marshalling::SchemaComposition::TypeDefSetting
+
+          composed_of :SimpleType, :ComplexType
+          macros :max_occurs, :min_occurs
+          attr_reader :name
+          class << self
+            delegate :create, :reified, :to => :instance
+
+            def is_referable?
+              true
+            end
+
+            def implementation(&block)
+              if block_given?
+                reified.class_eval(&block)
+              else
+                reified
+              end
+            end
+          end # << self
+
+          def initialize(type_def = nil)
+            super
+            set_type_def(type_def)
+          end
+
+          def reference?
+            !!@reference
+          end
+
+          def reify(reifiable)
+            super
+            return @reference.reify(reifiable) if reference?
+            many? ? reify_many(reifiable) : reify_one(reifiable)
+          end
+
+          def create(*args, &block)
+            reified.create(*args, &block)
+          end
+
+          #
+          # @todo - uuuugly
+          def reified
+            return @reference.reified if reference? && @reference.respond_to?(:reified)
+            @reified ||= Class.new(InstantiatableElement).tap do |inst|
+              inst.element_name = name
+              inst.element_namespace = namespace
+            end
+          end
+
+        private
+
+          def reify_many(reifiable)
+            reifiable.has_many(pluralized, self.reified)
+          end
+
+          def reify_one(reifiable)
+            reifiable.has_one(singularized, self.reified)
+          end
+
+          def many?
+            (max_occurs == "unbounded") || (max_occurs && max_occurs.to_i > 1)
+          end
+
+          def pluralized
+            name.to_s.underscore.pluralize
+          end
+
+          #
+          # @todo - singularizing breaks for a lot of things, just assume here
+          def singularized
+            name.to_s.underscore
+          end
+
+        end   # Element
+      end     # Schema
+    end       # XSD
+  end         # Marshalling
+end           # Enterprisifier

data/lib/enterprisifier/marshalling/xsd/schema/extension.rb

@@ -0,0 +1,29 @@
+require 'enterprisifier/marshalling/schema_composition'
+require 'enterprisifier/marshalling/xsd/schema/group'
+require 'enterprisifier/marshalling/xsd/schema/choice'
+require 'enterprisifier/marshalling/xsd/schema/sequence'
+require 'enterprisifier/marshalling/xsd/schema/attribute'
+
+module Enterprisifier
+  module Marshalling
+    module XSD
+      module Schema
+        class Extension
+          include Enterprisifier::Marshalling::SchemaComposition
+          composed_of :Group, :Choice, :Sequence, :Attribute
+
+          def initialize(base)
+            super
+            @base = base
+          end
+
+          def reify(reifiable)
+            super
+            @base.reify(reifiable)
+          end
+
+        end # Extension
+      end   # Schema
+    end     # XSD
+  end       # Marshalling
+end         # Enterprisifier

data/lib/enterprisifier/marshalling/xsd/schema/group.rb

@@ -0,0 +1,22 @@
+require 'enterprisifier/marshalling/schema_composition'
+require 'enterprisifier/marshalling/xsd/schema/choice'
+require 'enterprisifier/marshalling/xsd/schema/sequence'
+
+module Enterprisifier
+  module Marshalling
+    module XSD
+      module Schema
+        class Group
+          include Enterprisifier::Marshalling::SchemaComposition
+          composed_of :Choice, :Sequence
+          macros :ref
+
+          def initialize(type_def = nil)
+            super
+            @type_def = type_def
+          end
+        end # Group
+      end   # Schema
+    end     # XSD
+  end       # Marshalling
+end         # Enterprisifier

data/lib/enterprisifier/marshalling/xsd/schema/restriction.rb

@@ -0,0 +1,29 @@
+require 'enterprisifier/marshalling/schema_composition'
+require 'enterprisifier/marshalling/xsd/schema/simple_type'
+require 'enterprisifier/marshalling/xsd/schema/attribute'
+require 'enterprisifier/marshalling/xsd/schema/group'
+require 'enterprisifier/marshalling/xsd/schema/choice'
+require 'enterprisifier/marshalling/xsd/schema/sequence'
+
+module Enterprisifier
+  module Marshalling
+    module XSD
+      module Schema
+        class Restriction
+          include Enterprisifier::Marshalling::SchemaComposition
+          composed_of :SimpleType, :Attribute, :Group, :Choice, :Sequence
+          macros :enumeration, :fraction_digits, :length, :max_exclusive, :max_inclusive, :max_length,
+                 :min_exclusive, :min_inclusive, :min_length, :pattern, :total_digits, :white_space,
+                 :allow_multiple => true
+          attr_reader :base
+
+          def initialize(base)
+            super
+            @base = base
+          end
+
+        end   # Restriction
+      end     # Schema
+    end       # XSD
+  end         # Marshalling
+end           # Enterprisifier