mappum 0.2.3 → 0.2.4

data/lib/mappum/dsl.rb

@@ -19,10 +19,10 @@ module Mappum
     def self.parse_caller(at)
       if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
         file = Regexp.last_match[1]
-		line = Regexp.last_match[2].to_i
-		method = Regexp.last_match[3]
-		[file, line, method]
-	  end
+    line = Regexp.last_match[2].to_i
+    method = Regexp.last_match[3]
+    [file, line, method]
+    end
     end
     class Map
       attr_accessor :def
@@ -91,7 +91,7 @@ module Mappum
       #
       # Add comment to mapping.
       #
-      def `(str)
+      def `(str) #for bad colorizers add:```
         @comment ||= ""
         @comment += str
       end
@@ -126,8 +126,15 @@ module Mappum
       def func
         Mappum::DSL::Function.new        
       end
+      def const(cst)
+        Mappum::DSL::Constant.new(cst)        
+      end
       def tree(clazz)
-        return Field.new(nil, nil, clazz)
+        return Mappum::DSL::Field.new(nil, nil, clazz)
+      end
+      def context
+        fld = Mappum::DSL::Context.new
+        return fld
       end
     end
     class RootMap < Map
@@ -205,7 +212,7 @@ module Mappum
         end
         @def.submap_alias = attr[0][1][:map] if attr[0].size > type_size
                     
-      end   
+      end 
     end
     #Base class for all mapped elements eg. fields, constants
     class Mappet
@@ -241,12 +248,10 @@ module Mappum
     
     class Field < Mappet
       def initialize(parent, name, clazz, placeholder = false, src_ref = nil)
-        @def =  Mappum::Field.new
+        @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
         @def.src_ref = src_ref
@@ -279,19 +284,28 @@ module Mappum
         if symbol == :[]
           #empty [] is just indication that field is an array not function      
           if args.size == 0
-            @def.is_array = true
+            @def.enum_type = Array
             return self
           end
-          #[n] indicates both mapping function and array
-          if args.size == 1 and args[0].instance_of?(Fixnum)
-            @def.is_array = true
+          #[n] indicates both mapping function and Hash
+          if args.size == 1
+            @def.enum_type = Hash
           end
         end
-        #this functions also indicate Array -> element
+        #this functions also indicate enumerable -> element
         if symbol == :find or symbol == :detect or symbol == :select 
-          @def.is_array = true
+          @def.enum_type = Array
+        end
+        arguments = args.clone.collect do |a|
+          ret = nil
+          if a.kind_of? Symbol
+            ret = ":'#{a}'"
+          elsif a.kind_of? String
+            ret = "'#{a}'"
+          else
+            ret = a
+          end
         end
-        arguments = args.clone
         unless block.nil?
           arguments << "&mappum_block"
           @def.block = block
@@ -304,5 +318,11 @@ module Mappum
         return self
       end
     end
+    class Context < Field
+      def initialize
+        @def = Mappum::Context.new
+        @def.is_root
+      end
+    end
   end
 end

data/lib/mappum/java_transform.rb

@@ -10,25 +10,78 @@ module Mappum
     def initialize(*args)
       super(*args)
     end
-    
+    def transform(from, map=nil, to=nil, options={})
+      begin
+        if map.kind_of?(Java::JavaUtil::Map)
+          options = map
+          map = nil
+        end
+        super(from, map, to, options) 
+      rescue MappumException => me
+        jme = Java::pl::ivmx::mappum::JavaMappumException.new(me)
+        jme.from_name = me.from_name 
+        jme.to_name = me.to_name 
+        jme.from = me.from
+        jme.to = me.to
+        jme.from_root = me.from_root
+        jme.to_root = me.to_root 
+        jme.mappum_backtrace = me.mappum_backtrace
+        
+        raise jme
+      end
+    end
     protected
