spiderfw 0.5.19 → 0.6.0

data/lib/spiderfw/model/base_model.rb

@@ -1,6 +1,7 @@
 require 'spiderfw/model/mixins/state_machine'
 require 'spiderfw/model/element'
 require 'spiderfw/model/integrated_element'
+require 'spiderfw/model/junction'
 require 'iconv'
 
 module Spider; module Model
@@ -73,6 +74,9 @@ module Spider; module Model
         attr_accessor :_subclass_object
         # This object won't be put into the identity mapper
         attr_accessor :_no_identity_mapper
+        # Elements that were modified since a load or a save (note: this only keeps track of changed references on the object;
+        # it doesn't consider if a associated object or QuerySet has changed. Use element_modified? to get that information)
+        attr_reader :_modified_elements
         
         class <<self
             # An Hash of model attributes. They can be used freely.
@@ -185,7 +189,7 @@ module Spider; module Model
         #                             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 
+        #                             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.
@@ -230,6 +234,7 @@ module Spider; module Model
             if attributes[:computed_from] && !attributes[:computed_from].is_a?(Enumerable)
                 attributes[:computed_from] = [attributes[:computed_from]]
             end
+            attributes[:embedded] = true if attributes[:owned] && attributes[:embedded].nil?
             type.set_element_attributes(attributes) if type < Spider::DataType
 
 
@@ -274,11 +279,13 @@ module Spider; module Model
                     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, :junction_reference => true) # FIXME: must check if reverse exists?
+                    embedder = attributes[:junction_embedded] == false ? false : true
+                    assoc_type.element(attributes[:junction_id], Spider::DataTypes::PK, :primary_key => true, :autoincrement => true, :hidden => true) if attributes[:junction_id]
+                    assoc_type.element(self_name, self, :hidden => true, :reverse => name, :association => :choice, :junction_reference => true, :embedder => embedder) # FIXME: must check if reverse exists?
                     # FIXME! fix in case of clashes with existent elements
-                    assoc_type.element(other_name, orig_type, :association => :choice, :junction_reference => true)
+                    assoc_type.element(other_name, orig_type, :association => :choice, :junction_reference => true, :embedded => attributes[:embedded])
                     assoc_type.integrate(other_name, :hidden => true, :no_pks => true) # FIXME: in some cases we want the integrated elements
+                    assoc_type.send(:include, Spider::Model::Junction)
                     if (proc)                                   #        to be hidden, but the integrated el instead
                         attributes[:extended] = true
                         attributes[:keep_junction] = true
@@ -292,6 +299,7 @@ module Spider; module Model
                     assoc_type.elements[attributes[:junction_their_element]].attributes[:polymorph] = attributes[:polymorph]
                     attributes.delete(:polymorph)
                 end
+                attributes[:embedded] = true unless attributes[:junction_embedded] == false
             end
             
             
@@ -318,6 +326,9 @@ module Spider; module Model
                         rev[:junction_their_element] = self_name
                         rev[:junction_our_element] = other_name
                     end
+                    if attributes[:embedded] && !attributes[:junction]
+                        rev[:embedder] = true
+                    end
                     orig_type.element(rev_name, self, rev)
                 end
             elsif (attributes[:add_multiple_reverse])
@@ -370,7 +381,8 @@ module Spider; module Model
             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]
+                    imod.integrate_element(iel, self.elements[name]) unless imod.elements[name] || 
+                        (self.elements[name].reverse == iel && self.elements[name].type == imod)
                 end
             end
             if (@subclasses)
@@ -399,7 +411,7 @@ module Spider; module Model
             element_methods = self.const_get(:ElementMethods)
 
             #instance variable getter
-            element_methods.send(:define_method, name) do
+            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]
@@ -461,7 +473,7 @@ module Spider; module Model
                         get(element.integrated_from).merge!(integrated_obj)
                     end
                     if !element.primary_key? && integrated_obj.element_modified?(name)
-                        @modified_elements[name] = true
+                        @_modified_elements[name] = true
                     end
                     return res
                 end
@@ -498,7 +510,7 @@ module Spider; module Model
                     end
                 end
                 old_val = instance_variable_get(ivar)
-                @modified_elements[name] = true if !element.primary_key? && (!was_loaded || val != old_val)
+                @_modified_elements[name] = true if !element.primary_key? && (!was_loaded || val != old_val)
                 instance_variable_set(ivar, val)
                 set_reverse(element, val) if element.model?
                 if val && element.model? && !self.class.attributes[:no_type_check]
@@ -542,6 +554,7 @@ module Spider; module Model
             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
+            @extended_models.delete(element.type) if element && @extended_models && @extended_models[element.type] == el
             @elements.delete(el)
             @elements_order.delete(el)
             @primary_keys.delete_if{ |pk| pk.name == el}
