spiderfw 0.5.13 → 0.5.14

data/lib/spiderfw/model/base_model.rb

@@ -1,5 +1,6 @@
 require 'spiderfw/model/mixins/state_machine'
 require 'spiderfw/model/element'
+require 'spiderfw/model/integrated_element'
 require 'iconv'
 
 module Spider; module Model
@@ -54,6 +55,7 @@ module Spider; module Model
         include Spider::Logger
         include DataTypes
         include Spider::QueryFuncs
+        include EventSource
         # include StateMachine
         
         # The BaseModel class itself. Used when dealing with proxy objects.
@@ -65,6 +67,11 @@ module Spider; module Model
         # If _parent is a model instance, which element points to this one
         attr_accessor :_parent_element
         
+        # If this object is used as a superclass in class_table_inheritance, points to the current subclass
+        attr_accessor :_subclass_object
+        # This object won't be put into the identity mapper
+        attr_accessor :_no_identity_mapper
+        
         class <<self
             # An Hash of model attributes. They can be used freely.
             attr_reader :attributes
@@ -91,6 +98,9 @@ module Spider; module Model
             subclass.instance_variable_set("@mapper_procs_subclass", @mapper_procs_subclass.clone) if @mapper_procs_subclass
             subclass.instance_variable_set("@mapper_modules", @mapper_modules.clone) if @mapper_modules
             subclass.instance_variable_set("@extended_models", @extended_models.clone) if @extended_models
+            em = subclass.const_set(:ElementMethods, Module.new)
+            subclass.send(:include, em)
+            super
         end
         
         def self.subclasses
@@ -172,6 +182,9 @@ module Spider; module Model
         #                             :order attribute; if it is a Fixnum, it will mean the position in the ordering.
         # :default::                  (Proc or value) default value for the element. If it is a Proc, it will be passed
         #                             the object.
+        # :desc::                     (true or Fixnum) Use this element for the to_s string. Multiple elements
+        #                             with the :desc attribute will be joined by spaces; order may be specified if 
+        #                             a Fixnum is used for the parameter 
         # 
         # Other attributes may be used by DataTypes (see #DataType::ClassMethods.take_attributes), and other code.
         # See also Element.
@@ -179,6 +192,7 @@ module Spider; module Model
             name = name.to_sym
             @elements ||= {}
             @elements_order ||= []
+            raise "Element called #{name} already exists in #{self}" if @elements[name]
             if type.class == Class
                 default_attributes = case type.name
                 when 'String'
@@ -193,8 +207,8 @@ module Spider; module Model
             # if (type.class == Class && Model.base_type(type)) 
             #                 type = Model.base_type(type)
             #             els
-            if (type.class == Hash)
-                type = create_inline_model(name, type)
+            if (type.class <= Hash)
+                type = create_inline_model(name, type, attributes)
                 attributes[:inline] = true
             end
             if (attributes[:integrated_from])
@@ -258,10 +272,11 @@ module Spider; module Model
                 if (create_junction)
                     assoc_type = first_model.const_set(assoc_type_name, Class.new(BaseModel))
                     assoc_type.attributes[:sub_model] = self
+                    assoc_type.attributes[:sub_model_element] = name
                     assoc_type.element(attributes[:junction_id], Fixnum, :primary_key => true, :autoincrement => true, :hidden => true) if attributes[:junction_id]
-                    assoc_type.element(self_name, self, :hidden => true, :reverse => name, :association => :choice) # FIXME: must check if reverse exists?
+                    assoc_type.element(self_name, self, :hidden => true, :reverse => name, :association => :choice, :junction_reference => true) # FIXME: must check if reverse exists?
                     # FIXME! fix in case of clashes with existent elements
-                    assoc_type.element(other_name, orig_type, :association => :choice)
+                    assoc_type.element(other_name, orig_type, :association => :choice, :junction_reference => true)
                     assoc_type.integrate(other_name, :hidden => true, :no_pks => true) # FIXME: in some cases we want the integrated elements
                     if (proc)                                   #        to be hidden, but the integrated el instead
                         attributes[:extended] = true
@@ -278,7 +293,9 @@ module Spider; module Model
                 end
             end
             
-            @elements[name] = Element.new(name, type, attributes)
+            
+            add_element(Element.new(name, type, attributes))
+            
             
             if (attributes[:add_reverse] && attributes[:add_reverse].is_a?(Symbol))
                 attributes[:add_reverse] = {:name => attributes[:add_reverse]}
@@ -331,16 +348,7 @@ module Spider; module Model
             end
             
             
-            
-            if (attributes[:element_position])
-                @elements_order.insert(attributes[:element_position], name)
-            else
-                @elements_order << name
-            end
-            @primary_keys ||= []
-            if attributes[:primary_key] && !@primary_keys.include?(@elements[name])
-                @primary_keys << @elements[name] 
-            end
+
             
             # class element getter
             unless respond_to?(name)
@@ -351,18 +359,47 @@ module Spider; module Model
                 end
             end
             
-            ivar = :"@#{ name }"
+            define_element_methods(name)
             
