mappum 0.2.0

data/lib/mappum.rb

@@ -0,0 +1,46 @@
+# TODO docs
+require 'set'
+require 'mappum/dsl'
+require 'mappum/map'
+
+module Mappum
+  #
+  # Add mapinng in DSL to the catalogue.
+  #
+  def self.catalogue_add(name = "ROOT", &block)
+    @catalogue ||= {}
+    @catalogue_src ||= {}
+    @catalogue[name] ||= RootMap.new(name)
+    definition = DSL::RootMap.new(name, @source).make_definition(&block)
+    definition.maps.each{|m| @catalogue[name].add(m)}
+    definition.bidi_maps.each{|m| @catalogue[name].add(m)}
+  end
+  #
+  # Get root map.
+  #
+  def self.catalogue(name = "ROOT")
+    name = "ROOT" if name.nil?
+    if @catalogue.nil?
+      throw RuntimeError.new("No maps where loaded remember to put some moaps in 'map' folder and load them.\n"+
+        "To load in ruby just require files or use WorkdirLoader.generate_and_require.\n"+
+        "To load in java run:\nMappumApi mp = new MappumApi();\nmp.loadMaps();") 
+    end
+    @catalogue[name]
+  end
+  def self.catalogues
+    return @catalogue.keys
+  end
+  #
+  # Empty catalogues
+  #
+  def self.drop_all
+    @catalogue = {}
+    @catalogue_src = {}
+  end
+  #
+  #Set source file from which definitions are read
+  #
+  def self.source=(src)
+    @source = src
+  end
+end

data/lib/mappum/autoconv_catalogue.rb

@@ -0,0 +1,43 @@
+require 'date'
+require 'time'
+
+Mappum.catalogue_add "MAPPUM_AUTOCONV" do
+  map Date, String do |a,b|
+    map a.self << b.self do |b1|
+      Date.parse(b1)
+    end
+
+    map a.self >> b.self do |a1|
+      a1.to_s
+    end
+  end
+  map Time, String do |a,b|
+    map a.self << b.self do |b1|
+      Time.parse(b1)
+    end
+
+    map a.self >> b.self do |a1|
+      a1.rfc2822
+    end
+  end
+  map Fixnum, String do |a,b|
+    map a.self << b.self do |b1|
+      b1.to_i
+    end
+
+    map a.self >> b.self do |a1|
+      a1.to_s
+    end
+  end
+  map Float, String do |a,b|
+    map a.self << b.self do |b1|
+      b1.to_f
+    end
+
+    map a.self >> b.self do |a1|
+      a1.to_s
+    end
+  end
+
+
+end

data/lib/mappum/dsl.rb

