rxsd 0.2

data/lib/rxsd/resolver.rb

@@ -0,0 +1,52 @@
+# RXSD resolver
+#
+# resolves hanging node relationships and provides overall node access
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+module RXSD
+
+# resolves 
+class Resolver
+
+   # return hash of xsd types -> array of type instances for all nodes
+   # underneath given node_obj (inclusive)
+   def self.node_objects(node_obj, args = {})
+      if args.has_key? :node_objs
+        node_objs = args[:node_objs]
+      else
+        node_objs = {XSD::Attribute => [], XSD::AttributeGroup => [], XSD::Choice => [],
+                     XSD::ComplexContent => [], XSD::ComplexType => [], XSD::Element => [],
+                     XSD::Extension => [], XSD::Group => [], XSD::List => [], XSD::Restriction => [],
+                     XSD::Schema => [], XSD::Sequence => [], XSD::SimpleContent => [], XSD::SimpleType => []}
+
+        unless node_obj.nil?
+          node_objs[node_obj.class].push node_obj
+        end
+      end
+
+      unless node_obj.nil?
+        node_obj.children.each{ |noc|
+           unless noc.nil? || node_objs[noc.class].include?(noc)
+             node_objs[noc.class].push noc
+             node_objs = node_objects(noc, :node_objs => node_objs) # might be better to do a breadth first traversal instead?
+           end
+        }
+      end
+
+      node_objs
+   end
+
+   # resolves hanging node relationships for specified schema
+   def self.resolve_nodes(schema)
+      node_objs = node_objects(schema)
+      node_objs.each { |xsd_class, nobjs|
+         nobjs.each{ |no|
+           no.resolve(node_objs)
+         }
+      }
+   end
+
+end # class Resolver
+end # module RXSD

data/lib/rxsd/translator.rb

@@ -0,0 +1,127 @@
+# RXSD translator
+#
+# transaltes xsd <-> ruby classes & xml <-> instances
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+# include whatever output builders you want here,
+require 'builders/ruby_class'
+require 'builders/ruby_definition'
+require 'builders/ruby_object'
+
+module RXSD
+
+# Extend XSD Schema Interface to
+# translate xsd/xml to / from ruby classes/objects
+module XSD
+class Schema
+
+   # helper method, return hash of all tag names -> class builders under schema.
+   # An tag is an element or attribute name that can appear in a xml document
+   # conforming to the schema
+   def tags
+        unless defined? @tags
+          @tags = {}
+          Resolver.
+            node_objects(self)[Element].
+            find_all { |no| no.class == Element }.
+            each     { |elem|
+              unless elem.name.nil?
+                @tags[elem.name] = elem.to_class_builder
+                eca = elem.child_attributes
+                eca.each { |att|
+                  @tags[elem.name + ":" + att.name] = att.to_class_builder # prepend element to attribute name to prevent conflicts
+                } unless eca.nil?
+              end
+            }
+        end
+        return @tags
+   end
+
+   # helper method, return all class builders in/under schema
+   def all_class_builders
+        to_class_builders.collect { |cb| cb.associated.push cb }.flatten.uniq.compact # FIXME this only filters duplicates by obj id,
+                                                                                      # its possible we have multiple objects refering
+                                                                                      # to the same type, should filter these out here or sometime b4
+   end
+
+   # translates schema and all child entities to instances of specified output type.
+   # output_type may be one of
+   #   * :ruby_classes
+   #   * :ruby_definitions
+   def to(output_type)
+      cbs = all_class_builders
+      results = []
+      cbs.each { |cb|
+        # probably a better way to do this at some point than invoking the copy constructors
+        #
+        # FIXME we create class builders in the translator on the fly, this may cause
+        # problems for later operations that need to access class builder attributes which
+        # have been created
+        case(output_type)
+         when :ruby_classes
+            cl = RubyClassBuilder.new(:builder => cb).build
+            results.push cl unless results.include? cl
+            cb.klass = cl # small hack to get around the above fixme... for now
+         when :ruby_definitions
+            df = RubyDefinitionBuilder.new(:builder => cb).build
+            results.push df unless results.include? df
+        end
+      }
+      return results
+   end
+
+end # class Schema
+
+end # module XSD
+
+# SchemaInstance contains an array of ObjectBuilders and provides
+# mechanism to instantiate objects from conforming to a xsd schema
+class SchemaInstance
+
+  # array of object builders represented by current instance
+  attr_accessor :object_builders
+
+  # return array of ObjectBuilders parsed out of a RXSD::XML::Node.
+  # Optionally specify parent ObjectBuilder to use
+  def self.builders_from_xml(node, parent = nil)
+     node_builder = ObjectBuilder.new(:tag_name => node.name, :attributes => node.attrs, :parent => parent)
+     parent.children.push node_builder unless parent.nil? || parent.children.include?(node_builder)
+     builders = [ node_builder ]
+     node.children.each { |c|
+        if c.text?
+          node_builder.content = c.content  if node.children.size == 1 # FIXME if text/children-elements be mixed under a node this wont work
+        else
+          builders += SchemaInstance.builders_from_xml(c, node_builder )
+        end
+     }
+     return builders
+  end
+
+  # create new schema instance w/ specified args
+  def initialize(args = {})
+    @object_builders = args[:builders] if args.has_key? :builders
+  end
+
+  # translates SchemaInstance's objects into instances of the specified output type.
+  # :output_type may be one of
+  #   * :ruby_objects
+  # Must specify :schema argument containing RXSD::XSD::Schema to use in object creation
+  def to(output_type, args = {})
+    schema = args[:schema]
+    results = []
+    @object_builders.each { |ob|
+       # probably a better way to do this at some point than invoking the copy constructors
+       case(output_type)
+          when :ruby_objects
+            ob = RubyObjectBuilder.new(:builder => ob).build(schema)
+            results.push ob
+       end
+    }
+    return results
+  end
+
+end
+
+end # module RXSD