+            attr_reader "#{name}_junction" if attributes[:junction] && !attributes[:keep_junction]
+            
+            if (attributes[:integrate])
+                integrate_params = attributes[:integrate].is_a?(Hash) ? attributes[:integrate] : {}
+                integrate(name, integrate_params)
+            end
+            if self.attributes[:integrated_from_elements]
+                self.attributes[:integrated_from_elements].each do |imod, iel|
+                    imod.integrate_element(iel, self.elements[name]) unless imod.elements[name]
+                end
+            end
+            if (@subclasses)
+                @subclasses.each do |sub|
+                    next if sub.elements[name] # if subclass already defined an element with this name, don't overwrite it
+                    sub.elements[name] = @elements[name].clone
+                    sub.elements_order << name
+                end
+            end
+            element_defined(@elements[name])
+            @elements[name].model?
+            return @elements[name]
+
+        end
+        
+        
+        def self.define_element_methods(name)
+            ivar = :"@#{ name }"
+
             unless self.const_defined?(:ElementMethods)
                 em = self.const_set(:ElementMethods, Module.new)
                 include em
-                
+
             end
             element_methods = self.const_get(:ElementMethods)
 
             #instance variable getter
             element_methods.send(:define_method, name) do
                 element = self.class.elements[name]
+                raise "Internal error! Element method #{name} exists, but element not found" unless element
                 return element.attributes[:fixed] if element.attributes[:fixed]
                 if (element.integrated?)
                     integrated = get(element.integrated_from.name)
@@ -375,7 +412,7 @@ module Spider; module Model
                     return val
                 end
 
-#                Spider.logger.debug("Element not loaded #{name} (i'm #{self.class} #{self.object_id})")
+                #                Spider.logger.debug("Element not loaded #{name} (i'm #{self.class} #{self.object_id})")
                 if autoload? && primary_keys_set?
                     if (autoload? == :save_mode)
                         mapper.load_element!(self, element)
@@ -393,28 +430,37 @@ module Spider; module Model
                     else
                         val = element.attributes[:default]
                     end
+                    val = element.model.new(val) if element.model? && !val.is_a?(BaseModel)
                 end
-                val.set_parent(self, name) if element.model? && val && !val._parent # FIXME!!!
+                val.set_parent(self, name) if element.model? && val && val.respond_to?(:parent) && !val._parent # FIXME!!!
                 return val
             end
-            
-            alias_method :"#{name}?", name if type <= Spider::DataTypes::Bool
+
+            alias_method :"#{name}?", name if self.elements[name].type <= Spider::DataTypes::Bool
 
             #instance_variable_setter
             element_methods.send(:define_method, "#{name}=") do |val|
                 element = self.class.elements[name]
+                raise "Internal error! Element method #{name}= exists, but element not found" unless element
                 return if element.attributes[:fixed]
                 was_loaded = element_loaded?(element)
                 #@_autoload = false unless element.primary_key?
                 if (element.integrated?)
                     integrated_obj = get(element.integrated_from)
                     unless integrated_obj
-                        integrated_obj = instantiate_element(element.integrated_from.name)
+                        integrated_obj = instantiate_element(element.integrated_from.name) 
                         set(element.integrated_from, integrated_obj)
                     end
                     #integrated_obj.autoload = false
-                    res = integrated_obj.send("#{element.integrated_from_element}=", val)
-                    @modified_elements[name] = true unless element.primary_key?
+                    begin
+                        res = integrated_obj.send("#{element.integrated_from_element}=", val)
+                    rescue IdentityMapperException
+                        set(element.integrated_from, Spider::Model.get(integrated_obj))
+                        get(element.integrated_from).merge!(integrated_obj)
+                    end
+                    if !element.primary_key? && integrated_obj.element_modified?(name)
+                        @modified_elements[name] = true
+                    end
                     return res
                 end
                 if (val && element.model?)
@@ -432,38 +478,47 @@ module Spider; module Model
                             val = qs
                         end
                     else
-                        val = element.model.new(val) unless val.is_a?(BaseModel)
+                        val = element.model.get(val) unless val.is_a?(BaseModel)
                     end
                 end
                 val = prepare_child(element.name, val)
-                check(name, val)
+                _check(name, val)
                 notify_observers(name, val)
+                @_has_values = true
+                unless @_primary_keys_set
+                    if self.class.elements[element.name].primary_key? && primary_keys_set?
+                        @_primary_keys_set = true
+                        if Spider::Model.identity_mapper
+                            Spider::Model.identity_mapper.put(self, true, true)
+                        else
+                            Spider::Model.unit_of_work.add(self) if Spider::Model.unit_of_work
+                        end
+                    end
+                end
                 old_val = instance_variable_get(ivar)
                 @modified_elements[name] = true if !element.primary_key? && (!was_loaded || val != old_val)
                 instance_variable_set(ivar, val)
-                #extend_element(name)
-            end
-            
-            if (attributes[:integrate])
-                integrate_params = attributes[:integrate].is_a?(Hash) ? attributes[:integrate] : {}
-                integrate(name, integrate_params)
-            end
-            if (@subclasses)
-                @subclasses.each do |sub|
-                    sub.elements[name] = @elements[name].clone
-                    sub.elements_order << name
+                set_reverse(element, val) if element.model?
+                if val && element.model? && !self.class.attributes[:no_type_check]
+                    klass = val.is_a?(QuerySet) ? val.model : val.class
+                    if val && !(klass <= element.type || klass <= element.model)
+                        raise TypeError, "Object #{val} (#{klass}) is of the wrong type for element #{element.name} in #{self.class} (expected #{element.model})"
+                    end
                 end
+                val
+                #extend_element(name)
             end
-            element_defined(@elements[name])
-            return @elements[name]
-
         end
         
         def self.add_element(el)
             @elements ||= {}
             @elements[el.name] = el
             @elements_order ||= []
