spiderfw 0.6.21 → 0.6.22

data/lib/spiderfw/model/migrations/previous_model.rb

@@ -0,0 +1,73 @@
+module Spider; module Migrations
+
+    module PreviousModel
+
+        def self.included(klass)
+            klass.extend(ClassMethods)
+            klass.with_mapper do
+                def schema_table_name
+                    if @model.previous_model_of
+                        model.previous_model_of.mapper.schema.table.name
+                    else
+                        super.gsub('previousmodels__', '')
+                    end
+                end
+            end
+        end
+
+        def to_new_model
+            nm = self.class.previous_model_of
+            obj = nm.new
+            vals = self.to_hash
+            vals.each do |k, v|
+                obj.set(k, v) if nm.elements[k]
+            end
+            obj
+        end
+
+        module ClassMethods
+
+
+            def previous_model_of(model=nil)
+                @replacement_model = model if model
+                @replacement_model
+            end
+
+
+            def class_table_inheritance(params={})
+                unless params[:name]
+                    spm = nil
+                    mpm = nil
+                    if @replacement_model
+                        spm = @replacement_model.parent_module
+                    else
+                        spm = self.parent_module.parent_module
+                    end
+                    if superclass.respond_to?(:previous_model_of)
+                        if superclass.previous_model_of
+                            mpm = superclass.previous_model_of
+                        else
+                            mpm = superclass.parent_module.parent_module
+                        end
+                    else
+                        mpm = superclass.parent_module
+                    end
+                    integrated_name = (spm == mpm) ? superclass.short_name : superclass.name
+                    integrated_name = Spider::Inflector.underscore(integrated_name).gsub('/', '_')
+                    params[:name] = integrated_name
+                end
+                super(params)
+            end
+
+            def element(name, type, attributes={}, &proc)
+                super
+                if @elements[name].junction?
+                    @elements[name].model.send(:include, PreviousModel)
+                end
+            end
+
+        end
+
+    end
+
+end; end

data/lib/spiderfw/model/migrations/rename_element.rb

@@ -0,0 +1,42 @@
+module Spider; module Migrations
+
+    class RenameElement < Migration
+
+        def initialize(model, element, new_element, options={})
+            @model = model
+            @element = element
+            @new_element = new_element
+            @options = {}
+        end
+
+        def run
+            field = @options[:field_name]
+            schema_field = nil
+            new_schema_field = nil
+            unless field
+                schema_field = @model.mapper.schema.field(@element)
+                field = schema_field.name if schema_field
+            end
+            field ||= @model.mapper.storage.column_name(@element)
+            new_field = @options[:new_field_name]
+            unless new_field
+                new_schema_field = @model.mapper.schema.field(@new_element)
+                new_field = new_schema_field.name if new_schema_field
+            end
+            new_field ||= @model.mapper.storage.column_name(@new_element)
+            f = new_schema_field || schema_field
+            raise "Neither #{@element} nor #{@new_element} were found in schema" unless f
+
+            desc = @model.mapper.storage.describe_table(@model.mapper.schema.table)
+            if desc[:columns][field] && !desc[:columns][new_field]
+                @model.mapper.storage.change_field(@model.mapper.schema.table, field, new_field, f.type, f.attributes)
+            end
+        end
+
+        def undo
+            self.class.new(@model, @new_element, @element).run
+        end
+
+    end
+
+end; end

data/lib/spiderfw/model/migrations.rb

@@ -1,8 +1,10 @@
 require 'spiderfw/model/migrations/migration'
+require 'spiderfw/model/migrations/previous_model'
 require 'spiderfw/model/migrations/irreversible_migration'
 require 'spiderfw/model/migrations/replace'
 require 'spiderfw/model/migrations/drop_element'
 require 'spiderfw/model/migrations/drop_table'
+require 'spiderfw/model/migrations/rename_element'
 
 module Spider
     
@@ -17,7 +19,18 @@ module Spider
         end
 
         def self.drop_table!(model, options={})
-            Spider::Migrations::DropTable.new(model, element, options={})
+            Spider::Migrations::DropTable.new(model, options={})
+        end
+
+        def self.rename_element(model, element, new_element, options={})
+            RenameElement.new(model, element, new_element, options={})
+        end
+
+        def self.previous_model(model, previous=nil)
+            model.send(:include, PreviousModel)
+            if previous
+                model.previous_model_of(previous)
+            end
         end
         
         

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

@@ -21,15 +21,44 @@ module Spider; module Model
             res = element.model.find(q)
             return [] unless res
             right_stack = []
+            parents = []
+            first = nil
             res.each do |obj|
