spiderfw 0.5.19 → 0.6.0

data/lib/spiderfw/model/mappers/mapper.rb

@@ -50,6 +50,10 @@ module Spider; module Model
             mapped?(element) || element.attributes[:sortable]
         end
         
+        def base_type(type)
+            Spider::Model.base_type(type)
+        end
+        
         # Utility methods
         
         # An array of mapped elements.
@@ -59,7 +63,6 @@ module Spider; module Model
         
         # Calls the given action. Used by UnitOfWork tasks.
         def execute_action(action, object, params={}) # :nodoc:
-            @unit_of_work_task = true
             case action
             when :save
                 if params[:force] == :insert
@@ -76,7 +79,6 @@ module Spider; module Model
             else
                 raise MapperError, "#{action} action not implemented"
             end
-            @unit_of_work_task = false
         end
         
         # Converts hashes and arrays to QuerySets and BaseModel instances.
@@ -159,23 +161,29 @@ module Spider; module Model
                 end
             end
             done_extended = []
-            unless @unit_of_work_task
-                if (@model.extended_models)
-                    @model.extended_models.each do |m, el|
-                        sub = obj.get(el)
-                        done_extended << el
-                        if mode == :update || sub.class.auto_primary_keys? || sub._check_if_saved
-                            sub.save if (obj.element_modified?(el) || !obj.primary_keys_set?) && sub.mapper.class.write?
-                        else
-                            sub.insert unless sub.in_storage?
-                        end
+            unless Spider::Model.unit_of_work_running?
+                save_extended_models(obj, mode)
+                save_integrated(obj, mode)
+            end
+        end
+        
+        def save_extended_models(obj, mode)
+            if @model.extended_models
+                @model.extended_models.each do |m, el|
+                    sub = obj.get(el)
+                    if mode == :update || sub.class.auto_primary_keys? || sub._check_if_saved
+                        sub.save if (obj.element_modified?(el) || !obj.primary_keys_set?) && sub.mapper.class.write?
+                    else
+                        sub.insert unless sub.in_storage?
                     end
                 end
-                @model.elements_array.select{ |el| !el.integrated? && el.attributes[:integrated_model] }.each do |el|
-                    next if done_extended.include?(el.name)
-                    sub_obj = obj.get(el)
-                    sub_obj.save if sub_obj && sub_obj.modified? && obj.element_modified?(el) && obj.get(el).mapper.class.write?
-                end
+            end
+        end
+        
+        def save_integrated(obj, mode)
+            @model.elements_array.select{ |el| !el.integrated? && el.attributes[:integrated_model] && !el.attributes[:extended_model] }.each do |el|
+                sub_obj = obj.get(el)
+                sub_obj.save if sub_obj && sub_obj.modified? && obj.element_modified?(el) && obj.get(el).mapper.class.write?
             end
         end
         
@@ -211,27 +219,12 @@ module Spider; module Model
             prev_autoload = obj.autoload?
             obj.save_mode
             storage.in_transaction
-            if (@model.extended_models && !@model.extended_models.empty?)
-                is_insert = false
-                # Load local primary keys if they exist
-                
-                @model.elements_array.select{ |el| el.attributes[:local_pk] }.each do |local_pk|
-                    if !obj.get(local_pk)
-                        is_insert = true
-                        break
-                    end
-                end
-            end
-            save_mode = nil
-            if obj.class.auto_primary_keys? && !obj._check_if_saved
-                save_mode = (!is_insert && obj.primary_keys_set?) ? :update : :insert
-            else
-                save_mode = obj.in_storage? ? :update : :insert
-            end
+            save_mode = determine_save_mode(obj)
             before_save(obj, save_mode)
             # @model.elements_array.select{ |el| el.attributes[:integrated_model] }.each do |el|
             #     obj.get(el).save if obj.element_modified?(el)
             # end
+            
             if (save_mode == :update)
                 do_update(obj)
             else
@@ -249,16 +242,34 @@ module Spider; module Model
             true
         end
         
+        def determine_save_mode(obj)
+            if @model.extended_models && !@model.extended_models.empty?
+                is_insert = false
+                # Load local primary keys if they exist
+                
+                @model.elements_array.select{ |el| el.attributes[:local_pk] }.each do |local_pk|
+                    if !obj.get(local_pk)
+                        is_insert = true
+                        break
+                    end
+                end
+            end
+            save_mode = nil
+            if obj.class.auto_primary_keys? && !obj._check_if_saved
+                save_mode = (!is_insert && obj.primary_keys_set?) ? :update : :insert
+            else
+                save_mode = obj.in_storage? ? :update : :insert
+            end
+        end
+        
 
         # Elements that are associated to this one externally.
         def association_elements
