mappum 0.2.0

data/lib/mappum/map.rb

@@ -0,0 +1,194 @@
+module Mappum
+# Base Map class representing mapping betwean two or more types, properties etc.
+  class Map
+    
+    attr_accessor :maps, :bidi_maps, :strip_empty, :source
+    
+    def initialize
+      @maps = []
+      @bidi_maps =[]
+      @strip_empty = true
+    end
+    # When value of mapped property is null remove property.
+    def strip_empty?
+      @strip_empty
+    end
+  end
+  
+  
+  class RootMap < Map
+    attr_accessor :name
+    def initialize(name)
+      super()
+      @name = name
+      @strip_empty = false
+      @maps_by_name, @maps_by_from = {},{}
+      @maps_by_from_to = {}
+      @bidi_maps_by_name, @bidi_maps_by_class = {},{}
+    end
+    def [](arg1, to_class=nil)
+      from_class = arg1
+      unless to_class.nil?
+        key = [from_class.to_s, to_class.to_s]
+        return @maps_by_from_to[key]
+      end
+      mpa = @maps_by_from[from_class.to_s]
+      return mpa unless mpa.nil?
+      return @maps_by_name[arg1.to_s]
+    end
+    def get_bidi_map(name)
+      mpa = @bidi_maps_by_class[name.to_s]
+      return mpa unless mpa.nil?
+      
+      return @bidi_maps_by_name[name.to_s]
+    end
+    def list_map_names(full_list = false)
+      list = []
+      list += @maps_by_name.collect{|k,v| k}
+      list += @maps_by_from.collect{|k,v| k} if full_list
+      return list
+    end
+    def list_bidi_map_names
+      list = []
+      list += @bidi_maps_by_name.collect{|k, v| k}
+      return list
+    end
+    #
+    # Add array of maps to catalogue.
+    # Makes name index for map search.
+    # Map names will be used and no 2 names can be the same in the catalogue/
+    # Class names will be used for maps that are unique in regard to mapping from and to classes.
+    #
+    def add(map)
+      if map.normalized?
+        raise "Duplicate map name #{map.name}" if @maps_by_name.include?(map.name)
+        @maps_by_name[map.name] = map
+        #When there are 2 maps from same class to other classes non will be found by default
+        add_to_index(@maps_by_from, map.from.clazz.to_s, map)
+
+        #When there are 2 maps from same class to same class non will be found by default
+        from_to_key = [map.from.clazz.to_s, map.to.clazz.to_s]
+        add_to_index(@maps_by_from_to, from_to_key, map)
+      else
+        raise "Duplicate map name #{map.name}" if @bidi_maps_by_name.include?(map.name)
+        @bidi_maps_by_name[map.name] = map
+
+        add_to_index(@bidi_maps_by_class, map.left.clazz.to_s, map)
+        add_to_index(@bidi_maps_by_class, map.right.clazz.to_s, map)
+      end
+    end
+    #
+    # Add value to index in key position unless there is a value for such a key
+    # in such a case put nil in the index to mark position invalid
+    #
+    private 
+    def add_to_index(index, key, map)
+      if index.include?(key)
+        index[key] = nil
+      else
+        index[key] = map
+      end
+    end
+  end
+  
+  class FieldMap < Map
+    attr_accessor :dict, :desc, :left, :right, :func, :block, :to, :from, :func_on_nil, :submap_alias
+    attr_accessor :name, :l2r_name, :r2l_name, :name_prefix, :map_when, :when_r2l, :when_l2r
+    # True if map is unidirectional. Map is unidirectional
+    # when maps one way only.
+    def normalized?
+      not @from.nil?
+    end
+    def name
+      return @name unless @name.nil?
+      if normalized?
+        @name = "#{@name_prefix}#{@from.clazz}_to_#{@to.clazz}"
+      else
+        @name =  "#{@name_prefix}#{@left.clazz}_to_from-#{@right.clazz}"
+      end
+      return @name
+    end
+    def normalize
+      #if bidirectional
+      if not normalized?
+        map_r2l = self.clone
+        map_r2l.to = self.left
+        map_r2l.from = self.right
+        map_r2l.name = self.r2l_name
+        map_r2l.r2l_name, map_r2l.l2r_name = nil, nil
+        map_r2l.map_when = self.when_r2l
+        map_r2l.when_r2l, map_r2l.when_l2r = nil, nil
+        map_r2l.maps = self.maps.select do |m|
+          m.to.parent == map_r2l.to
+        end
+        
+        map_r2l.dict = self.dict.invert unless self.dict.nil?
+  
+        map_l2r = self.clone
+        map_l2r.to = self.right
+        map_l2r.from = self.left
+        map_l2r.name = self.l2r_name
+        map_l2r.r2l_name, map_l2r.l2r_name = nil, nil
+        map_l2r.map_when = self.when_l2r
+        map_l2r.when_r2l, map_l2r.when_l2r = nil, nil
+        map_l2r.maps = self.maps.select do |m|
+          m.to.parent == map_l2r.to
+        end
+  
+        [map_r2l, map_l2r]
+      else
+        [self]
+      end
+    end
+    def simple?
+        @func.nil? && @dict.nil? && @desc.nil? && 
+          @maps.empty? && @bidi_maps.empty? && @right.func.nil? && @left.func.nil?
+    end
+    def func_on_nil?
+      @func_on_nil
+    end
+  end
+  class Tree
+    attr_accessor :parent
+  
+    def initialize(parent)
+      @parent = parent
+    end
+    def method_missing(symbol, *args)
+      return Field.new(@parent, symbol, args[0])
+    end
+  end
+  class Field < Struct.new(:name, :clazz, :parent, :func, :block, :is_root, :is_array, :is_placeholder)
+    def array?
+      is_array
+    end
+    def placeholder?
+      is_placeholder
+    end
+  end
+  class Constant <  Struct.new(:value) 
+    def parent
+      nil
+    end
+    def is_array
+      @value.kind_of?(Array)
+    end
+    def func
+      nil      
+    end
+  end
+  class Function
+    def parent
+      nil
+    end
+    def array?
+      false
+    end
+    def func
+      nil      
+    end
+    def value
+      nil
+    end
+  end
+end