-                if (right_stack.length > 0)
-                    right_stack.pop while (right_stack[right_stack.length-1] && right_stack[right_stack.length-1] < obj.get(right_el))
+                first ||= obj
+                if right_stack.length > 0
+                    while right_stack.length > 0 && right_stack.last < obj.get(right_el)
+                        right_stack.pop
+                        p, sub = parents.pop
+                        p.set_loaded_value(element.name, sub)
+                        parents.last[1] << p if parents.last
+                    end
                     obj.set(element.attributes[:tree_depth], right_stack.length)
                 end
                 right_stack << obj.get(right_el)
+                parents << [obj, QuerySet.static(self.class)]
+            end
+            
+            while pair = parents.pop
+                p, sub = pair
+                p.set_loaded_value(element.name, sub)
+                parents.last[1] << p if parents.last
             end
+            
             return res
         end
+
+        def before_save
+            self.class.elements_array.select{ |el| el.attributes[:association] == :tree }.each do |el|
+                if element_modified?(el)
+                    cnt = 1
+                    self.get(el).each do |obj|
+                        obj.set(el.attributes[:tree_position], cnt)
+                        cnt += 1
+                    end
+                end
+            end
+            super
+        end
         
         module ClassMethods
             
@@ -189,27 +218,30 @@ module Spider; module Model
 
             def before_save(obj, mode)
                 @model.elements_array.select{ |el| el.attributes[:association] == :tree }.each do |el|
-                    unless obj.element_modified?(el.attributes[:reverse]) || obj.element_modified?(el.attributes[:tree_position])
+                    unless mode == :insert || obj.element_modified?(el.attributes[:reverse]) || obj.element_modified?(el.attributes[:tree_position])
                         next 
                     end
-                    if mode == :update
-                        tree_remove(el, obj)
-                    end
-                    parent = obj.get(el.attributes[:reverse])
-                    if parent
-                        sub = parent.get(el.name)
-                        if obj.element_modified?(el.attributes[:tree_position]) && sub.length > 0
-                            pos = obj.get(el.attributes[:tree_position]) 
-                            if pos == 1
-                                tree_insert_node_first(el, obj, parent)
+                    # already set by parent
+                    unless obj.element_modified?(el.attributes[:tree_left])
+                        if mode == :update
+                            tree_remove(el, obj)
+                        end
+                        parent = obj.get(el.attributes[:reverse])
+                        if parent
+                            sub = parent.get(el.name)
+                            if obj.element_modified?(el.attributes[:tree_position]) && sub.length > 0
+                                pos = obj.get(el.attributes[:tree_position]) 
+                                if pos == 1
+                                    tree_insert_node_first(el, obj, parent)
+                                else
+                                    tree_insert_node_right(el, obj, sub[pos-2])
+                                end
                             else
-                                tree_insert_node_right(el, obj, sub[pos-2])
+                                tree_insert_node_under(el, obj, parent)
                             end
                         else
-                            tree_insert_node_under(el, obj, parent)
+                            tree_insert_node(el, obj)
                         end
-                    else
-                        tree_insert_node(el, obj)
                     end
                 end
                 super
@@ -268,7 +300,7 @@ module Spider; module Model
                 left_el = tree_el.attributes[:tree_left]; right_el = tree_el.attributes[:tree_right]
                 cur = left+1
                 obj.get(tree_el).each do |child|
-                    cur = tree_assign_values(tree_el, child, cur)
+                    cur = tree_assign_values(tree_el, child, cur) + 1
                 end
                 obj.set(left_el, left)
                 obj.set(right_el, cur)
@@ -292,7 +324,7 @@ module Spider; module Model
             
             def tree_insert_node_right(tree_el, obj, sibling)
                 obj.set(tree_el.attributes[:reverse], sibling.get(tree_el.attributes[:reverse]))
-                tree_insert_node(tree_el, obj, sibling.get(tree_el.attributes[:tree_right]))
+                tree_insert_node(tree_el, obj, sibling.get(tree_el.attributes[:tree_right])+1)
             end
             
             def tree_remove(tree_el, obj)
@@ -337,6 +369,20 @@ module Spider; module Model
                 condition = Condition.new.set(left_el, '>', right)
                 bulk_update({:left_el => QueryFuncs::Expression.new(":#{left_el} - 2")}, condition)
             end
+
+            # Ensure that in Unit of Work parents are saved before children
+            def get_dependencies(task)
+                deps = super
+                if task.action == :save
+                    @model.elements_array.select{ |el| el.attributes[:association] == :tree }.each do |el|
+                        if task.object.element_modified?(el.attributes[:reverse])
+                            parent = task.object.get(el.attributes[:reverse])
+                            deps << [task, MapperTask.new(parent, :save)] if parent
+                        end
+                    end
+                end
+                deps
+            end
             
             
             

