spiderfw 0.5.10 → 0.5.11

data/lib/spiderfw/create.rb

@@ -39,6 +39,15 @@ module Spider
             raise RuntimeError, "Folder #{dest_path} already exists" if File.exist?(dest_path)
             FileUtils.mkdir_p(dest_path)
             erb_binding ||= binding
+            if File.exists?("#{source_path}/.dirs")
+                File.readlines("#{source_path}/.dirs").each do |dir|
+                    dir.strip!
+                    replacements.each do |search, replace|
+                        dir.gsub!(search, replace)
+                    end
+                    FileUtils.mkdir_p(dest_path+'/'+dir)
+                end
+            end
             Find.find(source_path) do |sp|
                 next if sp == source_path
                 sp =~ /\/([^\/]+)$/
@@ -49,7 +58,7 @@ module Spider
                     dp.gsub!(search, replace)
                 end
                 if (File.directory?(sp))
-                    FileUtils.mkdir(dest_path+'/'+dp)
+                    FileUtils.mkdir(dest_path+'/'+dp) unless File.directory?(dest_path+'/'+dp)
                 else
                     dst = File.new(dest_path+'/'+dp, 'w')
                     res = ERB.new(IO.read(sp)).result(erb_binding)

data/lib/spiderfw/model/base_model.rb

@@ -93,6 +93,10 @@ module Spider; module Model
             subclass.instance_variable_set("@extended_models", @extended_models.clone) if @extended_models
         end
         
+        def self.subclasses
+            @subclasses || []
+        end
+        
         # Returns the parent Spider::App of the module
         def self.app
             return @app if @app
@@ -103,12 +107,6 @@ module Spider; module Model
             @app = app
         end
         
-        # Returns an instance of the Model with #autoload set to false
-        def self.static(value=nil)
-            obj = self.new(value)
-            obj.autoload = false
-            return obj
-        end
         
         #######################################
         #   Model definition methods          #
@@ -163,6 +161,8 @@ module Spider; module Model
         # :computed_from::            (array of symbols) the element is not mapped; its value is computed
         #                             by the class from the given elements.
         # :unmapped::                 (bool) the element is not mapped.
+        # :sortable::                 (bool or Array of symbols) specifies that an unmapped element can be used for sorting.
+        #                             The model must provide a meaningful order using the prepare_query method.
         # :check::                    (a Proc, or a Regexp, or a Hash of messages => Regexp|Proc). See #check
         # :through::                  (a BaseModel subclass) model representing the many to many relationship.
         # :read_only::                (bool) hint to the UI that the element should not be user modifiable.
@@ -170,6 +170,8 @@ module Spider; module Model
         # :condition::                (hash or Condition) Restricts an association always adding the condition.
         # :order::                    (true or Fixnum) When doing queries, sort by this element. More than one element can have the
         #                             :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.
         # 
         # Other attributes may be used by DataTypes (see #DataType::ClassMethods.take_attributes), and other code.
         # See also Element.
@@ -210,6 +212,10 @@ module Spider; module Model
             if (attributes[:condition] && !attributes[:condition].is_a?(Condition))
                 attributes[:condition] = Condition.new(attributes[:condition])
             end
+            if attributes[:computed_from] && !attributes[:computed_from].is_a?(Enumerable)
+                attributes[:computed_from] = [attributes[:computed_from]]
+            end
+            type.set_element_attributes(attributes) if type < Spider::DataType
 
 
             orig_type = type
@@ -220,7 +226,7 @@ module Spider; module Model
                (attributes[:has_single_reverse] == false || !attributes[:reverse] ||  (!type.elements[attributes[:reverse]] || type.elements[attributes[:reverse]].multiple?))))
                 attributes[:anonymous_model] = true
                 attributes[:owned] = true unless attributes[:owned] != nil
-                first_model = self.first_definer(name)
+                first_model = self.first_definer(name, type)
                 assoc_type_name = Spider::Inflector.camelize(name)
                 create_junction = true
                 if (attributes[:through])