-             els = @model.elements_array.select{ |el| 
-                 mapped?(el) && !el.integrated? && !have_references?(el) && !(el.attributes[:added_reverse] && el.type <= @model)
-             }
-             if @unit_of_work_task
-                 els = els.select{ |el| el.attributes[:junction] && !el.attributes[:keep_junction] }
-             end
-             els
+            return [] if Spider::Model.unit_of_work_running?
+            els = @model.elements_array.select{ |el| 
+                mapped?(el) && !el.integrated? && !have_references?(el) && !(el.attributes[:added_reverse] && el.type <= @model)
+            }
+            els
         end
         
         # Saves object associations.
@@ -300,11 +311,11 @@ module Spider; module Model
         def save_element_associations(obj, element, mode)
             our_element = element.attributes[:reverse]
             val = obj.get(element)
-            if (element.attributes[:junction])
+            if element.attributes[:junction]
                 their_element = element.attributes[:junction_their_element]
-                if (val.model != element.model) # dereferenced junction
+                if val.model != element.model # dereferenced junction
                     val = [val] unless val.is_a?(Enumerable)
-                    unless (mode == :insert)
+                    unless mode == :insert
                         current = obj.get_new
                         current_val = current.get(element)
                         current_val = [current_val] unless current_val.is_a?(Enumerable)
@@ -346,7 +357,7 @@ module Spider; module Model
                     end
                 end
             else
-                if (element.multiple?)
+                if element.multiple?
                     condition = Condition.and
                     condition[our_element] = obj
                     val.each do |row|
@@ -354,7 +365,7 @@ module Spider; module Model
                         element.model.primary_keys.each{ |el| condition_row.set(el.name, '<>', row.get(el))}
                         condition << condition_row
                     end
-                    if (element.owned?)
+                    if element.owned?
                         element.mapper.delete(condition)
                     else
                         element.mapper.bulk_update({our_element => nil}, condition)
@@ -370,9 +381,10 @@ module Spider; module Model
         
         # Saves the given object and all objects reachable from it.
         def save_all(root)
-            uow = UnitOfWork.new
-            uow.add(root)
-            uow.run()
+            UnitOfWork.new do |uow|
+                uow.add(root)
+                uow.run()
+            end
         end
         
         # Inserts the object in the storage.
@@ -473,6 +485,10 @@ module Spider; module Model
             delete(all, true)
         end
         
+        def truncate!
+            raise MapperError, "Unimplemented"
+        end
+        
         # Actual interaction with the storage. May be implemented by subclasses.
         def do_delete(obj, force=false)
             raise MapperError, "Unimplemented"
@@ -576,25 +592,28 @@ module Spider; module Model
                         return false
                     end
                     set.total_rows = result.total_rows if (!was_loaded)
+                    merged = {}
                     result.each do |row|
                         obj =  map(query.request, row, @model) # set.model ?!?
                         next unless obj
-                        merge_object(set, obj, query.request)
+                        merged_obj = merge_object(set, obj, query.request)
+                        merged[merged_obj.object_id] = true
                         @raw_data[obj.object_id] = row
                     end
+                    query.request.keys.each do |k, v|
+                        set.element_loaded(k) if have_references?(k)
+                    end
+                    set.each do |obj|
+                        next if merged[obj.object_id]
+                        query.request.keys.each do |element_name|
+                            el = @model.elements[element_name]
+                            next if el.primary_key?
+                            next if el.integrated? || @model.extended_models[el.model]
+                            obj.set_loaded_value(element_name, nil) 
+                        end
+                    end
                 end
                 set = get_external(set, query)
-#                delay_put = true if (@model.primary_keys.select{ |k| @model.elements[k.name].integrated? }.length > 0)
-
-               
-                # if (delay_put)
-                #     set.no_autoload(false) do
-                #         set.each_index do |i|
-                #             set[i].primary_keys_set?
-                #             set[i] = im.put(set[i], true)
-                #         end
-                #     end
-                # end
             end
             return set
         end
@@ -608,11 +627,10 @@ module Spider; module Model
             if (obj_res && obj_res[0])
                 obj_res[0].set_parent(set, nil)
                 obj_res[0].merge!(obj, request)
