spiderfw 0.5.10 → 0.5.11

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

@@ -44,6 +44,12 @@ module Spider; module Model
             return true
         end
         
+        def sortable?(element)
+            element = element.name if (element.is_a? Element)
+            element = @model.elements[element]
+            mapped?(element) || element.attributes[:sortable]
+        end
+        
         # Utility methods
         
         # An array of mapped elements.
@@ -136,11 +142,19 @@ module Spider; module Model
                         raise NotUniqueError.new(el)
                     end
                 end
+                if mode == :insert && !el.integrated?
+                    obj.set(el.name, el.type.auto_value) if el.type < Spider::DataType && el.type.auto?(el) && !obj.element_has_value?(el)
+                    obj.set(el, obj.get(el)) if el.attributes[:default] && !obj.element_modified?(el)
+                end
             end
             if (@model.extended_models)
                 @model.extended_models.each do |m, el|
                     sub = obj.get(el)
-                    sub.save if (obj.element_modified?(el) || !obj.primary_keys_set?) && sub.mapper.class.write?
+                    if mode == :update || sub.class.auto_primary_keys?
+                        sub.save if (obj.element_modified?(el) || !obj.primary_keys_set?) && sub.mapper.class.write?
+                    else
+                        sub.insert unless sub.in_storage?
+                    end
                 end
             end
             @model.elements_array.select{ |el| el.attributes[:integrated_model] }.each do |el|
@@ -219,7 +233,9 @@ module Spider; module Model
 
         # Elements that are associated to this one externally.
         def association_elements
-             @model.elements_array.select{ |el| mapped?(el) && !el.integrated? && !have_references?(el) }
+             @model.elements_array.select{ |el| 
+                 mapped?(el) && !el.integrated? && !have_references?(el) && !(el.attributes[:added_reverse] && el.type == @model)
+             }
         end
         
         # Saves object associations.
@@ -261,7 +277,6 @@ 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
@@ -269,12 +284,12 @@ module Spider; module Model
                         current = obj.get_new
                         current_val = current.get(element)
                         condition = Condition.and
+                        val_condition = Condition.or
                         current_val.each do |row|
                             next if val.include?(row)
-                            condition_row = Condition.or
-                            condition_row[their_element] = row
-                            condition << condition_row
+                            val_condition[their_element] = row
                         end
+                        condition << val_condition
                         unless condition.empty?
                             condition[our_element] = obj
                             element.model.mapper.delete(condition)
@@ -319,8 +334,12 @@ module Spider; module Model
                         element.mapper.bulk_update({our_element => nil}, condition)
                     end
                 end
-                val.set(our_element, obj)
-                val.save
+                val.each do |v|
+                    if v.get(our_element) != obj
+                        v.set(our_element, obj)
+                        v.save
+                    end
+                end
             end
         end
         
@@ -650,6 +669,13 @@ module Spider; module Model
             result = objects.element_queryset(element).index_by(*index_by)
             @model.primary_keys.each{ |key| result.request[key.name] = true }
             result.request[element.attributes[:reverse]] = true
+            if element.attributes[:polymorph]
+                element.type.polymorphic_models.each do |mod, params|
+                    poly_req = Spider::Model::Request.new
+                    mod.primary_keys.each{ |k| poly_req.request(k) }
+                    result.request.with_polymorphs(mod, poly_req)
+                end
+            end
             result.load
             return associate_external(element, objects, result)
         end

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

@@ -79,6 +79,7 @@ module Spider; module Model
                 return nil unless l_cond
                 cond = l_cond.call(obj)
                 cond = Condition.new(cond) unless cond.is_a?(Condition)
+                preprocess_condition(cond)
                 return cond
             end
             
@@ -101,6 +102,7 @@ module Spider; module Model
             
             def list(name, attributes={})
                 attributes[:list] = true
+                attributes[:order] ||= true
                 element(name, Fixnum, attributes)
                 observe_element(name) do |obj, el, new_val|
                     obj.save_mode do

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

@@ -36,10 +36,11 @@ module Spider; module Model
                attributes[:association] = :tree
                attributes[:multiple] = true
                attributes[:reverse] ||= :"#{name}_parent"
