datamapper 0.2.4 → 0.2.5

data/lib/data_mapper/adapters/sql/mappings/table.rb

@@ -8,7 +8,7 @@ module DataMapper
     
         class Table
       
-          attr_reader :klass, :name
+          attr_reader :klass, :name, :indexes, :composite_indexes
       
           def initialize(adapter, klass_or_name)
             raise "\"klass_or_name\" must not be nil!" if klass_or_name.nil?
@@ -28,8 +28,7 @@ module DataMapper
             @paranoid = false
             @paranoid_column = nil
             
-            if @klass && @klass.ancestors.include?(DataMapper::Base) && @klass.superclass != DataMapper::Base
-              
+            if @klass && @klass.respond_to?(:persistent?) && @klass.superclass.respond_to?(:persistent?)
               super_table = @adapter.table(@klass.superclass)
               
               super_table.columns.each do |column|
@@ -120,6 +119,8 @@ module DataMapper
             else
               @adapter.connection do |db|
                 db.create_command(to_create_sql).execute_non_query
+                index_queries = to_create_index_sql + to_create_composite_index_sql
+                index_queries.each { |q| db.create_command(q).execute_non_query }
                 schema << self
                 true
               end
@@ -189,7 +190,7 @@ module DataMapper
             class << self
               attr_accessor :key
             end
-            Base::dependencies.resolve!
+            Persistence::dependencies.resolve!
             
             self.key
           end
@@ -199,8 +200,21 @@ module DataMapper
               @keys = @columns.select { |column| column.key? }
             end
           end
-      
-          def add_column(column_name, type, options)
+          
+          def indexes
+          	@indexes || begin
+          	  @indexes = @columns.select { |column| column.index? }
+          	end
+          end
+          
+          # Add a composite index to the table.
+          # +index_columns+ should be an array including each column name.
+          def add_composite_index(index_columns = [], unique = false)
+            @composite_indexes ||= []
+            @composite_indexes << [index_columns, unique] # add paired tuple with the index
+          end
+          
+          def add_column(column_name, type, options = {})
 
             column_ordinal = if options.is_a?(Hash) && options.has_key?(:ordinal)
               options.delete(:ordinal)
@@ -238,8 +252,8 @@ module DataMapper
               elsif @klass_or_name.kind_of?(String)
                 @klass_or_name
               elsif @klass_or_name.kind_of?(Class)
-                if @klass_or_name.superclass != DataMapper::Base \
-                  && @klass_or_name.ancestors.include?(DataMapper::Base)
+                persistent_ancestor = @klass_or_name.superclass.respond_to?(:persistent?)
+                if @klass_or_name.superclass.respond_to?(:persistent?)
                   @adapter.table(@klass_or_name.superclass).name
                 else
                   Inflector.tableize(@klass_or_name.name)
@@ -297,10 +311,38 @@ module DataMapper
                 sql << ", PRIMARY KEY (#{keys.map { |c| c.to_sql }.join(', ') })"
               end
               sql << ")"
+              
               sql.compress_lines
             end
           end
           
+          # Returns an array with each separate CREATE INDEX statement
+          def to_create_index_sql
+            queries = []
+            unless indexes.blank?
+              indexes.each do |column|
+                sql = "CREATE INDEX #{to_s.downcase}_#{column}_index ON "
+                sql << "#{to_sql} (#{column.to_sql})"
+                queries << sql.compress_lines
+              end
+            end
+            queries
+          end
+          
+          # Returns an array with each separate CREATE INDEX statement
+          def to_create_composite_index_sql
+            queries = []
+            unless composite_indexes.blank?
+              composite_indexes.each do |columns, unique|
+                sql = "CREATE #{unique ? 'UNIQUE ' : ''}INDEX "
+                sql << "#{to_s.downcase}_#{columns.join('_')}_index ON "
+                sql << "#{to_sql} (#{columns.join(', ')})"
+                queries << sql.compress_lines
+              end
+            end
+            queries
+          end
+          
           def to_drop_sql
             @to_drop_sql || @to_drop_sql = "DROP TABLE #{to_sql}"
           end