-                obj.loaded_elements.each do |name, bool| 
-                    set.element_loaded(name) if request.key?(name)
-                end
+                obj_res[0]
             else
                 set << obj
+                obj
             end
         end
         
@@ -649,7 +667,7 @@ module Spider; module Model
         
         
         # Transforms a Storage result into an object. Should be implemented by subclasses.
-        def map(request, result, obj)
+        def map(request, result, obj_or_model)
             raise MapperError, "Unimplemented"
         end
         
@@ -691,7 +709,7 @@ module Spider; module Model
         # Loads an external element, according to query, and merges the result into an object or QuerySet.
         def get_external_element(element, query, objects)
 #            Spider::Logger.debug("Getting external element #{element.name} for #{@model}")
-            return load_element(objects, element) if (have_references?(element))
+            return load_element(objects, element) if have_references?(element)
             return nil if objects.empty?
             index_by = []
             @model.primary_keys.each{ |key| index_by << :"#{element.attributes[:reverse]}.#{key.name}" }
@@ -717,7 +735,6 @@ module Spider; module Model
             objects.each_current do |obj|
                 search_params = {}
                 @model.primary_keys.each do |key|
-                    field = @schema.field(key.name)
                     search_params[:"#{element.attributes[:reverse]}.#{key.name}"] = obj.get(key)
                 end
                 sub_res = result.find(search_params)
@@ -748,13 +765,69 @@ module Spider; module Model
             return res
         end
         
+        # Prepares a value going to be bound to an insert or update statement
+         def map_save_value(type, value, save_mode=:save)
+             value = map_value(type, value, :save)
+             return @storage.value_for_save(Model.simplify_type(type), value, save_mode)
+         end
 
-        # Converts a value from the storage to a value for the object.
-        def map_back_value(type, value)
-            raise MapperError, "Unimplemented"
+        # Prepares a value for a condition.
+        def map_condition_value(type, value)
+            if value.is_a?(Range)
+                return Range.new(map_condition_value(type, value.first), map_condition_value(type, value.last))
+            end
+            return value if ( type.class == Class && type.subclass_of?(Spider::Model::BaseModel) )
+            value = map_value(type, value, :condition)
+            return @storage.value_for_condition(Model.simplify_type(type), value)
+        end
+
+        def storage_value_to_mapper(type, value)
+            storage.value_to_mapper(type, value)
         end
         
         
+        # Converts a value in one accepted by the storage.
+        def map_value(type, value, mode=nil)
+            return value if value.nil?
+            if type == Spider::DataTypes::PK
+                value = value.obj if value.is_a?(Spider::DataTypes::PK)
+            elsif type < Spider::DataType
+                value = type.from_value(value) unless value.is_a?(type)
+                value = value.map(self.type)
+            elsif type.class == Class && type.subclass_of?(Spider::Model::BaseModel)
+                value = type.primary_keys.map{ |key| value.send(key.name) }
+            end
+            value
+        end
+        
+
+        # Converts a storage value back to the corresponding base type or DataType.
+        def map_back_value(type, value)
+            value = value[0] if value.class == Array
+            value = storage_value_to_mapper(Model.simplify_type(type), value)
+
+            if type <= Spider::DataTypes::PK
+                value = value.is_a?(Spider::DataTypes::PK) ? value.obj : value
+            elsif type < Spider::DataType && type.maps_back_to
+                type = type.maps_back_to
+            end
+            case type.name
+            when 'Fixnum'
+                return value ? value.to_i : nil
+            when 'Float'
+                return value ? value.to_f : nil
+            end
+            return nil unless value
+            case type.name
+            when 'Date', 'DateTime'
+                return type.parse(value) unless value.is_a?(Date)
+            end
+            if type < Spider::DataType && type.force_wrap?
+                value = type.from_value(value)
+            end
+            return value
+        end        
+        
         ##############################################################
         #   Strategy                                                 #
         ##############################################################
@@ -951,10 +1024,20 @@ module Spider; module Model
         end
         
         # Returns task dependecies for the UnitOfWork. May be implemented by subclasses.
-        def get_dependencies(obj, action)
+        def get_dependencies(task)
             return []
         end
         
+        def children_for_unit_of_work(obj, action)
+            children = []
+            obj.class.elements_array.each do |el|
+                next unless obj.element_has_value?(el)
+                next unless el.model?
+                children << obj.get(el)
+            end
+            children
+        end
+        
         
     end
     
@@ -964,7 +1047,7 @@ module Spider; module Model
     
     # The MapperTask is used by the UnitOfWork.
     class MapperTask