-            @elements_order << el.name
+            if (el.attributes[:element_position])
+                @elements_order.insert(el.attributes[:element_position], el.name)
+            else
+                @elements_order << el.name
+            end            
             @primary_keys ||= []
             if el.attributes[:primary_key] && !@primary_keys.include?(el)
                 @primary_keys << el
@@ -475,11 +530,25 @@ module Spider; module Model
         def self.remove_element(el)
             return unless @elements
             el = el.name if el.is_a?(Element)
+            element = @elements[el]
+            if self.attributes[:integrated_from_elements]
+                self.attributes[:integrated_from_elements].each do |mod, iel|
+                    i = mod.elements[el]
+                    mod.remove_element(el) if i && i.integrated? && i.integrated_from.name == iel
+                end
+            end
+            self.elements_array.select{ |e| e.integrated? && e.integrated_from.name == el}.each{ |e| remove_element(e) }
+            self.const_get(:ElementMethods).send(:remove_method, :"#{el}") rescue NameError
+            self.const_get(:ElementMethods).send(:remove_method, :"#{el}=") rescue NameError
             @elements.delete(el)
             @elements_order.delete(el)
             @primary_keys.delete_if{ |pk| pk.name == el}
-            remove_method(:"#{el}") rescue NameError
-            remove_method(:"#{el}=") rescue NameError
+
+            # if (@subclasses)
+            #     @subclasses.each do |sub|
+            #         sub.remove_element(el)
+            #     end
+            # end
         end
         
         def self.element_defined(el)
@@ -513,29 +582,43 @@ module Spider; module Model
         def self.integrate(element_name, params={})
             params ||= {}
             elements[element_name].attributes[:integrated_model] = true
-            model = elements[element_name].model
+            model = elements[element_name].type
             self.attributes[:integrated_models] ||= {}
             self.attributes[:integrated_models][model] = element_name
             params[:except] ||= []
             model.each_element do |el|
                 next if params[:except].include?(el.name)
                 next if elements[el.name] unless params[:overwrite] # don't overwrite existing elements
-                attributes = el.attributes.clone.merge({
-                    :integrated_from => elements[element_name],
-                    :integrated_from_element => el.name
-                })
-                attributes.delete(:primary_key) if params[:no_pks]
-                attributes[:hidden] = params[:hidden] unless (params[:hidden].nil?)
-                if (add_rev = attributes[:add_reverse] || attributes[:add_multiple_reverse])
-                    attributes[:reverse] = add_rev[:name]
-                    attributes.delete(:add_reverse)
-                    attributes.delete(:add_multiple_reverse)
-                end
-                attributes.delete(:primary_key) unless (params[:keep_pks])
-                attributes.delete(:required)
-                name = params[:mapping] && params[:mapping][el.name] ? params[:mapping][el.name] : el.name
-                element(name, el.type, attributes)
+                integrate_element(element_name, el, params)
+            end
+            model.attributes[:integrated_from_elements] ||= []
+            model.attributes[:integrated_from_elements] << [self, element_name]
+        end
+        
+        def self.integrate_element(element_name, element_element, params={})
+            el = element_element
+            integrated_attributes = {}
+            integrated_attributes[:primary_key] = false if params[:no_pks]
+            integrated_attributes[:hidden] = params[:hidden] unless (params[:hidden].nil?)
+
+            integrated_attributes[:primary_key] = false unless (params[:keep_pks])
+            # attributes.delete(:required)
+            # attributes.delete(:integrate)
+            # attributes.delete(:local_pk)
+            integrated_attributes[:local_pk] = false
+            integrated_attributes[:lazy] = element_name
+            name = params[:mapping] && params[:mapping][el.name] ? params[:mapping][el.name] : el.name
+            add_element(IntegratedElement.new(name, self, element_name, el.name, integrated_attributes))
+            define_element_methods(name)
+        end
+        
+        def self.remove_integrate(element_name)
+            element = element_name.is_a?(Element) ? element_name : self.elements[element_name]
+            model = element.model
+            self.elements_array.select{ |el| el.attributes[:integrated_from] && el.attributes[:integrated_from].name == element.name }.each do |el|
+                self.remove_element(el)
             end
+            model.attributes[:integrated_from_elements].reject!{ |item| item[0] == self }
         end
         
         # Sets additional attributes on the element
@@ -543,7 +626,7 @@ module Spider; module Model
         # _Warning:_ for attributes which are parsed by the BaseModel during element definition,
         # this will not have the desired effect; remove and redefine the element instead.
         def self.element_attributes(element_name, attributes)
-            elements[element_name].attributes.merge!(attributes)
+            elements[element_name].attributes = elements[element_name].attributes.merge(attributes)
             if attributes[:primary_key] && !@primary_keys.include?(elements[element_name])
                 @primary_keys << elements[element_name]
             elsif !attributes[:primary_key]
@@ -607,17 +690,24 @@ module Spider; module Model
         end
         
         # Creates an inline model
-        def self.create_inline_model(name, hash) #:nodoc:
+        def self.create_inline_model(name, hash, attributes={}) #:nodoc:
             model = self.const_set(Spider::Inflector.camelize(name), Class.new(InlineModel))
             model.instance_eval do
