spiderfw 0.5.7 → 0.5.9

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

@@ -8,13 +8,25 @@ module Spider; module DataTypes
     class Decimal < BigDecimal
         include DataType
 
-        maps_back_to superclass
+        #maps_back_to superclass
         
         take_attributes :scale
         
-        def set(value)
-            @val = BigDecimal.new(value.to_s).round(attributes[:scale] || 2)
+        def self.from_value(value)
+            return nil if value.nil?
+            super(value.to_s)
         end
+        
+        def prepare
+            self.class.from_value(self.round(attributes[:scale] || 2))
+        end
+        
+        def to_s(s=nil)
+            s ||= "#{attributes[:scale]}F"
+            super(s)
+        end
+        
+
 
     end
     

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

@@ -0,0 +1,50 @@
+require 'pathname'
+
+module Spider; module DataTypes
+    
+    class FilePath < ::Pathname
+        include DataType
+        maps_to String
+        
+        take_attributes :base_path, :uploadable
+        
+        def self.from_value(value)
+            return nil if value.to_s.empty?
+            super
+        end
+        
+        def map(mapper_type)
+            val = nil
+            if attributes[:base_path]
+                begin
+                    val = self.relative_path_from(Pathname.new(attributes[:base_path]))
+                rescue ArgumentError
+                    val = self
+                end
+            else
+                val = self
+            end
+            val.to_s
+        end
+        
+        def prepare
+            if attributes[:base_path]
+                self.new(Pathname.new(attributes[:base_path]) + self)
+            else
+                self
+            end
+        end
+        
+        def format(format_type = :normal)
+            return super unless attributes[:base_path]
+            if format_type == :long || format_type == :full
+                self.to_s
+            else
+                self.relative_path_from(Pathname.new(attributes[:base_path])).to_s
+            end
+        end
+        
+        
+    end
+    
+end; end

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

@@ -22,10 +22,6 @@ module Spider; module DataTypes
             YAML::dump(self)
         end
         
-        def map_back(mapper_type, val)
-            YAML::load(val).extend(SerializedMixin)
-        end
-        
     end
     
     

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

@@ -1,4 +1,4 @@
-require "uuid"
+require "uuidtools"
 
 module Spider; module DataTypes
 
@@ -12,7 +12,7 @@ module Spider; module DataTypes
         end
         
         # format :short returns just the first part
-        def format(type)
+        def format(type = :normal)
             if (type == :short)
                 return self.to_s.split('-')[0]
             end
@@ -20,7 +20,7 @@ module Spider; module DataTypes
         end
         
         def self.generate
-            ::UUID.new.generate
+            UUIDTools::UUID.random_create.to_s
         end
 
     end

data/lib/spiderfw/model/datatypes.rb

@@ -6,6 +6,7 @@ require 'spiderfw/model/datatypes/binary'
 require 'spiderfw/model/datatypes/password'
 require 'spiderfw/model/datatypes/uuid'
 require 'spiderfw/model/datatypes/serialized_object'
+require 'spiderfw/model/datatypes/file_path'
 
 
 module Spider

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

@@ -30,10 +30,19 @@ module Spider; module Model
             true
         end
         
+        def _set_dates(bool=nil)
+            @_set_dates = true if @_set_dates == nil
+            @_set_dates = bool if bool != nil
+            @_set_dates
+        end
+        
+        
         with_mapper do
             def before_save(obj, mode)
-                obj.obj_created = DateTime.now if mode == :insert
-                obj.obj_modified = DateTime.now if obj.modified?
+                if obj._set_dates
+                    obj.obj_created = DateTime.now if mode == :insert
+                    obj.obj_modified = DateTime.now if obj.modified?
+                end
                 super
             end
         end

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

@@ -39,7 +39,7 @@ module Spider; module Model; module Mappers
         end            
         
         def save_all(root) #:nodoc:
-            @storage.start_transaction if @storage.supports_transactions?
+            @storage.start_transaction
             super
             @storage.commit
         end
@@ -80,7 +80,7 @@ module Spider; module Model; module Mappers
         end
         
         # Save preprocessing