+    def is_array?(obj)
+      return (obj.kind_of?(Array) or obj.kind_of?(ArrayJavaProxy) or obj.kind_of?(Set) or obj.kind_of?(Java::JavaUtil::Set))
+    end
     
-    def convert_to (to, field_def)
-      if to.kind_of? Array then
-        jtype = field_def.clazz
-        jtype ||= "String"
-        return to.to_java(jtype)
-      else 
+    def convert_to (to, field_def, parent)
+      if to.kind_of? Array or to.kind_of? Hash or to.kind_of? Set then
+        param_type = nil
+        unless parent.nil?
+          jclass = parent.java_class
+          unless jclass.nil?
+            jmethod = jclass.declared_method_smart "set#{classify(field_def.name.to_s)}".to_sym
+            param_type = jmethod.parameter_types[0]
+          end
+        end
+        if (param_type.nil? and to.kind_of? Array) or (not param_type.nil? and param_type.array?)
+          jtype = field_def.clazz
+          jtype ||= "String"
+          return to.to_java(jtype)
+        elsif (param_type.nil? and to.kind_of? Set) or (not param_type.nil? and param_type <= java.util.Set.java_class)
+          jset = java.util.LinkedHashSet.new to
+          unless param_type.class.kind_of? Module
+            jset = param_type.new to
+          end
+          return jset
+        elsif (param_type.nil? and to.kind_of? Hash) or (not param_type.nil? and param_type <= java.util.Map.java_class)
+          jmap = java.util.LinkedHashMap.new
+          unless param_type.class.kind_of? Module
+            jmap = param_type.new
+          end
+          jmap.put_all to
+          return jmap
+        else
+          raise "#{param_type} of enumerable not supported"
+        end
+      else
         return to
       end
     end
     def convert_from (from, field_def)
-        if from.kind_of? ArrayJavaProxy then
+        if from.kind_of?(ArrayJavaProxy) then
           return from.to_ary
-        else 
+        elsif from.kind_of?(Java::JavaUtil::Set) then 
+           return from.to_a
+        else
           return from
         end
     end
+    private
+    def classify(string)
+      return string.gsub(/(^|_)(.)/) { $2.upcase }
+    end
   end
   class JavaApi < Java::pl.ivmx.mappum.MappumApi
     def initialize

data/lib/mappum/map.rb

@@ -121,9 +121,7 @@ module Mappum
         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
+
         
         map_r2l.dict = self.dict.invert unless self.dict.nil?
   
@@ -136,14 +134,18 @@ module Mappum
         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_r2l.maps = self.maps.select do |m|
+          m.to.parent == map_r2l.to or m.to.parent.kind_of? Context
+        end
         map_l2r.maps = self.maps.select do |m|
-          m.to.parent == map_l2r.to
+          m.to.parent == map_l2r.to or m.to.parent.kind_of? Context
         end
   
         [map_r2l, map_l2r]
       else
         [self]
-      end
+      end 
     end
     def simple?
         @func.nil? && @dict.nil? && @desc.nil? && 
@@ -164,15 +166,20 @@ module Mappum
     end
   end
   class Field < Struct.new(:name, :clazz, :parent, :func, :block, :is_root, :is_placeholder, :src_ref)
-    #define is_array separetly to exclude it from equals
-    attr_accessor :is_array
+    #define enum_type separetly to exclude it from equals
+    attr_accessor :enum_type
     def array?
-      is_array
+      not enum_type.nil?
     end
     def placeholder?
       is_placeholder
     end
   end
+  class Context < Field
+    def is_root
+      true
+    end
+  end
   class Constant <  Struct.new(:value,:parent) 
     def parent
       nil
@@ -191,6 +198,9 @@ module Mappum
     def func
       nil      
     end
+    def name
+      nil
+    end
     def value
       nil
     end

data/lib/mappum/map_space.rb

@@ -0,0 +1,11 @@
+module Mappum
+  #
+  # Objects of this class hold variables
+  # and helper methods for a mapping.
+  # New object is created for each mapping
+  #
+  class MapSpace
+      attr_accessor :context
+    
+  end
+end