-                hash.each do |key, val|
-                    element(:id, key.class, :primary_key => true)
-                    if (val.class == Hash)
-                        # TODO: allow passing of multiple values like {:element1 => 'el1', :element2 => 'el2'}
-                    else
-                        element(:desc, val.class)
+                if attributes[:inline_model]
+                    attributes[:inline_model].each do |el|
+                        element(el[0], el[1], el[2] || {})
+                    end
+                else
+                    hash.each do |key, val|
+                        key = key.to_s if key.is_a?(Symbol)
+                        element(:id, key.class, :primary_key => true)
+                        if (val.class == Hash)
+                            # TODO: allow passing of multiple values like {:element1 => 'el1', :element2 => 'el2'}
+                        else
+                            element(:desc, val.class, :desc => true)
+                        end
+                        break
                     end
-                    break
                 end
             end
             model.data = hash
@@ -634,7 +724,7 @@ module Spider; module Model
             if (model == superclass) # first undo table per class inheritance
                 @elements = {}
                 @elements_order = []
-                @extended_models.delete(model) if @extended_models
+                @extended_models.delete(model.superclass) if @extended_models
             end
             primary_keys.each{ |k| remove_element(k) } if (params[:replace_pks])
             model.primary_keys.each{ |k| remove_element(k) }
@@ -666,9 +756,10 @@ module Spider; module Model
         # Externalizes the superclass elements making the superclass an external integrated element.
         # Parameters may be:
         # * :name               (symbol) name of the created element
-        # * :delete_cascade     (bool) delete cascade the superclass instance
+        # * :delete_cascade     (bool) delete cascade the superclass instance. True by default.
         # * :no_local_pk        (bool) do not define an id for this class
         def self.class_table_inheritance(params={})
+            
             self.extend_model(superclass, params)
         end
         
@@ -784,6 +875,25 @@ module Spider; module Model
             self.primary_keys.select{ |k| !k.autogenerated? }.empty?
         end
         
+        def self.containing_module
+            par = self.parent_module
+            while par <= BaseModel
+                par = par.parent_module
+            end
+            par
+        end
+        
+        def self.get_element(el)
+            el = el.name if el.is_a?(Element)
+            el = el.to_sym
+            raise "No element called #{el} in #{self}" unless @elements[el]
+            @elements[el]
+        end
+        
+        def self.junction?
+            !!self.attributes[:sub_model]
+        end
+        
         ########################################################
         #   Methods returning information about the elements   #
         ########################################################
@@ -906,6 +1016,7 @@ module Spider; module Model
         # Mixin!
         def self.get_storage(storage_string='default')
             storage_regexp = /([\w\d]+?):(.+)/
+            orig_string = nil
             if (storage_string !~ storage_regexp)
                 orig_string = storage_string
                 storage_conf = Spider.conf.get('storages')[storage_string]
@@ -916,6 +1027,7 @@ module Spider; module Model
             end
             type, url = $1, $2
             storage = Storage.get_storage(type, url)
+            storage.instance_name = orig_string
             storage.configure(storage_conf) if storage_conf
             return storage
         end
@@ -955,6 +1067,17 @@ module Spider; module Model
             return mapper
         end
 
+        # Syncs the schema with the storage.
+        def self.sync_schema(options={})
+            options = ({
+                :force => false,
+                :drop_fields => false,
+                :update_sequences => false,
+                :no_foreign_key_constraints => true
+            }).merge(options)
+            Spider::Model.sync_schema(self, options[:force], options)
+        end
+
         # Executes #self.where, and calls QuerySet#load on the result.
         # Returns nil if the result is empty, the QuerySet otherwise
         # See #self.where for parameter syntax
@@ -1039,15 +1162,24 @@ module Spider; module Model
             @_has_values = false
             @loaded_elements = {}
             @modified_elements = {}
-            @value_observers = {}
-            @all_values_observers = []
+            @value_observers = nil
+            @all_values_observers = nil
             @_extra = {}
             @model = self.class
-            @all_values_observers << Proc.new do |element, new_value|
-                @_has_values = true
-                Spider::Model.unit_of_work.add(self) if (Spider::Model.unit_of_work)
-            end
+            @_primary_keys_set = false
             set_values(values) if values
+            # if primary_keys_set?
+            #     @_primary_keys_set = true
+            #     if Spider::Model.identity_mapper
+            #         Spider::Model.identity_mapper.put(self, true)
+            #     else
+            #         Spider::Model.unit_of_work.add(self) if Spider::Model.unit_of_work
+            #     end
+            # else
+            #     #nil
+            # end
+                
+            
         end
         
         # Returns an instance of the Model with #autoload set to false
@@ -1058,6 +1190,29 @@ module Spider; module Model
             return obj
         end
         
+        def self.create(values)
+            obj = self.static(values)
+            obj.insert
+            return obj
+        end
+        
+        def self.get(values)
+            return self.new(values) unless Spider::Model.identity_mapper
+            values = [values] unless values.is_a?(Hash) || values.is_a?(Array)
+            if values.is_a?(Array)
+                vals = {}
+                self.primary_keys.each_with_index do |k, i|
+                    vals[k.name] = values[i]
+                end
+                values = vals
+            end
+            curr = Spider::Model.identity_mapper.get(self, values)
+            return curr if curr
+            obj = self.new(values)
+            Spider::Model.identity_mapper.put(obj)
+            obj
+        end
+        
         def set_values(values)
             if (values.is_a? Hash)
                 values.keys.select{ |k| 
@@ -1107,7 +1262,10 @@ module Spider; module Model
                     val.autoload = autoload?
                 end
             end
-            return prepare_child(name, val)
+            val = prepare_child(name, val)
+            instance_variable_set("@#{name}", val)
+            set_reverse(element, val) if element.model?
+            val
         end
         
         # Prepares an object that is being set as a child.
@@ -1126,7 +1284,9 @@ module Spider; module Model
                                 }
                                 obj = qs
                             elsif (!element.attributes[:keep_junction] && obj.model == element.model)
