enterprisifier 0.0.1

data/lib/enterprisifier/code_generation/generators/attribute_generator.rb

@@ -0,0 +1,22 @@
+require 'enterprisifier/code_generation/code_generator'
+
+module Enterprisifier
+  module CodeGeneration
+    class AttributeGenerator < CodeGenerator
+      extends "Enterprisifier::Marshalling::XSD::Schema::Attribute"
+      register :attribute, :namespace => true, :as => :class
+      macro_mappings :default, :fixed, :form, :use
+
+      def macro_reference_type
+        if @node.value_type
+          @generator.modularize_type(@node.value_type, @mod_name, "Types")
+        elsif @node.ref
+          @generator.modularize_type(@node.ref, @mod_name, "Attributes")
+        else
+          nil
+        end
+      end
+
+    end # AttributeGenerator
+  end   # CodeGenerator
+end     # Enterprisifier

data/lib/enterprisifier/code_generation/generators/choice_generator.rb

@@ -0,0 +1,12 @@
+require 'enterprisifier/code_generation/code_generator'
+
+module Enterprisifier
+  module CodeGeneration
+    class ChoiceGenerator < CodeGenerator
+      extends "Enterprisifier::Marshalling::XSD::Schema::Choice"
+      register :choice, :namespace => true
+      macro_mappings :min_occurs, :max_occurs
+
+    end # ChoiceGenerator
+  end   # CodeGenerator
+end     # Enterprisifier

data/lib/enterprisifier/code_generation/generators/complex_content_generator.rb

@@ -0,0 +1,12 @@
+require 'enterprisifier/code_generation/code_generator'
+
+module Enterprisifier
+  module CodeGeneration
+    class ComplexContentGenerator < CodeGenerator
+      extends "Enterprisifier::Marshalling::XSD::Schema::ComplexContent"
+      register :complexContent, :namespace => true
+      macro_mappings :mixed
+
+    end # ComplexContentGenerator
+  end   # CodeGenerator
+end     # Enterprisifier

data/lib/enterprisifier/code_generation/generators/complex_type_generator.rb

@@ -0,0 +1,12 @@
+require 'enterprisifier/code_generation/code_generator'
+
+module Enterprisifier
+  module CodeGeneration
+    class ComplexTypeGenerator < CodeGenerator
+      extends "Enterprisifier::Marshalling::XSD::Schema::ComplexType"
+      register :complexType, :namespace => true, :in => "Types"
+      macro_mappings :abstract, :mixed, :block, :final
+
+    end # ComplexTypeGenerator
+  end   # CodeGenerator
+end     # Enterprisifier

data/lib/enterprisifier/code_generation/generators/element_generator.rb

@@ -0,0 +1,28 @@
+require 'enterprisifier/code_generation/code_generator'
+
+module Enterprisifier
+  module CodeGeneration
+    class ElementGenerator < CodeGenerator
+      extends "Enterprisifier::Marshalling::XSD::Schema::Element"
+      register :element, :namespace => true, :as => :class
+      macro_mappings :default, :fixed, :form, :min_occurs, :max_occurs, :nillable, :abstract, :block, :final
+
+      def macro_reference_type
+        if @node.ref
+          @generator.modularize_type(@node.ref, @mod_name, "Elements")
+        elsif @node.element_type
+          @generator.modularize_type(@node.element_type, @mod_name, "Types")
+        else
+          nil
+        end
+      end
+
+      def attribute_macros
+        @attribute_macros ||= super.tap do |m|
+          m << [:substitution_group, @generator.modularize_type(@node.substitution_group, @mod_name, "Elements")] if @node.substitution_group
+        end
+      end
+
+    end # ElementGenerator
+  end   # CodeGenerator
+end     # Enterprisifier

data/lib/enterprisifier/code_generation/generators/extension_generator.rb