data/lib/mappum/mappum_exception.rb

@@ -1,6 +1,14 @@
 module Mappum
    class MappumException < RuntimeError
-     attr_accessor :from_name, :to_name, :from, :to, :from_root, :to_root, :mappum_backtrace 
+     attr_accessor :from_name, :to_name, :from, :to, :from_root, :to_root, :mappum_backtrace , :caused_by
+     
+     def initialize(mess=nil)
+       super(mess)
+       if mess.kind_of? Exception
+         @caused_by = mess 
+         set_backtrace(mess.backtrace)
+       end
+     end
      def wrap(map, from, to)
         
         if map != nil and map != @map #don't store same maps twice
@@ -8,9 +16,9 @@ module Mappum
           from_suffix, to_suffix = "",""
           
 		  add_to_mappum_backtrace(map)
-		  from_suffix = "[]" if map.from.is_array
+		  from_suffix = "[]" if map.from.array?
 		  add_from_name(map.from.name, from_suffix)
-		  to_suffix = "[]" if map.to.is_array
+		  to_suffix = "[]" if map.to.array?
 		  add_to_name(map.to.name, to_suffix)
 	    end
 		@to = to if @to.nil?
@@ -29,10 +37,10 @@ module Mappum
      def add_to_mappum_backtrace(map)
        if @mappum_backtrace.nil?
          @mappum_backtrace = []
-         @mappum_backtrace << map.from.src_ref
-         @mappum_backtrace << map.to.src_ref
+         @mappum_backtrace << map.from.src_ref if map.from.respond_to?(:src_ref)
+         @mappum_backtrace << map.to.src_ref if map.to.respond_to?(:src_ref)
        end
-       @mappum_backtrace << map.src_ref
+       @mappum_backtrace << map.src_ref if map.respond_to?(:src_ref)
      end
    end
 end

data/lib/mappum/mapserver/mapgraph.rb

@@ -157,7 +157,7 @@ DOT
               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
+            name = "#{name}[]" if not name.nil? and element.array?
             return name, path, level
         end
       end 

data/lib/mappum/mapserver/mapserver.rb

@@ -81,17 +81,24 @@ module Mappum
       @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?
+      map_name = nil
+      map_name = params["map"] unless params["map"].nil? or params["map"] == "auto_select"
+      from_qname_str = params["from_qname"] unless params["from_qname"].nil? or params["from_qname"] == "auto_select"
+      from_qname = nil
+      unless from_qname_str.nil? or from_qname_str==''
+        /^\{([^}]*)\}(.*)$/  =~ from_qname_str
+        from_qname = XSD::QName.new($1,$2)
+      end
+      force_openstruct = false
+      force_openstruct = params["ignore"] unless params["map"].nil?
+
+      rt = Mappum::XmlTransform.new(@catalogue, force_openstruct)
+      
+      xml = params["doc"]
 
-	  rt = Mappum::XmlTransform.new(@catalogue, force_openstruct)
-	  
-	  xml = params["doc"]
-	  content = rt.transform(xml,map_name)
-	  
-	  [200, {"Content-Type" => "text/xml"}, [content]]
+      content = rt.transform(xml,map_name, from_qname)
+      
+      [200, {"Content-Type" => "text/xml"}, [content]]
     end
     post "*/transform-ws" do
       @catalogue = params[:splat][0] || "ROOT"
@@ -173,31 +180,31 @@ module Mappum
       @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]
+      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)]]
+      @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)]]
+      @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
     error do
       @xml_convertor = Syntax::Convertors::HTML.for_syntax "xml"

data/lib/mappum/mapserver/views/main.erb

@@ -18,6 +18,7 @@
 	      <%end%>
 		</select>
 		<input type="checkbox" name="ignore" value="false">Ignore types</input>