data/lib/rxsd/xml.rb

@@ -0,0 +1,92 @@
+# xml parsing subsystem
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'rubygems'
+
+# require libxml adapter
+require 'libxml_adapter'
+
+module RXSD
+module XML
+
+# RXSD XML node interface subclasses must conform to and helper methods
+class Node
+ 
+  # should return name of node, eg <foo> => "foo"
+  virtual :name
+
+  # return hash of attribute name / values
+  virtual :attrs
+  
+  # should return bool if node has a parent
+  virtual :parent?
+
+  # should return this nodes's parent, if any
+  virtual :parent
+  
+  # should return children nodes
+  virtual :children
+
+  # should return bool if node only contains text
+  virtual :text?
+
+  # should return string contents of text node
+  virtual :content
+
+  # should return list of namespaces corresponding to node
+  virtual :namespaces
+
+  # should also define class method 'xml_root' that returns a node instance corresponding
+  # to the root xml node in provided xml data
+
+  ############################################################################
+
+  # node factory, returns root node corresponding to specified backend and xml data
+  def self.factory(args = {})
+    backend = args[:backend]
+    xml     = args[:xml]
+  
+    # add additional backend drivers here if desired
+    return LibXMLNode.xml_root(xml) if backend == :libxml
+    return nil
+  end
+
+  # returns root node
+  def root
+     parent? ? parent.root : self
+  end
+
+  # provides accessor interface to related obj, in our case related xsd obj
+  attr_accessor :related
+
+  # instantiate all children of provided class type
+  def children_objs(klass)
+     elements = []
+     children.find_all { |c| c.name == klass.tag_name }.each { |c| 
+        elements.push(klass.from_xml(c)) }
+     return elements
+  end
+
+  # instantiate first child of provided class type
+  def child_obj(klass)
+      return children_objs(klass)[0]
+  end
+
+  # return 'value' attribute of all children w/ specified tag
+  def child_values(tag_name)
+     values = []
+     children.find_all { |c| c.name == tag_name }.each { |c| values.push(c.attrs['value']) }
+     return values
+  end
+
+  # return 'value' attribute of first childw/ specified tag
+  def child_value(tag_name)
+     return child_values(tag_name)[0]
+  end
+
+end
+
+end # module XML
+end # module RXSD

data/lib/rxsd/xsd/attribute.rb

