mappum 0.2.0 → 0.2.1

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/lib/mappum/dsl.rb

@@ -1,4 +1,4 @@
-require 'facets/kernel/instance_exec'
+#require 'facets/kernel/instance_exec'
 class Object 
   def >> field
   return {Mappum::DSL::Constant.new(self) => field} if field.kind_of?(Mappum::DSL::Field)
@@ -49,6 +49,29 @@ module Mappum
          end 
       end
       #
+      # Define how "to" array is passed to function. 
+      # First argument is a label
+      # :> - left to right map
+      # :< - right to left map
+      # :<=> - both maps
+      # Second argument is the_way and can be:
+      # :new - will create new element
+      # :first - will map to the first element
+      # :all - will map to all elements
+      #
+      def to_array_take(label, the_way)
+        raise "the_way should be one of :new, :first, :all" unless [:new, :first, :all].include? the_way.to_sym 
+        case label
+          when :<=>
+            @def.to_array_take_l2r = the_way.to_sym
+            @def.to_array_take_r2l = the_way.to_sym
+          when :>, '>'
+            @def.to_array_take_l2r = the_way.to_sym
+          when :<, '<'
+            @def.to_array_take_r2l = the_way.to_sym
+         end 
+      end
+      #
       # Add comment to mapping.
       #
       def `(str)
@@ -159,7 +182,10 @@ module Mappum
         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.to_array_take = attr[0][1][:to_array_take] if attr[0].size > type_size
+        if not @def.normalized? and not @def.to_array_take.nil?
+          raise ":to_array_take property can be set only on unidirectional maps use :to_array_take_r2l and :to_array_take_l2r or to_array_take function"  
+        end
         @def.submap_alias = attr[0][1][:map] if attr[0].size > type_size
                     
       end   
@@ -235,7 +261,7 @@ module Mappum
           end
         end
         #this functions also indicate Array -> element
-        if symbol == :find or symbol == :detect
+        if symbol == :find or symbol == :detect or symbol == :select 
           @def.is_array = true
         end
         arguments = args.clone

data/lib/mappum/map.rb

@@ -94,6 +94,7 @@ module Mappum
   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
+    attr_accessor :to_array_take, :to_array_take_r2l, :to_array_take_l2r
     # True if map is unidirectional. Map is unidirectional
     # when maps one way only.
     def normalized?
@@ -118,6 +119,8 @@ module Mappum
         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.to_array_take = self.to_array_take_r2l
+        map_r2l.to_array_take_r2l, map_r2l.to_array_take_l2r = nil, nil
         map_r2l.maps = self.maps.select do |m|
           m.to.parent == map_r2l.to
         end
@@ -131,6 +134,8 @@ module Mappum
         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.to_array_take = self.to_array_take_l2r
+        map_l2r.to_array_take_r2l, map_l2r.to_array_take_l2r = nil, nil
         map_l2r.maps = self.maps.select do |m|
           m.to.parent == map_l2r.to
         end
@@ -158,7 +163,9 @@ module Mappum
       return Field.new(@parent, symbol, args[0])
     end
   end
-  class Field < Struct.new(:name, :clazz, :parent, :func, :block, :is_root, :is_array, :is_placeholder)
+  class Field < Struct.new(:name, :clazz, :parent, :func, :block, :is_root, :is_placeholder)
+    #define is_array separetly to exclude it from equals
+    attr_accessor :is_array
     def array?
       is_array
     end
@@ -166,7 +173,7 @@ module Mappum
       is_placeholder
     end
   end
-  class Constant <  Struct.new(:value) 
+  class Constant <  Struct.new(:value,:parent) 
     def parent
       nil
     end
@@ -177,10 +184,7 @@ module Mappum
       nil      
     end
   end
-  class Function
-    def parent
-      nil
-    end
+  class Function <  Struct.new(:parent) 
     def array?
       false
     end

data/lib/mappum/ruby_transform.rb

@@ -40,11 +40,7 @@ module Mappum
       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
+        from_value = get(from, sm.from, map.from) 
 
         # skip to next mapping on false :map_when function
         next unless sm.map_when.nil? or sm.map_when.call(from_value)
@@ -81,6 +77,8 @@ module Mappum
           end
         end
         unless submaps.empty? or from_value.nil?
+          #We should make some kind of test like this
+          #raise "Not an array: #{sm.from.name} inspect:" + from_value.inspect if sm.from.is_array and not from_value.kind_of?(Array)
           if from_value.kind_of?(Array) or 
               (Module.constants.include? "ArrayJavaProxy" and from_value.kind_of?(Module.const_get(:ArrayJavaProxy)))
             sm_v = sm.clone
@@ -92,21 +90,41 @@ module Mappum
               sm_v.to = sm.to.clone
               sm_v.to.is_array = false
             end
-            sm_v.maps = submaps if sm_v.maps.empty?
-
-            to_value = from_value.collect{|v| transform(v, sm_v)}
+            if sm_v.maps.empty?
+							sm_v.maps = submaps 
+							sm_v.maps.each{|m| m.from.parent = sm_v.from}
+							#don't add parent we need separation
+							to_value = from_value.collect{|v| transform(v, sm_v)}
+						else
+							to_value = from_value.collect{|v| transform(add_parent(v, from), sm_v)}
+						end
           else
             to ||= map.to.clazz.new unless @force_open_struct or map.to.clazz.nil? or map.to.clazz.kind_of?(Symbol)
             to ||= @default_struct_class.new
-            v_to = nil
+            v_to = []
             #array values are assigned after return
-            v_to = get(to, sm.to.name) unless sm.to.is_array and not sm.from.is_array
-            sm_v = sm
-            if sm_v.maps.empty?
-              sm_v = sm.clone
-              sm_v.maps = submaps
+            v_to << get(to, sm.to) unless sm.to.is_array and not sm.from.is_array
+            #nless one whants to update existing to array
+            if sm.to_array_take == :first
+              arr_v = get(to, sm.to)
+              v_to << arr_v[0]  if not arr_v.nil?
+            end
+            if sm.to_array_take == :all
+              arr_v = get(to, sm.to)
+              v_to += arr_v  if not arr_v.nil?
             end
-            to_value = transform(from_value, sm_v, v_to)
+            v_to.each do |v_t|
+				sm_v = sm
+				if sm_v.maps.empty?
+				  sm_v = sm.clone
+				  sm_v.maps = submaps
+				  sm_v.maps.each{|m| m.from.parent = sm_v.from}
+				  #don't add parent we need separation
+				  to_value = transform(from_value, sm_v, v_t)
+				else
+				  to_value = transform(add_parent(from_value, from), sm_v, v_t)
+				end
+		    end
           end
 
         end
@@ -114,9 +132,9 @@ module Mappum
           to_value = sm.dict[to_value]
         end
         if sm.to.is_array and not sm.from.is_array
-          to_array = convert_from(get(to,sm.to.name),sm.from)
+          to_array = convert_from(get(to,sm.to),sm.from)
           to_array ||= []
-          to_array << to_value
+          to_array << to_value unless sm.to_array_take == :first or sm.to_array_take == :all
           
           if to_array.empty? and sm.strip_empty?
             to_array = nil
@@ -157,21 +175,36 @@ module Mappum
     
     protected
     
-    def get(object, field)
-      if field.nil? or object.nil?
-        return object
-      elsif
-        begin
-          return object.send(field)
-        rescue NoMethodError => e
-          #for open structures field will be defined later
-            if object.kind_of?(@default_struct_class)
-              return nil
-            else
-              raise e
-            end
-         end          
-      end
+    def get(object, field, parent_field=nil)
+		  if field.kind_of?(String) or field.kind_of?(Symbol)
+		    field_name = field
+		  else
+				unless field.respond_to?(:name)
+					return field.value
+				end
+				if field.name.nil? or object.nil?
+					return object
+				end
+				#for fields targeted at parents go up the tree
+				if (not parent_field.nil?) and field.parent != parent_field
+				  if object.respond_to?(:_mpum_parent)
+				    return get(object._mpum_parent, field, parent_field.parent)
+				  else 
+				    raise "We hit an element with no parent: #{object.inspect}"
+				  end
+				end
+				field_name = field.name
+			end
+			begin
+				return object.send(field_name)
+			rescue NoMethodError => e
+			#for open structures field will be defined later
+			if object.kind_of?(@default_struct_class)
+				return nil
+			else
+				raise e
+			end
+	   end
     end
     def convert_to(to, field_def)
       return to
@@ -179,6 +212,15 @@ module Mappum
     def convert_from(from, field_def)
       return from
     end
+    def add_parent(value, parent)
+      #don't work for Fixnums and Floats
+      return value if value.kind_of?(Fixnum) or value.kind_of?(Float)
+      class << value
+        attr_accessor :_mpum_parent
+      end
+      value._mpum_parent = parent
+      return value
+    end
   end
   class OpenStruct < OpenStruct
     def type(*attr)

data/lib/mappum/xml_transform.rb

@@ -178,12 +178,12 @@ module Mappum
     def initialize(*args)
       super(*args)
     end
-    def get(object, field)
+    def get(object, field, parent_field=nil)
       begin
-        super(object, field)
+        super(object, field, parent_field)
       rescue NoMethodError
         begin
-          super(object, XSD::CodeGen::GenSupport.safemethodname(field.to_s).to_sym)
+          super(object, XSD::CodeGen::GenSupport.safemethodname(field.name.to_s).to_sym, parent_field)
         rescue NoMethodError
           #for dynamic xml nil value == no methond
           if object.kind_of?(SOAP::Mapping::Object)

data/mappum.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{mappum}
-  s.version = "0.2.0"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jan Topi\305\204ski"]
-  s.date = %q{2009-11-08}
+  s.date = %q{2009-11-13}
   s.default_executable = %q{mapserver.rb}
   s.description = %q{}
   s.email = %q{jtopinski@chatka.org}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mappum
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - "Jan Topi\xC5\x84ski"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-08 00:00:00 +01:00
+date: 2009-11-13 00:00:00 +01:00
 default_executable: mapserver.rb
 dependencies: 
 - !ruby/object:Gem::Dependency