@@ -591,6 +604,7 @@ module Spider; module Model
             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
+                next if el.reverse == element_name && el.type == self
                 integrate_element(element_name, el, params)
             end
             model.attributes[:integrated_from_elements] ||= []
@@ -599,6 +613,7 @@ module Spider; module Model
         
         def self.integrate_element(element_name, element_element, params={})
             el = element_element
+            el = self.elements[element_name].model.elements[el] if el.is_a?(Symbol)
             integrated_attributes = {}
             integrated_attributes[:primary_key] = false if params[:no_pks]
             integrated_attributes[:hidden] = params[:hidden] unless (params[:hidden].nil?)
@@ -739,9 +754,10 @@ module Spider; module Model
             @extended_models ||= {}
             @extended_models[model] = integrated_name
             attributes = {}
-            attributes[:hidden] = true unless (params[:hide_integrated] == false)
+            attributes[:hidden] = true unless params[:hide_integrated] == false
             attributes[:delete_cascade] = params[:delete_cascade]
             attributes[:extended_model] = true
+            attributes[:embedded] = true unless params[:embedded] == false
             attributes[:add_reverse] = params[:reverse]
             integrated = element(integrated_name, model, attributes)
             integrate_options = {:keep_pks => true}.merge((params[:integrate_options] || {}))
@@ -762,7 +778,6 @@ module Spider; module Model
         # * :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
         
@@ -897,6 +912,22 @@ module Spider; module Model
             !!self.attributes[:sub_model]
         end
         
+        def self.not_embeddable
+            @embeddable = false
+        end
+        
+        def self.embeddable?
+            @embeddable.nil? ? true : @embeddable
+        end
+        
+        def self.only_embedded
+            @only_embedded = true
+        end
+        
+        def self.only_embedded?
+            @only_embedded
+        end
+        
         ########################################################
         #   Methods returning information about the elements   #
         ########################################################
@@ -995,6 +1026,8 @@ module Spider; module Model
         # Sets the url or the name of the storage to use
         def self.use_storage(name=nil)
             @use_storage = name if name
+            @use_storage ||= self.attributes[:sub_model].use_storage if self.attributes[:sub_model]
+            @use_storage ||= self.superclass.use_storage if self.superclass.respond_to?(:use_storage) && self.superclass.use_storage
             @use_storage
         end
         
@@ -1002,10 +1035,8 @@ module Spider; module Model
         # The storage to use can be set with #use_storage
         def self.storage
             return @storage if @storage
-            if (!@use_storage && self.attributes[:sub_model])
-                @use_storage = self.attributes[:sub_model].use_storage
-            end
-            return @use_storage ? get_storage(@use_storage) : get_storage
+            st = self.use_storage
+            return st ? get_storage(st) : get_storage
         end
         
         # Returns an instancethe storage corresponding to the storage_string if it is given, 
@@ -1148,7 +1179,7 @@ module Spider; module Model
             @_autoload = true
             @_has_values = false
             @loaded_elements = {}
-            @modified_elements = {}
+            @_modified_elements = {}
             @value_observers = nil
             @all_values_observers = nil
             @_extra = {}
@@ -1183,6 +1214,10 @@ module Spider; module Model
             return obj
         end
         
+        def self.load_or_create(values)
+            self.load(values) || self.create(values)
+        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)
@@ -1339,6 +1374,11 @@ module Spider; module Model
             end
         end
         
+        # Returns the object's embedder element, if any
+        def embedder
+            self.class.elements_array.select{ |el| el.attributes[:embedder] && self.element_has_value?(el) }[0]
+        end
+        
         
         #################################################
         #   Get and set                                 #
@@ -1427,7 +1467,7 @@ module Spider; module Model
         # appropriate type.
         def self.prepare_value(element, value)
             element = self.class.elements[element] unless element.is_a?(Element)
-            if (element.type < Spider::DataType)
+            if element.type < Spider::DataType && element.type.force_wrap?
                 value = element.type.from_value(value) unless value.is_a?(element.type)
                 if value
                     element.type.take_attributes.each do |a|
@@ -1442,7 +1482,9 @@ module Spider; module Model
             elsif element.model?
                 value.autoload(autoload?, true) if value && value.respond_to?(:autolad)
             else
-                case element.type.name
+                type = element.type
+                type = mapper.base_type(type) if type < Spider::DataType && type.mapper_dependant?
+                case type.name
                 when 'Date', 'DateTime'
                     return nil if value.is_a?(String) && value.empty?
                     parsed = nil
@@ -1474,8 +1516,9 @@ module Spider; module Model
         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?)
-                get(element.integrated_from).set_loaded_value(element.integrated_from_element, value)
+            if element.integrated?
+                integrated = get(element.integrated_from)
+                integrated.set_loaded_value(element.integrated_from_element, value) if integrated
             else
                 value = prepare_child(element.name, value)
                 current = instance_variable_get("@#{element_name}")