-        def prepare_save(obj, save_mode, request=nil) #:nodoc:
+        def prepare_save(obj, save_mode) #:nodoc:
             values = {}
             obj.no_autoload do
                 @model.each_element do |element|
@@ -105,6 +105,7 @@ module Spider; module Model; module Mappers
                                     key_value = element_val.get(key.name)
                                 end
                                 store_key = schema.foreign_key_field(element.name, key.name)
+                                next if store_key.is_a?(FieldExpression)
                                 values[store_key] = map_save_value(key_type, key_value, save_mode)
                             end
                         else
@@ -330,15 +331,15 @@ module Spider; module Model; module Mappers
             elements.each do |el|
                 element = @model.elements[el.to_sym]
                 next if !element || !element.type || element.integrated?
-                if (!element.model?)
+                if !element.model?
                     field = schema.field(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])
-                    if (schema.has_foreign_fields?(el))
+                elsif !element.attributes[:junction]
+                    if schema.has_foreign_fields?(el)
                         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
@@ -423,18 +424,37 @@ module Spider; module Model; module Mappers
         # FIXME: document
         def prepare_joins(joins) # :nodoc:
             h = {}
+            left_joins = []
             joins.each do |join|
                 h[join[:from]] ||= {}
                 cur = (h[join[:from]][join[:to]] ||= [])
                 has_join = false
                 cur.each do |cur_join|
                     if (cur_join[:keys] == join[:keys] && cur_join[:conditions] == join[:conditions])
+                        cur_join[:type] = :left if join[:type] == :left
                         has_join = true
                         break
                     end
                 end
+                left_joins << join if join[:type] == :left
                 h[join[:from]][join[:to]] << join unless has_join
             end
+            while left_joins.length > 0
+                new_left_joins = []
+                left_joins.each do |lj|
+                    if h[lj[:to]]
+                        h[lj[:to]].each_key do |to|
+                            h[lj[:to]][to].each do |j|
+                                unless j[:type] == :left
+                                    new_left_joins << j
+                                    j[:type] = :left
+                                end
+                            end
+                        end
+                    end
+                end
+                left_joins = new_left_joins
+            end
             return h
         end
         
@@ -454,11 +474,12 @@ module Spider; module Model; module Mappers
             # FIXME: move to mapper
             model = condition.polymorph ? condition.polymorph : @model
             model_schema = model.mapper.schema
+            cond = {}
             # debugger if condition.polymorph
             condition.each_with_comparison do |k, v, comp|
                 # normalize condition values
                 element = model.elements[k.to_sym]
-                if (!v.is_a?(Condition) && element.model?)
+                if (v && !v.is_a?(Condition) && element.model?)
                     condition.delete(element.name)
                     def set_pks_condition(condition, el, val, prefix)
                         el.model.primary_keys.each do |primary_key|
@@ -469,20 +490,19 @@ module Spider; module Model; module Mappers
                                     condition.set(new_prefix, '=', val.get(primary_key).get(primary_key.model.primary_keys[0]))
                                 else
                                     # FIXME! does not work, the subcondition does not get processed
-                                    raise "Subonditions on multiple key elements not supported yet"
-                                    set_pks_condition(condition,  primary_key, val.get(primary_key), new_prefix)
+                                    raise "Subconditions on multiple key elements not supported yet"
+                                    subcond = Condition.new
+                                    set_pks_condition(subcond,  primary_key, val.get(primary_key), new_prefix)
+                                    condition << subcond
                                 end
                             else
                                 condition.set(new_prefix, '=', val.get(primary_key))
                             end
                         end
                     end
-                    if (v.is_a?(BaseModel))
+                    if v.is_a?(BaseModel)
                         set_pks_condition(condition, element, v, element.name)
-                        # element.model.primary_keys.each do |primary_key|
-                        #                             condition.set("#{element.name}.#{primary_key.name}", '=', v.get(primary_key))
-                        #                         end
-                    elsif (element.model.primary_keys.length == 1 )
+                    elsif element.model.primary_keys.length == 1 
                         new_v = Condition.new
                         if (model.mapper.have_references?(element.name))
                             new_v.set(element.model.primary_keys[0].name, comp, v)