@@ -266,6 +272,10 @@ module Spider; module Model
                 orig_type.referenced_by_junctions << [assoc_type, other_name]
                 attributes[:keep_junction] = true if (attributes[:through] && attributes[:keep_junction] != false)
                 attributes[:association_type] = assoc_type
+                if attributes[:polymorph]
+                    assoc_type.elements[attributes[:junction_their_element]].attributes[:polymorph] = attributes[:polymorph]
+                    attributes.delete(:polymorph)
+                end
             end
             
             @elements[name] = Element.new(name, type, attributes)
@@ -282,8 +292,14 @@ module Spider; module Model
                     attributes[:reverse] ||= attributes[:add_reverse][:name]
                     rev = attributes[:add_reverse].merge(:reverse => name, :added_reverse => true, 
                         :delete_cascade => attributes[:reverse_delete_cascade])
-                    rev[:through] = assoc_type if assoc_type
                     rev_name = rev.delete(:name)
+                    if assoc_type
+                        rev[:junction] = true
+                        rev[:keep_junction] = false
+                        rev[:through] = assoc_type
+                        rev[:junction_their_element] = self_name
+                        rev[:junction_our_element] = other_name
+                    end
                     orig_type.element(rev_name, self, rev)
                 end
             elsif (attributes[:add_multiple_reverse])
@@ -293,6 +309,7 @@ module Spider; module Model
                         :added_reverse => true, :delete_cascade => attributes[:reverse_delete_cascade])
                     rev_name = rev.delete(:name)
                     if assoc_type
+                        rev[:junction] = true
                         rev[:through] = assoc_type
                         rev[:junction_their_element] = self_name
                         rev[:junction_our_element] = other_name
@@ -304,7 +321,7 @@ module Spider; module Model
                 # if attributes[:primary_key]
                 #                     attributes[:lazy] = true
                 #                 els
-                if (type < BaseModel && attributes[:multiple])
+                if (type < BaseModel && (attributes[:multiple] || attributes[:polymorph]))
                     # FIXME: we can load eagerly single relations if we can do a join
                     attributes[:lazy] = true
                 else
@@ -370,9 +387,18 @@ module Spider; module Model
                 if !val && element.model? && (element.multiple? || element.attributes[:extended_model])
                     val = instance_variable_set(ivar, instantiate_element(name))
                 end
+                if !val && element.attributes[:default]
+                    if element.attributes[:default].is_a?(Proc)
+                        val = element.attributes[:default].call(self)
+                    else
+                        val = element.attributes[:default]
+                    end
+                end
                 val.set_parent(self, name) if element.model? && val && !val._parent # FIXME!!!
                 return val
             end
+            
+            alias_method :"#{name}?", name if type <= Spider::DataTypes::Bool
 
             #instance_variable_setter
             element_methods.send(:define_method, "#{name}=") do |val|
@@ -634,9 +660,7 @@ module Spider; module Model
                 pk_name = @elements[:id] ? :"id_#{self.short_name.downcase}" : :id
                 element(pk_name, Fixnum, :autoincrement => true, :local_pk => true, :hidden => true)
             end
-            if (params[:add_polymorphic])
-                model.polymorphic(self, :through => integrated_name)
-            end
+            model.polymorphic(self, :through => integrated_name)
         end
         
         # Externalizes the superclass elements making the superclass an external integrated element.
@@ -644,7 +668,6 @@ module Spider; module Model
         # * :name               (symbol) name of the created element
         # * :delete_cascade     (bool) delete cascade the superclass instance
         # * :no_local_pk        (bool) do not define an id for this class
-        # * :add_polymorphic    (bool) notify the superclass that it is extended, making polymorphic queries possible
         def self.class_table_inheritance(params={})
             self.extend_model(superclass, params)
         end
@@ -757,6 +780,10 @@ module Spider; module Model
             _(@label_plural || self.name || '')
         end
         
+        def self.auto_primary_keys?
+            self.primary_keys.select{ |k| !k.autogenerated? }.empty?
+        end
+        
         ########################################################
         #   Methods returning information about the elements   #
         ########################################################