data/lib/spiderfw/model/model_hash.rb

@@ -32,11 +32,15 @@ module Spider; module Model
                 val = n
             end
             key = key.name if key.is_a?(Element)
-            parts = key.to_s.split('.', 2)
-            return super(key.to_sym, val) unless parts[1]
-            parts[0] = parts[0].to_sym
-            self[parts[0]] = get_deep_obj unless self[parts[0]].is_a?(self.class)
-            self[parts[0]][parts[1]] = val
+            if key.is_a?(String)
+                parts = key.split('.', 2)
+                return super(key.to_sym, val) unless parts[1]
+                parts[0] = parts[0].to_sym
+                self[parts[0]] = get_deep_obj unless self[parts[0]].is_a?(self.class)
+                self[parts[0]][parts[1]] = val
+            else
+                super(key, val)
+            end
         end
         
         def [](key)

data/lib/spiderfw/model/query.rb

@@ -21,6 +21,7 @@ module Spider; module Model
         attr_reader :request
         attr_reader :page_rows
         attr_reader :page
+        attr_accessor :group_by_elements
         
         # Instantiates a new query, calling Condition#where on the condition.
         def self.where(*params)
@@ -82,6 +83,12 @@ module Spider; module Model
            end
            return self
        end
+
+       def group_by(*elements)
+           @group_by_elements ||= []
+           @group_by_elements += elements
+           return self
+       end
        
        # Adds each element in the given list to the request.
        def select(*elements)
@@ -160,6 +167,7 @@ module Spider; module Model
            cl.offset = @offset
            cl.limit = @limit
            cl.polymorphs = @polymorphs.clone
+           cl.group_by_elements = @group_by_elements.clone if @group_by_elements
            return cl
        end
        

data/lib/spiderfw/model/query_funcs.rb

@@ -94,6 +94,29 @@ module Spider; module QueryFuncs
             "#{self.func_name.to_s.upcase}(#{elements.map{ |el| el.inspect }.join(', ')})"
         end
 
+        def as(name)
+            SelectFunction.new(self, name)
+        end
+
+    end
+
+    class SelectFunction
+        attr_reader :function, :as
+
+
+        def initialize(function, as)
+            @function = function
+            @as = as
+        end
+
+        def inspect
+            "#{@function.inspect} AS #{@as}"
+        end
+
+        def method_missing(method, *args)
+            @function.send(method, *args)
+        end
+
     end
 
     class ZeroArityFunction < Function

data/lib/spiderfw/model/query_set.rb

@@ -281,7 +281,7 @@ module Spider; module Model
         
         # Total number of objects that would be returned had the Query no limit.
         def total_rows
-            return @total_rows ? @total_rows : @model.mapper.count(@query.condition)
+            return @total_rows ? @total_rows : (@total_rows = @model.mapper.count(@query.condition))
         end
         
         # Current number of objects fetched.

data/lib/spiderfw/model/request.rb

@@ -24,15 +24,23 @@ module Spider; module Model
             @polymorphs = {}
             @expandable = true
         end
+
+        def self.strict(val=nil, params={})
+            r = self.new(val, params)
+            r.expandable = false
+            r
+        end
         
         # TODO: fix/remove?
         def request(element) # :nodoc:
-            if (element.is_a?(Element))
+            if element.is_a?(Element)
                 self[element.name.to_s] = true
-            else
-                element.to_s.split(',').each do |el|
+            elsif element.is_a?(String)
+                element.split(',').each do |el|
                     self[el.strip] = true
                 end
+            else
+                self[element] = true
             end
         end
     

data/lib/spiderfw/model/storage/db/adapters/mysql.rb

@@ -290,8 +290,19 @@ module Spider; module Model; module Storage; module Db
              sql += "#{sql_keys(query)} FROM #{tables_sql} "
              bind_vars += tables_values
              where, vals = sql_condition(query)
-             bind_vars += vals
+
+             bind_vars += vals if vals
              sql += "WHERE #{where} " if where && !where.empty?
+             having, having_vals = sql_condition(query, true)
+             unless having.blank? && query[:group_by].blank?
+                group_fields = query[:group_by] || (
+                    query[:keys].select{ |k| !k.is_a?(FieldExpression)
+                } + collect_having_fields(query[:condition])).flatten.uniq
+                group_keys = sql_keys(group_fields)
+                sql += "GROUP BY #{group_keys} " 
+                sql += "HAVING #{having} " unless having.blank?
+                bind_vars += having_vals if having_vals
+            end
              order = sql_order(query)
              sql += "ORDER BY #{order} " if order && !order.empty?
              limit = sql_limit(query)