@@ -0,0 +1,11 @@
+require 'enterprisifier/code_generation/code_generator'
+
+module Enterprisifier
+  module CodeGeneration
+    class ExtensionGenerator < CodeGenerator
+      extends "Enterprisifier::Marshalling::XSD::Schema::Extension"
+      register :extension, :namespace => true
+
+    end # ExtensionGenerator
+  end   # CodeGenerator
+end     # Enterprisifier

data/lib/enterprisifier/code_generation/generators/group_generator.rb

@@ -0,0 +1,27 @@
+require 'enterprisifier/code_generation/code_generator'
+
+module Enterprisifier
+  module CodeGeneration
+    class GroupGenerator < CodeGenerator
+      extends "Enterprisifier::Marshalling::XSD::Schema::Group"
+      register :group, :namespace => true
+      macro_mappings :min_occurs, :max_occurs
+
+      def attribute_macros
+        @attribute_macros ||= super.tap do |m|
+          m << [:ref, @generator.modularize_type(@node.ref, @mod_name, "Groups")] if @node.ref
+        end
+      end
+
+      def requires
+        @requires ||= super.tap do |r|
+          next unless @node.ref
+          mt = @generator.modularize_type(@node.ref, @mod_name, "Groups")
+          p = mt.split("::").map(&:underscore).join("/")
+          r << p
+        end
+      end
+
+    end # GroupGenerator
+  end   # CodeGenerator
+end     # Enterprisifier

data/lib/enterprisifier/code_generation/generators/restriction_generator.rb

@@ -0,0 +1,11 @@
+require 'enterprisifier/code_generation/code_generator'
+
+module Enterprisifier
+  module CodeGeneration
+    class RestrictionGenerator < CodeGenerator
+      extends "Enterprisifier::Marshalling::XSD::Schema::Restriction"
+      register :restriction, :namespace => true
+
+    end # RestrictionGenerator
+  end   # CodeGenerator
+end     # Enterprisifier

data/lib/enterprisifier/code_generation/generators/sequence_generator.rb

@@ -0,0 +1,12 @@
+require 'enterprisifier/code_generation/code_generator'
+
+module Enterprisifier
+  module CodeGeneration
+    class SequenceGenerator < CodeGenerator
+      extends "Enterprisifier::Marshalling::XSD::Schema::Sequence"
+      register :sequence, :namespace => true
+      macro_mappings :min_occurs, :max_occurs
+
+    end # SequenceGenerator
+  end   # CodeGenerator
+end     # Enterprisifier

data/lib/enterprisifier/code_generation/generators/simple_content_generator.rb

@@ -0,0 +1,12 @@
+require 'enterprisifier/code_generation/code_generator'
+
+module Enterprisifier
+  module CodeGeneration
+    class SimpleContentGenerator < CodeGenerator
+      extends "Enterprisifier::Marshalling::XSD::Schema::SimpleContent"
+      register :simpleContent, :namespace => true
+
+
+    end # SimpleContentGenerator
+  end   # CodeGenerator
+end     # Enterprisifier

data/lib/enterprisifier/code_generation/generators/simple_type_generator.rb

@@ -0,0 +1,11 @@
+require 'enterprisifier/code_generation/code_generator'
+
+module Enterprisifier
+  module CodeGeneration
+    class SimpleTypeGenerator < CodeGenerator
+      extends "Enterprisifier::Marshalling::XSD::Schema::SimpleType"
+      register :simpleType, :namespace => true, :in => "Types"
+
+    end # SimpleTypeGenerator
+  end   # CodeGenerator
+end     # Enterprisifier

data/lib/enterprisifier/code_generation/generators/union_generator.rb