@@ -791,13 +818,13 @@ module Spider; module Model
         
         # Returns the model actually defining element_name; that could be the model
         # itself, a superclass, or an integrated model.
-        def self.first_definer(element_name)
-            if (@extended_models && @extended_models[self.superclass] && self.superclass.elements[element_name])
-                return self.superclass.first_definer(element_name)
+        def self.first_definer(element_name, type)
+            if (@extended_models && @extended_models[self.superclass] && self.superclass.elements[element_name] && self.superclass.elements[element_name].type == type)
+                return self.superclass.first_definer(element_name, type)
             end
             if (self.attributes[:integrated_models])
                 self.attributes[:integrated_models].keys.each do |mod|
-                    return mod.first_definer(element_name) if (mod.elements[element_name])
+                    return mod.first_definer(element_name, type) if (mod.elements[element_name] && mod.elements[element_name].type == type)
                 end
             end
             return self
@@ -939,7 +966,9 @@ module Spider; module Model
         # Executes #self.where, returning the first result.
         # See #self.where for parameter syntax.
         def self.load(*params, &proc)
-            return self.where(*params, &proc)[0]
+            qs = self.where(*params, &proc)
+            qs.limit = 1
+            return qs[0]
         end
         
         # Returns a queryset without conditions
@@ -1018,31 +1047,41 @@ module Spider; module Model
                 @_has_values = true
                 Spider::Model.unit_of_work.add(self) if (Spider::Model.unit_of_work)
             end
-            if (values)
-                if (values.is_a? Hash)
-                    values.keys.select{ |k| 
-                        k = k.name if k.is_a?(Element)
-                        self.class.elements[k.to_sym] && self.class.elements[k.to_sym].primary_key? 
-                    }.each do |k|
-                        set!(k, values[k])
-                    end
-                    values.each do |key, val|
-                        set!(key, val)
-                    end
-                elsif (values.is_a? BaseModel)
-                    values.each_val do |name, val|
-                        set(name, val) if self.class.has_element?(name)
-                    end
-                elsif (values.is_a? Array)
-                    self.class.primary_keys.each_index do |i|
-                        set(self.class.primary_keys[i], values[i])
-                    end
-                 # Single unset key, single value
-                elsif ((empty_keys = self.class.primary_keys.select{ |key| !element_has_value?(key) }).length == 1)
-                    set(empty_keys[0], values)
-                else
-                    raise ArgumentError, "Don't know how to construct a #{self.class} from #{values.inspect}"
+            set_values(values) if values
+        end
+        
+        # Returns an instance of the Model with #autoload set to false
+        def self.static(values=nil)
+            obj = self.new
+            obj.autoload = false
+            obj.set_values(values) if values
+            return obj
+        end
+        
+        def set_values(values)
+            if (values.is_a? Hash)
+                values.keys.select{ |k| 
+                    k = k.name if k.is_a?(Element)
+                    self.class.elements[k.to_sym] && self.class.elements[k.to_sym].primary_key? 
+                }.each do |k|
+                    set!(k, values[k])
+                end
+                values.each do |key, val|
+                    set!(key, val)
+                end
+            elsif (values.is_a? BaseModel)
+                values.each_val do |name, val|
+                    set(name, val) if self.class.has_element?(name)
                 end
+            elsif (values.is_a? Array)
+                self.class.primary_keys.each_index do |i|
+                    set(self.class.primary_keys[i], values[i])
+                end
+             # Single unset key, single value
+            elsif ((empty_keys = self.class.primary_keys.select{ |key| !element_has_value?(key) }).length == 1)
+                set(empty_keys[0], values)
+            else
+                raise ArgumentError, "Don't know how to construct a #{self.class} from #{values.inspect}"
             end
         end
         
@@ -1067,7 +1106,7 @@ module Spider; module Model
                     val = element.type.new
                     val.autoload = autoload?
                 end
-            end       
+            end
             return prepare_child(name, val)
         end
         
