spiderfw 0.5

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

@@ -0,0 +1,296 @@
+module Spider; module Model
+    
+    module Tree
+        
+        def self.included(model)
+            model.extend(ClassMethods)
+            model.mapper_include(MapperMethods)
+        end
+        
+        def tree_all(element)
+            element = self.class.elements[element] unless element.is_a?(Element)
+            left_el = element.attributes[:tree_left]
+            right_el = element.attributes[:tree_right]
+            left = get(left_el)
+            right = get(right_el)
+            return nil unless (left && right)
+            c = Condition.and
+            c[left_el] = (left..right)
+            q = Query.new(c)
+            q.order_by(left_el)
+            res = element.model.find(q)
+            right_stack = []
+            res.each do |obj|
+                if (right_stack.length > 0)
+                    right_stack.pop while (right_stack[right_stack.length-1] < obj.get(right_el))
+                    obj.set(element.attributes[:tree_depth], right_stack.length)
+                end
+                right_stack << obj.get(right_el)
+            end
+            return res
+        end
+        
+        module ClassMethods
+            
+           def tree(name, attributes={})
+               attributes[:association] = :tree
+               attributes[:multiple] = true
+               attributes[:reverse] ||= :"#{name}_parent"
+               attributes[:tree_left] ||= :"#{name}_left"
+               attributes[:tree_right] ||= :"#{name}_right"
+               attributes[:tree_depth] ||= :"#{name}_depth"
+               choice(attributes[:reverse], self, :association => :tree_parent)
+               element(name, self, attributes)
+               element(attributes[:tree_left], Fixnum, :hidden => true)
+               element(attributes[:tree_right], Fixnum, :hidden => true)
+               element(attributes[:tree_depth], Fixnum, :unmapped => true, :hidden => true)
+#               sequence(name)
+               qs_module ||= Module.new
+               
+               qs_module.module_eval do
+                   
+                   define_method("#{name}_roots") do
+                       qs = self.clone
+                       qs.condition[attributes[:reverse]] = nil
+                       qs
+                   end
+
+                   define_method("#{name}_leafs") do
+                       qs = self.clone
+                       qs.condition[attributes[:tree_left]] = QueryFuncs::Expression.new(":#{attributes[:tree_right]} - 1")
+                       qs
+                   end
+                   
+                   
+               end
+               @elements[name].attributes[:queryset_module] = qs_module
+               
+               def extend_queryset(qs)
+                   super
+                   @elements.each do |name, el|
+                       qs_module = el.attributes[:queryset_module]
+                       qs.extend(qs_module) if qs_module
+                   end
+               end
+               
+               (class << self; self; end).instance_eval do
+                   
+                   define_method("#{name}_roots") do
+                       QuerySet.autoloading(self).send("#{name}_roots")
+                   end
+                   
+                   define_method("#{name}_leafs") do
+                       QuerySet.autoloading(self).send("#{name}_leafs")
+                      
+                   end
+                   
+                   define_method("#{name}_all") do
+                       qs = QuerySet.new(self)
+                       self.send("#{name}_roots").each do |root|
+                           qs += root.tree_all(name)
+                       end
+                       return qs
+                   end
+                   
+               end
+               
+               define_method("#{name}_leaf?") do
+                   element = self.class.elements[name]
+                   left_el = element.attributes[:tree_left]
+                   right_el = element.attributes[:tree_right]
+                   left = get(left_el)
+                   right = get(right_el)
+                   return left == (right - 1)
+               end
+
+               
+               define_method("#{name}_all") do
+                   tree_all(name)
+               end
+               
+               define_method(attributes[:tree_depth]) do
+                   ivar = :"@#{ attributes[:tree_depth] }"
+                   return instance_variable_get(ivar)
+               end
+               
+               define_method("#{name}_path") do
+                   element = self.class.elements[name]
+                   left_el = element.attributes[:tree_left]
+                   right_el = element.attributes[:tree_right]
+                   left = get(left_el)
+                   right = get(right_el)
+                   return nil unless (left && right)
+                   c = Condition.and
+                   c.set(tree_left, '<', left)
+                   c.set(tree_right, '>', right)
+                   q = Query.new(c)
+                   q.order_by(left_el)
+                   return element.model.find(q)
+               end
+               
+               define_method("#{name}_append_first") do |new_child|
+                   
+               end
+               
+               define_method("#{name}_append_after") do |new_child, child|
+                   element = self.class.elements[name]
+                   left_el = element.attributes[:tree_left]
+                   right_el = element.attributes[:tree_right]
+                   parent_el = element.attributes[:reverse]
+                   if (child.get(left_el))
+                       
+                   end
+               end
+
+           end
+            
+        end
+
+        module MapperMethods
+
+            def before_save(obj, mode)
+                @model.elements_array.select{ |el| el.attributes[:association] == :tree }.each do |el|
+                    if (mode == :update)
+                        tree_remove(el, obj)
+                    end
+                    parent = obj.get(el.attributes[:reverse])
+                    if (parent)
+                        tree_insert_node_under(el, obj, parent)
+                    else
+                        tree_insert_node(el, obj)
+                    end
+                end
+                super
+            end
+            
+            def before_delete(objects)
+                @model.elements_array.select{ |el| el.attributes[:association] == :tree }.each do |el|
+                    objects.each{ |obj| tree_remove(el, obj) }
+                end
+            end
+            
+            # def after_save(obj, mode)
+            #     super
+            #     debugger
+            #     @model.elements_array.select{ |el| el.attributes[:association] == :tree }.each do |el|
+            #         debugger
+            #         left_el = el.attributes[:tree_left]
+            #         left = obj.get(left_el)
+            #         if (!left)
+            #             left = sequence_next(el.name)
+            #             obj.set(left_el, left)
+            #         end
+            #         parent = obj.get(el.attributes[:reverse])
+            #         rebuild_from = parent ? parent : obj
+            #         tree_rebuild(el, rebuild_from, left)
+            #     end
+            # end
+            
+            def tree_rebuild(tree_el, obj, left)
+                left_el = tree_el.attributes[:tree_left]; right_el = tree_el.attributes[:tree_right]
+                right = left + 1
+                children = obj.get(tree_el)
+                if (children)
+                    children.each do |child|
+                        right = child.mapper.tree_rebuild(tree_el, child, right)
+                    end
+                end
+                obj.set(left_el, left)
+                obj.set(right_el, right)
+                do_update(obj)
+                return right + 1
+            end
+            
+            def tree_insert_node(tree_el, obj, left=nil)
+                left_el = tree_el.attributes[:tree_left]; right_el = tree_el.attributes[:tree_right]
+                left = max(right_el) + 1 unless left
+                right = tree_assign_values(tree_el, obj, left)
+                diff = right-left+1
+                condition = Condition.new.set(right_el, '>=', left)
+                bulk_update({right_el => QueryFuncs::Expression.new(":#{right_el}+#{diff}")}, condition)
+                condition = Condition.new.set(left_el, '>=', left)
+                bulk_update({left_el => QueryFuncs::Expression.new(":#{left_el}+#{diff}")}, condition)
+            end
+            
+            def tree_assign_values(tree_el, obj, left)
+                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)
+                end
+                obj.set(left_el, left)
+                obj.set(right_el, cur)
+            end
+            
+            def tree_insert_node_under(tree_el, obj, parent)
+                obj.set(tree_el.attributes[:reverse], parent)
+                tree_insert_node(tree_el, obj, parent.get(tree_el.attributes[:tree_right]))
+            end
+            
+            def tree_insert_node_first(tree_el, obj, parent)
+                obj.set(tree_el.attributes[:reverse], parent)
+                tree_insert_node(tree_el, obj, parent.get(tree_el.attributes[:tree_left])+1)
+            end
+            
+            def tree_insert_node_left(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_left]))
+            end
+            
+            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]))
+            end
+            
+            def tree_remove(tree_el, obj)
+                left_el = tree_el.attributes[:tree_left]; right_el = tree_el.attributes[:tree_right]
+                left = obj.get(left_el); right = obj.get(right_el)
+                return unless left && right
+                diff = right-left+1
+                condition = Condition.new.set(left_el, '>', right)
+                bulk_update({left_el => QueryFuncs::Expression.new(":#{left_el} - #{diff}")}, condition)
+                condition = Condition.new.set(right_el, '>', right)
+                bulk_update({right_el => QueryFuncs::Expression.new(":#{right_el} - #{diff}")}, condition)
+                def unset_tree_vals(obj, tree_el)
+                    left_el = tree_el.attributes[:tree_left]; right_el = tree_el.attributes[:tree_right]
+                    obj.set(left_el, nil); obj.set(right_el, nil)
+                    obj.get(tree_el).each do |sub|
+                        unset_tree_vals(sub, tree_el)
+                    end
+                end
+                unset_tree_vals(obj, tree_el)
+            end
+            
+            def tree_delete(tree_el, obj)
+                tree_remove(tree_el, obj)
+                def delete_children(obj, tree_el)
+                    obj.get(tree_el).each do |child| 
+                        delete_children(child, tree_el)
+                    end
+                    obj.delete
+                end
+                delete_children(obj, tree_el)
+            end
+            
+            def tree_move_up_children(tree_el, obj)
+                left_el = tree_el.attributes[:tree_left]; right_el = tree_el.attributes[:tree_right]
+                left = obj.get(left_el); right = obj.get(right_el)
+                bulk_update({
+                    :left_el => QueryFuncs::Expression.new(":#{left_el} - 1"),
+                    :right_el => QueryFuncs::Expression.new(":#{right_el} - 1")
+                }, Condition.new.set(left_el, 'between', [left, right]))
+                condition = Condition.new.set(right_el, '>', right)
+                bulk_update({:right_el => QueryFuncs::Expression.new(":#{right_el} - 2")}, condition)
+                condition = Condition.new.set(left_el, '>', right)
+                bulk_update({:left_el => QueryFuncs::Expression.new(":#{left_el} - 2")}, condition)
+            end
+            
+            
+            
+            
+        end
+        
+    end
+    
+    
+end; end

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

