rxsd 0.2

data/lib/rxsd/builders/ruby_definition.rb

@@ -0,0 +1,54 @@
+# RXSD Ruby Definition 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 string Ruby Class Definitions from xsd
+class RubyDefinitionBuilder < ClassBuilder
+
+   # implementation of RXSD::ClassBuilder::build
+   def build
+      return "class #{@klass.to_s}\nend" if Parser.is_builtin? @klass
+
+      # need the class name to build class
+      return nil    if @klass_name.nil?
+
+      Logger.debug "building definition for #{@klass}/#{@klass_name}  from xsd"
+
+      # defined class w/ base
+      superclass = "Object"
+      unless @base_builder.nil?
+        if    ! @base_builder.klass_name.nil?
+          superclass = @base_builder.klass_name
+        elsif ! @base_builder.klass.nil?
+          superclass = @base_builder.klass.to_s
+        end
+      end
+      res = "class " + @klass_name + " < " + superclass + "\n"
+
+      # 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
+          else
+             att_name = atb.klass.to_s.underscore
+          end
+
+          res += "attr_accessor :#{att_name}\n"
+        end
+      }
+      res += "end"
+
+      Logger.debug "definition #{res} built, returning"
+      return res
+   end
+
+end
+
+end

data/lib/rxsd/builders/ruby_object.rb

@@ -0,0 +1,59 @@
+# RXSD Ruby Object builder
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+module RXSD
+
+# Implements the RXSD::ObjectBuilder interface to build Ruby Objects from a xsd-conforming xml doc
+class RubyObjectBuilder < ObjectBuilder
+
+   # implementation of RXSD::ObjectBuilder::build
+   def build(schema)
+      # return object if already built
+      return @obj unless @obj.nil?
+      
+      Logger.debug "instantiating class #{@tag_name} from xsd"
+
+      # find class builder corresponding to tag_name to instantiate
+      tags   = schema.tags
+      klass  = tags[@tag_name].klass
+
+      # instantiate the target class
+      if @content.nil? # not a text based obj, construct normally
+        @obj = klass.new
+      elsif klass == Array # special case when instantiating arrays, need to specify item type
+        @obj = klass.from_s @content, tags[@tag_name].associated_builder.klass
+      else
+        @obj = klass.from_s @content
+      end
+
+      # go through each attribute, find corresponding class builder, 
+      # instantiate, and assign to object
+      @attributes.each { |atn, atv|
+        if tags.has_key? @tag_name + ":" + atn # FIXME how do we want to handle attributes that are not in the schema (eg the else here)
+          aklass  = tags[@tag_name + ":" + atn].klass
+          if aklass == Array # special case when instantiating arrays, need to specify item type
+            val = aklass.from_s atv, tags[@tag_name + ":" + atn].associated_builder.klass
+          else
+            val = aklass.from_s atv
+          end
+          @obj.send("#{atn.underscore}=".intern, val)
+        end
+      }
+
+      # instantiate each child using builder and assign to object
+      @children.each { |child|
+        cob  = RubyObjectBuilder.new(:builder => child)
+        cobj = cob.build(schema)
+        @obj.send("#{cob.tag_name.underscore}=".intern, cobj)
+      }
+
+      Logger.debug "object type #{@tag_name} instantiated, returning"
+
+      return @obj
+   end
+
+end
+
+end

data/lib/rxsd/builtin_types.rb

@@ -0,0 +1,82 @@
+# RXSD builtin types
+#
+# Here we add some functionality to some basic
+# Ruby types and define some of our own.
+#
+# Each type must be able to be instantiated with
+# no arguments as well as from a string string parameter
+# (exception is made in the case of Array)
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'date'
+
+# Array, String, Time can be instantiated as is
+
+class Array
+  # arrays take addition parameter when instantiating from
+  # string, the item type which to instantiate array elements w/
+  def self.from_s(str, item_type)
+     arr = []
+     str.split.each { |i|
+       arr.push item_type.from_s(i)
+     }
+     return arr
+  end
+end
+
+class String
+  # convert string to boolean
+  def to_b
+    return true if self == true || self =~ /^true$/i
+    return false if self == false || self.nil? || self =~ /^false$/i
+    raise ArgumentError, "invalid value for Boolean: \"#{self}\""
+  end
+
+  def self.from_s(str)
+     str
+  end
+end
+
+class Time
+  def self.from_s(str)
+     return Time.parse(str)
+  end
+end
+
+# ruby doesn't define Char class, so we dispatch to string
+class Char < String
+end
+
+# Since we can't create new instances of Integer, Float,
+# etc subclasses, we use the delegate module
+# http://codeidol.com/other/rubyckbk/Numbers/Simulating-a-Subclass-of-Fixnum/
+require 'delegate'
+
+class XSDInteger < DelegateClass(::Integer)
+  def self.from_s(str)
+     str.to_i
+  end
+end
+
+class XSDFloat < DelegateClass(::Float)
+  def self.from_s(str)
+     str.to_f
+  end
+end
+
+# ruby doesn't define Boolean class, so we define one ourselves
+class Boolean
+  def self.from_s(str)
+     str.to_b
+  end
+
+  def initialize(val=false)
+     @val = val
+  end
+
+  def nil?
+     return !@val
+  end
+end