+                                instance_variable_set("@#{element.name}_junction", obj)
                                 qs = QuerySet.new(element.type, obj.map{ |el_obj| el_obj.get(element.attributes[:junction_their_element])})
+
                                 obj = qs
                             end 
                         end
@@ -1151,6 +1311,9 @@ module Spider; module Model
                     # FIXME: is it always ok to not set the element as modified? But otherwise sub objects
                     # are always saved (and that's definitely no good)
                 end
+                if element.type == self.class.superclass && self.class.extended_models[element.type] && self.class.extended_models[element.type] == element.name
+                    obj._subclass_object = self
+                end
             else
                 obj = prepare_value(element, obj)
             end
@@ -1178,6 +1341,17 @@ module Spider; module Model
             @_parent_element = element
         end
         
+        def set_reverse(element, obj)
+            return unless element.model? && obj
+            if element.has_single_reverse? && (!element.attributes[:junction] || element.attributes[:keep_junction])
+                unless element.multiple?
+                    val = obj.get_no_load(element.reverse)
+                    return if val && val.object_id == self.object_id
+                end
+                obj.set(element.reverse, self)
+            end
+        end
+        
         
         #################################################
         #   Get and set                                 #
@@ -1188,7 +1362,7 @@ module Spider; module Model
         # Will call the associated getter.
         #   cat.get('favorite_food.name')
         def get(element)
-            element = element.name if (element.class == Spider::Model::Element)
+            element = element.name if element.is_a?(Element)
             first, rest = element.to_s.split('.', 2)
             if (rest)
                 sub_val = send(first)
@@ -1212,7 +1386,7 @@ module Spider; module Model
         # Will call the associated setter.
         #   cat.set('favorite_food.name', 'Salmon')
         def set(element, value, options={})
-            element = element.name if (element.class == Element)
+            element = element.name if element.is_a?(Element)
             first, rest = element.to_s.split('.', 2)
             if (rest)
                 first_val = send(first)
@@ -1264,7 +1438,7 @@ module Spider; module Model
         
         # Prepares a value going to be set on the object. Will convert the value to the
         # appropriate type.
-        def prepare_value(element, value)
+        def self.prepare_value(element, value)
             element = self.class.elements[element] unless element.is_a?(Element)
             if (element.type < Spider::DataType)
                 value = element.type.from_value(value) unless value.is_a?(element.type)
@@ -1305,8 +1479,12 @@ module Spider; module Model
             value
         end
         
+        def prepare_value(element, value)
+            self.class.prepare_value(element, value)
+        end
+        
         # Sets a value without calling the associated setter; used by the mapper.
-        def set_loaded_value(element, value)
+        def set_loaded_value(element, value, mark_loaded=true)
             element_name = element.is_a?(Element) ? element.name : element
             element = self.class.elements[element_name]
             if (element.integrated?)
@@ -1315,22 +1493,24 @@ module Spider; module Model
                 value = prepare_child(element.name, value)
                 current = instance_variable_get("@#{element_name}")
                 current.set_parent(nil, nil) if current && current.is_a?(BaseModel)
+                value.set_parent(self, element.name) if value.is_a?(BaseModel)
                 instance_variable_set("@#{element_name}", value)
             end
             value.loaded = true if (value.is_a?(QuerySet))
-            element_loaded(element_name)
+            element_loaded(element_name) if mark_loaded
+            set_reverse(element, value) if element.model?
             @modified_elements[element_name] = false
         end
         
         # Records that the element has been loaded.
         def element_loaded(element_name)
-            element_name = element_name.name if (element_name.class == Element)
+            element_name = self.class.get_element(element_name).name
             @loaded_elements[element_name] = true
         end
         
         # Returns true if the element has been loaded by the mapper.
         def element_loaded?(element)
-            element = element.name if (element.class == Element)
+            element = self.class.get_element(element).name
             return @loaded_elements[element]
         end        
 
@@ -1341,7 +1521,7 @@ module Spider; module Model
         # Will raise a Model::FormatError when a check is not succesful.
         # If the :check attribute is an Hash, the Hash keys will be used as messages, which will be passed
         # to the FormatError.
-        def check(name, val)
+        def _check(name, val)
             element = self.class.elements[name]
             element.type.check(val) if (element.type.respond_to?(:check))
             if (checks = element.attributes[:check])
@@ -1360,10 +1540,19 @@ module Spider; module Model
         
         # Converts the object to the instance of a subclass for which this model is polymorphic.
         def polymorphic_become(model)
-            raise ModelException, "#{self.class} is not polymorphic for #{model}" unless self.class.polymorphic_models[model]
-            obj = model.new
+            return self if self.is_a?(model)
+            unless self.class.polymorphic_models && self.class.polymorphic_models[model]
+                sup = model.superclass
+                while sup < Spider::Model::BaseModel && !self.class.polymorphic_models[sup]
+                    sup = sup.superclass
+                end
+                raise ModelException, "#{self.class} is not polymorphic for #{model}" unless self.class.polymorphic_models[sup]
+                sup_poly = polymorphic_become(sup)
+                return sup_poly.polymorphic_become(model)
+            end
             el = self.class.polymorphic_models[model][:through]
-            obj.set(el, self)
+            obj = model.new(el => self)
+            obj = Spider::Model.identity_mapper.get(obj) if Spider::Model.identity_mapper
             obj.element_loaded(el)
             return obj
         end