@@ -496,18 +516,15 @@ module Spider; module Model; module Mappers
                 end
             end 
             bind_values = []
-            joins = []
-            cond = {}
+            joins = options[:joins] || []
             remaining_condition = Condition.new # TODO: implement
             cond[:conj] = condition.conjunction.to_s
             cond[:values] = []
-            # FIXME: the allow_left_joins hack will probably not work in the general case
-            cond[:allow_left_joins] = options[:allow_left_joins] || {}
             condition.each_with_comparison do |k, v, comp|
                 element = model.elements[k.to_sym]
                 next unless model.mapper.mapped?(element)
                 if (element.model?)
-                    if (model.mapper.have_references?(element.name) && v.select{ |key, value| !element.model.elements[key].primary_key? }.empty?)
+                    if (v && model.mapper.have_references?(element.name) && v.select{ |key, value| !element.model.elements[key].primary_key? }.empty?)
                         # 1/n <-> 1 with only primary keys
                         element_cond = {:conj => 'AND', :values => []}
                         v.each_with_comparison do |el_k, el_v, el_comp|
@@ -516,24 +533,49 @@ module Spider; module Model; module Mappers
                             op = el_comp
                             field_cond = [field, op,  map_condition_value(element.model.elements[el_k.to_sym].type, el_v)]
                             element_cond[:values] << field_cond
-                            if (el_v.nil? && el_comp == '=')
-                                cond[:allow_left_joins][element.model] = true
-                            end
                         end
                         cond[:values] << element_cond
                     else
                         if (element.storage == model.mapper.storage)
-                            join_type = cond[:allow_left_joins][element.model] ? :left : :inner
+                            if v.nil?
+                                join_type = comp == '=' ? :left : :inner
+                            else
+                                join_type = :inner
+                            end
                             sub_join = model.mapper.get_join(element, join_type)
-                            joins << sub_join
-                            element.model.mapper.prepare_query_condition(v)
+                            # 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] }
+                            j_cnt = nil
+                            had_join = false
+                            existent.each do |j|
+                                if sub_join[:to] == j[:to] && sub_join[:keys] == j[:keys] && sub_join[:conditions] == j[:conditions]
+                                    j[:type] = :left if sub_join[:type] == :left
+                                    sub_join = j
+                                    had_join = true
+                                    break
+                                else
+                                    j_cnt ||= 0; j_cnt += 1
+                                end
+                            end
+                            sub_join[:as] = "#{sub_join[:to]}#{j_cnt}" if j_cnt
+                            joins << sub_join unless had_join
                             