data/lib/mappum/mapserver/mapgraph.rb

@@ -0,0 +1,192 @@
+module Mappum
+  module MapServer
+      class Graph
+        attr_reader :edge_maps
+        def initialize(map)
+            @map = map
+            @root = []
+            @struct_from = StrTree.new(nil,0,@root)
+            @struct_from.name = "struct1"
+            @struct_to = StrTree.new(nil,0,@root)
+            @struct_to.name = "struct2"
+            @edges = []
+            @edge_maps = {}
+            init(@map,@struct_from, @struct_to)
+        end
+        def getSvg
+            cmd = "dot"
+            format = "svg"
+            xCmd = "#{cmd} -T#{format}"
+            dot = getDot
+            f = IO.popen( xCmd ,"r+")
+            f.print(dot)
+            f.close_write
+            return f
+        end
+        def getPng
+            cmd = "dot"
+            format = "png"
+            xCmd = "#{cmd} -T#{format}"
+            dot = getDot
+            f = IO.popen( xCmd ,"r+")
+            f.print(dot)
+            f.close_write
+            return f
+        end
+        def getDot
+            str1 = makeStruct(@struct_from)
+            str2 = makeStruct(@struct_to)
+            edge = @edges.join
+            return <<DOT
+digraph structs { node [shape=plaintext]; rankdir=LR;  nodesep=0.1;    
+ struct1 [
+             label=<
+              #{str1}
+            >
+            ]; 
+ struct2 [
+             label=<
+              #{str2}
+             >
+            ];
+            #{@root.collect { |struct| struct.line}}
+            #{edge}
+            
+            }              
+DOT
+        end
+          
+        private
+        def makeStruct(struct_tree)
+            str = struct_tree.line || ""
+            unless struct_tree.children.nil? or struct_tree.children.empty?
+              str += "<TR><TD></TD> <TD CELLPADDING=\"1\">" unless struct_tree.parent.nil? 
+              str += "<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\" BGCOLOR=\"cornsilk2\">\n"
+              st = struct_tree.children.collect { |child| makeStruct(child)}
+              st.uniq!          
+              str += st.join + "</TABLE>" 
+              str += "</TD></TR>\n" unless struct_tree.parent.nil? 
+            end
+            return str
+        end
+        def init(map, struct_from, struct_to)
+            if map.normalized?
+              map_from, map_to = map.from, map.to
+            else
+              map_from, map_to = map.left, map.right
+            end
+            to_name, to_path, level_to = get_name_and_path(map_to) 
+            from_name, from_path, level_from = get_name_and_path(map_from)
+
+            str_from = StrTree.new(struct_from,level_from, @root)
+            unless from_name.nil?
+              if level_from > -1
+                str_from.line = "<TR> <TD COLSPAN=\"2\" PORT=\"#{from_path}\">#{from_name}</TD></TR>\n"
+              else
+                str_from.line = "#{from_path} [ label = <\"#{from_name}\">];\n"
+              end
+            end
+            str_to = StrTree.new(struct_to,level_to,@root)
+            unless to_name.nil?
+              if level_to > -1
+                str_to.line ="<TR> <TD COLSPAN=\"2\" PORT=\"#{to_path}\">#{to_name}</TD></TR>\n"              
+              else
+                str_to.line = "#{to_path} [ label = <\"#{to_name}\">];\n"
+              end
+            end
+            maps = []
+            if  map.normalized?
+              maps = map.maps
+            else
+              maps = map.bidi_maps
+            end
+            
+            
+            unless maps.empty?
+              maps.each do |sub_map|
+                if(map.normalized? or sub_map.left.parent == map_from or 
+                  sub_map.right.parent == map_to)
+                
+                  init(sub_map, str_from, str_to)
+                else
+                  init(sub_map, str_to, str_from)
+                end
+              end
+            else
+              # as option? labelfloat=true 
+              from_ref = "#{str_from.root.name}:#{from_path}" if level_from > -1
+              to_ref = "#{str_to.root.name}:#{to_path}" if level_to > -1
+              from_ref ||= from_path
+              to_ref ||= to_path
+              edge = "#{from_ref} -> #{to_ref} [" 
+              if map.normalized?
+                edge += " arrowtail = none tooltip=\"#{from_name} >> #{to_name}\" "
+              else 
+                edge += " arrowtail = vee tooltip=\"#{from_name} <=> #{to_name}\" "
+              end
+              edge += " arrowhead = vee URL=\"##{@edges.size+1}\" fontsize=10 "
+              unless map.simple?
+                edge += " label=\"#{@edges.size+1}\" labeltooltip = \"#{@edges.size+1}: #{from_name} >> #{to_name}\"" 
+              end
+              color = "black"
+              color = "blue" if level_to == -1 or level_from == -1
+              edge += " minlen=\"3\" color=\"#{color}\"];\n"
+              
+              @edges << edge
+              unless map.simple?
+                  @edge_maps[@edges.size] = map             
+              end
+            end
+
+        end
+        def get_name_and_path(element, level = 0)
+            #on non filed elements
+            if element.kind_of?(Function)
+              return "Function", "c#{element.__id__.abs}", -1              
+            end 
+            if element.kind_of?(Constant)
+              return element.value.to_s, "c#{element.__id__.abs}", -1              
+            end 
+          
+            name = element.name
+            if element.parent.nil?
+              #root element
+              name ||= element.clazz.to_s
+            else
+              level = level + 1 if name.nil?
+              pname, path, level = get_name_and_path(element.parent, level) 
+            end
+            path = "#{path}v#{name}".gsub(":","vv") unless name.nil?
+            name = "#{name}[]" if not name.nil? and element.is_array
+            return name, path, level
+        end
+      end 
+      class StrTree
+       attr_accessor :line, :parent,:children, :name
+       def initialize(parent, level, root)
+         @parent=parent  if level > -1
+         root << self if level == -1
+         @parent.add(self, level) unless @parent.nil?
+       end
+       
+       def add(child, level=0)
+         @children ||= []
+         if level == 0 
+           @children << child  unless @children.include?(child)
+         else
+           @parent.add(child, level - 1)
+         end
+       end
+       def ==(other)
+         return false unless other.kind_of?(StrTree)
+         if @line == other.line and @parent == other.parent and @children == other.children
+           return true
+         end
+       end 
+       def root
+         return parent.root unless parent.nil?
+         return self         
+       end
+      end
+  end  
+end

