simcha-mappum 0.1.0

data/lib/mappum/open_xml_object.rb

@@ -0,0 +1,61 @@
+class SOAP::Mapping::Object
+  def id
+    self[XSD::QName.new(nil, "id")]
+  end
+  def type
+    self[XSD::QName.new(nil, "type")]
+  end
+  
+  # 
+  # XmlAny element is equal to the other xmlAny element when it 
+  # has same elements and attributes regardles of ordering of 
+  # elements and attributes.
+  #
+  def == other
+    return false if other.class != self.class  
+    return false if @__xmlele - other.__xmlele == []
+    return false if @__xmlattr != other.__xmlattr
+    return true
+  end
+end
+
+class OpenXmlObject < SOAP::Mapping::Object
+  def method_missing(sym, *args, &block)
+    if sym.to_s[-1..-1] == "=" then
+      if sym.to_s[0..7] == "xmlattr_"
+        #attribute
+        name = sym.to_s[8..-2]
+        __add_xmlattr_from_method(name, args[0])
+      else
+        #element
+        __add_xmlele_from_method(sym.to_s[0..-2], args[0])
+      end        
+    else  
+      super(sym, *args, &block)
+    end
+  end
+  def id=(value)
+    __add_xmlele_from_method("id", value)        
+  end
+  def type=(value)
+    __add_xmlele_from_method("type",value)        
+  end
+  private
+  def __add_xmlattr_from_method(name, value)
+    @__xmlattr[XSD::QName.new(nil, name)] = value
+    self.instance_eval <<-EOS
+      def xmlattr_#{name}
+        @__xmlattr[XSD::QName.new(nil, #{name})]
+      end
+
+      def xmlattr_#{name}=(value)
+        @__xmlattr[XSD::QName.new(nil, #{name})] = value
+      end
+    EOS
+  end
+  def __add_xmlele_from_method(name, value)
+    Thread.current[:SOAPMapping] ||= {}
+    Thread.current[:SOAPMapping][:SafeMethodName] ||= {}
+    __add_xmlele_value(XSD::QName.new(nil, name),value)
+  end
+end 

data/lib/mappum/ruby_transform.rb

@@ -0,0 +1,129 @@
+# TODO docs
+require 'set'
+require 'mappum'
+require 'ostruct'
+
+module Mappum
+  class OpenStruct < OpenStruct
+    def type(*attr)
+      method_missing(:type, *attr)
+    end
+    def id(*attr)
+      method_missing(:id, *attr)
+    end
+  end
+  class MapMissingException < RuntimeError
+    attr_accessor :from
+    def initialize(from, msg=nil)
+      msg ||= "Map for class \"#{from.class}\" not found!"
+      super(msg)
+      @from = from
+    end
+  end
+  class RubyTransform
+    attr_accessor :map_catalogue
+    
+    def initialize(map_catalogue = nil, default_struct_class=nil)
+      @map_catalogue = map_catalogue if map_catalogue.kind_of?(Mappum::Map)
+      @map_catalogue ||= Mappum.catalogue(map_catalogue)
+      @default_struct_class = default_struct_class
+      @default_struct_class ||= Mappum::OpenStruct;
+    end
+    def get(object, field)
+      if field.nil?
+        return object
+      elsif not object.kind_of?(@default_struct_class) or 
+        object.respond_to?(field)
+        return object.send(field)
+      else
+        #for open structures field will be defined later
+        return nil
+      end
+    end
+    def transform(from, map=nil, to=nil)
+
+      map ||= @map_catalogue[from.class]
+      
+      raise MapMissingException.new(from) if map.nil?
+      
+      to ||= map.to.clazz.new unless map.to.clazz.nil? or map.to.clazz.kind_of?(Symbol)
+      
+      all_nils = true
+
+      map.maps.each do |sm|
+        from_value, to_value = nil, nil
+        
+        if sm.from.respond_to?(:name)
+           from_value = get(from, sm.from.name) 
+        else
+           from_value = sm.from.value
+        end
+        
+        if sm.maps.empty?
+          to_value = from_value
+        elsif not from_value.nil?
+          if from_value.instance_of?(Array)
+            sm_v = sm.clone
+            sm_v.from.is_array = false
+            sm_v.to.is_array = false
+            to_value = from_value.collect{|v| transform(v, sm_v)}
+          else
+            to ||= @default_struct_class.new
+            v_to = nil
+            #array values are assigned after return
+            v_to = get(to, sm.to.name) unless sm.to.is_array and not sm.from.is_array
+            to_value = transform(from_value, sm, v_to)
+          end
+
+        end
+        unless sm.func.nil? or (not sm.func_on_nil? and to_value.nil?)
+          to_value = sm.func.call(to_value)
+        end
+        unless sm.from.func.nil? or to_value.nil?
+          to_value = to_value.instance_eval(sm.from.func)
+        end
+        unless sm.dict.nil?
+          to_value = sm.dict[to_value]
+        end
+        if sm.to.is_array and not sm.from.is_array
+          to_array = get(to,sm.to.name)
+          to_array ||= []
+          to_array << to_value
+          
+          if to_array.empty? and sm.strip_empty?
+            to_array = nil
+          end
+          
+          all_nils = false unless to_array.nil?
+
+          if sm.to.name.nil?
+            to = to_array
+          else
+            to ||= @default_struct_class.new
+            to.send("#{sm.to.name}=", to_array) unless to_array.nil?
+          end
+        else
+
+          if to_value.respond_to?(:empty?) and to_value.empty? and sm.strip_empty?
+            to_value = nil
+          end
+          
+          all_nils = false unless to_value.nil?
+                    
+          if sm.to.name.nil?
+            to ||= to_value
+          elsif
+            to ||= @default_struct_class.new 
+            
+            to.send("#{sm.to.name}=", to_value) unless to_value.nil?
+          end
+        end
+        
+      end
+      if all_nils and map.strip_empty?
+        return nil
+      end
+      return to
+    end
+  end
+end

data/lib/mappum/xml_transform.rb

@@ -0,0 +1,298 @@
+require 'mappum/ruby_transform'
+require 'rubygems'
+gem 'soap4r'
+require 'soap/marshal'
+require 'xsd/mapping'
+require 'wsdl/xmlSchema/xsd2ruby'
+require 'mappum/open_xml_object'
+require 'tmpdir'
+
+class XSD::Mapping::Mapper
+  attr_reader :registry
+  def self.inherited(klass)
+    @@mapper_classes ||= []
+    @@mapper_classes << klass
+  end
+  def self.find_mapper_for_class(klass)
+    klass = const_get(klass) if klass.instance_of?(Symbol)
+    ret_maper=nil
+    #FIXME add cache
+    mappers.each do |mapper|
+      begin 
+        sch = mapper.registry.schema_definition_from_class klass
+        ret_maper = mapper unless sch.nil?
+      rescue NoMethodError
+      end
+    end
+    return ret_maper
+  end
+  def self.get_qname_from_class(klass)
+    begin
+      klass = const_get(klass) if klass.instance_of?(Symbol)
+    rescue NameError
+      return nil
+    end
+    ret_qname = nil
+    #FIXME add cache
+    mappers.each do |mapper|
+      begin 
+        sch = mapper.registry.schema_definition_from_class klass
+        ret_qname =  sch.elename unless sch.nil?
+      rescue NoMethodError
+      end
+    end
+    return ret_qname
+  
+  end
+  def self.find_mapper_for_type(qname)
+    ret_maper=nil
+    #FIXME add cache
+    mappers.each do |mapper|
+      begin 
+        sch = mapper.registry.schema_definition_from_elename qname
+        ret_maper = mapper unless sch.nil?
+      rescue NoMethodError
+      end
+    end
+    return ret_maper
+  end
+  def obj2soap(obj, elename = nil, io = nil)
+    opt = MAPPING_OPT.dup
+    unless elename
+      if definition = @registry.elename_schema_definition_from_class(obj.class)
+        elename = definition.elename
+        opt[:root_type_hint] = false
+      end
+    end
+    elename = SOAP::Mapping.to_qname(elename) if elename
+    soap = SOAP::Mapping.obj2soap(obj, @registry, elename, opt)
+    if soap.elename.nil? or soap.elename == XSD::QName::EMPTY
+      soap.elename =
+        XSD::QName.new(nil, SOAP::Mapping.name2elename(obj.class.to_s))
+    end
+    return soap
+  end
+
+ private
+  def self.mappers
+    @@mappers ||= []
+    @@mapper_classes ||= []
+    if @@mapper_classes.size > @@mappers.size
+      @@mappers = @@mapper_classes.collect{|k|k.new()}
+    end
+    @@mappers
+  end
+end
+  
+module Mappum
+  class XmlTransform
+    def initialize(map_catalogue = nil)
+      @default_mapper =  XSD::Mapping::Mapper.new(SOAP::Mapping::LiteralRegistry.new)
+      @ruby_transform = RubyXmlTransform.new(map_catalogue, OpenXmlObject)
+    end
+    def transform(from_xml, map=nil, from_qname=nil, to_qname=nil, handle_soap=true)
+      soap = false
+      
+      parser = SOAP::Parser.new(XSD::Mapping::Mapper::MAPPING_OPT)
+      preparsed = parser.parse(from_xml)
+
+      if from_qname.nil?
+        from_qname = preparsed.elename
+      end
+      
+      if handle_soap and from_qname == XSD::QName.new("http://schemas.xmlsoap.org/soap/envelope/","Envelope")
+        soap = true
+        #for soap remove envelope
+        preparsed = preparsed.body.root_node
+        from_qname = preparsed.elename
+      end
+      
+            
+      from_mapper = XSD::Mapping::Mapper.find_mapper_for_type(from_qname)
+      if from_mapper.nil?
+         from_mapper = @default_mapper
+      end
+     
+      begin
+        parsed =SOAP::Mapping.soap2obj(preparsed, from_mapper.registry, nil)
+      rescue NoMethodError => e
+        raise ParsingFailedException.new("Parsing failed for xml with root element: #{from_qname}")
+      end
+
+      map ||= @ruby_transform.map_catalogue[from_qname]
+      map ||= @ruby_transform.map_catalogue[from_qname.name.to_sym]
+      if not map.nil? and not map.kind_of?(Map)
+        map = @ruby_transform.map_catalogue[map.to_sym]
+      end
+
+      begin
+        transformed = @ruby_transform.transform(parsed, map)
+      rescue MapMissingException => e
+        if e.from == parsed
+          raise MapMissingException.new(e.from,"Map for element \"#{from_qname}\" not found!")
+        else
+          raise e
+        end
+      end
+      
+      to_mapper = XSD::Mapping::Mapper.find_mapper_for_class(transformed.class)
+      if to_mapper.nil?
+        to_mapper = @default_mapper
+      end
+
+      if transformed.kind_of?(OpenXmlObject) and to_qname.nil? and not map.nil?
+        to = map.to
+        if to.clazz.kind_of?(XSD::QName)
+          to_qname = to.clazz
+        else
+          to_qname = XSD::QName.new(nil, to.clazz.to_s)
+        end
+      end
+      to_preparsed = to_mapper.obj2soap(transformed,to_qname)
+      if soap == true 
+        to_preparsed = SOAP::SOAPEnvelope.new(SOAP::SOAPHeader.new, SOAP::SOAPBody.new(to_preparsed))
+      end
+      generator = SOAP::Generator.new(XSD::Mapping::Mapper::MAPPING_OPT)
+      to_xml = generator.generate(to_preparsed, nil)
+      return to_xml
+    end
+  end
+  class RubyXmlTransform < RubyTransform
+    def initialize(*args)
+      super(*args)
+    end
+    def get(object, field)
+      begin
+        super(object, field)
+      rescue NoMethodError
+        super(object, XSD::CodeGen::GenSupport.safemethodname(field.to_s).to_sym)
+      end
+    end
+  end
+  # Class supporting loading working directory of the layout:
+  #
+  # schema/ - Directory containing xsd files
+  #
+  # map/ - directory containing Mappum maps
+  #
+  class WorkdirLoader
+    def initialize(schema_path = "schema", map_dir="maps", basedir=nil)
+      @schema_path = schema_path
+      @basedir = basedir
+      @basedir ||= Dir.mktmpdir
+      @map_dir = map_dir
+      @mapper_scripts = []
+    end
+    def generate_and_require
+      generate_classes
+      require_all
+    end
+    def require_all
+      require_schemas
+      require_maps
+    end
+    # Generate classes from xsd files in shema_path (defaults to schema).
+    # Files containt in subdirectories are generated to modules where module name is
+    # optaind from folder name.
+    # Generated classes are saved to basedir (defaults to tmp)
+    def generate_classes(schema_path=nil, module_path=nil)
+      class_dir = @basedir
+      modname = module_path
+      unless module_path.nil?
+        class_dir = File.join(class_dir, module_path) 
+        modname = modname.gsub(File::SEPARATOR, "::")
+        modname = modname.gsub(/^[a-z]|\s+[a-z]|\:\:+[a-z]/) { |a| a.upcase }
+      end
+      
+      Dir.mkdir(class_dir) unless File.exist? class_dir
+      
+
+      
+      schema_path ||= @schema_path 
+      
+      Dir.foreach(schema_path) do |file_name|
+        full_name = File.join(schema_path,file_name)
+        #when file is a directory
+        #generate classes in module (recursive)
+        if File.directory?(full_name) and not file_name == "." and not file_name == ".."
+          #make directory for future class files
+          module_pth = file_name
+          module_pth = File.join(module_path, module_pth) unless module_path.nil?
+           
+          generate_classes(full_name, module_pth)
+        # for XSD files generate classes using XSD2Ruby
+        elsif /.*.xsd/ =~ file_name
+          run_xsd2ruby(full_name, file_name, module_path, modname)
+          @mapper_scripts <<  class_dir + File::SEPARATOR + file_name[0..-5] + "_mapper.rb"
+        end
+      end
+    end
+    def require_schemas
+      $:.unshift @basedir
+      @mapper_scripts.each do |script|
+        require script
+      end
+    end
+    def require_maps
+      $:.unshift @map_dir
+      Dir.foreach(@map_dir) do |file_name|
+        if /.*.rb/ =~ file_name
+          require File.join(@map_dir, file_name)
+        end
+      end
+    end
+    private 
+    def run_xsd2ruby(full_name, file_name, module_path, modname)
+      worker = WSDL::XMLSchema::XSD2Ruby.new
+      worker.location = full_name
+      worker.basedir = @basedir
+      
+      classdef = file_name[0..-5]
+      classdef = File.join(module_path,classdef) unless module_path.nil?
+      
+      opt = {"classdef" => classdef, "mapping_registry"  => "", "mapper" => "", "force" => ""}
+      opt["module_path"] = modname unless modname.nil?
+      worker.opt.update(opt)
+      worker.run
+    end
+  end
+  class XmlSupport
+    #choose parser
+    begin
+      gem 'libxml-ruby'
+      require 'libxml'
+      @@parser = :libxml
+    rescue Gem::LoadError
+      require 'rexml/parsers/sax2parser'
+      @@parser = :rexml
+    end
+    #
+    # Get target namespace from given xsd file
+    #
+    def self.get_target_ns(xsd_file)
+      return get_target_ns_libxml(xsd_file) if @@parser == :libxml
+      return get_target_ns_rexml(xsd_file)
+    end
+    def self.get_target_ns_rexml(xsd_file)
+      reader = REXML::Parsers::SAX2Parser.new(File.new(xsd_file))
+      namespace = nil
+      #FIXME: quit after root
+      reader.listen(:start_element) do |uri, localname, qname, attributes|
+        namespace ||= attributes["targetNamespace"]
+      end
+
+      reader.parse
+      return namespace
+    end
+    def self.get_target_ns_libxml(xsd_file)
+      reader = LibXML::XML::Reader.file(xsd_file)
+      reader.read
+      reader.move_to_attribute("targetNamespace")
+      namespace = reader.value
+      reader.close
+      return namespace 
+    end
+  end  
+  class ParsingFailedException  < RuntimeError    
+  end
+end