+               attributes[:reverse_attributes] = {:association => :tree_parent}.merge(attributes[:reverse_attributes] || {})
                attributes[:tree_left] ||= :"#{name}_left"
                attributes[:tree_right] ||= :"#{name}_right"
                attributes[:tree_depth] ||= :"#{name}_depth"
-               choice(attributes[:reverse], self, :association => :tree_parent)
+               choice(attributes[:reverse], self, attributes[:reverse_attributes])
                element(name, self, attributes)
                element(attributes[:tree_left], Fixnum, :hidden => true)
                element(attributes[:tree_right], Fixnum, :hidden => true)

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

@@ -5,16 +5,16 @@ module Spider; module Model
     module Versioned
         
         def self.included(model)
-            
             model.extend(ClassMethods)
             model.mapper_include(Mapper)
+            #model.versioning
             vmod = Class.new(model)
             vmod.primary_keys.each do |pk|
                 vmod.element_attributes(pk.name, :primary_key => false)
             end
-            model.const_set("Versioned", vmod)
+            model.const_set(:Versioned, vmod)
             model.set_version_model(nil, vmod)
-            model.element(:sha1, String, :length => 40)
+            model.element(:v_sha1, String, :length => 40)
         end
         
         module ClassMethods
@@ -31,13 +31,16 @@ module Spider; module Model
               end
               vmod = @version_models[branch]
               vmod.primary_keys.each do |pk|
-                  vmod.delete_element(pk.name)
+                  vmod.remove_element(pk.name)
               end
               vmod.elements_array.each do |el|
                   el.attributes[:autoincrement] = false
               end
-              vmod.element(:sha1, String, :primary_key => true, :length => 40)
-              vmod.element(self.short_name.to_sym, self, :add_multiple_reverse => :history)
+              vmod.remove_element(:v_sha1) if vmod.elements[:v_sha1]
+              vmod.remove_element(:v_original) if vmod.elements[:v_original]
+              vmod.remove_element(:version_date) if vmod.elements[:version_date]
+              vmod.element(:v_sha1, String, :primary_key => true, :length => 40)
+              vmod.element(:v_original, self, :add_multiple_reverse => :history)
               vmod.element(:version_date, DateTime)
               self.elements_array.each do |el|
                   elh = dump_element(el)
@@ -74,7 +77,7 @@ module Spider; module Model
            end
            
            def version_element(el=nil)
-               return :sha1 unless el
+               return :v_sha1 unless el
                el = el.name if el.respond_to?(:name)
                @version_elements[el]
            end
@@ -96,7 +99,7 @@ module Spider; module Model
            def save_done(obj, mode)
                obj.set(obj.class.version_element, obj.version_sha1)
                obj.reset_modified_elements
-               obj.set_modified(:sha1 => true)
+               obj.set_modified(:v_sha1 => true)
                obj.mapper.do_update(obj)
                super
            end
@@ -104,7 +107,7 @@ module Spider; module Model
         end
         
         def version_sha1
-            yaml = self.to_yaml(:except => [:sha1])
+            yaml = self.to_yaml(:except => [:v_sha1])
             sha1 = Digest::SHA1.hexdigest(yaml)
         end
         

data/lib/spiderfw/model/model.rb

@@ -207,6 +207,78 @@ module Spider
             
         end
         