data/lib/mappum/mapserver/mapserver.rb

@@ -0,0 +1,213 @@
+require 'rubygems'
+gem 'soap4r'
+require 'mappum/xml_transform'
+require 'soap/marshal'
+require 'mappum/mapserver/mapgraph'
+require 'mappum/mapserver/maptable'
+require 'syntax/convertors/html'
+require 'sinatra/base'
+require 'erb'
+
+module Mappum
+  class Mapserver < Sinatra::Default
+    set :views => File.join(File.dirname(__FILE__), 'views')
+    set :public => File.join(File.dirname(__FILE__), 'public')
+    configure do
+      set :schema_dir => 'schema', :map_dir => 'map', :tmp_dir => nil
+      set :catalogue => nil
+      set :port => 9292      
+
+      # FIXME make configurable
+      #wl = Mappum::WorkdirLoader.new(options.schema_dir, options.tmp_dir, options.map_dir)
+      @wl = Mappum::WorkdirLoader.new('schema', 'map')
+      @wl.generate_and_require
+    end
+    helpers do
+      def explain_func(element)
+        name = element.name.to_s
+        name ||= "self"    
+        func = element.func.gsub(/^self/,name)
+        #replace [](1) with [1]
+        func = func.gsub(/\.\[\]\((.*)\)/,"[\\1]")
+        return "Simple function call: \"#{func}\"<br/>"
+      end
+      def explain(map)
+        str=""
+        if not map.right.nil? and not map.right.func.nil?
+          str+= explain_func(map.right)
+        elsif not map.from.nil? and not map.from.func.nil?
+          str+= explain_func(map.from)
+        end
+        unless map.func.nil?
+          str+= "Multiline function call (see source)<br/>"
+        end
+        unless map.dict.nil?
+          str+= "Dictionary mapping:<br/>"
+          str+= "<table border=\"1\">"
+          str+= "<tr><td>#{map.left.name}</td><td>#{map.right.name}</td></tr>"
+          map.dict.each do |k,v|
+            str+= "<tr><td>#{k}</td><td>#{v}</td></tr>"
+          end
+          str+= "</table>"
+        end
+        return str
+      end
+      def get_xmlns(namespace)
+        @namespaces ||= {}
+        @i ||= 0
+        @namespaces[namespace] = "ns#{@i+=1}" unless @namespaces.include?(namespace)
+        return @namespaces[namespace]
+      end
+    end
+    #make get methods for xsd files
+    Dir.glob('schema'+'/**/*.xsd') do |filename1|
+      get "/"+filename1 do
+        [200, {"Content-Type" => "text/xml"}, IO.read(filename1)]
+      end
+    #make get methods for map files
+    Dir.glob('map'+'/**/*.rb') do |filename|
+      get "/"+filename do
+        convertor = Syntax::Convertors::HTML.for_syntax "ruby"
+        @body = convertor.convert( IO.read(filename) ) 
+        
+        [200, {"Content-Type" => "text/html"}, erb(:rubysource)]
+      end
+    end
+   end
+    post "*/transform" do
+      @catalogue = params[:splat][0] || "ROOT"
+      @catalogue = @catalogue[1..-1] if @catalogue[0..0] == "/"
+
+	  map_name = nil
+	  map_name = params["map"] unless params["map"].nil? or params["map"] == "auto_select"
+	  force_openstruct = false
+	  force_openstruct = params["ignore"] unless params["map"].nil?
+
+	  rt = Mappum::XmlTransform.new(@catalogue, force_openstruct)
+	  
+	  xml = params["doc"]
+	  content = rt.transform(xml,map_name)
+	  
+	  [200, {"Content-Type" => "text/xml"}, [content]]
+    end
+    post "*/transform-ws" do
+      @catalogue = params[:splat][0] || "ROOT"
+      @catalogue = @catalogue[1..-1] if @catalogue[0..0] == "/"
+   
+      map_name = env["HTTP_SOAPACTION"] unless env["HTTP_SOAPACTION"].nil? or env["HTTP_SOAPACTION"] == ""
+      #remove "" if present 
+      map_name = map_name[1..-2] if map_name =~ /^".*"$/
+      
+      rt = Mappum::XmlTransform.new(@catalogue)
+      
+      xml = env["rack.input"].read
+      begin
+        content = rt.transform(xml,map_name)
+      rescue Exception => e
+        @error = e
+        return [200, {"Content-Type" => "text/xml"}, [erb(:'ws-error')]]
+      end          
+      return [200, {"Content-Type" => "text/xml"}, [content]]
+    end
+    get "*/transform-ws.wsdl" do
+      @catalogue = params[:splat][0] || "ROOT"
+      @catalogue = @catalogue[1..-1] if @catalogue[0..0] == "/"
+
+      @xml_imports = {}
+      Dir.glob('schema'+'/**/*.xsd') do |xsd_file|
+        namespace = XmlSupport.get_target_ns(xsd_file)
+        @xml_imports[xsd_file] = namespace unless namespace.nil?
+        #FIXME log warning
+      end
+ 
+      @xml_maps = []
+      @xml_elements = Set.new
+      Mappum.catalogue(@catalogue).list_map_names.each do |mapname|
+        map = Mappum.catalogue(@catalogue)[mapname]
+        
+        from_qname = XSD::Mapping::Mapper.get_qname_from_class(map.from.clazz)
+        @xml_elements << from_qname unless from_qname.nil?
+        from_qname ||= XSD::QName.new(nil,"any")
+        
+        
+        to_qname = XSD::Mapping::Mapper.get_qname_from_class(map.to.clazz)
+        @xml_elements << to_qname unless to_qname.nil?
+        to_qname ||= XSD::QName.new(nil,"any")
+        
+        @xml_maps << [mapname, from_qname, to_qname]
+      end
+      
+      [200, {"Content-Type" => "text/xml"}, [erb(:'transform-ws.wsdl')]]
    end