@@ -1077,18 +1116,24 @@ module Spider; module Model
             element = self.class.elements[name]
             if (element.model?)
                 # convert between junction and real type if needed
-                if (obj.is_a?(QuerySet) && element.attributes[:junction])
-                    obj.no_autoload do
-                        if (element.attributes[:keep_junction] && obj.model == element.type)
-                            qs = QuerySet.new(element.model)
-                            obj.each{ |el_obj| 
-                                qs << {element.reverse => self, element.attributes[:junction_their_element] => el_obj}
-                            }
-                            obj = qs
-                        elsif (!element.attributes[:keep_junction] && obj.model == element.model)
-                            qs = QuerySet.new(element.type, obj.map{ |el_obj| el_obj.get(element.attributes[:junction_their_element])})
-                            obj = qs
-                        end 
+                if element.attributes[:junction]
+                    if obj.is_a?(QuerySet) 
+                        obj.no_autoload do
+                            if (element.attributes[:keep_junction] && obj.model == element.type)
+                                qs = QuerySet.new(element.model)
+                                obj.each{ |el_obj| 
+                                    qs << {element.reverse => self, element.attributes[:junction_their_element] => el_obj}
+                                }
+                                obj = qs
+                            elsif (!element.attributes[:keep_junction] && obj.model == element.model)
+                                qs = QuerySet.new(element.type, obj.map{ |el_obj| el_obj.get(element.attributes[:junction_their_element])})
+                                obj = qs
+                            end 
+                        end
+                    else
+                        if (!element.attributes[:keep_junction] && obj.class == element.model)
+                            obj = obj.get(element.attributes[:junction_their_element])
+                        end
                     end
                 end
                 self.class.elements_array.select{ |el| el.attributes[:fixed] }.each do |el|
@@ -1268,6 +1313,8 @@ module Spider; module Model
                 get(element.integrated_from).set_loaded_value(element.integrated_from_element, value)
             else
                 value = prepare_child(element.name, value)
+                current = instance_variable_get("@#{element_name}")
+                current.set_parent(nil, nil) if current && current.is_a?(BaseModel)
                 instance_variable_set("@#{element_name}", value)
             end
             value.loaded = true if (value.is_a?(QuerySet))
@@ -1333,8 +1380,8 @@ module Spider; module Model
         # not contain all of the current model's elements.
         def subclass(model)
             obj = model.new
-            elements_array.each do |el|
-                obj.set(el, self.get(el)) if element_has_value?(el)
+            self.class.elements_array.each do |el|
+                obj.set(el, self.get(el)) if element_has_value?(el) && model.elements[el.name]
             end
             return obj
         end

data/lib/spiderfw/model/condition.rb

@@ -294,7 +294,11 @@ module Spider; module Model
         
         # True if there are no comparisons and no subconditions.
         def empty?
-            return super && @subconditions.empty?
+            return false unless super
+            @subconditions.each do |sub|
+                return false unless sub.empty?
+            end
+            return true
         end
         
         alias :hash_replace :replace  # :nodoc:
@@ -390,6 +394,10 @@ module Spider; module Model
             return ConditionElement.new(name, @condition_context)
         end
         
+        def id
+            return ConditionElement.new(:id, @condition_context)
+        end
+        
         def AND(&proc)
             @condition_context = []
             instance_eval(&proc)

data/lib/spiderfw/model/data_type.rb

@@ -45,6 +45,21 @@ module Spider
                 end
             end
             
+            # Tells the class that this type generates the element's value automatically
+            def autogenerated
+                @autogenerated = true
+            end
+            
+            # Returns whether the given element is autogenerated
+            def auto?(element)
+                @autogenerated && element.attributes[:auto]
+            end
+            
+            # Is called by the BaseModel when creating an element of this type. Can modify the element's attributes.
+            def set_element_attributes(attributes)
+                attributes[:auto] = true unless attributes[:auto] == false
+            end
+            
         end
         
         # Returns the DataType attributes, as set in the Model Element.

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

@@ -6,6 +6,7 @@ module Spider; module DataTypes
 
     class UUID < String
         include DataType