-                            sub_condition, sub_joins = element.mapper.prepare_condition(v, :table => sub_join[:as], :allow_left_joins => cond[:allow_left_joins])
-                            sub_condition[:table] = sub_join[:as] if sub_join[:as]
-                            joins += sub_joins
+                            if v.nil? && comp == '='
+                                element_cond = {:conj => 'AND', :values => []}
+                                element.model.primary_keys.each do |k|
+                                    field = model_schema.qualified_foreign_key_field(element.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
+                                element.model.mapper.prepare_query_condition(v)                            
+                                sub_condition, sub_joins = element.mapper.prepare_condition(v, :table => sub_join[:as], :joins => joins)
+                                sub_condition[:table] = sub_join[:as] if sub_join[:as]
+                                joins = sub_joins
+                                cond[:values] << sub_condition
+                            end
                             
-                            cond[:values] << sub_condition
-                            cond[:allow_left_joins].merge!(sub_condition[:allow_left_joins])
                         else
                            remaining_condition ||= Condition.new
                            remaining_condition.set(k, comp, v)
@@ -555,14 +597,14 @@ module Spider; module Model; module Mappers
             sub_sqls = []
             sub_bind_values = []
             condition.subconditions.each do |sub|
-                sub_res = self.prepare_condition(sub, :allow_left_joins => cond[:allow_left_joins])
+                sub_res = self.prepare_condition(sub, :joins => joins)
                 cond[:values] << sub_res[0]
-                joins += sub_res[1]
+                joins = sub_res[1]
                 remaining_condition += sub_res[2]
             end
             return [cond, joins, remaining_condition]
         end
-        
+
         # Figures out a join for element. Returns join hash description, i.e. :
         #   join = {
         #     :type => :inner|:outer|...,
@@ -587,7 +629,10 @@ module Spider; module Model; module Mappers
                     else
                         el_field = element.mapper.schema.field(key.name)
                     end
-                    keys[schema.foreign_key_field(element.name, key.name)] = el_field
+
+                    fk = schema.foreign_key_field(element.name, key.name)
+                    fk = fk.expression if fk.is_a?(FieldExpression)
+                    keys[fk] = el_field
                     # FIXME: works with models as primary keys through a hack in the field method of db_schema,
                     # assuming the model has only one key. the correct way would be to get another join
                 end
@@ -617,12 +662,13 @@ module Spider; module Model; module Mappers
                         our_field = schema.field(key.name)
                     end
                     keys[our_field] = element.mapper.schema.foreign_key_field(element.reverse, key.name)
+                    keys[our_field] = keys[our_field].expression if keys[our_field].is_a?(FieldExpression)
                 end
                 if (element.condition)
                     condition, condition_joins, condition_remaining = element.mapper.prepare_condition(element.condition)
                 end
                 join = {
-                    :type => :inner,
+                    :type => join_type,
                     :from => schema.table,
                     :to => element.mapper.schema.table,
                     :keys => keys,
@@ -654,7 +700,7 @@ module Spider; module Model; module Mappers
                     current_model = el.integrated_from.type
                     el = current_model.elements[el.integrated_from_element]
                 end
-                if (el.model?) # && can_join?(el)
+                if (el.model? && can_join?(el))
                     joins << current_model.mapper.get_join(el)
                     current_model = el.model
                 end
@@ -705,8 +751,14 @@ module Spider; module Model; module Mappers
                     el_joins, el_model, el = get_deep_join(order_element)
                     if (el.model?)
                         # FIXME: integrated elements
-                        el.model.primary_keys.each do |pk|
-                            fields << [el.model.mapper.schema.field(pk.name), direction]
+                        if !joins.empty?
+                            el.model.primary_keys.each do |pk|
+                                fields << [el.model.mapper.schema.field(pk.name), direction]
+                            end
+                        else
+                            el.model.primary_keys.each do |pk|
+                                fields << [schema.qualified_foreign_key_field(el.name, pk.name), direction]
+                            end
                         end
                     else
                         field = el_model.mapper.schema.field(el.name)
@@ -761,10 +813,14 @@ module Spider; module Model; module Mappers
             return @storage.value_for_condition(Model.simplify_type(type), value)
         end
 
+        def storage_value_to_mapper(type, value)
+            storage.value_to_mapper(type, value)
+        end
+
         # Converts a storage value back to the corresponding base type or DataType.
         def map_back_value(type, value)
             value = value[0] if value.class == Array
-            value = storage.value_to_mapper(Model.simplify_type(type), value)
+            value = storage_value_to_mapper(Model.simplify_type(type), value)
             if (type < Spider::DataType && type.maps_back_to)
                 type = type.maps_back_to
             end
@@ -872,6 +928,10 @@ module Spider; module Model; module Mappers
             return schema
         end
 
+        def storage_column_type(type, attributes)
+            @storage.column_type(type, attributes)
+        end
+
         # Autogenerates schema. Returns a DbSchema.
         def generate_schema(schema=nil)
             had_schema = schema ? true : false
@@ -901,7 +961,7 @@ module Spider; module Model; module Mappers
                             schema.set_sequence(element.name, @storage.sequence_name("#{schema.table}_#{element.name}"))
                         end
                     end
-                    column_type = element.attributes[:db_column_type] || @storage.column_type(storage_type, element.attributes)
+                    column_type = element.attributes[:db_column_type] || storage_column_type(storage_type, element.attributes)
                     unless column
                         column_name = element.attributes[:db_column_name] || @storage.column_name(element.name)
                         column = Field.new(schema.table, column_name, column_type)
@@ -1010,13 +1070,13 @@ module Spider; module Model; module Mappers
                 table_attributes = {
                     :primary_keys => table_schema[:attributes][:primary_keys]
                 }
-                unless options[:no_foreign_key_constraints]
+                unless options[:no_foreign_key_constraints] || !storage.supports?(:foreign_keys)
                     table_attributes[:foreign_key_constraints] = table_schema[:attributes][:foreign_key_constraints] || []
                 end
                 if @storage.table_exists?(table_name)
-                    alter_table(table_name, table_schema[:columns], table_attributes, force)
+                    alter_table(table_name, table_schema, table_attributes, force)
                 else
-                    create_table(table_name, table_schema[:columns], table_attributes)
+                    create_table(table_name, table_schema, table_attributes)
                 end
                 if (options[:drop_fields])
                     current = @storage.describe_table(table_name)[:columns]
@@ -1045,28 +1105,33 @@ module Spider; module Model; module Mappers
         end
 
         # Returns a create table structure description.
-        def create_table(table_name, fields, attributes) # :nodoc:
-            fields = fields.map{ |name, details| {
-              :name => name,
-              :type => details[:type],
-              :attributes => details[:attributes]  
-            } }
+        def create_table(table_name, schema, attributes) # :nodoc:
+            fields = schema[:fields_order].map do |f| 
+                details = schema[:columns][f.name]
+                {
+                    :name => f.name,
+                    :type => details[:type],
+                    :attributes => details[:attributes]  
+                }
+            end
             @storage.create_table({
                 :table => table_name,
                 :fields => fields,
-                :attributes => attributes,
+                :attributes => attributes
             })
         end
 
         # Returns an alter table structure description
-        def alter_table(name, fields, attributes, force=nil) # :nodoc:
+        def alter_table(name, schema, attributes, force=nil) # :nodoc:
             current = @storage.describe_table(name)
             current_fields = current[:columns]
             add_fields = []
             alter_fields = []
             all_fields = []
             unsafe = []
-            fields.each_key do |field|
+            fields = schema[:columns]
+            schema[:fields_order].each do |f|
+                field = f.name
                 field_hash = {
                     :name => field, 
                     :type => fields[field][:type], 
@@ -1131,7 +1196,6 @@ module Spider; module Model; module Mappers
     end
 
     # Error raised when a conversion results in a potential data loss.
-    
     class SchemaSyncUnsafeConversion < RuntimeError
         attr :fields
         def initialize(fields)

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

@@ -127,7 +127,9 @@ module Spider; module Model
                         obj.set(el, set_data)
                     end
                 end
-                raise RequiredError.new(el) if (el.required? && obj.element_modified?(el) && !obj.element_has_value?(el))
+                if (el.required? && (mode == :insert || obj.element_modified?(el)) && !obj.element_has_value?(el))
+                    raise RequiredError.new(el) 
+                end
                 if (el.unique? && !el.integrated? && obj.element_modified?(el))
                     existent = @model.where(el.name => obj.get(el))
                     if (mode == :insert && existent.length > 0) || (mode == :update && existent.length > 1)
@@ -137,10 +139,7 @@ module Spider; module Model
             end
             if (@model.extended_models)
                 @model.extended_models.each do |m, el|
-                    obj.instantiate_element(el) unless obj.get(el)
-                    unless sub = obj.get(el)
-                        raise "Object #{obj} is missing its superclass object for model #{m} (element #{el.name})"
-                    end
+                    sub = obj.get(el)
                     sub.save if (obj.element_modified?(el) || !obj.primary_keys_set?) && sub.mapper.class.write?
                 end
             end
@@ -215,6 +214,7 @@ module Spider; module Model
                 save_done(obj, save_mode) 
             end
             @doing_save_done = false
+            true
         end
 
         # Elements that are associated to this one externally.
@@ -261,6 +261,7 @@ module Spider; module Model
         def save_element_associations(obj, element, mode)
             our_element = element.attributes[:reverse]
             val = obj.get(element)
+
             if (element.attributes[:junction])
                 their_element = element.attributes[:junction_their_element]
                 if (val.model != element.model) # dereferenced junction
@@ -288,15 +289,20 @@ module Spider; module Model
                     unless mode == :insert
                         condition = Condition.and
                         condition[our_element] = obj
-                        raise "Can't save without a junction id" unless element.attributes[:junction_id]
-                        val.each do |row|
-                            next unless row_id = row.get(element.attributes[:junction_id])
-                            condition.set(:id, '<>', row_id)
+                        if element.attributes[:junction_id]
+                            val.each do |row|
+                                next unless row_id = row.get(element.attributes[:junction_id])
+                                condition.set(:id, '<>', row_id)
+                            end
                         end
                         element.model.mapper.delete(condition)
                     end
                     val.set(our_element, obj)
-                    val.save
+                    if element.attributes[:junction_id]
+                        val.save
+                    else
+                        val.insert
+                    end
                 end
             else
                 if (element.multiple?)
@@ -399,6 +405,13 @@ module Spider; module Model
                     end
                 end
             end
+            @model.referenced_by_junctions.each do |junction, element|
+                curr.each do |curr_obj|
+                    junction_condition = Spider::Model::Condition.new
+                    junction_condition[element] = curr_obj
+                    junction.mapper.delete(junction_condition)
+                end
+            end
             do_delete(condition, force)
             vals.each do |obj_vals|
                 obj_vals.each do |el, val|
@@ -504,7 +517,7 @@ module Spider; module Model
                 end
                 if (do_fetch)
                     @model.primary_keys.each{ |key| query.request[key] = true}
-                    expand_request(query.request, set) unless options[:no_expand_request]
+                    expand_request(query.request, set) unless options[:no_expand_request] || !query.request.expandable?
                     query = prepare_query(query, query_set)
                     query.request.total_rows = true unless query.request.total_rows == false
                     result = fetch(query)
@@ -516,7 +529,7 @@ module Spider; module Model
                                 obj.set_loaded_value(element_name, nil) 
                             end
                         end
-                        return set
+                        return false
                     end
                     set.total_rows = result.total_rows if (!was_loaded)
                     result.each do |row|
@@ -778,18 +791,27 @@ module Spider; module Model
             condition.simplify
             condition.each_with_comparison do |k, v, c|
                 raise MapperError, "Condition for nonexistent element #{k} on model #{model}" unless element = model.elements[k]
+                if (element.attributes[:computed_from]) # FIXME: temp fix
+                    condition.delete(k)
+                    condition.set(element.attributes[:computed_from][0], c, v)
+                    element = model.elements[element.attributes[:computed_from][0]]
+                end
                 if (element.integrated?)
                     condition.delete(k)
                     integrated_from = element.integrated_from
                     integrated_from_element = element.integrated_from_element
                     condition.set("#{integrated_from.name}.#{integrated_from_element}", c, v)
-                elsif (element.junction? && !v.is_a?(BaseModel) && !v.is_a?(Hash)) # conditions on junction id don't make sense
+                elsif (element.junction? && !v.is_a?(BaseModel) && !v.is_a?(Hash) && !v.nil?) # conditions on junction id don't make sense
                     condition.delete(k)
                     condition.set("#{k}.#{element.attributes[:junction_their_element]}", c, v)
                 end
                 if (element.type < Spider::DataType && !v.is_a?(element.type))
                     condition.delete(k)
-                    condition.set(k, c, element.type.from_value(v))
+                    begin
+                        condition.set(k, c, element.type.from_value(v))
+                    rescue TypeError => exc
+                        raise TypeError, "Can't convert #{v} to #{element.type} for element #{k} (#{exc.message})"
+                    end
                 elsif element.type == DateTime && v && !v.is_a?(Date)
                     condition.delete(k)
                     condition.set(k, c, DateTime.parse(v))