@@ -1485,8 +1528,8 @@ module Spider; module Model
             end
             value.loaded = true if (value.is_a?(QuerySet))
             element_loaded(element_name) if mark_loaded
-            set_reverse(element, value) if element.model?
-            @modified_elements[element_name] = false
+            set_reverse(element, value) if element.model? && value
+            @_modified_elements[element_name] = false
         end
         
         # Records that the element has been loaded.
@@ -1608,7 +1651,7 @@ module Spider; module Model
         # If a block is given, the current autoload setting will be restored after yielding.
         def save_mode
             prev_autoload = autoload?
-            self.autoload = :save_mode
+            self.autoload = :save_mode unless prev_autoload == false
             if (block_given?)
                 yield
                 self.autoload = prev_autoload
@@ -1631,6 +1674,13 @@ module Spider; module Model
             return true
         end
         
+        # Like ==, but other must be of the same class (no subclasses)
+        def eql?(other)
+            return false unless other.class == self.class
+            return self == other
+        end
+        
+        
         ##############################################################
         #   Iterators                                                #
         ##############################################################
@@ -1666,7 +1716,16 @@ module Spider; module Model
         
         # Returns a string with the primary keys joined by ','
         def keys_string
-            self.class.primary_keys.map{ |pk| self.get(pk) }.join(',')
+            self.class.keys_string(self.primary_keys)
+        end
+        
+        
+        def self.keys_string(keys)
+            keys.join(',')
+        end
+        
+        def self.split_keys_string(string)
+            string.split(',')
         end
 
             
@@ -1698,9 +1757,9 @@ module Spider; module Model
         # Returns true if the element value has been modified since instantiating or loading
         def element_modified?(element)
             element = self.class.get_element(element)
-            set_mod = @modified_elements[element.name]
+            set_mod = @_modified_elements[element.name]
             return set_mod if set_mod
-            if (element.integrated?)
+            if element.integrated?
                 return false unless integrated = get_no_load(element.integrated_from)
                 return integrated.element_modified?(element.integrated_from_element)
             end
@@ -1719,9 +1778,9 @@ module Spider; module Model
         
         # Returns true if any element, or any child object, has been modified
         def modified?
-            return true unless @modified_elements.reject{ |key, val| !val }.empty?
+            return true unless @_modified_elements.reject{ |key, val| !val }.empty?
             self.class.elements_array.select{ |el| 
-                !el.model? && element_has_value?(el) && el.type.is_a?(Spider::DataType)
+                element_has_value?(el) && (el.type.is_a?(Spider::DataType) || el.multiple?)
             }.each do |el|
                 return true if get(el).modified?
             end
@@ -1735,18 +1794,30 @@ module Spider; module Model
         
         # Given elements are set as modified
         def set_modified(request) #:nodoc:
+            request = {request => true} unless request.is_a?(Hash)
             request.each do |key, val| # FIXME: go deep
-                @modified_elements[key] = true
+                key = key.name if key.is_a?(Element)
+                @_modified_elements[key] = true
             end
         end
         
         # Resets modified elements
         def reset_modified_elements(*elements) #:nodoc:
             if (elements.length > 0)
-                elements.each{ |el_name| @modified_elements.delete(el_name) }
+                elements.each{ |el_name| @_modified_elements.delete(el_name) }
             else
-                @modified_elements = {}
+                @_modified_elements = {}
+            end
+            elements = self.class.elements_array.map{ |el| el.name } if elements.empty?
+            elements.each do |el_name|
+                val = instance_variable_get("@#{el_name}")
+                val.modified = false if val.is_a?(QuerySet)
             end
+            self.class.elements_array.select{ |el| el.attributes[:integrated_model] && self.element_has_value?(el) }.each do |el|
+                self.get(el).reset_modified_elements(elements)
+            end
+
+            nil
         end
         
         # Returns true if all primary keys have a value; false if some primary key
@@ -1787,7 +1858,7 @@ module Spider; module Model
                 else
                     Spider.logger.warn("Element #{el.name} overwritten in #{obj.inspect}") if our_val && our_val != val
                 end
-                set_loaded_value(el, val, false) unless val.nil? && element.multiple?
+                set_loaded_value(el, val, false) # unless val.nil? && element.multiple?
             end
             self
         end
@@ -1945,33 +2016,16 @@ 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
+            saving(:save) do
+                before_save
+                save!
             end
             self
         end
                 
         def save!
             mapper.save(self)
+            after_save
             self
         end
         
@@ -1983,79 +2037,54 @@ module Spider; module Model
         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
+            saving(:insert) do
+                before_save
+                insert!
             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!
             mapper.insert(self)