+        def self.sort(models)
+
+            sorter = Sorter.new(models)
+            sorter.sort
+        end
+        
+        require 'tsort'
+        
+        class Sorter
+            include TSort
+            
+            def initialize(models)
+                @model_tasks = {}
+                @processed_deps = {}
+                @processed = {}
+                @models = models
+                @models.each{ |m| collect_dependencies(m) }
+            end
+            
+            def tsort_each_node(&block)
+                 @model_tasks.each_value(&block)
+             end
+
+             def tsort_each_child(node, &block)
+                 node.dependencies.each(&block)
+             end
+
+             def collect_dependencies(model)
+                 return if model.subclass_of?(Spider::Model::InlineModel)
+                 @processed_deps[model] = true
+                 @model_tasks[model] ||= SortTask.new(model)
+                 if @models.include?(model.superclass)
+                     @model_tasks[model.superclass] ||= SortTask.new(model.superclass)
+                     @model_tasks[model] << @model_tasks[model.superclass]
+                 end
+             end
+
+
+             def sort
+                 tasks = tsort
+                 tasks.map{ |t| t.model }
+             end
+
+
+             def length
+               @model_tasks.keys.length
+             end
+            
+        end
+        
+        class SortTask
+            attr_reader :model, :dependencies
+            
+            def initialize(model)
+                @model = model
+                @dependencies = []
+            end
+            
+            def <<(model)
+                @dependencies << model
+            end
+            
+            def eql?(other)
+                @model == other.model
+            end
+            
+            def inspect
+                "#{@model.name} -> (#{dependencies.map{|d| d.model.name }.join(', ')})"
+            end
+                
+        end
+        
     end
     
 

data/lib/spiderfw/model/query_set.rb

@@ -406,6 +406,13 @@ module Spider; module Model
             return self
         end
         
+        def with_polymorphs
+            @model.polymorphic_models.each do |model, attributes|
+                @query.with_polymorph(model)
+            end
+            self
+        end
+        
         # Sets the value of an element on all currently loaded objects.
         def set(element, value)
             element_name = element.is_a?(Element) ? element.name : element

data/lib/spiderfw/model/storage/base_storage.rb

@@ -54,6 +54,10 @@ module Spider; module Model; module Storage
         def create_sequence(name, start=1, increment=1)
             sequence_next(name, start-1, increment)
         end
+        
+        def generate_uuid
+            Spider::DataTypes::UUID.generate
+        end
             
         
         def update_sequence(name, val)
@@ -65,7 +69,7 @@ module Spider; module Model; module Storage
         def sequence_next(name, newval=nil, increment=1)
             path = sequence_file_path(name)
             FileUtils.mkpath(File.dirname(path))
-            self.class.sequence_sync.lock(Sync::EX)
+            self.class.sequence_sync.lock(::Sync::EX)
             if newval
                 seq = newval
             else

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

@@ -131,7 +131,7 @@ module Spider; module Model; module Storage; module Db
         end
         
         def savepoint(name)
-            execute("SAVEPOINT #{name}")
+            connection.query("SAVEPOINT #{name}")
             super
         end
         
@@ -151,7 +151,7 @@ module Spider; module Model; module Storage; module Db
         end
         
         def rollback_savepoint(name=nil)
-            execute("ROLLBACK TO #{name}")
+            connection.query("ROLLBACK TO #{name}")
             super
         end
         
@@ -266,6 +266,9 @@ module Spider; module Model; module Storage; module Db
              tables_sql, tables_values = sql_tables(query)
              sql = "SELECT "
              sql += "SQL_CALC_FOUND_ROWS " unless query[:query_type] == :count
+             if query[:joins] && query[:joins].values.map{ |h| h.values }.flatten.select{ |v| v[:type] == :left}.length > 0
+                 sql += "DISTINCT "
+             end
              sql += "#{sql_keys(query)} FROM #{tables_sql} "
              bind_vars += tables_values
              where, vals = sql_condition(query)

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

@@ -210,6 +210,7 @@ module Spider; module Model; module Storage; module Db
                  return curr[:last_result] ? curr[:last_result].length : nil
              end
              q.delete(:offset); q.delete(:limit)
+             q[:query_type] = :count
              sql, vars = sql_select(q)
              res = execute("SELECT COUNT(*) AS N FROM (#{sql})", *vars)
              return nil unless res && res[0]
@@ -284,12 +285,13 @@ module Spider; module Model; module Storage; module Db
              bind_vars += vals
              sql += "WHERE #{where} " if where && !where.empty?
              order = sql_order(query, replaced_fields)
-             if (query[:limit])
+             if (query[:limit] || query[:query_type] == :count)
+                 limit = nil
                  if (query[:offset])
                      limit = "oci8_row_num between :#{curr[:bind_cnt]+=1} and :#{curr[:bind_cnt]+=1}"
                      bind_vars << query[:offset] + 1
                      bind_vars << query[:offset] + query[:limit]