-        attr_reader :dependencies, :object, :action
+        attr_reader :dependencies, :object, :action, :params
        
         def initialize(object, action, params={})
             @object = object
@@ -978,13 +1061,18 @@ module Spider; module Model
         end
         
         def execute()
-            Spider::Logger.debug "Executing #{@action} on #{@object.inspect}"
+            debug_str = "Executing #{@action} on #{@object.inspect}"
+            debug_str += " (#{@params.inspect})" unless @params.empty?
+            Spider::Logger.debug debug_str
             @object.mapper.execute_action(@action, @object, @params)
         end
         
         def eql?(task)
             return false unless task.class == self.class
             return false unless (task.object == self.object && task.action == self.action)
+            @params.each do |k, v|
+                return false unless task.params[k] == v
+            end
             return true
         end
         
@@ -1002,9 +1090,10 @@ module Spider; module Model
         
         def inspect
             if (@action && @object)
-                str = "#{@action} on #{@object} (#{object.class})"
+                str = "#{@action} on #{@object}##{@object.object_id} (#{object.class})"
+                str += " (#{@params.inspect})" unless @params.empty?
                 if (@dependencies.length > 0)
-                    str += " (dependencies: #{@dependencies.map{ |dep| "#{dep.action} on #{dep.object.class} #{dep.object}"}.join(', ')})"
+                    str += " (dependencies: #{@dependencies.map{ |dep| "#{dep.action} on #{dep.object.class} #{dep.object}##{dep.object.object_id}"}.join(', ')})"
                     # str += "-dependencies:\n"
                     #                    @dependencies.each do |dep|
                     #                        str += "---#{dep.action} on #{dep.object}\n"

data/lib/spiderfw/model/mixins/list.rb

@@ -14,6 +14,7 @@ module Spider; module Model
         module MapperMethods
             
             def before_save(obj, mode)
+                return super if obj.embedder && storage.supports?(:embedding)
                 obj.class.lists.each do |l|
                     next if (!check_list_condition(l, obj))
                     cond = get_list_condition(l, obj)

data/lib/spiderfw/model/mixins/versioned.rb

@@ -7,6 +7,7 @@ module Spider; module Model
         
         
         def self.included(model)
+            return if model.is_a?(ClassMethods) && model.version_model
             model.extend(ClassMethods)
             model.mapper_include(Mapper)
             model.remove_element(:v_sha1) if model.elements[:v_sha1] && model.elements[:v_sha1].integrated?
@@ -92,28 +93,31 @@ module Spider; module Model
                   # debugger if elh[:attributes][:junction]
                   # vmod.send(elh[:method], elh[:name], elh[:type], elh[:attributes])
                   if (el.model?)
+                      is_version_content = el.type < Spider::Model::Versioned && el.attributes[:version_content] != false
                       if elh[:attributes][:integrated_model]
-                          
                           elh[:type].elements.each do |ielname, iel|
                               i = vmod.elements[ielname]
                               vmod.remove_element(ielname) if i && i.integrated? && i.integrated_from.name == el.name
                           end
                           elh[:attributes][:integrate] = true
+                          elh[:attributes].delete(:extended_model)
+                          elh[:attributes].delete(:embedded)
                       end
                       if el.attributes[:add_reverse] || el.attributes[:add_multiple_reverse]
                           rev = el.attributes[:add_reverse] || el.attributes[:add_multiple_reverse]
                           el.type.version_model.remove_element(rev[:name]) if el.type.respond_to?(:version_model)
                       end
-                      if vmod.elements[el.name] && elh[:attributes][:reverse] && !(el.model < Spider::Model::Versioned)
+                      if vmod.elements[el.name] && elh[:attributes][:reverse] && !is_version_content
                           vmod.elements[el.name].attributes.delete(:reverse)
+                          vmod.elements[el.name].attributes.delete(:condition)
                       end
-                      if el.multiple? && !el.attributes[:junction] && !(el.model < Spider::Model::Versioned)
+                      if el.multiple? && !el.attributes[:junction] && !is_version_content
                           elh[:attributes].delete(:reverse)
                           elh[:attributes].delete(:add_reverse)
                           elh[:attributes].delete(:add_multiple_reverse)
                           vmod.remove_element(el.name)
                           vmod.send(elh[:method], el.name, el.type, elh[:attributes])