@@ -0,0 +1,34 @@
+require 'enterprisifier/code_generation/code_generator'
+
+module Enterprisifier
+  module CodeGeneration
+    class UnionGenerator < CodeGenerator
+      extends "Enterprisifier::Marshalling::XSD::Schema::Union"
+      register :union, :namespace => true
+
+      def attribute_macros
+        @attribute_macros ||= super.tap do |m|
+          m << [:member_types, modularized_member_types.join(", ")] unless modularized_member_types.empty?
+        end
+      end
+
+      def requires
+        @requires ||= super.tap do |r|
+          mmt = modularized_member_types.collect do |mt|
+            mt.split("::").map(&:underscore).join("/")
+          end
+          r.concat(mmt)
+        end
+      end
+
+    private
+
+      def modularized_member_types
+        @modularized_member_types ||= @node.member_types.collect do |mt|
+          @generator.modularize_type(mt, @mod_name, "Types")
+        end
+      end
+
+    end # UnionGenerator
+  end   # CodeGenerator
+end     # Enterprisifier

data/lib/enterprisifier/constants.rb

@@ -0,0 +1,3 @@
+module Enterprisifier
+  XMLSchemaNameSpaceURI = "http://www.w3.org/2001/XMLSchema"
+end

data/lib/enterprisifier/logging.rb

@@ -0,0 +1,5 @@
+require 'logger'
+
+module Enterprisifier
+  Logger = ::Logger.new($stdout)
+end

data/lib/enterprisifier/marshalling/builder.rb

@@ -0,0 +1,11 @@
+require 'nokogiri/xml/builder'
+
+#
+# @todo - ugly monkey patch here because nokogiri breaks when i extend builder
+class Nokogiri::XML::Builder
+
+  def tag(tag_name, *args, &block)
+    send(tag_name, *args, &block)
+  end
+
+end

data/lib/enterprisifier/marshalling/instantiatable_element.rb