@@ -1406,7 +1595,8 @@ module Spider; module Model
             @_tmp_autoload_walk = true
             @_autoload = a
             if (traverse)
-                self.class.elements_array.select{ |el| el.model? && element_has_value?(el.name)}.each do |el|
+                self.class.elements_array.select{ |el| el.model? && \
+                    (element_has_value?(el.name) || el.attributes[:extended_model])}.each do |el|
                     val = get(el)
                     val.autoload = a if val.respond_to?(:autoload=)
                 end
@@ -1475,7 +1665,8 @@ module Spider; module Model
         # Returns an array of current primary key values
         def primary_keys
             self.class.primary_keys.map{ |k|
-                k.model? ? get(k).primary_keys : get(k)
+                val = get(k)
+                k.model? && val ? val.primary_keys : val
             }
         end
         
@@ -1498,8 +1689,7 @@ module Spider; module Model
         # FIXME: should probably try to get away without this method
         # it is the only method that relies on the mapper
         def element_has_value?(element)
-            element_name = (element.is_a?(Element)) ? element.name : element
-            element = self.class.elements[element_name]
+            element = self.class.get_element(element)
             if (element.integrated?)
                 return false unless obj = instance_variable_get(:"@#{element.integrated_from.name}")
                 return obj.element_has_value?(element.integrated_from_element)
@@ -1508,8 +1698,9 @@ module Spider; module Model
                 element.attributes[:computed_from].each{ |el| return false unless element_has_value?(el) }
                 return true
             end
-            ivar = instance_variable_get(:"@#{element_name}")
-            return ivar == nil ? false : true
+            ivar = nil
+            ivar = instance_variable_get(:"@#{element.name}") if instance_variable_defined?(:"@#{element.name}")
+            return nil == ivar ? false : true
             # FIXME: is this needed?
             # if (!mapper.mapped?(element)
             #     return send("#{element_name}?") if (respond_to?("#{element_name}?"))
@@ -1519,7 +1710,7 @@ module Spider; module Model
 
         # Returns true if the element value has been modified since instantiating or loading
         def element_modified?(element)
-            element = element.is_a?(Element) ? element : self.class.elements[element]
+            element = self.class.get_element(element)
             set_mod = @modified_elements[element.name]
             return set_mod if set_mod
             if (element.integrated?)
@@ -1534,6 +1725,7 @@ module Spider; module Model
         
         # Returns true if any of elements has been modified
         def elements_modified?(*elements)
+            elements = elements[0] if elements[0].is_a?(Array)
             elements.each{ |el| return true if element_modified?(el) }
             return false
         end
@@ -1592,18 +1784,31 @@ module Spider; module Model
             return @_has_values
         end
         
-        # Sets all values of obj on the current object, cloning them if possible
-        def merge!(obj)
+        # Sets all values of obj on the current object
+        def merge!(obj, only=nil)
+            return self if obj.object_id == self.object_id
             obj.class.elements_array.select{ |el| 
-                obj.element_has_value?(el) && !el.integrated? && !el.attributes[:computed_from]
+                (only || obj.element_has_value?(el)) && !el.integrated? && !el.attributes[:computed_from]
             }.each do |el|
-                val = obj.get(el)
-                if (!val.is_a?(BaseModel) && val.respond_to?(:clone))
-                    begin; val = val.clone; rescue TypeError; end;
+                next if only && !only.key?(el.name)
+                val = obj.element_has_value?(el.name) ? obj.get_no_load(el) : nil
+                our_val = self.element_has_value?(el.name) ? self.get_no_load(el) : nil
+                next if our_val == val
+                if el.model? && only && only[el.name].is_a?(Hash) && our_val \
+                    && val.is_a?(BaseModel) && our_val.is_a?(BaseModel)
+                    val = our_val.merge!(val, only[el.name])                    
+                else
+                    Spider.logger.warn("Element #{el.name} overwritten in #{obj.inspect}") if our_val && our_val != val
                 end
-                set_loaded_value(el, val)
+                set_loaded_value(el, val, false) unless val.nil? && element.multiple?
+            end
+            self
+        end
+        
+        def merge_hash(h)
+            h.each do |k, v|
+                self.set(k.to_sym, v)
             end
-            @loaded_elements.merge!(obj.loaded_elements)
         end
         
         # Returns a deep copy of the object
@@ -1615,15 +1820,23 @@ module Spider; module Model
         
         # Returns a new instance with the same primary keys
         def get_new
-            obj = self.class.new
-            self.class.primary_keys.each{ |k| obj.set(k, self.get(k)) }
+            obj = nil
+            Spider::Model.no_identity_mapper do
+                obj = self.class.new
+                obj._no_identity_mapper = true
+                self.class.primary_keys.each{ |k| obj.set(k, self.get(k)) }
+            end
             return obj
         end
         
         # Returns a new static instance with the same primary keys
         def get_new_static
-            obj = self.class.static
-            self.class.primary_keys.each{ |k| obj.set(k, self.get(k)) }
+            obj = nil
+            Spider::Model.no_identity_mapper do
+                obj = self.class.static
+                obj._no_identity_mapper = true
+                self.class.primary_keys.each{ |k| obj.set(k, self.get(k)) }
+            end
             return obj
         end
         
@@ -1652,16 +1865,18 @@ module Spider; module Model
         #   obj.observe_all_values do |instance, element_name, old_val|
         #     puts "#{element_name} for object #{instance} has changed from #{old_val} to #{instance.get(element_name) }"
         def observe_all_values(&proc)