-                      elsif (!el.attributes[:added_reverse] &&  el.model < Spider::Model::Versioned)
+                      elsif !el.attributes[:added_reverse] && el.model < Spider::Model::Versioned
                           vmod.remove_element(el.name)
                           if elh[:method] == :tree
                               vmod.remove_element(elh[:attributes][:reverse])
@@ -125,10 +129,10 @@ module Spider; module Model
                               vmod.send(elh[:method], el.name, el.type.version_model, elh[:attributes])
                           end
                           @version_elements[el.name] = el.name
-                      elsif (el.attributes[:junction] && el.attributes[:owned])
+                      elsif el.attributes[:junction] && el.attributes[:owned]
                           # elh[:attributes][:has_single_reverse] = (el.attributes[:reverse] && !el.type.elements[el.attributes[:reverse]].multiple?)
                           junction = vmod.elements[el.name].attributes[:association_type]
-                          unless junction < Spider::Model::Versioned 
+                          unless junction < Spider::Model::Versioned || (el.attributes[:embedded] && self.storage.supports?(:embedding))
                               junction.module_eval{ include Spider::Model::Versioned } 
                               junction.versioning(branch)
                           end
@@ -138,13 +142,18 @@ module Spider; module Model
                               elh[:attributes][:junction_their_element] = "#{elh[:attributes][:junction_their_element]}".to_sym
                               vmod.remove_element(el.name)
                               junction_type = nil
-                              if el.type.respond_to?(:version_model)
+                              if is_version_content
                                   junction_type = el.type.version_model
                               else
                                   junction_type = el.type
                                   elh[:attributes].delete(:reverse)
                                   elh[:attributes].delete(:add_reverse)
                                   elh[:attributes].delete(:add_multiple_reverse)
+                                  v_junction = junction.version_model
+                                  v_junction.remove_element(elh[:attributes][:junction_their_element])
+                                  v_junction.element(elh[:attributes][:junction_their_element], el.type, :association => :choice, :junction_reference => true)
+                                  v_junction.integrate(elh[:attributes][:junction_their_element], :hidden => true, :no_pks => true)
+                                  
                               end
                               vmod.send(elh[:method], el.name, junction_type, elh[:attributes])
                               
@@ -154,7 +163,14 @@ module Spider; module Model
                       end
                   end
               end
-              vmod.elements_array.each{ |el| el.attributes[:unique] = false if el.attributes[:unique] }              
+              vmod.elements_array.each{ |el| el.attributes[:unique] = false if el.attributes[:unique] }            
+              doc_storage = Spider.conf.get('storage.versioning.use_document')
+              if doc_storage && Spider.conf.get("storages.#{doc_storage}")
+                  vmod.use_storage(doc_storage)
+                  vmod.elements_array.select{ |el| el.junction? }.each do |el|
+                      el.model.use_storage(doc_storage)
+                  end
+              end
            end
            
            def version_element(el=nil)
@@ -173,14 +189,15 @@ module Spider; module Model
                @version_models[branch] = model
            end
            
-           # Returns the elements that concurr to define the objects version
+           # Returns the elements that concur to define the objects version
            def version_contents
                #no_content_assocs = [:choice, :multiple_choice]
                no_content_assocs = []
+               supports_embed = self.storage.supports?(:embedding)
 
                self.elements_array.select{ |el|
                    el.attributes[:version_content] || mapper.have_references?(el.name) || (!el.attributes[:added_reverse] && !no_content_assocs.include?(el.association))
-               }.reject{ |el| el.model? && !(el.model < Spider::Model::Versioned) }
+               }.reject{ |el| el.attributes[:version_content] == false || (el.model? && !(el.model < Spider::Model::Versioned)) }
            end
            
            def version_ignored_elements
@@ -195,22 +212,28 @@ module Spider; module Model
         
         module Mapper
             
-            def get_dependencies(obj, action)
-
+            def get_dependencies(task)
+                return super unless @model.respond_to?(:version_model)
                 deps = []
+                obj = task.object
+                action = task.action
                 version_contents = obj.class.version_contents
-                task = MapperTask.new(obj, action)
+                vmod = @model.version_model
                 case action
                 when :save_version
-                    #Spider.logger.debug("PROCESSING DEPS ON #{obj}")
                     version_contents.each do |vc|
                         next unless vc.model?
                         next if vc.integrated?
+                        v_el = vmod.elements[vc.name]
+                        next unless v_el
+                        is_embedded = v_el.attributes[:embedded] && vmod.storage.supports?(:embedding)
+                        next if is_embedded && !vc.junction?
+                        Spider.logger.debug("VC #{vc.name}")
                         set = obj.send(vc.name)
                         next unless set
                         set = obj.prepare_version_object(vc.name, set) if obj.respond_to?(:prepare_version_object)