+		<input type="text" name="from_qname"></input>
 		<br/>
 		 <TEXTAREA name="doc" rows="20" cols="80"></TEXTAREA><br/>
 		 <INPUT type="submit" value="Send"/><INPUT type="reset"/>

data/lib/mappum/ruby_transform.rb

@@ -4,6 +4,8 @@ require 'mappum'
 require 'ostruct'
 require 'mappum/autoconv_catalogue'
 require 'mappum/mappum_exception'
+require 'mappum/map_space'
+
 
 module Mappum
   #
@@ -24,8 +26,18 @@ module Mappum
     #
     # Method for transforming from object using map to "to" object.
     #
-    def transform(from, map=nil, to=nil)
+    def transform(from, map=nil, to=nil, options={})
       begin
+
+      options ||= {}
+      
+      map_space_added = false
+      if options["map_space"].nil?
+        map_space_added = true
+        options["map_space"] = Mappum::MapSpace.new
+        options["map_space"].context = get_context(options)
+      end
+      
       raise RuntimeError.new("Map catalogue is empty!") if @map_catalogue.nil?
       
       map ||= @map_catalogue[from.class]
@@ -39,29 +51,31 @@ module Mappum
 
       all_nils = true
       map.maps.each do |sm|
-        begin
+       begin
         from_value, to_value = nil, nil
         
-        from_value = get(from, sm.from, map.from) 
+        from_value = get(from, sm.from, map.from, options) 
 
         # skip to next mapping on false :map_when function
         next unless sm.map_when.nil? or sm.map_when.call(from_value)
 
         unless sm.func.nil? or (not sm.func_on_nil? and from_value.nil?)
-          from_value = sm.func.call(from_value)
+          from_value = options["map_space"].instance_exec(from_value,&sm.func)
         end
         unless sm.from.func.nil? or from_value.nil?
           mappum_block = sm.from.block
-            if from_value.kind_of?(Array) 
-            # TODO Fix it for JavaArrays
-            #or (Module.constants.include? "ArrayJavaProxy" and from_value.kind_of?(Module.const_get(:ArrayJavaProxy)))
-               from_value = from_value.compact.instance_eval(sm.from.func)
+            if from_value.kind_of?(Array)
+                from_value = from_value.compact.instance_eval(sm.from.func)
             else
+              # TODO Fix it for Java to make campact as well
+              #non real arrays
+              if is_array?(from_value)
+                from_value = convert_from(from_value,sm.from)
+              end
               from_value = from_value.instance_eval(sm.from.func)
             end
         end
-
-       submaps = sm.maps
+        submaps = sm.maps
         if sm.maps.empty?
           unless sm.submap_alias.nil? or sm.submap_alias.empty?
             submaps = @map_catalogue[sm.submap_alias].maps
@@ -81,63 +95,70 @@ module Mappum
         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)))
+          if is_array?(from_value)
             sm_v = sm.clone
-            if sm_v.from.is_array
+            if sm_v.from.array?
               sm_v.from = sm.from.clone
-              sm_v.from.is_array = false
+              sm_v.from.enum_type = nil
             end
-            if sm_v.to.is_array
+            if sm_v.to.array?
               sm_v.to = sm.to.clone
-              sm_v.to.is_array = false
+              sm_v.to.enum_type = nil
             end
             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
+              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, nil, pass_options(options))}
+            else
+              to_value = from_value.collect{|v| transform(add_parent(v, from), sm_v, nil, pass_options(options))}
+            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 = []
             #array values are assigned after return
-            v_to << get(to, sm.to) unless sm.to.is_array and not sm.from.is_array
+            v_to << get(to, sm.to, nil, options) unless sm.to.array? and not sm.from.array?
             #nless one whants to update existing to array
             if sm.to_array_take == :first
-              arr_v = get(to, sm.to)
+              arr_v = get(to, sm.to, nil, options)
               v_to << arr_v[0]  if not arr_v.nil?
             end
             if sm.to_array_take == :all