@@ -0,0 +1,147 @@
+require 'digest/sha1'
+
+module Spider; module Model
+    
+    module Versioned
+        
+        def self.included(model)
+            
+            model.extend(ClassMethods)
+            model.mapper_include(Mapper)
+            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.set_version_model(nil, vmod)
+            model.element(:sha1, String, :length => 40)
+        end
+        
+        module ClassMethods
+           
+           def versioning(branch=nil)
+              @version_models ||= {} 
+              @version_elements ||= {}
+              unless @version_models[branch]
+                  vmod = Class.new(self)
+                  vmod_name = "Versioned"
+                  vmod_name += Spider::Inflector.camelize(branch) if branch
+                  const_set(vmod_name.to_sym, vmod)
+                  @version_models[branch] = vmod
+              end
+              vmod = @version_models[branch]
+              vmod.primary_keys.each do |pk|
+                  vmod.delete_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.element(:version_date, DateTime)
+              self.elements_array.each do |el|
+                  elh = dump_element(el)
+                  next if el.integrated?
+                  next unless elh
+                  # elh[:attributes][:primary_key] = false
+                  # debugger if elh[:attributes][:junction]
+                  # vmod.send(elh[:method], elh[:name], elh[:type], elh[:attributes])
+                  if (el.model?)
+                      if (self.mapper.have_references?(el) && el.model < Spider::Model::Versioned)
+                          vname = "#{el.name}_versioned".to_sym
+                          @version_elements[el.name] = vname
+                          vmod.send(elh[:method], vname, el.model.version_model)
+                      elsif (el.attributes[:junction] && el.type < Spider::Model::Versioned)
+                          # el.attributes[:association_type].module_eval{ include Spider::Model::Versioned }
+                          # el.attributes[:association_type].versioning(branch)
+                          # elh[:attributes].
+                          # debugger
+                          # elh[:attributes][:has_single_reverse] = (el.attributes[:reverse] && !el.type.elements[el.attributes[:reverse]].multiple?)
+                          junction = el.attributes[:association_type]
+                          unless junction < Spider::Model::Versioned && junction.version_model
+                              junction.module_eval{ include Spider::Model::Versioned }
+                              junction.versioning(branch)
+                          end
+                          elh[:attributes][:through] = junction.version_model
+                          elh[:attributes][:junction_our_name] = "#{elh[:attributes][:reverse]}_versioned".to_sym
+                          elh[:attributes][:junction_their_element] = "#{elh[:attributes][:junction_their_element]}_versioned".to_sym
+                          vname = "#{elh[:name]}_versioned".to_sym
+                          vmod.send(elh[:method], vname, el.type.version_model, elh[:attributes])
+                          @version_elements[el.name] = vname
+                      end
+                  end
+              end
+           end
+           
+           def version_element(el=nil)
+               return :sha1 unless el
+               el = el.name if el.respond_to?(:name)
+               @version_elements[el]
+           end
+           
+           def version_model(branch=nil)
+               @version_models ||= {}
+               @version_models[branch]
+           end
+           
+           def set_version_model(branch, model)
+               @version_models ||= {}
+               @version_models[branch] = model
+           end
+            
+        end
+        
+        module Mapper
+           
+           def save_done(obj, mode)
+               obj.set(obj.class.version_element, obj.version_sha1)
+               obj.reset_modified_elements
+               obj.set_modified(:sha1 => true)
+               obj.mapper.do_update(obj)
+               super
+           end
+            
+        end
+        
+        def version_sha1
+            yaml = self.to_yaml(:except => [:sha1])
+            sha1 = Digest::SHA1.hexdigest(yaml)
+        end
+        
+        def save_version
+            mod = self.class
+            vmod = mod.version_model
+            vobj = vmod.new()
+            vobj.set(mod.elements[:history].reverse, self)
+            ve = mod.version_element
+            unless self.get(ve)
+                self.set(ve, self.version_sha1)
+                self.mapper.do_update(self)
+            end
+            mod.elements_array.each do |el|
+                vobj.set(el.name, self.get(el))
+                vel = mod.version_element(el)
+                if (vel)
+                    if (mod.mapper.have_references?(el))
+                        el_sha1 = self.get(el).get(el.model.version_element)
+                        vobj.set(vel, el_sha1)
+                    else
+                        cond = Spider::Model::Condition.and
+                        cond[el.reverse] = self
+                        ass = el.model.find(cond)
+                        ass.each do |row|
+                            row.save_version
+                        end
+                    end
+                end
+            end
+            vobj.set(:version_date, DateTime.now)
+            begin
+                vobj.mapper.do_insert(vobj)
+            rescue Spider::Model::Storage::DuplicateKey
+            end
+        end
+        
+    end
+    
+end; end