@@ -0,0 +1,119 @@
+# The XSD Attribute definition
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+module RXSD
+module XSD
+
+# XSD Attribute defintion
+# http://www.w3schools.com/Schema/el_attribute.asp 
+class Attribute
+
+  # attribute attributes
+  attr_accessor :id, :name, :use, :form, :default, :fixed, :ref, :type
+
+  # attribute children
+  attr_accessor :simple_type
+
+  # attribute parent
+  attr_accessor :parent
+
+  # xml tag name
+  def self.tag_name
+    "attribute"
+  end
+
+  # return xsd node info
+  def info
+    "attribute id: #{@id} name: #{@name} type: #{@type.class} ref: #{ref.nil? ? "" : ref.name} "
+  end
+
+  # returns array of all children
+  def children
+    c = []
+    c.push @simple_type unless @simple_type.nil?
+    return c
+  end
+
+  # node passed in should be a xml node representing the attribute
+  def self.from_xml(node)
+     attribute = Attribute.new
+     attribute.parent = node.parent.related
+     node.related = attribute
+
+     # TODO attribute attributes: | anyAttributes
+     attribute.id       = node.attrs["id"]
+     attribute.name     = node.attrs["name"]
+     attribute.use      = node.attrs["use"]
+ 
+     attribute.form     = node.attrs.has_key?("form") ? 
+                          node.attrs["form"] : node.parent.attrs["attributeFormDefault"]
+
+     attribute.default  = node.attrs["default"]
+     attribute.fixed    = node.attrs["fixed"]
+
+     # FIXME ignoring reference namepsace prefix (if any) for now
+     ref = node.attrs["ref"]
+     ref = ref.split(':')[1] if !(ref.nil? || ref.index(":").nil?)
+     attribute.ref              = ref
+     
+     if node.children.find { |c| c.name == SimpleType.tag_name }.nil?
+       attribute.type     = node.attrs["type"]
+     else
+       attribute.simple_type = node.child_obj SimpleType
+     end
+
+     return attribute
+  end
+
+  # resolve hanging references given complete xsd node object array
+  def resolve(node_objs)
+    unless @type.nil?
+      builtin = Parser.parse_builtin_type @type
+      @type = !builtin.nil? ? builtin : node_objs[SimpleType].find { |no| no.name == @type }
+    end
+
+    unless @ref.nil?
+      @ref = node_objs[Attribute].find { |no| no.name == @ref }
+    end
+  end
+
+  # convert complex type to class builder
+  def to_class_builder
+     unless defined? @class_builder
+       @class_builder = nil
+       if !@ref.nil? 
+          @class_builder = @ref.to_class_builder
+
+       elsif !@type.nil?
+          if @type.class == SimpleType
+            @class_builder = @type.to_class_builder.clone # need to clone here as we're refering to a type that may be used elsewhere
+          else
+            @class_builder = ClassBuilder.new :klass => @type
+          end
+
+       elsif !@simple_type.nil?
+          @class_builder = @simple_type.to_class_builder
+
+       end
+
+       unless @class_builder.nil? || @name == "" || @name.nil?
+          @class_builder.attribute_name = @name
+          @class_builder.klass_name = @name.camelize if @class_builder.klass.nil? && @class_builder.klass_name.nil?
+       end
+     end
+
+     return @class_builder
+  end
+
+  # return this attribute (or ref if appropriate) in array
+  def child_attributes
+     return [@ref] unless @ref.nil?
+     return [self]
+  end
+
+end
+
+end # module XSD
+end # module RXSD

data/lib/rxsd/xsd/attribute_group.rb

@@ -0,0 +1,90 @@
+# The XSD AttributeGroup definition
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+module RXSD
+module XSD
+
+# XSD AttributeGroup defintion
+# http://www.w3schools.com/Schema/el_attributegroup.asp
+class AttributeGroup
+
+  # attribute group attributes
+  attr_accessor :id, :name, :ref
+
+  # attribute group children
+  attr_accessor :attributes, :attribute_groups
+
+  # attribute group parent
+  attr_accessor :parent
+
+  # xml tag name
+  def self.tag_name
+    "attributeGroup"
+  end
+
+  # return xsd node info
+  def info
+    "attributeGroup id: #{@id} name: #{@name} ref: #{ref.nil? ? "" : ref.class == String ? ref : ref.name} "
+  end
+
+  # returns array of all children
+  def children
+     @attributes + @attribute_groups
+  end
+
+  # node passed in should be a xml node representing the attribute group
+  def self.from_xml(node)
+     attribute_group = AttributeGroup.new
+     attribute_group.parent = node.parent.related
+     node.related = attribute_group
+
+     # TODO attribute group attributes: | anyAttributes
+     attribute_group.id       = node.attrs["id"]
+     attribute_group.name     = node.attrs["name"]
+     attribute_group.ref      = node.attrs["ref"]
+
+     # TODO attribute group children: | anyAttribute
+     attribute_group.attributes        = node.children_objs Attribute
+     attribute_group.attribute_groups = node.children_objs AttributeGroup
+
+     return attribute_group
+  end
+
+  # resolve hanging references given complete xsd node object array
+  def resolve(node_objs)
+    unless @ref.nil?
+      @ref = node_objs[AttributeGroup].find { |no| no.name == @ref }
+    end
+  end
+
+  # convert attribute group to array of class builders
+  def to_class_builders
+    unless defined? @class_builders
+      @class_builders = []
+      @attributes.each { |att|
+         @class_builders.push att.to_class_builder
+      }
+      @attribute_groups.each { |atg|
+         atg.to_class_builders.each { |atcb|
+            @class_builders.push atcb
+         }
+      }
+    end
+
+    return @class_builders
+  end
+
+  # return all child attributes associated w/ attribute group
+  def child_attributes
+     atts = []
+     @attribute_groups.each { |atg| atts += atg.child_attributes } unless @attribute_groups.nil?
+     @attributes.each       { |att| atts += att.child_attributes } unless @attributes.nil?
+     return atts
+  end
+
+end
+
+end # module XSD
+end # module RXSD