+        autogenerated
         
         def map(mapper_type)
             self.to_s
@@ -22,6 +23,10 @@ module Spider; module DataTypes
         def self.generate
             UUIDTools::UUID.random_create.to_s
         end
+        
+        def self.auto_value
+            generate
+        end
 
     end
     

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

@@ -18,8 +18,8 @@ module Spider; module Model
             :read_only => true, 
             :element_position => 0
         }
-        element :obj_created, DateTime, :hidden => true
-        element :obj_modified, DateTime, :hidden => true
+        element :obj_created, DateTime, :label => _('Created'), :hidden => true
+        element :obj_modified, DateTime, :label => _('Modified'), :hidden => true
         
 
         def assign_id(val) #:nodoc:

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

@@ -86,8 +86,10 @@ module Spider; module Model; module Mappers
                 @model.each_element do |element|
                     next if !mapped?(element) || element.integrated?
                     next if save_mode == :update && !obj.element_modified?(element)
-                    if (save_mode == :insert && element.attributes[:autoincrement] && !schema.attributes(element.name)[:autoincrement])
-                        obj.set(element.name, @storage.sequence_next(schema.sequence(element.name)))
+                    if (save_mode == :insert)
+                        if element.attributes[:autoincrement] && !schema.attributes(element.name)[:autoincrement]
+                            obj.set(element.name, @storage.sequence_next(schema.sequence(element.name)))
+                        end
                     end
                     if (!element.multiple?)
                         next if (save_mode == :update && element.primary_key?)
@@ -332,9 +334,9 @@ module Spider; module Model; module Mappers
                 next if !element || !element.type || element.integrated?
                 if !element.model?
                     field = schema.field(el)
+                    primary_keys << field if model_pks.include?(el)
                     unless seen_fields[field.name]
                         keys << field
-                        primary_keys << field if model_pks.include?(el)
                         seen_fields[field.name] = true
                     end
                 elsif !element.attributes[:junction]
@@ -342,9 +344,9 @@ module Spider; module Model; module Mappers
                         element.model.primary_keys.each do |key|
                             field = schema.foreign_key_field(el, key.name)
                             raise "Can't find a foreign key field for key #{key.name} of element #{el} of model #{@model}" unless field
+                            primary_keys << field if model_pks.include?(el)
                             unless seen_fields[field.name]
                                 keys << field
-                                primary_keys << field if model_pks.include?(el)
                                 seen_fields[field.name] = true
                             end
                         end