data/lib/spiderfw/model/model.rb

@@ -0,0 +1,226 @@
+require 'spiderfw/model/datatypes'
+require 'spiderfw/model/unit_of_work'
+require 'spiderfw/model/identity_mapper'
+
+module Spider 
+    
+    module Model
+        
+        @base_types = [
+            String, Spider::DataTypes::Text, Fixnum, Float, BigDecimal, Date, DateTime, Spider::DataTypes::Bool
+        ]
+        
+        # Base types are:
+        #
+        # String, Spider::DataTypes::Text, Fixnum, Float, BigDecimal, Date, DateTime, Spider::DataTypes::Bool.
+        #
+        # These types must be handled by all mappers.
+        def self.base_types
+            @base_types
+        end
+        
+        # Returns the base type corresponding to class. Will walk superclasses and DataType info until
+        # a base type is found.
+        def self.base_type(klass)
+            k = klass
+            while (k && !base_types.include?(k))
+                k = simplify_type(k)
+            end
+            return k
+        end
+        
+        # TODO: remove?
+        def self.ruby_type(klass) #:nodoc:
+            map_types = {
+                Spider::DataTypes::Text => String,
+                Spider::DataTypes::Bool => FalseClass,
+                Spider::DataTypes::Binary => String
+            }
+            return map_types[klass] if map_types[klass]
+            return klass
+        end
+        
+        # An iteration in the search for base type.
+        def self.simplify_type(klass) #:nodoc:
+            map_types = {
+                
+            }
+            return klass if base_types.include?(klass)
+            return t if t = map_types[klass]
+            return klass.maps_to if (klass.subclass_of?(Spider::DataType) && klass.maps_to)
+            return klass.superclass if klass.superclass
+            return nil
+        end
+        
+        # FIXME: Tread global variables are no good in no-threaded mode
+        def self.unit_of_work #:nodoc:
+            Thread.current[:unit_of_work]
+        end
+        
+        # Returns the identity-mapped object
+        def self.get(model, val)
+            if (!val.is_a?(Hash))
+                if (model.primary_keys.length == 1)
+                    val = {model.primary_keys[0].name => val}
+                else
+                    raise ModelException, "Can't get without primary keys"
+                end
+            end
+            if identity_mapper
+                return identity_mapper.get(model, val)
+            else
+                return model.new(val)
+            end
+        end
+        
+        # Puts an object into the IdentityMapper
+        def self.put(obj, check=false)
+            if (identity_mapper)
+                return identity_mapper.put(obj, check)
+            else
+                return obj
+            end
+        end
+        
+        # FIXME: no good
+        def self.identity_mapper #:nodoc:
+            Thread.current[:identity_mapper]
+        end
+        
+        # FIXME: no good
+        def self.identity_mapper=(im) #:nodoc:
+            Thread.current[:identity_mapper] = im
+        end
+        
+        # Creates a new unit of work with the proc
+        def self.with_unit_of_work(&proc) #:nodoc: TODO: test
+            return if unit_of_work
+            UnitOfWork.new(&proc)
+        end
+        
+        # Executes the block in the context of the main IdentityMapper.
+        def self.with_identity_mapper(&proc)
+            if identity_mapper
+                yield identity_mapper
+            else
+                IdentityMapper.new do |im|
+                    yield im
+                end
+            end
+        end
+        
+        # Syncs the schema with the storage.
+        #--
+        # FIXME: this is clearly db specific. Move somewhere else.
+        def self.sync_schema(model_or_app, force=false, options={}) #:nodoc:
+            models = []
+            mod = const_get_full(model_or_app)
+            if (mod.is_a?(Module) && mod.include?(Spider::App))
+                mod.models.each { |m| models << m }
+            elsif (mod.subclass_of?(Spider::Model::BaseModel))
+                models << mod
+            end
+            storages = []
+            tables = []
+            models.each do |m|
+                unless (options[:no_sync])
+                    Spider::Logger.debug("SYNCING #{m}")
+                    m.mapper.sync_schema(force, options) if m.mapper.respond_to?(:sync_schema)
+                end
+                if (options[:drop_tables] && m.mapper.respond_to?(:schema))
+                    storages << m.mapper.storage unless storages.include?(m.mapper.storage)
+                    tables += m.mapper.schema.get_schemas.keys
+                end
+            end
+            if (options[:drop_tables])
+                dt = options[:drop_tables]
+                tables.flatten
+                storage_tables = {}
+                storages.each do |s|
+                    s.list_tables.each do |t|
+                        storage_tables[t] = s
+                    end
+                end
+                tables_to_drop = []
+                storage_tables.each do |table_name, storage|
+                    if !tables.include?(table_name) && (dt == true || table_name.index(dt) == 0)
+                        tables_to_drop << table_name
+                    end
+                end
+                raise Spider::Model::Mappers::SchemaSyncUnsafeConversion.new(tables_to_drop) unless tables_to_drop.empty?
+                tables_to_drop.each{ |t| storage.drop_table(t) }
+            end
+        end
+        
+        # Load YAML data
+        def self.load_fixtures(file)
+            if (file =~ /\.([^\.]+)$/)
+                extension = $1
+            else
+                raise ArgumentError, "Can't determine type of fixtures file #{file}"
+            end
+            data = {}
+            case extension
+            when 'yml'
+                require 'yaml'
+                data = YAML.load_file(file)
+            end
+             # Ruby 1.9: steps are not needed with ordered hashes
+            data = [data] unless data.is_a?(Array)
+            data.each do |step|
+                step.each do |mod_name, mod_data|
+                    mod = const_get_full(mod_name)
+                    mod_data.each do |row|
+                        obj = mod.new(row)
+                        obj.insert
+                    end
+                end
+            end
+        end
+        
+        # Generic Model error.
+        
+        class ModelException < RuntimeError
+        end
+        
+        # Error raised when data can't be accepted.
+        
+        class FormatError < ::FormatError
+            attr_reader :element, :value
+            
+            # Takes an Element, the value, and a message.
+            # The message should be a format specification; it will be %'d with the value.
+            #   error = FormatError.new(my_element, 3, "Element value %s is wrong.")
+            #   error.to_s  => "Element value 3 is wrong."
+            def initialize(element, value, message)
+                @element = element
+                @message = message
+                @value = value
+                super(message)
+            end
+            
+            
+            def to_s
+                @message % @value
+            end
+            
+        end
+        
+    end
+    
+
+end
+
+require 'spiderfw/model/base_model'
+require 'spiderfw/model/mixins/mixins'
+require 'spiderfw/model/extended_models/managed'
+require 'spiderfw/model/inline_model'
+require 'spiderfw/model/storage'
+require 'spiderfw/model/request'
+require 'spiderfw/model/condition'
+require 'spiderfw/model/query'
+require 'spiderfw/model/query_set'
+require 'spiderfw/model/unit_of_work'
+require 'spiderfw/model/proxy_model'
+require 'spiderfw/model/mixins/tree'
+require 'spiderfw/model/mixins/list'