data/lib/data_mapper/associations.rb

@@ -1,7 +1,6 @@
 require 'data_mapper/associations/reference'
 require 'data_mapper/associations/has_many_association'
 require 'data_mapper/associations/belongs_to_association'
-require 'data_mapper/associations/has_one_association'
 require 'data_mapper/associations/has_and_belongs_to_many_association'
 
 module DataMapper
@@ -17,6 +16,10 @@ module DataMapper
         database.schema[self].associations << HasManyAssociation.new(self, association_name, options)
       end
       
+      def has_one(association_name, options = {})
+        database.schema[self].associations << HasManyAssociation.new(self, association_name, options)
+      end
+      
       def belongs_to(association_name, options = {})
         database.schema[self].associations << BelongsToAssociation.new(self, association_name, options)
       end
@@ -25,10 +28,6 @@ module DataMapper
         database.schema[self].associations << HasAndBelongsToManyAssociation.new(self, association_name, options)
       end
       
-      def has_one(association_name, options = {})
-        database.schema[self].associations << HasOneAssociation.new(self, association_name, options)
-      end
-      
     end
     
   end

data/lib/data_mapper/associations/has_and_belongs_to_many_association.rb

@@ -184,7 +184,7 @@ module DataMapper
                 command = db.create_command(association.to_delete_sql)
                 command.execute_non_query(@instance.key)
               end
-            
+              
               unless @entries.empty?
                 if adapter.batch_insertable?
                   sql = association.to_insert_sql
@@ -224,7 +224,7 @@ module DataMapper
         
         def <<(member)
           @new_members = true
-          entries << member
+          entries << member unless member.nil?
         end
         
         def clear

data/lib/data_mapper/associations/has_many_association.rb

@@ -22,6 +22,14 @@ module DataMapper
         "UPDATE #{associated_table.to_sql} SET #{foreign_key_column.to_sql} = NULL WHERE #{foreign_key_column.to_sql} = ?"
       end
       
+      def instance_variable_name
+        class << self
+          attr_reader :instance_variable_name
+        end
+        
+        @instance_variable_name = "@#{@association_name}"
+      end
+      
       class Set < Associations::Reference
         
         include Enumerable
@@ -60,7 +68,7 @@ module DataMapper
         end
         
         def <<(associated_item)
-          items << associated_item
+          (@items || @items = []) << associated_item
           
           # TODO: Optimize!
           fk = association.foreign_key_column
@@ -85,8 +93,12 @@ module DataMapper
           item
         end
         
-        def set(items)
-          @items = items
+        def set(value)
+          values = value.is_a?(Enumerable) ? value : [value]
+          @items = []
+          values.each do |item|
+            self << item
+          end
         end
         
         def method_missing(symbol, *args, &block)
@@ -100,6 +112,8 @@ module DataMapper
               end
             end
             results.flatten
+          elsif items.size == 1 && items.first.respond_to?(symbol)
+            items.first.send(symbol, *args, &block)
           else
             super
           end
@@ -117,17 +131,12 @@ module DataMapper
           @items || begin
             if @instance.loaded_set.nil?
               @items = []
-            else
-              fk = association.foreign_key_column.to_sym
-              
-              finder_options = { association.foreign_key_column.to_sym => @instance.loaded_set.map { |item| item.key } }
-              finder_options.merge!(association.finder_options)
-              
-              associated_items = @instance.database_context.all(
-                association.associated_constant,
-                finder_options
-              ).group_by { |entry| entry.send(fk) }
+            else              
+              associated_items = fetch_sets
               
+              # This is where @items is set, by calling association=,
+              # which in turn calls HasManyAssociation::Set#set.
+              association_ivar_name = association.instance_variable_name
               setter_method = "#{@association_name}=".to_sym
               @instance.loaded_set.each do |entry|
                 entry.send(setter_method, associated_items[entry.key])