+            @all_values_observers ||= []
             @all_values_observers << proc
         end
         
         def observe_element(element_name, &proc)
+            @value_observers ||= {}
             @value_observers[element_name] ||= []
             @value_observers[element_name] << proc
         end
         
         def self.observer_all_values(&proc)
-            @all_values_observers << proc
+            self.all_values_observers << proc
         end
         
         def self.observe_element(element_name, &proc)
@@ -1680,9 +1895,23 @@ module Spider; module Model
         
         # Calls the observers for element_name
         def notify_observers(element_name, new_val) #:nodoc:
-            (self.class.value_observers[element_name].to_a + @value_observers[element_name].to_a) \
-                .each { |proc| proc.call(self, element_name, new_val) }
-            (self.class.all_values_observers.to_a + @all_values_observers.to_a).each { |proc| proc.call(self, element_name, new_val) }
+            if @value_observers && @value_observers[element_name]
+                @value_observers[element_name].each{ |proc| proc.call(self, element_name, new_val) }
+            end
+            if @all_values_observers
+                @all_values_observers.each{ |proc| proc.call(self, element_name, new_val) }
+            end
+            self.class.notify_observers(element_name, new_val, self)
+        end
+        
+        # Calls the observers for element_name
+        def self.notify_observers(element_name, new_val, obj=nil)
+            if @value_observers && @value_observers[element_name]
+                @value_observers[element_name].each{ |proc| proc.call(obj, element_name, new_val) }
+            end
+            if @all_values_observers
+                @all_values_observers.each{ |proc| proc.call(obj, element_name, new_val) }
+            end
         end
         
         
@@ -1708,6 +1937,7 @@ module Spider; module Model
         
         # Returns the current mapper, or instantiates a new one (base on the current storage, if set)
         def mapper
+            @storage ||= nil
             if (@storage)
                 @mapper ||= self.class.get_mapper(@storage)
             else
@@ -1728,8 +1958,33 @@ module Spider; module Model
         # Saves the object to the storage
         # (see Mapper#save)
         def save
+            if @unit_of_work
+                @unit_of_work.add(self)
+                return
+            end
+            save_mode do
+                before_save unless unit_of_work_available?
+                if unit_of_work_available?
+                    Spider.current[:unit_of_work].add(self)
+                    if @unit_of_work
+                        @unit_of_work.commit
+                        Spider::Model.stop_unit_of_work
+                        if @uow_identity_mapper
+                            Spider.current[:identity_mapper] = nil
+                            @uow_identity_mapper = nil
+                        end
+                        @unit_of_work = nil
+                    end
+                    return
+                else
+                    save!
+                end
+            end
+            self
+        end
+                
+        def save!
             mapper.save(self)
-            reset_modified_elements
             self
         end
         
@@ -1740,11 +1995,41 @@ module Spider; module Model
             self
         end
         
+        def insert
+            if @unit_of_work
+                @unit_of_work.add(self)
+                return
+            end
+            save_mode do
+                before_save unless unit_of_work_available?
+                if unit_of_work_available?
+                    Spider.current[:unit_of_work].add(self, :save, :force => :insert)
+                    if @unit_of_work
+                        @unit_of_work.commit
+                        Spider::Model.stop_unit_of_work
+                        if @uow_identity_mapper
+                            Spider.current[:identity_mapper] = nil
+                            @uow_identity_mapper = nil
+                        end
+                        @unit_of_work = nil
+                    end
+                    return
+                else
+                    insert!
+                end
+            end
+            self
+        end
+        
+        def unit_of_work_available?
+            Spider.current[:unit_of_work] && !Spider.current[:unit_of_work].running?
+        end
+        
         # Inserts the object in the storage
         # Note: if the object is already present in the storage and unique indexes are enforced,
         # this will raise an error.
         # (See Mapper#insert).
-        def insert
+        def insert!
             mapper.insert(self)
             reset_modified_elements
         end
@@ -1760,9 +2045,54 @@ module Spider; module Model
         # Deletes the object from the storage
         # (see Mapper#delete).
         def delete
+            if @unit_of_work
+                @unit_of_work.add(self, :delete)
+                return
+            end
+            before_delete unless Spider.current[:unit_of_work]
+            if Spider.current[:unit_of_work]
+                Spider.current[:unit_of_work].add(self, :delete)
+                if @unit_of_work
+                    @unit_of_work.commit
+                    @unit_of_work.stop
+                    if @uow_identity_mapper
+                        Spider.current[:identity_mapper] = nil
+                        @uow_identity_mapper = nil
+                    end
+                    @unit_of_work = nil
+                end
+                return
+            else
+                delete!
+            end
+        end
+        
+        def delete!
             mapper.delete(self)
         end
         
+        def before_delete
+        end
+        
+        def before_save
+        end
+        
+        def use_unit_of_work
+            had_uow = true
+            unless Spider.current[:unit_of_work]
+                had_wow = false
+                @unit_of_work = Spider::Model.start_unit_of_work
+            end
+            unless Spider::Model.identity_mapper
+                @uow_identity_mapper = Spider::Model::IdentityMapper.new
+                Spider.current[:identity_mapper] = @uow_identity_mapper
+                @uow_identity_mapper.put(self) if self.primary_keys_set?
+            end
+#            Spider.current[:unit_of_work].add(self)
+            Spider.current[:unit_of_work]
+            return had_uow
+        end
+        
         # Loads the object from the storage
         # Acceptable arguments are:
         # * a Query object, or