data/lib/rxsd/common.rb

@@ -0,0 +1,69 @@
+# Things that don't fit elsewhere
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+# we make use of the activesupport inflector
+require 'active_support'
+
+# logger support
+require 'logger'
+
+class Logger
+  def format_message(severity, timestamp, progname, msg)
+    "#{severity} #{timestamp} (#{$$}) #{msg}\n"
+  end
+end
+
+module RXSD
+    # Logger helper class
+    class Logger
+      private
+        LOG_LEVEL = ::Logger::FATAL # FATAL ERROR WARN INFO DEBUG
+
+        def self._instantiate_logger
+           unless defined? @@logger
+             @@logger = ::Logger.new(STDOUT)
+             @@logger.level = LOG_LEVEL
+           end 
+        end 
+
+      public
+        def self.method_missing(method_id, *args)
+           _instantiate_logger
+           @@logger.send(method_id, args)
+        end 
+        def self.logger
+           _instantiate_logger
+           @@logger
+        end
+    end
+end
+
+class Module
+  # add virtual method support
+  def virtual(*methods)
+    methods.each do |m|
+      define_method(m) {
+        raise VirtualMethodCalledError, m
+      }
+    end
+  end
+
+  # add helper method to define a class method on any class
+  def class_method(method_name, &block)
+    (class << self; self; end).instance_eval do
+      define_method method_name, block
+    end
+  end
+end
+
+# read entire file into string
+def File.read_all(path)
+  File.open(path, 'rb') {|file| return file.read }
+end
+
+# write contents of file from string
+def File.write(path, str)
+  File.open(path, 'wb') {|file| file.write str }
+end

data/lib/rxsd/exceptions.rb

@@ -0,0 +1,25 @@
+# RXSD exceptions
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'uri' # use uri to parse sources
+
+# add virtual method support
+class VirtualMethodCalledError < RuntimeError
+  attr :name
+  def initialize(name)
+    super("Virtual function '#{name}' called")
+    @name = name
+  end
+end
+
+module RXSD
+module Exceptions
+
+# thrown when specified resource uri is invalid
+class InvalidResourceUri
+end
+
+end # module Exceptions
+end # module RXSD

data/lib/rxsd/libxml_adapter.rb

@@ -0,0 +1,77 @@
+
+# libxml adapter
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'rubygems'
+require 'libxml' # based on libxml
+
+module RXSD
+module XML
+
+# class prototype needed :-(
+class Node
+end
+
+# some additions to libxml xml node interface 
+class LibXMLNode < Node
+
+  # implementation of RXSD::XML::Node::xml_root(xml)
+  def self.xml_root(xml)
+      LibXMLNode.new :node => LibXML::XML::Document.string(xml).root
+  end
+
+  # create libxml node adapter w/ specified args, which may include
+  #   * :node LibXML::Node to use to satify requests
+  def initialize(args = {})
+     @node = args[:node]
+  end
+
+
+  # implementation of RXSD::XML::Node.name
+  def name 
+     @node.name
+  end
+
+  # implementation of RXSD::XML::Node.attrs
+  def attrs
+     @node.attributes.to_h
+  end
+  
+  # implementation of RXSD::XML::Node.parent?
+  def parent?
+     @node.parent? && @node.parent.class != LibXML::XML::Document
+  end
+
+  # implementation of RXSD::XML::Node.parent
+  def parent
+     parent? ? LibXMLNode.new(:node => @node.parent) : nil
+  end
+
+  # implementation of RXSD::XML::Node.children
+  def children
+     @node.children.collect { |n|
+       LibXMLNode.new :node => n
+     }
+  end
+
+  # implementation of RXSD::XML::Node.text?
+  def text?
+     @node.text?
+  end
+
+  # implementation of RXSD::XML::Node.content
+  def content
+     @node.content
+  end
+
+  # implementation of RXSD::XML::Node.namespaces
+  def namespaces
+     @node.namespaces
+  end
+
+end
+
+end # module XML
+end # module RXSD

data/lib/rxsd/loader.rb

