simcha-mappum 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+nbproject/
+pkg/
+.project
+.buildpath

data/LICENSE

@@ -0,0 +1,15 @@
+== mappum
+
+Copyright 2009 by Jan Topinski
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README

@@ -0,0 +1,53 @@
+== mappum
+
+Mappum is the tree to tree (object, bean etc.) mapping DSL. The example of usage
+is provided below. More documentation will follow.
+
+Mappum.catalogue_add "CRM-ERP" do
+
+  map ERP::Person, CRM::Client do |p, c|
+
+    #simple mapping
+    map p.title <=> c.title
+
+    #map with simple function call
+    map p.person_id << c.key.downcase
+    map p.person_id.upcase >> c.key
+
+    #dictionary use
+    map p.sex <=> c.sex_id, :dict => {"F" => "1", "M" => "2"}
+
+    #submaps
+    map p.address(ERP::Address) <=> c.address(CRM::Address) do |a, b|
+      map a.street <=> b.street
+      #etc.
+    end
+
+    #subobject to fields
+    map p.main_phone(ERP::Phone) <=> c.self do |a, b|
+      map a.number <=> b.main_phone
+      map a.type <=> b.main_phone_type
+    end
+
+    #compilcated function call
+    map p.name >> c.surname do |name|
+      name + "ski"
+    end
+    map p.name << c.surname do |name|
+      if name =~ /ski/
+        name[0..-4]
+      else
+        name
+      end
+    end
+    #field to array and array to field
+    map p.email1 <=> c.emails[0]
+    map p.email2 <=> c.emails[1]
+    map p.email3 <=> c.emails[2]
+
+    map p.phones(ERP::Phone)[] <=> c.phones[] do |a, b|
+      map a.number <=> b.self
+    end
+
+  end
+end

data/Rakefile

@@ -0,0 +1,46 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'spec/rake/spectask'
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "rupper Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "mappum"
+    gemspec.summary = "Mappum is the tree to tree (object, bean etc.) mapping DSL."
+    gemspec.email = "jtopinski@chatka.org"
+    gemspec.homepage = "http://wiki.github.com/simcha/mappum"
+    gemspec.description = ""
+    gemspec.authors = ["Jan Topiński"]
+    gemspec.add_dependency('facets', '>= 2.5.2')
+    gemspec.add_dependency('soap4r', '>= 1.5.8')
+    gemspec.add_dependency('sinatra', '>= 0.9.2')
+    gemspec.add_dependency('thin', '>= 1.2.2')
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/mapserver.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/ruby1.8
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+load 'mappum/mapserver/mapserver.rb'

data/lib/mappum.rb

@@ -0,0 +1,19 @@
+# TODO docs
+require 'set'
+require 'mappum/dsl'
+require 'mappum/map'
+
+module Mappum
+  def self.catalogue_add(name = "ROOT", &block)
+    @catalogue ||= {}
+    @catalogue[name] ||= RootMap.new(name)
+    definition = DSL::RootMap.new(name).make_definition(&block)
+    @catalogue[name].maps += definition.maps
+    @catalogue[name].bidi_maps += definition.bidi_maps
+      
+  end
+  def self.catalogue(name = "ROOT")
+    name = "ROOT" if name.nil?
+    @catalogue[name]
+  end
+end

data/lib/mappum/dsl.rb

@@ -0,0 +1,186 @@
+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.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
+      def `(str)
+        @comment ||= ""
+        @comment += str
+      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)
+        @def = Mappum::RootMap.new(name)
+      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
+        
+      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)
+        @def =  Mappum::Field.new
+        @def.parent = parent
+        @def.name = name
+        @def.clazz = clazz
+        @def.is_array = false
+        @def.is_root = false
+      end
+  
+      def type(*attr)
+        method_missing(:type, *attr)
+      end
+      def id(*attr)
+        method_missing(:id, *attr)
+      end
+  
+      def method_missing(symbol, *args)
+        if @def.is_root
+          if(symbol == :self)
+            return  Field.new(@def, nil, args[0])
+          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
+        if @def.func.nil?
+          @def.func =  "self.#{symbol}(#{args.join(", ")})"
+        else
+          @def.func += ".#{symbol}(#{args.join(", ")})"
+        end
+  
+        return self
+      end
+    end
+  end
+end

data/lib/mappum/map.rb

@@ -0,0 +1,133 @@
+module Mappum
+# Base Map class representing mapping betwean two or more types, properties etc.
+  class Map
+    
+    attr_accessor :maps, :bidi_maps, :strip_empty
+    
+    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
+    end
+    def [](clazz)
+      #TODO optimize
+      mpa = @maps.find{|m| m.from.clazz == clazz or m.from.clazz.to_s == clazz.to_s }
+      return mpa unless mpa.nil?
+      return @maps.find{|m| "#{m.from.clazz}-to-#{m.to.clazz}" == clazz.to_s}
+    end
+    def get_bidi_map(name)
+      #TODO optimize
+      mpa = @bidi_maps.find{|m| m.right.clazz == name or m.right.clazz.to_s == name.to_s }
+      mpa ||= @bidi_maps.find{|m| m.left.clazz == name or m.left.clazz.to_s == name.to_s }
+      return mpa unless mpa.nil?
+      
+      return @bidi_maps.find{|m| "#{m.left.clazz}-to-from-#{m.right.clazz}" == name.to_s}
+    end
+    def list_map_names(full_list = false)
+      list = []
+      list += @maps.collect{|m| "#{m.from.clazz}-to-#{m.to.clazz}"}
+      list += @maps.collect{|m|m.from.clazz} if full_list
+      return list
+    end
+    def list_bidi_map_names
+      list = []
+      list += @bidi_maps.collect{|m| "#{m.left.clazz}-to-from-#{m.right.clazz}"}
+      return list
+    end
+  end
+  
+  class FieldMap < Map
+    attr_accessor :dict, :desc, :left, :right, :func, :to, :from, :func_on_nil
+    # True if map is unidirectional. Map is unidirectional
+    # when maps one way only.
+    def normalized?
+      not @from.nil?
+    end
+    
+    def normalize
+      #if bidirectional
+      if not normalized?
+        map_l = self.clone
+        map_l.to = self.left
+        map_l.from = self.right
+        map_l.maps = self.maps.select do |m|
+          m.to.parent == map_l.to
+        end
+        
+        map_l.dict = self.dict.invert unless self.dict.nil?
+  
+        map_r = self.clone
+        map_r.to = self.right
+        map_r.from = self.left
+        map_r.maps = self.maps.select do |m|
+          m.to.parent == map_r.to
+        end
+  
+        [map_l, map_r]
+      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, :is_root, :is_array)
+    def array?
+      @is_array
+    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