@@ -141,6 +150,24 @@ module DataMapper
         def inspect
           entries.inspect
         end
+        
+        def ==(other)
+          (items.size == 1 ? items.first : items) == other
+        end
+        
+        private
+        def fetch_sets
+          finder_options = { association.foreign_key_column.to_sym => @instance.loaded_set.map { |item| item.key } }
+          finder_options.merge!(association.finder_options)
+          
+          foreign_key_ivar_name = association.foreign_key_column.instance_variable_name
+          
+          @instance.database_context.all(
+            association.associated_constant,
+            finder_options
+          ).group_by { |entry| entry.instance_variable_get(foreign_key_ivar_name) }
+        end
+        
       end
 
     end

data/lib/data_mapper/associations/has_n_association.rb

@@ -23,7 +23,7 @@ module DataMapper
         
         define_accessor(klass)
         
-        Base::dependencies.add(associated_constant_name) do |klass|
+        Persistence::dependencies.add(associated_constant_name) do |klass|
           @foreign_key_column = associated_table[foreign_key_name]
           
           unless @foreign_key_column

data/lib/data_mapper/base.rb

@@ -1,12 +1,4 @@
-require 'data_mapper/property'
-require 'data_mapper/support/active_record_impersonation'
-require 'data_mapper/support/serialization'
-require 'data_mapper/validations'
-require 'data_mapper/associations'
-require 'data_mapper/callbacks'
-require 'data_mapper/embedded_value'
-require 'data_mapper/auto_migrations'
-require 'data_mapper/dependency_queue'
+require 'data_mapper/persistence'
 
 begin
   require 'ferret'
@@ -16,449 +8,14 @@ end
 module DataMapper
 
   class Base
-    
-    # This probably needs to be protected
-    attr_accessor :loaded_set
-    
-    include CallbacksHelper
-    include Support::ActiveRecordImpersonation
-    include Support::Serialization
-    include Validations
-    include Associations
-    
-    # Track classes that inherit from DataMapper::Base.
-    def self.subclasses
-      @subclasses || (@subclasses = [])
-    end
-    
-    def self.auto_migrate!
-      subclasses.each do |subclass|
-        subclass.auto_migrate!
-      end
-    end
-    
-    def self.dependencies
-      @dependency_queue || (@dependency_queue = DependencyQueue.new) 
-    end
+    include DataMapper::Persistence
     
     def self.inherited(klass)