@@ -0,0 +1,255 @@
+require 'facets/kernel/instance_exec'
+class Object 
+  def >> field
+  return {Mappum::DSL::Constant.new(self) => field} if field.kind_of?(Mappum::DSL::Field)
+    throw "Constant can be mapped to field only"
+  end
+end
+module Mappum
+  module DSL
+    class Map
+      attr_accessor :def
+      def initialize
+        @def = Mappum::Map.new
+      end
+      def map(*attr, &block)
+        mapa  = FieldMap.new(attr)
+        mapa.def.source = @def.source
+
+        mapa.def.desc = @comment
+        @comment = nil
+        
+        if (not mapa.def.normalized?) && block_given?
+          eval_right = mapa.mpun_right.clone
+          eval_right.mpun_definition.is_root = true
+          eval_left = mapa.mpun_left.clone
+          eval_left.mpun_definition.is_root = true
+          mapa.instance_exec(eval_left, eval_right, &block)
+        elsif block_given?
+          mapa.def.func = block
+          mapa.def.func_on_nil = true if mapa.mpun_left.kind_of?(Function)
+        end 
+        @def.maps += mapa.def.normalize
+        @def.bidi_maps << mapa.def
+        return mapa.def
+      end
+      #
+      # Define condition evaluated before this mapping is applyed.
+      # First argument is a label
+      # :> - left to right map
+      # :< - right to left map
+      # Second argument is a block and from elemnt is pased to the block.
+      #
+      def map_when(label,&condition)
+        case label
+          when :>, '>'
+            @def.when_l2r = condition
+          when :<, '<'
+            @def.when_r2l = condition
+         end 
+      end
+      #
+      # Add comment to mapping.
+      #
+      def `(str)
+        @comment ||= ""
+        @comment += str
+      end
+
+      # Add prefix to auto map names
+      def name_map_prefix(name)
+        name_map(:prefix, name)
+      end
+      #
+      # Give name to a map where map is:
+      # :<=> - bidirectional map name
+      # :> - left to right map name
+      # :< - right to left map name
+      # :prefix - add prefix to auto generated names
+      #
+      def name_map(map, name)
+          case map
+          when :<=>, '<=>'
+            @def.name = name.to_s
+          when :>, '>'
+             @def.l2r_name = name.to_s
+          when :<, '<'
+             @def.r2l_name = name.to_s
+          when :prefix, 'prefix'
+             if name.to_s[-1..-1]=='_'
+               @def.name_prefix = name.to_s 
+             else
+               @def.name_prefix = "#{name.to_s}_" 
+             end
+          end 
+      end
+      def func
+        Mappum::DSL::Function.new        
+      end
+      def tree(clazz)
+        return Field.new(nil, nil, clazz)
+      end
+    end
+    class RootMap < Map
+      def initialize(name,source=nil)
+        @def = Mappum::RootMap.new(name)
+        @def.source = source
+      end
+      def make_definition &block
+        instance_eval(&block)
+        @def
+      end
+    end
+    class FieldMap < Map
+      attr_accessor :mpun_left, :mpun_right
+      def mpun_left=(left_map_dsl)
+        @mpun_left=left_map_dsl
+        @def.left=left_map_dsl.mpun_definition
+      end
+      def mpun_right=(right_map_dsl)
+        @mpun_right=right_map_dsl
+        @def.right=right_map_dsl.mpun_definition
+        end
+      def initialize(*attr)
+        @def = Mappum::FieldMap.new
+        type_size = 1
+        if attr == [[nil]]
+          raise """Can't make map for [[nil]] arguments. 
+          Can be that You define top level class mapping with \"<=>\" please use \",\" instead (we know its a Bug). """
+        end
+        mapped = attr[0][0]
+        if attr[0][0].instance_of?(Class) or attr[0][0].instance_of?(Symbol) and
+               attr[0][1].instance_of?(Class) or attr[0][1].instance_of?(Symbol)
+           mapped = [attr[0][0], attr[0][1]]
+           type_size = 2   
+        end
+        
+        if mapped.instance_of?(Array) then
+          if(mapped[0]).instance_of?(Class) or (mapped[0]).instance_of?(Symbol)
+            @def.strip_empty = false
+            self.mpun_left = Field.new(nil,nil,mapped[0])
+          else
+            self.mpun_left = mapped[0]
+          end
+          if(mapped[1]).instance_of?(Class) or (mapped[1]).instance_of?(Symbol)
+            @def.strip_empty = false
+            self.mpun_right = Field.new(nil,nil,mapped[1])
+          else
+            self.mpun_right = mapped[1]
+          end
+        end
+        if mapped.instance_of?(Hash) then
+          self.mpun_left = mapped.keys[0]
+          self.mpun_right = mapped.values[0]
+        end
+  
+        if mapped.instance_of?(Hash) then
+          @def.from = @def.left
+          @def.to = @def.right
+        end
+
+        @def.dict = attr[0][1][:dict] if attr[0].size > type_size
+        @def.desc = attr[0][1][:desc] if attr[0].size > type_size
+        @def.map_when = attr[0][1][:when] if attr[0].size > type_size
+        @def.when_r2l = attr[0][1][:when_r2l] if attr[0].size > type_size
+        @def.when_l2r = attr[0][1][:when_l2r] if attr[0].size > type_size
+        if @def.normalized? and not (@def.when_r2l.nil? and  @def.when_l2r.nil?)
+          raise "r2l and l2r :when functions can be set only on bidirectional maps"  
+        end
+        if not @def.normalized? and not @def.map_when.nil?
+          raise ":when function can be set only on unidirectional maps use :when_r2l and :when_l2r or map_when function"  
+        end
+        
+        @def.submap_alias = attr[0][1][:map] if attr[0].size > type_size
+                    
+      end   
+    end
+    #Base class for all mapped elements eg. fields, constants
+    class Mappet
+      def mpun_definition
+        @def
+      end
+      def <=> field
+        [self, field]
+      end
+  
+      def << field
+        return {field => self} if field.kind_of?(Mappum::DSL::Mappet)
+        return {Constant.new(field) => self}
+      end
+  
+      def >> field
+        return {self => field}  if field.kind_of?(Mappum::DSL::Mappet)
+        throw "Must map to a field"
+      end
+    end
+    class Constant < Mappet
+      def initialize(value)
+        @def = Mappum::Constant.new
+        @def.value = value
+      end
+    end
+
+    class Function < Mappet
+      def initialize
+        @def = Mappum::Function.new
+      end
+    end
+    
+    class Field < Mappet
+      def initialize(parent, name, clazz, placeholder = false)
+        @def =  Mappum::Field.new
+        @def.parent = parent
+        @def.name = name
+        @def.clazz = clazz
+        @def.is_array = false
+        @def.is_root = false
+        @def.is_root = false
+        @def.is_placeholder = placeholder
+      end
+  
+      def type(*attr)
+        method_missing(:type, *attr)
+      end
+      def id(*attr)
+        method_missing(:id, *attr)
+      end
+  
+      def method_missing(symbol, *args, &block)
+        if @def.is_root
+          if(symbol == :self)
+            return Field.new(@def, nil, args[0], true)
+          end
+          return Field.new(@def, symbol, args[0])
+        end
+  
+        if symbol == :[]
+          #empty [] is just indication that field is an array not function      
+          if args.size == 0
+            @def.is_array = true
+            return self
+          end
+          #[n] indicates both mapping function and array
+          if args.size == 1 and args[0].instance_of?(Fixnum)
+            @def.is_array = true
+          end
+        end
+        #this functions also indicate Array -> element
+        if symbol == :find or symbol == :detect
+          @def.is_array = true
+        end
+        arguments = args.clone
+        unless block.nil?
+          arguments << "&mappum_block"
+          @def.block = block
+        end
+        if @def.func.nil?
+          @def.func =  "self.#{symbol}(#{arguments.join(", ")})"
+        else
+          @def.func += ".#{symbol}(#{arguments.join(", ")})"
+        end
+        return self
+      end
+    end
+  end
+end

data/lib/mappum/java_transform.rb

@@ -0,0 +1,107 @@
+require 'mappum/ruby_transform'
+require 'mappum/xml_transform'
+require 'java'
+
+module Mappum
+  #
+  # Java Pojo to Pojo transforming class. Requires JRuby to work correctly.
+  #
+  class JavaTransform < RubyTransform
+    def initialize(*args)
+      super(*args)
+    end
+    
+    protected
+    
+    def convert_to (to, field_def)
+      if to.kind_of? Array then
+        jtype = field_def.clazz
+        jtype ||= "String"
+        return to.to_java(jtype)
+      else 
+        return to
+      end
+    end
+    def convert_from (from, field_def)
+        if from.kind_of? ArrayJavaProxy then
+          return from.to_ary
+        else 
+          return from
+        end
+    end
+  end
+  class JavaApi < Java::pl.ivmx.mappum.MappumApi
+    def initialize
+      super(false)
+    end
+    def getWorkdirLoader(schema_path="schema", map_dir="map", basedir=nil)
+      return WorkdirLoader.new(schema_path, map_dir, basedir)
+    end
+    def getJavaTransform(catalogueName=nil)
+      catalogue = Mappum.catalogue(catalogueName)
+      return JavaTransform.new(catalogue)
+    end
+    def loadMaps(dir="map",reload=true)
+      Mappum.drop_all
+      JavaSupport.list_maps_on_cp(dir).each do |map_file|
+        Mappum.source = map_file
+        load map_file
+        Mappum.source = nil
+      end
+    end
+    def startServer
+      require 'webrick'
+      load 'mappum/mapserver/mapserver.rb'
+      Mappum::Mapserver.parseopt
+      Mappum::Mapserver.run!
+
+    end
+  end
+
+  #
+  # Utility class providing some usefull methods in java.
+  #
+  class JavaSupport
+    #
+    # List map files on classpath.
+    #
+    def self.list_maps_on_cp(dir="map")
+      dir="map" if dir.nil?
+      thread = java.lang.Thread.new
+      class_loader = thread.context_class_loader
+      container_urls = class_loader.find_resources(dir).to_a
+      maplist = []
+      container_urls.each do |url|
+        if url.protocol == "file"
+          filelist = Dir.glob(File.join(url.path,"*.rb"))
+          #make paths relative again
+          maplist += filelist.collect{|f| f[(url.path.size-dir.size)..-1]}
+        elsif url.protocol ==  "vfsfile"
+          filelist = Dir.glob(File.join(url.path,"*.rb"))
+          #make paths relative again
+          maplist += filelist.collect{|f| f[(url.path.size-dir.size-1)..-1]}
+        elsif url.protocol == "jar"
+          #beware nestet url
+          path = URI.new(url.path).path
+          path = path[0..(path.rindex("!")-1)]
+          zip = java.util.zip.ZipFile.new(path)
+          names = zip.entries.to_a.collect{|ze| ze.name}
+          maplist += names.select{|nm| nm.index("map") == 0 and nm[-3..-1] == ".rb"}
+        else
+          #ups
+          puts "WARN: Unknown protocol #{url.protocol} on the classpath. When looking for #{dir} in #{__FILE__}"
+        end
+      end
+      return maplist
+    end
+  end
+  class JavaTransform
+    include Java::pl.ivmx.mappum.JavaTransform
+  end
+  class WorkdirLoader
+    include Java::pl.ivmx.mappum.WorkdirLoader
+  end
+  class TreeElement
+    include Java::pl.ivmx.mappum.TreeElement
+  end
+end