-            reset_modified_elements
+            after_save
         end
         
         # Updates the object in the storage
         # Note: the update will silently fail if the object is not present in the storage
         # (see Mapper#update).
         def update
+            saving(:update) do
+                before_save
+                update!
+            end
+        end
+        
+        def update!
             mapper.update(self)
-            reset_modified_elements
+            after_save
         end
         
+        def unit_of_work_available?
+            Spider.current[:unit_of_work] && !Spider.current[:unit_of_work].running?
+        end
+        
+
         # 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
+            saving(:delete) do
+                before_delete
                 delete!
             end
         end
         
         def delete!
             mapper.delete(self)
+            after_delete
         end
         
         def before_delete
@@ -2064,22 +2093,24 @@ module Spider; module Model
         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
+        def after_save
+            reset_modified_elements
+            autoload(@_saving[:prev_autoload]) if @_saving
+            @_saving = nil
         end
         
+        def after_delete
+        end
+        
+        def saving(mode, &proc)
+            @_saving ||= { :prev_autoload => save_mode }
+            if unit_of_work_available?
+                Spider.current[:unit_of_work].add(self, mode)
+            else
+                yield
+            end
+        end
+                
         # Loads the object from the storage
         # Acceptable arguments are:
         # * a Query object, or

data/lib/spiderfw/model/data_type.rb

@@ -60,6 +60,21 @@ module Spider
                 attributes[:auto] = true if @autogenerated && attributes[:auto] != false
             end
             
+            # Returns whether values need to be wrapped in this DataType when they are set on models instances.
+            def force_wrap?
+                true
+            end
+            
+            # Indicates that the actual type of this DataType depends on the mapper (e.g. PK)
+            def mapper_dependant
+                @mapper_dependant = true
+            end
+
+            # Returns whether this DataTypes is mapper dependant
+            def mapper_dependant?
+                @mapper_dependant
+            end
+            
         end
         
         # Returns the DataType attributes, as set in the Model Element.

data/lib/spiderfw/model/datatypes/decimal.rb

@@ -30,6 +30,14 @@ module Spider; module DataTypes
             to_f
         end
         
+        def to_json(options=nil)
+            to_f.to_json
+        end
+        
+        def attributes
+            {:scale => 2}.merge(super)
+        end
+        
 
 
     end

data/lib/spiderfw/model/datatypes/pk.rb

@@ -0,0 +1,29 @@
+require 'delegate'
+
+module Spider; module DataTypes
+    
+    class PK < Delegator
+        include DataType
+        mapper_dependant
+        
+        def initialize(obj)
+            @delegate_sd_obj = obj
+        end
+        
+        def __getobj__
+            @delegate_sd_obj
+        end
+        alias :obj :__getobj__
+
+        def __setobj__(obj)
+            @delegate_sd_obj = obj
+        end
+        
+        def self.force_wrap?
+            false
+        end
+
+        
+    end
+    
+end; end

data/lib/spiderfw/model/datatypes.rb

@@ -1,4 +1,5 @@
 require 'spiderfw/model/data_type'
+require 'spiderfw/model/datatypes/pk'
 require 'spiderfw/model/datatypes/bool'
 require 'spiderfw/model/datatypes/text'
 require 'spiderfw/model/datatypes/decimal'

data/lib/spiderfw/model/element.rb

@@ -104,7 +104,7 @@ module Spider; module Model
             self.attributes[:reverse]
         end
         
-        # True if the element has a reverse, and it is not multiple (i.e., the relationship is 1 <-> 1|n)
+        # True if the element has a reverse, and that reverse is not multiple
         def has_single_reverse?
             return true if self.attributes[:reverse] && !model.elements[self.attributes[:reverse]].multiple?
         end
@@ -129,6 +129,10 @@ module Spider; module Model
             self.attributes[:owned]
         end
         
+        def embedded?
+            self.attributes[:embedded]
+        end
+        
         # True if the element is generated on save by the model or the mapper.
         def autogenerated?
             return (self.attributes[:auto] || self.attributes[:autoincrement])

data/lib/spiderfw/model/extended_models/managed.rb

@@ -12,7 +12,7 @@ module Spider; module Model
     # Other modules may be mixed-in to add default functionality to managed models.
     
     class Managed < BaseModel
-        element :id, Fixnum, {
+        element :id, PK, {
             :primary_key => true, 
             :autoincrement => true, 
             :read_only => true, 

data/lib/spiderfw/model/junction.rb

@@ -0,0 +1,23 @@
+module Spider; module Model
+    
+    module Junction
+        
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+        
+        module ClassMethods
+            
+            def has_added_elements?
+                junction_added_elements.length > 0
+            end
+            
+            def junction_added_elements
+                self.elements_array.select{ |el| !el.integrated? && !el.attributes[:junction_id] && !el.attributes[:junction_reference] }
+            end
+            
+        end
+        
+    end
+    
+end; end