rxsd 0.2

data/COPYING

@@ -0,0 +1,8 @@
+RXSD is free software, you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License
+as published by the Free Software Foundation, either version 3
+of the License, or (at your option) any later version.
+
+You should have received a copy of the the GNU Lesser
+General Public License, along with RXSD. If not, see 
+<http://www.gnu.org/licenses/>

data/LICENSE

@@ -0,0 +1,165 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README

@@ -0,0 +1,19 @@
+RXSD - XSD / Ruby Translator
+Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+See COPYING for the License of this software
+
+RXSD is a library that translates XSD XML Schema Definitions into Ruby Classes 
+on the fly. It is able to read XSD resources and use them to define Ruby 
+classes in memory or string class definitions to be written to the filesystem
+
+RXSD implements a full XSD parser that not only defines the various xsd schema
+classes, parsing them out of a XSD file, but translates them into a 
+meta-class heirarchy, for use in subsequent transformations. The builder interface
+can easily be extended to output any format one could want including classes
+in other languages (Python, C++, Java, etc), other XML formats, etc.
+
+RXSD also parses XML conforming to a XSD schema, and instantiates objects 
+corresponding to the XSD classes created. Furthermore, RXSD will work with
+existing class definitions resulting in a quick way to map XSD to Ruby constructs,
+letting you define the schema features that you need, and autogenerting handlers
+to the others.

data/bin/rxsd-test.rb

@@ -0,0 +1,41 @@
+# Simple rxsd test utility
+#
+# Usage rxsd-test.rb uri-to-schema uri-to-xml-instance
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'lib/rxsd'
+
+if ARGV.size < 2
+  puts "missing required arguments"
+  exit
+end
+
+xsd_uri = ARGV[0]
+xml_uri = ARGV[1]
+
+schema = RXSD::Parser.parse_xsd :uri => xsd_uri
+#def disp_child(obj)
+#  if obj.respond_to? 'children'
+#  puts "#{obj}"
+#    obj.children.each { |c|
+#      disp_child c
+#    }
+#  end
+#end
+#disp_child(schema)
+
+puts "=======Classes======="
+classes = schema.to :ruby_classes
+puts classes.collect{ |cl| !cl.nil? ? (cl.to_s + " < " + cl.superclass.to_s) : ""}.sort.join("\n")
+
+puts "=======Tags======="
+puts schema.tags.collect { |n,cb| n + ": " + cb.to_s + ": " + (cb.nil? ? "ncb" : cb.klass_name.to_s + "-" + cb.klass.to_s) }.sort.join("\n")
+
+puts "=======Objects======="
+data = RXSD::Parser.parse_xml :uri => xml_uri
+objs = data.to :ruby_objects, :schema => schema
+objs.each {  |obj|
+  puts "#{obj}"
+}

data/lib/rxsd.rb

@@ -0,0 +1,22 @@
+# include all rxsd modules
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+lib = File.dirname(__FILE__)
+
+$: << lib + '/rxsd/'
+
+require 'rubygems'
+
+require lib + '/rxsd/exceptions'
+require lib + '/rxsd/common'
+require lib + '/rxsd/builtin_types'
+require lib + '/rxsd/xml'
+require lib + '/rxsd/loader'
+require lib + '/rxsd/resolver'
+require lib + '/rxsd/parser'
+require lib + '/rxsd/builder'
+require lib + '/rxsd/translator'
+
+Dir[lib + '/rxsd/xsd/*.rb'].each { |xsd_module| require xsd_module }

data/lib/rxsd/builder.rb