@@ -409,7 +411,7 @@ module Spider; module Model; module Mappers
             return {
                 :query_type => :select,
                 :keys => keys,
-                :primary_keys => primary_keys,
+                :primary_keys => primary_keys.uniq,
                 :tables => tables,
                 :condition => condition,
                 :joins => joins,
@@ -480,24 +482,40 @@ module Spider; module Model; module Mappers
             cond[:conj] = condition.conjunction.to_s
             cond[:values] = []
             
-            # find out which elements have non nil conditions to figure out joins
-            def get_not_nil(model, condition, not_nil)
-                condition.all_each_with_comparison do |k, v, comp|
+
+            
+            def get_join_info(model, condition)
+                join_info = {}
+                condition.each_with_comparison do |k, v, comp|
                     next unless k.respond_to?(:to_sym)
                     element = model.elements[k.to_sym]
                     next unless element
                     next unless model.mapper.mapped?(element)
                     next unless element.model?
-                    not_nil[k] = {} if !v.nil? || comp != '='
-                    get_not_nil(element.model, v, not_nil[k]) if v.is_a?(Condition)
+                    join_info[k.to_s] = true if !v.nil? || comp != '='
+                    if v.is_a?(Spider::Model::Condition)
+                        el_join_info = get_join_info(element.model, v) 
+                        el_join_info.each do |jk, jv|
+                            join_info["#{k}.#{jk}"] = jv
+                        end
+                    end
                 end
+                condition.subconditions.each do |sub_cond|
+                    sub_join_info = get_join_info(model, sub_cond)
+                    if condition.conjunction == :or
+                        join_info.each_key do |k|
+                            join_info.delete(k) unless sub_join_info[k]
+                        end
+                    else
+                        join_info.merge!(sub_join_info)
+                    end
+                end
+                join_info
             end
             
-            not_nil = options[:not_nil]
-            unless not_nil
-                not_nil = {}
-                get_not_nil(@model, condition, not_nil)
-            end
+            join_info = options[:join_info]
+            join_info ||= get_join_info(@model, condition)
+
                         
             condition.each_with_comparison do |k, v, comp|
                 if k.is_a?(QueryFuncs::Function)
@@ -509,6 +527,12 @@ module Spider; module Model; module Mappers
                 element = model.elements[k.to_sym]
                 next unless model.mapper.mapped?(element)
                 if (element.model?)
+                    el_join_info = {}
+                    join_info.each do |jk, jv|
+                        if jk.index(k.to_s+'.') == 0
+                            el_join_info[jk[k.to_s.length..-1]] = jv
+                        end
+                    end
                     if (v && model.mapper.have_references?(element.name) && v.select{ |key, value| 
                         !element.model.elements[key] || !element.model.elements[key].primary_key? }.empty?)
                         # 1/n <-> 1 with only primary keys
@@ -523,7 +547,7 @@ module Spider; module Model; module Mappers
                         cond[:values] << element_cond
                     else
                         if (element.storage == model.mapper.storage)
-                            join_type = (v.nil? && comp == '=') ? :left : :inner
+                            join_type = join_info[element.name.to_s] ? :inner : :left
                             sub_join = model.mapper.get_join(element, join_type)
                             # FIXME! cleanup, and apply the check to joins acquired in other places, too (maybe pass the current joins to get_join)
                             existent = joins.select{ |j| j[:to] == sub_join[:to] }
@@ -542,25 +566,26 @@ module Spider; module Model; module Mappers
                             sub_join[:as] = "#{sub_join[:to]}#{j_cnt}" if j_cnt
                             joins << sub_join unless had_join
                             
-                            if v.nil? && comp == '=' && !not_nil[element.name]
+                            if v.nil? && comp == '='
+                                el_model_schema = model_schema
                                 element_cond = {:conj => 'AND', :values => []}
                                     if model.mapper.have_references?(element.name)
                                     el_name = element.name
                                     el_model = element.model
                                 else
                                     el_model = element.type
-                                    model_schema = element.model.mapper.schema 
+                                    el_model_schema = element.model.mapper.schema 
                                     el_name = element.attributes[:junction_their_element]
                                 end
                                 el_model.primary_keys.each do |k|
-                                    field = model_schema.qualified_foreign_key_field(el_name, k.name)
+                                    field = el_model_schema.qualified_foreign_key_field(el_name, k.name)
                                     field_cond = [field, comp,  map_condition_value(element.model.elements[k.name].type, nil)]
                                     element_cond[:values] << field_cond
                                 end
                                 cond[:values] << element_cond
                             elsif v
                                 v = element.model.mapper.preprocess_condition(v)                          
-                                sub_condition, sub_joins = element.mapper.prepare_condition(v, :table => sub_join[:as], :joins => joins, :not_nil => not_nil[element.name])
+                                sub_condition, sub_joins = element.mapper.prepare_condition(v, :table => sub_join[:as], :joins => joins, :join_info => el_join_info)
                                 sub_condition[:table] = sub_join[:as] if sub_join[:as]
                                 joins = sub_joins
                                 cond[:values] << sub_condition
@@ -587,7 +612,7 @@ module Spider; module Model; module Mappers
             sub_sqls = []
             sub_bind_values = []
             condition.subconditions.each do |sub|
-                sub_res = self.prepare_condition(sub, :joins => joins, :not_nil => not_nil)
+                sub_res = self.prepare_condition(sub, :joins => joins, :join_info => join_info)
                 cond[:values] << sub_res[0]
                 joins = sub_res[1]
                 remaining_condition += sub_res[2]