@@ -0,0 +1,170 @@
+module Enterprisifier
+  module Marshalling
+    class InstantiatableElement
+      include Observable
+      include ActiveSupport::Callbacks
+
+      class AssociationProxy < BlankSlate
+        def initialize(parent, element_klass)
+          @parent = parent
+          @collection = []
+          @element_klass = element_klass
+        end
+
+        def build
+          @element_klass.new.tap do |e|
+            e.parent = @parent
+            @collection << e
+          end
+        end
+
+        def method_missing(sym, *args, &block)
+          @collection.send(sym, *args, &block)
+        end
+      end # AssociationProxy
+
+      define_callbacks :after_create
+      delegate :element_name, :to => "self.class"
+      delegate :element_namespace, :to => "self.class"
+      attr_reader :parent
+      class_inheritable_accessor :element_name, :element_namespace, :attribute_definitions
+      self.attribute_definitions = {}
+
+      class << self
+
+        def create(*args, &block)
+          new(*args, &block).tap do |inst|
+            inst.run_callbacks(:after_create)
+          end
+        end
+
+        def inspect
+          "<Element Class #{element_name} (#{object_id}) ns: #{element_namespace.inspect}>"
+        end
+
+        def has_many(name, element_klass)
+          define_method("#{name}") do
+            next(instance_variable_get("@#{name}")) if instance_variable_set("@#{name}")
+            proxy = AssociationProxy.new(self, element_klass)
+            instance_variable_set("@#{name}", proxy)
+            children << proxy
+            proxy
+          end
+        end
+
+        def has_one(name, element_klass)
+          attr_reader name
+          define_method("build_#{name}") do
+            next(send(name)) if send(name)
+            element_klass.new.tap do |e|
+              instance_variable_set("@#{name}", e)
+              e.parent = self
+              children << e
+            end
+          end
+        end
+
+        def has_attribute(namespace, name, attribute_klass)
+          (attribute_definitions[namespace] ||= {})[name.to_sym] = attribute_klass
+        end
+
+      end # << self
+
+      def attributes
+        @attributes ||= []
+      end
+
+      def children
+        @children ||= []
+      end
+
+      def attribute(name, val = nil)
+        if val
+          find_or_initialize_attribute(name).value = val
+        else
+          find_or_initialize_attribute(name).try(:value)
+        end
+      end
+
+      def namespaced_attribute(namespace, name, val = nil)
+        if val
+          find_or_initialize_attribute(name, namespace).value = val
+        else
+          find_or_initialize_attribute(name, namespace).try(:value)
+        end
+      end
+
+      def to_xml(builder = nil)
+        builder ||= Nokogiri::XML::Builder.new { |builder| }
+        builder.tag(element_name, value_to_string) do
+          set_root_ns(builder) if root?
+          flattened_children.each { |c| c.to_xml(builder) }
+        end
+        builder.to_xml
+      end
+
+      def inspect
+        "<Element #{element_name} (#{object_id}) ns: #{element_namespace.inspect}>"
+      end
+
+      def parent=(parent_element)
+        add_observer(parent_element)
+        changed
+        notify_observers(:child_added, self)
+        parent_element
+      end
+
+      def update(message, obj)
+        send(:"observe_#{message}", obj) if respond_to?(:"observe_#{message}", true)
+      end
+
+      def root?
+        !parent
+      end
+
+    private
+
+      def observe_child_added(child)
+        notify_observers(:child_added, child)
+      end
+
+      def find_or_initialize_attribute(name, ns_short_name_or_url = nil)
+        find_attribute(name, ns_short_name_or_url) || initialize_attribute(namen ns_short_name_or_url)
+      end
+
+      def find_attribute(name, ns_short_name_or_url = nil)
+        ns = ns_short_name_or_url || element_namespace
+        attributes.detect do |attr|
+          attr.attribute_namespace.is?(ns) && attr.name == name
+        end
+      end
+
+      def initialize_attribute(name, ns_short_name_or_url = nil)
+        if ns_short_name_or_url
+          attribute_col = attribute_definitions.detect { |(k,v)| k.is?(ns_short_name_or_url) }
+          raise(ArgumentError, "Unknown namespace #{ns.inspect}") unless attribute_col
+        else
+          attribute_col = attribute_definitions[element_namespace]
+        end
+        if attribute_col && attribute_col[name.to_sym]
+          attribute_col[name.to_sym].new.tap {|a| attributes << a}
+        else
+          raise(ArgumentError, "Unknown attribute #{name.inspect}")
+        end
+      end
+
+      def flattened_children
+        children.flatten
+      end
+
+      def value_to_string
+        nil
+      end
+
+      def set_root_ns(builder)
+        builder.parent["xmlns"] = element_namespace.url
+      end
+
+    end # InstantiatableElement
+  end   # Marshalling
+end     # Enterprisifier

data/lib/enterprisifier/marshalling/namespace.rb

@@ -0,0 +1,23 @@
+module Enterprisifier
+  module Marshalling
+    class Namespace
+      attr_reader :short_name, :url
+
+      def initialize(short_name, url)
+        @short_name, @url = short_name, url
+      end
+
+      def ==(other_ns)
+        other_ns.url == url
+      end
+
+      def hash
+        url.hash
+      end
+
+      def is?(short_name_or_url)
+        @short_name == short_name_or_url || @url == short_name_or_url
+      end
+    end # Namespace
+  end   # Marshalling
+end     # Enterprisifier

data/lib/enterprisifier/marshalling/reification.rb

@@ -0,0 +1,30 @@
+module Enterprisifier
+  module Marshalling
+    module Reification
+
+      #
+      # @todo - this is ugly.
+      def reify(reified)
+        here = self
+        reified.instance_eval do
+          define_method(:value=) do |ruby_val|
+            (@value ||= here.new).value = ruby_val
+          end
+
+          define_method(:value) do
+            @value ? @value.ruby_value : nil
+          end
+
+          define_method(:value_from_string) do |str_val|
+            @value ||= here.from_string(str_val)
+          end
+
+          define_method(:value_to_string) do
+            @value ? @value.to_xml_string : nil
+          end
+        end
+      end
+
+    end # Reification
+  end   # Marshalling
+end     # Enterprisifier