-      klass.instance_variable_set('@properties', [])
-      
-      klass.send :extend, AutoMigrations
-      DataMapper::Base::subclasses << klass
-      klass.send(:undef_method, :id)
-      
-      # When this class is sub-classed, copy the declared columns.
-      klass.class_eval do
-        def self.subclasses
-          @subclasses || (@subclasses = [])
-        end
-        
-        def self.inherited(subclass)
-          
-          super_table = database.table(self)
-          
-          if super_table.type_column.nil?
-            super_table.add_column(:type, :class, {})
-          end
-          
-          self::subclasses << subclass
-        end
-      end
-    end
-    
-    def self.logger
-      database.logger
-    end
-    
-    def logger
-      self.class.logger
-    end
-    
-    def self.transaction
-      yield
-    end
-    
-    def self.properties
-      @properties
-    end
-    
-    # Allows you to override the table name for a model.
-    # EXAMPLE:
-    #   class WorkItem
-    #     set_table_name 't_work_item_list'
-    #   end
-    def self.set_table_name(value)
-      database.schema[self].name = value
-    end
-    
-    def initialize(details = nil)
-      
-      case details
-      when Hash then self.attributes = details
-      when DataMapper::Base then self.attributes = details.attributes
-      when NilClass then nil
-      end
-    end
-    
-    PROPERTY_OPTIONS = [
-      :public, :protected, :private, :accessor, :reader, :writer,
-      :lazy, :default, :nullable, :key, :serial, :column
-    ]
-    
-    # Adds property accessors for a field that you'd like to be able to modify.  The DataMapper doesn't
-    # use the table schema to infer accessors, you must explicity call #property to add field accessors
-    # to your model.
-    #
-    # EXAMPLE:
-    #   class CellProvider
-    #     property :name, :string
-    #     property :rating, :integer
-    #   end
-    #
-    #   att = CellProvider.new(:name => 'AT&T')
-    #   att.rating = 3
-    #   puts att.name, att.rating
-    #
-    #   => AT&T
-    #   => 3
-    #
-    # OPTIONS:
-    #   * <tt>lazy</tt>: Lazy load the specified property (:lazy => true). False by default.
-    #   * <tt>accessor</tt>: Set method visibility for the property accessors. Affects both 
-    #   reader and writer. Allowable values are :public, :protected, :private. Defaults to 
-    #   :public
-    #   * <tt>reader</tt>: Like the accessor option but affects only the property reader.
-    #   * <tt>writer</tt>: Like the accessor option but affects only the property writer.
-    #   * <tt>protected</tt>: Alias for :reader => :public, :writer => :protected
-    #   * <tt>private</tt>: Alias for :reader => :public, :writer => :private
-    def self.property(name, type, options = {})
-      
-      options.each_pair do |k,v|
-        raise ArgumentError.new("#{k.inspect} is not a supported option in DataMapper::Base::PROPERTY_OPTIONS") unless PROPERTY_OPTIONS.include?(k)
-      end
-      
-      visibility_options = [:public, :protected, :private]
-      reader_visibility = options[:reader] || options[:accessor] || :public
-      writer_visibility = options[:writer] || options[:accessor] || :public
-      writer_visibility = :protected if options[:protected]
-      writer_visibility = :private if options[:private]
-
-      raise(ArgumentError.new, "property visibility must be :public, :protected, or :private") unless visibility_options.include?(reader_visibility) && visibility_options.include?(writer_visibility)
-
-      mapping = database.schema[self].add_column(name.to_s.sub(/\?$/, '').to_sym, type, options)
-
-      property_getter(mapping, reader_visibility)
-      property_setter(mapping, writer_visibility)
-      
-      if MAGIC_PROPERTIES.has_key?(name)
-        class_eval(&MAGIC_PROPERTIES[name])
-      end
-      
-      return name
-    end
-    
-    MAGIC_PROPERTIES = {
-      :updated_at => lambda { before_save { |x| x.updated_at = Time::now } },
-      :updated_on => lambda { before_save { |x| x.updated_on = Date::today } },
-      :created_at => lambda { before_create { |x| x.created_at = Time::now } },
-      :created_on => lambda { before_create { |x| x.created_on = Date::today } }
-    }
-    
-    # An embedded value maps the values of an object to fields in the record of the object's owner.
-    # #embed takes a symbol to define the embedded class, options, and an optional block. See 
-    # examples for use cases.
-    # 
-    # EXAMPLE:
-    #   class CellPhone < DataMapper::Base
-    #     property :number, :string
-    #
-    #     embed :owner, :prefix => true do
-    #       property :name, :string
-    #       property :address, :string
-    #     end
-    #   end
-    #
-    #   my_phone = CellPhone.new
-    #   my_phone.owner.name = "Nick"
-    #   puts my_phone.owner.name
-    #
-    #   => Nick
-    #
-    # OPTIONS:
-    #   * <tt>prefix</tt>: define a column prefix, so instead of mapping :address to an 'address' 
-    #   column, it would map to 'owner_address' in the example above. If :prefix => true is 
-    #   specified, the prefix will be the name of the symbol given as the first parameter. If the
-    #   prefix is a string the specified string will be used for the prefix.
-    #   * <tt>lazy</tt>: lazy-load all embedded values at the same time. :lazy => true to enable.
-    #   Disabled (false) by default.
-    #   * <tt>accessor</tt>: Set method visibility for all embedded properties. Affects both
-    #   reader and writer. Allowable values are :public, :protected, :private. Defaults to :public
-    #   * <tt>reader</tt>: Like the accessor option but affects only embedded property readers.
-    #   * <tt>writer</tt>: Like the accessor option but affects only embedded property writers.
-    #   * <tt>protected</tt>: Alias for :reader => :public, :writer => :protected
-    #   * <tt>private</tt>: Alias for :reader => :public, :writer => :private
-    #
-    def self.embed(name, options = {}, &block)
-      EmbeddedValue::define(self, name, options, &block)
-    end
-
-    def self.property_getter(mapping, visibility = :public)
-      if mapping.lazy?
-        class_eval <<-EOS
-          #{visibility.to_s}
-          def #{mapping.name}
-            lazy_load!(#{mapping.name.inspect})
-            class << self;
-              attr_accessor #{mapping.name.inspect}
-            end
-            @#{mapping.name}
-          end
-        EOS
-      else
-        class_eval("#{visibility.to_s}; def #{mapping.name}; #{mapping.instance_variable_name} end") unless [ :public, :private, :protected ].include?(mapping.name)
-      end
-      
-      if mapping.type == :boolean
-        class_eval("#{visibility.to_s}; def #{mapping.name}?; #{mapping.instance_variable_name} end")
-      end
-    end
-    
-    def self.property_setter(mapping, visibility = :public)
-      if mapping.lazy?
-        class_eval <<-EOS
-          #{visibility.to_s}
-          def #{mapping.name}=(value)
-            class << self;
-              attr_accessor #{mapping.name.inspect}
-            end
-            @#{mapping.name} = value
-          end
-        EOS
-      else
-        class_eval("#{visibility.to_s}; def #{mapping.name}=(value); #{mapping.instance_variable_name} = value end")
-      end
-    end
-    
-    # Lazy-loads the attributes for a loaded_set, then overwrites the accessors
-    # for the named methods so that the lazy_loading is skipped the second time.
-    def lazy_load!(*names)
-      
-      names = names.map { |name| name.to_sym }.reject { |name| lazy_loaded_attributes.include?(name) }
-      
-      reset_attribute = lambda do |instance|
-        singleton_class = (class << instance; self end)
-        names.each do |name|
-          instance.lazy_loaded_attributes << name
-          singleton_class.send(:attr_accessor, name)
-        end
-      end
-      
-      unless names.empty? || new_record? || loaded_set.nil?
-        
-        key = database_context.table(self.class).key.to_sym
-        keys_to_select = loaded_set.map do |instance|
-          instance.send(key)
-        end
-        
-        database_context.all(
-          self.class,
-          :select => ([key] + names),
-          :reload => true,
-          key => keys_to_select
-        ).each(&reset_attribute)
-      else
-        reset_attribute[self]
-      end
-      
-    end
-    
-    def new_record?
-      @new_record.nil? || @new_record
-    end
-
-    def ==(other)
-      private_attributes == other.send("private_attributes")
-    end
-    
-    # Returns the difference between two objects, in terms of their attributes. 
-    def ^(other)
-      results = {}
-      
-      self_attributes, other_attributes = attributes, other.attributes
-      
-      self_attributes.each_pair do |k,v|
-        other_value = other_attributes[k]
-        unless v == other_value
-          results[k] = [v, other_value]
-        end
-      end
-      
-      results      
-    end
-    
-    def lazy_loaded_attributes
-      @lazy_loaded_attributes || @lazy_loaded_attributes = Set.new
-    end
-    
-    def loaded_attributes
-      pairs = {}
-      
-      database_context.table(self).columns.each do |column|
-        pairs[column.name] = instance_variable_get(column.instance_variable_name)
-      end
-      
-      pairs
-    end
-    
-    def update_attributes(update_hash)
-      self.attributes = update_hash
-      self.save
-    end
-    
-    def attributes
-      pairs = {}
-      
-      database_context.table(self).columns.each do |column|
-        if self.class.public_method_defined?(column.name)
-          lazy_load!(column.name) if column.lazy?
-          value = instance_variable_get(column.instance_variable_name)
-          pairs[column.name] = column.type == :class ? value.to_s : value
-        end
-      end
-      
-      pairs
-    end
-    
-    # Mass-assign mapped fields.
-    def attributes=(values_hash)
-      table = database_context.table(self.class)
-      
-      values_hash.delete_if do |key, value|
-        !self.class.public_method_defined?("#{key}=")
-      end.each_pair do |key, value|
-        if respond_to?(key)
-          send("#{key}=", value)
-        elsif column = table[key]
-          instance_variable_set(column.instance_variable_name, value)          
-        end
-      end
-    end
-    
-    def dirty?
-      result = database_context.table(self).columns.any? do |column|
-        if column.type == :object
-          Marshal.dump(self.instance_variable_get(column.instance_variable_name)) != original_values[column.name]
-        else
-          self.instance_variable_get(column.instance_variable_name) != original_values[column.name]
-        end
-      end
-      
-      return true if result
-      
-      loaded_associations.any? do |loaded_association|
-        loaded_association.dirty?
-      end
+      DataMapper::Persistence::prepare_for_persistence(klass)
     end
 
-    def dirty_attributes
-      pairs = {}
-      
-      database_context.table(self).columns.each do |column|
-        value = instance_variable_get(column.instance_variable_name)
-        if value != original_values[column.name] && (!new_record? || !column.serial?)
-          pairs[column.name] = column.type != :object ? value : YAML.dump(value)
-        end
-      end
-      
-      pairs
-    end
-    
-    def original_values
-      @original_values || (@original_values = {})
-    end
-    
-    def self.index
-      @index || @index = Ferret::Index::Index.new(:path => "#{database.adapter.index_path}/#{name}")
-    end
-    
-    def self.reindex!
-      all.each do |record|
-        index << record.attributes
-      end
-    end
-    
-    def self.search(phrase)
-      ids = []
-      
-      query = "#{database.schema[self].columns.map(&:name).join('|')}:\"#{phrase}\""
-
-      index.search_each(query) do |document_id, score|
-        ids << index[document_id][:id]
-      end
-      return all(:id => ids)
-    end
-    
-    def self.foreign_key
-      Inflector.underscore(self.name) + "_id"
-    end
-    
-    def self.table
-      database.schema[self]
-    end
-    
-    def inspect
-      inspected_attributes = attributes.map { |k,v| "@#{k}=#{v.inspect}" }
-      
-      instance_variables.each do |name|
-        if instance_variable_get(name).kind_of?(Associations::HasManyAssociation)
-          inspected_attributes << "#{name}=#{instance_variable_get(name).inspect}"
-        end
-      end
-      
-      "#<%s:0x%x @new_record=%s, %s>" % [self.class.name, (object_id * 2), new_record?, inspected_attributes.join(', ')]
-    end
-    
-    def loaded_associations
-      @loaded_associations || @loaded_associations = []
-    end
-    
-    def database_context=(value)
-      @database_context = value
-    end
-    
-    def database_context
-      @database_context || ( @database_context = database )
-    end
-    
-    def key=(value)
-      key_column = database_context.table(self.class).key
-      @__key = key_column.type_cast_value(value)
-      instance_variable_set(key_column.instance_variable_name, @__key)
-    end
-    
-    def key
-      @__key || @__key = begin
-        key_column = database_context.table(self.class).key
-        key_column.type_cast_value(instance_variable_get(key_column.instance_variable_name))
-      end
-    end
-
-    private
-
-    # return all attributes, regardless of their visibility
-    def private_attributes
-      pairs = {}
-
-      database_context.table(self).columns.each do |column|
-        lazy_load!(column.name) if column.lazy?
-        value = instance_variable_get(column.instance_variable_name)
-        pairs[column.name] = column.type == :class ? value.to_s : value
-      end
-
-      pairs
+    def self.subclasses
+      []
     end
-    
   end
-  
 end