@@ -304,12 +315,28 @@ module Spider; module Model; module Storage; module Db
              sql += " AUTO_INCREMENT" if attributes[:autoincrement]
              return sql
          end
+
+         def sql_add_field(table_name, name, type, attributes)
+             sqls = super
+             sqls[0] += ", ADD PRIMARY KEY(#{name})" if attributes[:primary_key]
+             sqls
+         end
+
+         def sql_alter_field(table_name, name, type, attributes)
+             sqls = super
+             sqls[0] += ", ADD PRIMARY KEY(#{name})" if attributes[:primary_key]
+             sqls
+         end
          
          def sql_create_table(create)
              sqls = super
              sqls[0] += " ENGINE=#{@configuration['default_engine']}" if @configuration['default_engine']
              sqls
          end
+
+         def sql_create_primary_key(table_name, fields)
+            nil # done in add field or alter field
+        end
          
          def function(func)
              return super unless func.func_name == :concat

data/lib/spiderfw/model/storage/db/adapters/oracle.rb

@@ -118,24 +118,24 @@ module Spider; module Model; module Storage; module Db
                  query[:order] << [query[:keys][0], 'desc'] if query[:order].length < 1
                  query[:order].each do |o|
                      field, direction = o
-                     # i = query[:keys].index(field)
-                     #   unless i
-                     #       query[:keys].push(field)
-                     #       i = query[:keys].length < 1
-                     #   end
-                     transformed = "O#{replace_cnt += 1}"
-                     query[:order_replacements][field.to_s] = transformed
+                     
                      if field.is_a?(Spider::Model::Storage::Db::Field) && !query[:tables].include?(field.table)
                          query[:order_on_different_table] = true 
                      end
                      if field.is_a?(FieldFunction)
                          query[:order_on_different_table] = true if field.joins.length > 0
                      end
-                     if (field.is_a?(Spider::Model::Storage::Db::Field) && field.type == 'CLOB')
+                     if field.is_a?(Spider::Model::Storage::Db::Field) && field.type == 'CLOB'
                          field = "CAST(#{field} as varchar2(100))"
                      end
+                     field_expr = field.is_a?(FieldExpression) ? field.expression : field.to_s
                      
-                     query[:keys] << Db::FieldExpression.new(field.table, transformed, field.type, :expression => "#{field}")
+                     unless query[:keys].include?(field) || field.is_a?(FieldExpression)
+                        transformed = "O#{replace_cnt += 1}"
+                        query[:order_replacements][field.to_s] = transformed
+
+                        query[:keys] << Db::FieldExpression.new(field.table, transformed, field.type, :expression => field_expr)
+                    end
                  end
              end
              keys = sql_keys(query)
@@ -145,7 +145,7 @@ module Spider; module Model; module Storage; module Db
              bind_vars += tables_values
 
              where, vals = sql_condition(query)
-             bind_vars += vals
+             bind_vars += vals if vals
              sql += "WHERE #{where} " if where && !where.empty?
 
              having, having_vals = sql_condition(query, true)

data/lib/spiderfw/model/storage/db/db_schema.rb

@@ -110,9 +110,14 @@ module Spider; module Model; module Storage; module Db
             if field.is_a?(Hash)
                 field[:attributes] ||= {}
                 field[:attributes][:expression] ||= field[:expression]
-                if field[:attributes][:expression]
+                field[:attributes][:fixed] ||= field[:fixed]
+                if field[:attributes][:expression] || field[:attributes][:fixed]
                     field[:name] = "#{@table}_#{element_name}_#{element_key}".upcase
-                    field = FieldExpression.new(@table, field[:name], field[:type], field[:attributes] || {})
+                    if field[:attributes][:fixed]
+                        field = FixedExpression.new(@table, field[:name], field[:type], field[:attributes][:fixed], field[:attributes])
+                    else
+                        field = FieldExpression.new(@table, field[:name], field[:type], field[:attributes] || {})
+                    end
                 else
                     field = Field.new(@table, field[:name], field[:type], field[:attributes] || {}) 
                 end
@@ -280,9 +285,17 @@ module Spider; module Model; module Storage; module Db
         end
         
     end
+
+    class FixedExpression < FieldExpression
+        def initialize(table, name, type, fixed_value, attributes={})
+            attributes[:expression] = fixed_value
+            super(table, name, type, attributes)
+        end
+    end
     
     class FieldFunction
         attr_reader :expression, :table, :joins
+        attr_accessor :as
         def initialize(expression, table, joins)
             @expression = expression
             @table = table
@@ -298,7 +311,11 @@ module Spider; module Model; module Storage; module Db
         end
         
         def to_s
-            @expression
+            if @as
+                "#{@expression} AS #{@as}"
+            else
+                @expression
+            end
         end
     end