@@ -0,0 +1,159 @@
+# RXSD builder
+#
+# responsible for providing  interface to build any output format from XSD metadata
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+module RXSD
+
+# base interface and helper methods to build classes in various formats from specified parameters
+class ClassBuilder
+   # actual class built
+   attr_accessor :klass
+
+   # name of class to build
+   attr_accessor :klass_name
+
+   # class builder corresponding to associated type where approprate
+   attr_accessor :associated_builder
+
+   # class builder corresponding to base type where approprate
+   attr_accessor :base_builder
+
+   # array of class builders for all attributes
+   attr_accessor :attribute_builders
+
+   # name of the attribute which this class represents, for use in accessor construction
+   attr_accessor :attribute_name
+
+   # create a new class builder w/ specified args
+   def initialize(args = {})
+      if args.has_key? :builder
+        @klass              = args[:builder].klass
+        @klass_name         = args[:builder].klass_name
+        @associated_builder = args[:builder].associated_builder
+        @base_builder       = args[:builder].base_builder
+        @attribute_builders = args[:builder].attribute_builders
+        @attribute_name     = args[:builder].attribute_name
+
+      else
+        @klass = args[:klass]
+        @klass_name = args[:klass_name]
+
+        if args.has_key? :base_builder
+          @base_builder = args[:base_builder]
+        elsif args.has_key?(:base) && !args[:base].nil?
+          @base_builder = ClassBuilder.new :klass => args[:base]
+        end
+
+        @attribute_builders = []
+
+      end
+   end
+
+   # helper method
+   def base=(base)
+     @base_builder = ClassBuilder.new :klass => base
+   end
+
+   # perform a deep copy of builder, takes optional recursive guard
+   def clone(cloned = {})
+      return cloned[self] if cloned.has_key? self
+
+      cb = ClassBuilder.new
+      cloned[self]          = cb
+      cb.klass              = @klass
+      cb.klass_name         = @klass_name
+      cb.attribute_name     = @attribute_name
+      cb.associated_builder = @associated_builder.clone(cloned) unless @associated_builder.nil?
+      cb.base_builder       = @base_builder.clone(cloned) unless @base_builder.nil?
+      @attribute_builders.each { |ab|
+         cb.attribute_builders.push ab.clone(cloned) unless ab.nil?
+      }
+      return cb
+   end
+
+   # helper method to get all associated class builders
+   def associated(builders = [])
+       unless @base_builder.nil? || builders.include?(@base_builder)
+         builders.push @base_builder
+         builders = @base_builder.associated(builders)
+       end
+
+       unless @associated_builder.nil? || builders.include?(@associated_builder)
+         builders.push @associated_builder
+         builders = @associated_builder.associated(builders)
+       end
+
+       @attribute_builders.each { |ab|
+         unless ab.nil? || builders.include?(ab)
+           builders.push ab
+           builders = ab.associated(builders)
+         end
+       }
+
+       return builders
+   end
+
+   # subclasses must implement build method to
+   # construct target output type
+   virtual :build
+
+end # class ClassBuilder
+
+# base interface and helper methods to build objects in various formats from specified parameters
+class ObjectBuilder
+   # name of class instance to build
+   attr_accessor :tag_name
+
+   # content, for text based data types, will contain text to instantiate object w/
+   # TODO might want at some point to store a bool in ClassBuilder (only set to true in SimpleType) indicating
+   # that constructed class is a text based type, for verification purposes
+   attr_accessor :content
+
+   # actual object built
+   attr_accessor :obj
+
+   # hash of attribute names / values to assign to class instance attributes
+   attr_accessor :attributes
+
+   # array of children object builders to construct instances and assign to class instance attributes
+   attr_accessor :children
+
+   # parent object builder, optionally set
+   attr_accessor :parent
+
+   # create a new class builder w/ specified args
+   def initialize(args = {})
+      if args.has_key? :builder
+        @tag_name           = args[:builder].tag_name
+        @content            = args[:builder].content
+        @obj                = args[:builder].obj
+        @attributes         = args[:builder].attributes
+        @children           = args[:builder].children
+        @parent             = args[:builder].parent
+
+      else
+        @tag_name   = args[:tag_name]
+        @content    = args[:content]
+        @obj        = args[:obj]
+        @attributes = args[:attributes]
+        @children   = args[:children]
+        @parent     = args[:parent]
+
+      end
+
+      @children = [] if @children.nil?
+      @attributes = [] if @attributes.nil?
+   end
+
+   # subclasses must implement build method to
+   # construct target output type, should take one parameter,
+   # the schema which to use in object construction
+   virtual :build
+
+end
+
+
+end # module RXSD

data/lib/rxsd/builders/ruby_class.rb

@@ -0,0 +1,79 @@
+# RXSD Ruby Class builder
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+module RXSD
+
+# Implements the RXSD::ClassBuilder interface to build Ruby Classes from xsd
+class RubyClassBuilder < ClassBuilder
+
+
+   # implementation of RXSD::ClassBuilder::build
+   def build
+      # return if already built
+      return @klass unless @klass.nil?
+
+      # need the class name to build class
+      return nil    if @klass_name.nil?
+
+      # return if we can find constant corresponding to class name
+      if Object.constants.include? @klass_name
+        @klass = @klass_name.constantize
+        return @klass
+      end
+
+      Logger.debug "building class #{@klass}/#{@klass_name} from xsd"
+
+      # determine object's superclass, creating it if need be
+      superclass = Object
+      unless @base_builder.nil?
+        if @base_builder.klass.nil?
+          @base_builder = RubyClassBuilder.new(:builder => @base_builder)
+          @base_builder.build
+        end
+        superclass = @base_builder.klass
+      end
+
+      # create class
+      Object.const_set(@klass_name, Class.new(superclass))
+      @klass = @klass_name.constantize
+
+      # FIXME should only do this if the klass corresponds to a simple type
+      @klass.class_method :from_s do |str|
+            new(:superclass_value => superclass.from_s(str))
+      end
+      @klass.send :define_method, :initialize do |*args|
+        args = args.first || Hash.new
+        if !args.nil? && args.has_key?(:superclass_value)
+           if Parser.is_builtin? superclass
+              super(args[:superclass_value])
+           else
+              super(:superclass_value => args[:superclass_value])
+           end
+        end
+      end
+
+      # define accessors for attributes
+      @attribute_builders.each { |atb|
+        unless atb.nil?
+          att_name = nil
+          if !atb.attribute_name.nil?
+             att_name = atb.attribute_name.underscore
+          elsif !atb.klass_name.nil?
+             att_name = atb.klass_name.underscore
+          elsif !atb.klass.nil?
+             att_name = atb.klass.to_s.underscore
+          end
+
+          @klass.send :attr_accessor,  att_name.intern unless att_name.nil?
+        end
+      }
+
+      Logger.debug "class #{@klass} built, returning"
+      return @klass
+   end
+
+end
+
+end