-                        next if set == self
-                        set = self.instance_variable_get("@#{vc.name}_junction") if vc.junction? && !vc.attributes[:keep_junction]
+                        next if set.eql?(obj)
+                        set = obj.instance_variable_get("@#{vc.name}_junction") if vc.junction? && !vc.attributes[:keep_junction]
                         next unless set
                         set = [set] unless vc.multiple?
                         set.each do |set_obj|
@@ -223,8 +246,12 @@ module Spider; module Model
                                 dejunct = obj.class.prepare_junction_version_object(vc.name, dejunct) if obj.class.respond_to?(:prepare_junction_version_object)
                                 dejunct_task = MapperTask.new(dejunct, :save_version)
                                 junction_task = MapperTask.new(set_obj, :save_version)
-                                deps << [junction_task, dejunct_task] if dejunct.class < Spider::Model::Versioned
-                                deps << [junction_task, task]
+                                if is_embedded
+                                    deps << [task, dejunct_task] if dejunct.class < Spider::Model::Versioned
+                                else
+                                    deps << [junction_task, dejunct_task] if dejunct.class < Spider::Model::Versioned
+                                    deps << [junction_task, task]
+                                end
                             else
                                 #Spider.logger.debug("Version on #{set_obj} (#{set_obj.class}) depends on #{obj} (#{obj.class})")
                                 deps << [MapperTask.new(set_obj, :save_version), task]
@@ -239,14 +266,12 @@ module Spider; module Model
             
             def execute_action(action, object, params) # :nodoc:
                 return super unless [:save_version, :save_junction_version].include?(action)
-                @unit_of_work_task = true
                 case action
                 when :save_version
                     save_version(object)
                 when :save_junction_version
                     save_junction_version(object)
                 end
-                @unit_of_work_task = false
             end
             
             def save_version(object)
@@ -381,7 +406,7 @@ module Spider; module Model
                         obj.each{ |o| except_objects << o }
                     else
                         except_objects << obj
-                    end 
+                    end
                 end
             end
             self.class.elements_array.each do |el|                
@@ -433,10 +458,12 @@ module Spider; module Model
             version_contents = self.class.version_contents
             
             self.class.elements_array.each do |el|
-                next unless vmod.elements[el.name]
+                v_el = vmod.elements[el.name]
+                next unless v_el
                 next if el.model? && el.type.attributes[:version_model]
-                next if el.integrated?
-                next if el.multiple? && el.model.respond_to?(:version_element)
+                next if el.integrated? && !(el.integrated_from.embedded? && vmod.storage.supports?(:embedding))
+                is_embedded = el.attributes[:embedded] && vmod.storage.supports?(:embedding)
+                next if el.multiple? && el.model.respond_to?(:version_element) && !is_embedded
                 is_version_content = version_contents.include?(el)
                 #debugger if el.name == :news_list
                 el_val = self.get(el)
@@ -445,14 +472,23 @@ module Spider; module Model
                 end
                 #next unless mod.mapper.have_references?(el)
                 if el_val && el.multiple?
-                    if !el.model.respond_to?(:version_element)
+                    if !(v_el.model < Spider::Model::VersionModel)
                         el_val.each do |v|
                             vobj.get(el.name) << v
                         end
+                    elsif is_embedded && el.junction?
+                        el_val = instance_variable_get("@#{el.name}_junction") if !el.attributes[:keep_junction]
+                        el_val.each do |v|
+                            jv = v_el.model.new
+                            jv_sha1 = v.version_sha1
+                            v.populate_version_object(jv)
+                            jv.v_sha1 = jv_sha1
+                            vobj.get(el.name) << jv
+                        end
                     end
-                elsif el.model? && el_val && el.model.respond_to?(:version_element) # && is_version_content 
+                elsif el.model? && el_val && v_el.type < Spider::Model::VersionModel # && is_version_content 
                     
-                    vobj.set(el.name, el_val.get(el.model.version_element))
+                    vobj.set(el.name, el_val.get(el.type.version_element))
                             # if self.class.attributes[:sub_model] && self.class.attributes[:sub_model].respond_to?(:prepare_junction_version_object)
                             #     prep_val = self.class.attributes[:sub_model].prepare_junction_version_object(self.class.attributes[:sub_model_element], el_val)
                             #     prep_val.save_version