+
+    get "*/svggraph" do
+      @catalogue = params[:splat][0] || "ROOT"
+      @catalogue = @catalogue[1..-1] if @catalogue[0..0] == "/"
+
+      map_name = params["map"]
+      map = Mappum.catalogue(@catalogue).get_bidi_map(map_name)
+      map ||= Mappum.catalogue(@catalogue)[map_name]
+      return [404,  {"Content-Type" => "text/html"}, ["No map " + map_name]] if map.nil?
+      graph = Mappum::MapServer::Graph.new(map)
+      [200, {"Content-Type" => "image/svg+xml"}, graph.getSvg]
+            
+    end
+    get "*/maptable" do
+      @catalogue = params[:splat][0] || "ROOT"
+      @catalogue = @catalogue[1..-1] if @catalogue[0..0] == "/"
+
+      @map_name = params["map"]
+      @map = Mappum.catalogue(@catalogue)[@map_name]
+      return [404,  {"Content-Type" => "text/html"}, ["No map " + @map_name]] if @map.nil?
+      @maptable = Mappum::MapServer::MapTable.new(@map)
+      @edge_maps = @maptable.edge_maps.keys.sort.collect{|k| [k, @maptable.edge_maps[k], explain(@maptable.edge_maps[k])]}
+
+      [200, {"Content-Type" => "text/html"}, [erb(:maptable)]]
+            
+    end
+
+    get "*/pnggraph" do
+      @catalogue = params[:splat][0] || "ROOT"
+      @catalogue = @catalogue[1..-1] if @catalogue[0..0] == "/"
+
+      map_name = params["map"]
+	  map = Mappum.catalogue(@catalogue).get_bidi_map(map_name)
+	  map ||= Mappum.catalogue(@catalogue)[map_name]
+	  return [404,  {"Content-Type" => "text/html"}, ["No map '#{map_name}'"]] if map.nil?
+	  graph = Mappum::MapServer::Graph.new(map)
+	  [200, {"Content-Type" => "image/png"}, graph.getPng]
+            
+    end 
+    get "*/doc" do
+      @catalogue = params[:splat][0] || "ROOT"
+      @catalogue = @catalogue[1..-1] if @catalogue[0..0] == "/"
+
+	  @map_name = params["map"]
+	  @map = Mappum.catalogue(@catalogue).get_bidi_map(@map_name)
+	  @map ||= Mappum.catalogue(@catalogue)[@map_name]
+	  return [404,  {"Content-Type" => "text/html"}, ["No map " + @map_name]] if @map.nil?
+	  graph = Mappum::MapServer::Graph.new(@map)
+	  @edge_maps = graph.edge_maps.keys.sort.collect{|k| [k, graph.edge_maps[k], explain(graph.edge_maps[k])]}
+	  [200, {"Content-Type" => "text/html"}, [erb(:doc)]]
+    end
+    get "/" do
+      @catalogue = params["catalogue"] || "ROOT"
+      @catalogues = Mappum.catalogues
+	  @bidi_maps_name_source = Mappum.catalogue(@catalogue).list_bidi_map_names.collect{|mn| [mn,  Mappum.catalogue(@catalogue).get_bidi_map(mn).source] }
+	  @maps_name_source = Mappum.catalogue(@catalogue).list_map_names.collect{|mn| [mn, Mappum.catalogue(@catalogue)[mn].source]}
+	  [200, {"Content-Type" => "text/html"}, [erb(:main)]]
+    end
+    def self.parseopt
+      require 'optparse'
+      OptionParser.new { |op|
+        op.on('-x')        {       set :lock, true }
+        op.on('-e env')    { |val| set :environment, val.to_sym }
+        op.on('-s server') { |val| set :server, val }
+        op.on('-p port')   { |val| set :port, val.to_i }
+      }.parse!
+    end
+  end
+end
+if File.basename($0) == File.basename(__FILE__)
+    Mappum::Mapserver.parseopt
+    Mappum::Mapserver.run!
+end