@@ -0,0 +1,33 @@
+# RXSD resource loader 
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'uri'      # use uri to parse sources
+require 'net/http' # get http:// based resources
+
+module RXSD
+
+# loads resources from uris
+class Loader
+
+ # loads and return text resource from specified source uri
+ def self.load(source_uri)
+    Logger.info "loading resource from uri #{source_uri}" 
+    data = nil
+    uri = URI.parse(source_uri)
+    if uri.scheme == "file"
+       data = File.read_all uri.path
+    elsif uri.scheme == "http"
+       data = Net::HTTP.get_response(uri.host, uri.path).body
+    # elsif FIXME support other uri types
+    end
+
+    return data
+
+    rescue URI::InvalidURIError
+       raise Exceptions::InvalidResourceUri
+ end
+
+end # class loader
+end # module RXSD

data/lib/rxsd/parser.rb

@@ -0,0 +1,135 @@
+# xml / xsd parsers
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+module RXSD
+
+# provides class methods to parse xsd and xml data
+class Parser
+ private
+  def initialize
+  end
+
+ public
+
+  # parse xsd specified by uri or in raw data form into RXSD::XSD::Schema instance
+  # args should be a hash w/ optional keys:
+  #   * :uri location which to load resource from
+  #   * :raw raw data which to parse
+  def self.parse_xsd(args)
+     data = Loader.load(args[:uri]) unless args[:uri].nil?
+     data = args[:raw]              unless args[:raw].nil?
+     Logger.debug "parsing xsd"
+
+     # FIXME validate against xsd's own xsd
+     root_xml_node = XML::Node.factory :backend => :libxml, :xml => data
+     schema = XSD::Schema.from_xml root_xml_node
+
+     Logger.debug "parsed xsd, resolving relationships"
+     Resolver.resolve_nodes schema
+
+     Logger.debug "xsd parsing complete"
+     return schema
+  end
+
+  # parse xml specified by uri or in raw data form into RXSD::XSD::SchemaInstance instance
+  def self.parse_xml(args)
+     data = Loader.load(args[:uri]) unless args[:uri].nil?
+     data = args[:raw]              unless args[:raw].nil?
+     Logger.debug "parsing xml"
+
+     root_xml_node = XML::Node.factory :backend => :libxml, :xml => data
+     schema_instance = SchemaInstance.new :builders => SchemaInstance.builders_from_xml(root_xml_node)
+
+     Logger.debug "xml parsing complete"
+     return schema_instance
+  end
+
+  # return true is specified class is builtin, else false
+  def self.is_builtin?(builtin_class)
+    [Array, String, Boolean, Char, Time, XSDFloat, XSDInteger].include? builtin_class
+  end
+
+  # return ruby class corresponding to builting type
+  def self.parse_builtin_type(builtin_type_name)
+    res = nil
+
+    case builtin_type_name
+      when "xs:string":
+        res = String
+      when "xs:boolean":
+        res = Boolean
+      when "xs:decimal":
+        res = XSDFloat
+      when "xs:float":
+        res = XSDFloat
+      when "xs:double":
+        res = XSDFloat
+      when "xs:duration":
+      when "xs:dateTime":
+        res = Time
+      when "xs:date":
+        res = Time
+      when "xs:gYearMonth":
+        res = Time
+      when "xs:gYear":
+        res = Time
+      when "xs:gMonthDay":
+        res = Time
+      when "xs:gDay":
+        res = Time
+      when "xs:gMonth":
+        res = Time
+      when "xs:hexBinary":
+      when "xs:base64Binary":
+      when "xs:anyURI":
+      when "xs:QName":
+      when "xs:NOTATION":
+      when "xs:normalizedString"
+      when "xs:token"
+         res = String # FIXME should be a string derived class, eliminating whitespace
+      when "xs:language"
+      when "xs:NMTOKEN"
+      when "xs:NMTOKENS"
+      when "xs:Name"
+      when "xs:NCName"
+      when "xs:ID"
+      when "xs:IDREF"
+      when "xs:IDREFS"
+      when "xs:ENTITY"
+      when "xs:ENTITIES"
+      when "xs:integer"
+         res = XSDInteger
+      when "xs:nonPositiveInteger"
+         res = XSDInteger
+      when "xs:negativeInteger"
+         res = XSDInteger
+      when "xs:long"
+         res = XSDInteger
+      when "xs:int"
+         res = XSDInteger
+      when "xs:short"
+         res = XSDInteger
+      when "xs:byte"
+         res = Char
+      when "xs:nonNegativeInteger"
+         res = XSDInteger
+      when "xs:unsignedLong"
+         res = XSDInteger
+      when "xs:unsignedInt"
+         res = XSDInteger
+      when "xs:unsignedShort"
+         res = XSDInteger
+      when "xs:unsignedByte"
+         res = Char
+      when "xs:positiveInteger"
+         res = XSDInteger
+    end
+
+    return res
+  end
+
+end
+
+end