@@ -1841,15 +2171,43 @@ module Spider; module Model
                     end
                 end
             end
-            super
+            raise NoMethodError, "undefined method `#{method}' for #{self.class}"
+            #super
             # end
         end
         
+        def respond_to?(symbol, include_private=false)
+            return true if super
+            if (self.class.attributes[:integrated_models])
+                self.class.attributes[:integrated_models].each do |model, name|
+                    if (model.method_defined?(symbol))
+                        return true
+                    end
+                end
+            end
+            return false
+        end
+        
         # Returns a descriptive string for the object.
         # By default this method returns the value of the first String element, if any; otherwise,
         # the string representation of the first element of any type.
         # Descendant classes may well provide a better representation.
         def to_s
+            desc_elements = self.class.elements_array.select{ |el| el.attributes[:desc] }
+            unless desc_elements.empty?
+                return desc_elements.sort{ |a, b| 
+                    ad = a.attributes[:desc]; bd = b.attributes[:desc]
+                    if ad == true && bd == true
+                        0
+                    elsif bd == true
+                        -1
+                    elsif ad == true
+                        1
+                    else
+                        ad <=> bd
+                    end
+                }.map{ |el| self.get(el).to_s }.join(' ')
+            end
             self.class.each_element do |el|
                 if ((el.type == String || el.type == Text) && !el.primary_key?)
                     v = get(el)
@@ -1986,6 +2344,7 @@ module Spider; module Model
             end
             Spider::Model.with_identity_mapper do |im|
                 where.keys.each do |name|
+                    next unless where[name]
                     if (where[name].is_a?(Proc))
                         val = where[name].call(self, name)
                     else
@@ -2016,9 +2375,12 @@ module Spider; module Model
         
         # Returns a yaml representation of the object. Will try to autoload all elements, unless autoload is false;
         # foreign keys will be expressed as an array if multiple, as a single primary key value otherwise
-        def to_yaml(params)
+        def to_yaml(params={})
             require 'yaml'
-            #return YAML::dump(self)
+            return YAML::dump(to_yaml_h(params))
+        end
+        
+        def to_yaml_h(params={})
             h = {}
             def obj_pks(obj, klass)
                 unless obj
@@ -2028,12 +2390,15 @@ module Spider; module Model
                 return pks[0] if pks.length == 1
                 return pks
             end 
+
             self.class.elements_array.each do |el|
                 next if params[:except] && params[:except].include?(el.name)
                 if (el.model?)
                     obj = get(el)
-                    if (el.multiple?)
-                        h[el.name] = obj.map_array{ |o| obj_pks(o, el.model) }
+                    if !obj
+                       h[el.name] = nil 
+                    elsif (el.multiple?)
+                        h[el.name] = obj.map{ |o| obj_pks(o, el.model) }
                     else
                         h[el.name] = obj_pks(obj, el.model)
                     end
@@ -2041,7 +2406,7 @@ module Spider; module Model
                     h[el.name] = get(el)
                 end
             end
-            return YAML::dump(h)
+            h
         end
         
         def self.from_yaml(yaml)
@@ -2062,8 +2427,73 @@ module Spider; module Model
             return obj
         end
         
-        def self.transaction
+        def dump_to_hash
+            h = {}
+            def obj_pks(obj, klass)
+                unless obj
+                    return klass.primary_keys.length > 1 ? [] : nil
+                end
+                pks = obj.primary_keys
+                return pks[0] if pks.length == 1
+                return pks
+            end 
+
+            self.class.elements_array.each do |el|
+                next unless mapper.have_references?(el) || (el.junction? && el.model.attributes[:sub_model] == self.class)
+                if (el.model?)
+                    obj = get(el)
+                    if !obj
+                       h[el.name] = nil 
+                    elsif (el.multiple?)
+                        h[el.name] = obj.map{ |o| obj_pks(o, el.model) }
+                    else
+                        h[el.name] = obj_pks(obj, el.model)
+                    end
+                else
+                    val = get(el)
+                    if val
+                        case val.class.name.to_sym
+                        when :Date, :DateTime, :Time
+                            val = val.strftime
+                        end
+                    end
+                    h[el.name] = val
+                end
+            end
+            h
+        end
+        
+        def dump_to_all_data_hash(options={}, h={}, seen={})
+            Spider::Model.with_identity_mapper do |im|
+                clname = self.class.name.to_sym
+                seen[clname] ||= {}
+                return if seen[clname][self.primary_keys]
+                seen[clname][self.primary_keys] = true
+                h[clname] ||= []
+                h[clname] << self.dump_to_hash
+                self.class.elements_array.each do |el|
+                    next unless el.model?
+                    next if el.model < Spider::Model::InlineModel
+                    next if options[:models] && !options[:models].include?(el.type)
+                    next if options[:except_models] && options[:except_models].include?(el.type)
+                    el_clname == el.type.name.to_sym
+                    next if options[:elements] && (options[:elements][el_clname] && !options[:elements][el_clname].include?(el.name))
+                    next if options[:except_elements] && (options[:except_elements][el_clname] && options[:except_elements][el_clname].include?(el.name))
+                    val = self.get(el)
+                    next unless val
+                    val = [val] unless val.is_a?(Enumerable)
+                    val.each do |v|
+                        v.dump_to_all_data_hash(options, h, seen)
+                    end
+                end
+            end
+            h
+        end
+        
+        def self.in_transaction
+            self.storage.in_transaction
             yield
+            self.storage.commit_or_continue
         end
         
         def self.dump_element(el)