-                 else
+                 elsif query[:limit]
                      limit = "oci8_row_num < :#{curr[:bind_cnt]+=1}"
                      bind_vars << query[:limit] + 1
                  end
@@ -303,7 +305,11 @@ module Spider; module Model; module Storage; module Db
                      data_sql = "#{sql} order by #{order}"
                  end
                  count_sql = "SELECT /*+ FIRST_ROWS(n) */ a.*, ROWNUM oci8_row_num FROM (#{data_sql}) a"
-                 sql = "SELECT * FROM (#{count_sql}) WHERE #{limit}"
+                 if limit
+                     sql = "SELECT * FROM (#{count_sql}) WHERE #{limit}"
+                 else
+                     sql = count_sql
+                 end
              else
                  sql += "ORDER BY #{order} " if order && !order.empty?
              end

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

@@ -168,6 +168,7 @@ module Spider; module Model; module Storage; module Db
         end
         
         def start_transaction
+            return unless transactions_enabled?
             return savepoint("point#{curr[:savepoints].length}") if in_transaction?
             curr[:transaction_nesting] += 1
             Spider.logger.debug("#{self.class.name} starting transaction for connection #{connection.object_id}")
@@ -343,18 +344,20 @@ module Spider; module Model; module Storage; module Db
                 else
                     func.mapper_fields[func_el]
                 end
-            }.join(', ')
+            }
             case func.func_name
             when :length
-                return "LENGTH(#{fields})"
+                return "LENGTH(#{fields.join(', ')})"
             when :trim
-                return "TRIM(#{fields})"
+                return "TRIM(#{fields.join(', ')})"
             when :concat
-                return "CONCAT(#{fields})"
+                return "CONCAT(#{fields.join(', ')})"
             when :substr
                 arguments = "#{func.start}"
                 arguments += ", #{func.length}" if func.length
-                return "SUBSTR(#{fields}, #{arguments})"
+                return "SUBSTR(#{fields.join(', ')}, #{arguments})"
+            when :subtract
+                return "(#{fields[0]} - #{fields[1]})"
             end
             raise NotImplementedError, "#{self.class} does not support function #{func.func_name}"
         end

data/lib/spiderfw/model/sync.rb

@@ -11,15 +11,21 @@ module Spider; module Model
             @processed = {}
         end
         
-        def add(model)
-            collect_dependencies(model)
+        def add(models)
+            models = [models] unless models.is_a?(Array)
+            models.each do |model|
+                collect_dependencies(model)
+            end
         end
         
-        def each
+        def sorted
             tasks = tsort
-            pp tasks
-            tasks.each do |task|
-                yield task.model
+            tasks.map{ |t| t.model }
+        end
+        
+        def each
+            sorted.each do |model|
+                yield model
             end
         end
         

data/lib/spiderfw/requires.rb

@@ -10,6 +10,7 @@ require 'spiderfw/utils/monkey/date_time'
 require 'spiderfw/utils/monkey/numeric'
 require 'spiderfw/utils/monkey/exception'
 require 'spiderfw/utils/monkey/nil_class'
+require 'spiderfw/utils/monkey/object'
 require 'spiderfw/utils/multi_level_hash'
 require 'spiderfw/utils/thread_out'
 require 'spiderfw/utils/inflector'

data/lib/spiderfw/templates/blocks/parent_context.rb

@@ -0,0 +1,26 @@
+require 'spiderfw/templates/template_blocks'
+
+module Spider; module TemplateBlocks
+    
+    # *sp:parent-context*
+    # Executes the content using the parent's scene
+    
+    class ParentContext < Block
+        
+        def compile(options={})
+            init = ""
+            c = ""
+#            c += "debugger\n"
+            parent_c, parent_init = compile_content(c, init, options)
+            parent_c.gsub!("'", "\\\\'")
+            parent_init.gsub!("'", "\\\\'")
+            c += "self[:_parent].instance_eval('def __run_block\n;#{parent_c}\nend\n')\n"
+            c += "yield :_parent\n"
+            return CompiledBlock.new(init, c)
+        end
+        
+        
+    end
+    
+    
+end; end