-              arr_v = get(to, sm.to)
+              arr_v = get(to, sm.to, nil, options)
               v_to += arr_v  if not arr_v.nil?
             end
+            #array values are assigned after return
+            v_to = [nil] if sm.to.array? and not sm.from.array? and v_to.empty?
             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
+        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, pass_options(options))
+        else
+          to_value = transform(add_parent(from_value, from), sm_v, v_t, pass_options(options))
+        end
+        end
           end
 
         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 = convert_from(get(to,sm.to),sm.from)
-          to_array ||= []
-          to_array << to_value unless sm.to_array_take == :first or sm.to_array_take == :all
-          
+
+        if sm.to.array? and not sm.from.array?
+          to_array = convert_from(get(to,sm.to,nil,options),sm.from)
+          to_array ||= sm.to.enum_type.new
+          to_array << to_value unless sm.to.enum_type != Array or sm.to_array_take == :first or sm.to_array_take == :all
+          #FIXME change array and hash to something sane! 
+          if sm.to.enum_type == Hash and sm.to.func[0..6] == "self.[]"
+            bad_func = "self.[]=#{sm.to.func[7..-2]},to_value)"
+            to_array.instance_eval(bad_func)
+          end
+
           if to_array.empty? and sm.strip_empty?
             to_array = nil
           end
@@ -147,9 +168,13 @@ module Mappum
           if sm.to.name.nil?
             to = convert_to(to_array, sm.to)
           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
-            to.send("#{sm.to.name}=", convert_to(to_array, sm.to)) unless to_array.nil?
+            if sm.to.parent.kind_of? Context
+              get_context(options).send("#{sm.to.name}=", convert_to(to_array, sm.to, get_context(options))) unless to_array.nil?
+            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
+              to.send("#{sm.to.name}=", convert_to(to_array, sm.to, to)) unless to_array.nil?
+            end
           end
         else
 
@@ -162,9 +187,13 @@ module Mappum
           if sm.to.name.nil?
             to ||= to_value
           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 
-            to.send("#{sm.to.name}=", convert_to(to_value, sm.to)) unless to_value.nil?
+            if sm.to.parent.kind_of? Context
+              get_context(options).send("#{sm.to.name}=", convert_to(to_value, sm.to, get_context(options))) unless to_value.nil?
+            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 
+             to.send("#{sm.to.name}=", convert_to(to_value, sm.to, to)) unless to_value.nil?
+            end
           end
         end
        rescue Exception => e
@@ -173,6 +202,13 @@ module Mappum
         raise e
        end 
       end
+      if map_space_added
+        if options.respond_to? :delete
+          options.delete("map_space") 
+        else
+          options["map_space"]=nil
+        end
+      end
       if all_nils and map.strip_empty?
         return nil
       end
@@ -185,39 +221,44 @@ module Mappum
     end
     
     protected
-    
-    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
+    def is_array?(obj)
+      return (obj.kind_of?(Array) or obj.kind_of?(Set) or obj.kind_of?(Hash))
     end
-    def convert_to(to, field_def)
+    def get(object, field, parent_field=nil,options={})
+      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.parent.kind_of?(Context)
+          object = get_context(options)
+        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 (not parent_field.is_root) and field.parent != parent_field
+          if object.respond_to?(:_mpum_parent)
+            return get(object._mpum_parent, field, parent_field.parent, options)
+          else 
+            raise "No parent for this object"
+          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, parent)
       return to
     end
     def convert_from(from, field_def)
@@ -232,6 +273,17 @@ module Mappum
       value._mpum_parent = parent
       return value
     end
+    def pass_options(options)
+      return options
+    end
+    def get_context(options)
+      ctx = options[:context] 
+      ctx ||= options["context"]
+      if ctx.nil?
+        ctx = @default_struct_class.new
+      end
+      return ctx
+    end
   end
   class OpenStruct < OpenStruct
     def type(*attr)