datamapper 0.1.1 → 0.2.0

data/lib/data_mapper/associations/has_n_association.rb

@@ -0,0 +1,64 @@
+module DataMapper
+  module Associations
+    
+    class HasNAssociation
+      
+      attr_reader :adapter, :table, :options
+      
+      OPTIONS = [
+        :class,
+        :class_name,
+        :foreign_key
+      ]
+      
+      def initialize(klass, association_name, options)
+        @adapter = database.adapter
+        @table = adapter.table(klass)
+        @association_name = association_name.to_sym
+        @options = options || Hash.new
+        
+        define_accessor(klass)
+      end
+      
+      def name
+        @association_name
+      end
+
+      def constant
+        @associated_class || @associated_class = if @options.has_key?(:class) || @options.has_key?(:class_name)
+          associated_class_name = (@options[:class] || @options[:class_name])
+          if associated_class_name.kind_of?(String)
+            Kernel.const_get(Inflector.classify(associated_class_name))
+          else
+            associated_class_name
+          end
+        else            
+          Kernel.const_get(Inflector.classify(@association_name))
+        end
+      end
+      
+      def foreign_key
+        @foreign_key || @foreign_key = begin
+          association_table[@options[:foreign_key] || table.default_foreign_key]
+        end
+      end
+      
+      def association_table
+        @association_table || (@association_table = adapter.table(constant))
+      end
+      
+      def to_sql
+        "JOIN #{association_table.to_sql} ON #{foreign_key.to_sql(true)} = #{table.key.to_sql(true)}"
+      end
+      
+      def association_columns
+        association_table.columns.reject { |column| column.lazy? }
+      end
+      
+      def finder_options
+        @finder_options || @finder_options = @options.reject { |k,v| self.class::OPTIONS.include?(k) }
+      end
+    end
+    
+  end
+end

data/lib/data_mapper/associations/has_one_association.rb

@@ -1,107 +1,77 @@
+require 'data_mapper/associations/has_n_association'
+
 module DataMapper
   module Associations
     
-    class HasOneAssociation
-      
-      def initialize(instance, association_name, options)
-        @instance = instance
-        @association_name = association_name
-        @options = options
-        
-        @associated_class = if options.has_key?(:class) || options.has_key?(:class_name)
-          associated_class_name = (options[:class] || options[:class_name])
-          if associated_class_name.kind_of?(String)
-            Kernel.const_get(Inflector.classify(associated_class_name))
-          else
-            associated_class_name
-          end
-        else            
-          Kernel.const_get(Inflector.classify(association_name))
-        end
-      end
+    class HasOneAssociation < HasNAssociation
       
-      def self.setup(klass, association_name, options)
-        
-        # Define the association instance method (i.e. Exhibit#zoo)
+      # Define the association instance method (i.e. Project#tasks)
+      def define_accessor(klass)        
         klass.class_eval <<-EOS
-          def create_#{association_name}(options = {})
-            #{association_name}_association.create(options)
+          def create_#{@association_name}(options)
+            #{@association_name}_association.create(options)
           end
           
-          def build_#{association_name}(options = {})
-            #{association_name}_association.build(options)
+          def build_#{@association_name}(options)
+            #{@association_name}_association.build(options)
           end
 
-          def #{association_name}
-            # Let the HasOneAssociation do the finding, just to keep things neat around here...
-            #{association_name}_association.find
+          def #{@association_name}
+            #{@association_name}_association.instance
           end
           
-          def #{association_name}=(value)
-            #{association_name}_association.set(value)
+          def #{@association_name}=(value)
+            #{@association_name}_association.set(value)
           end
           
           private
-            def #{association_name}_association
-              @#{association_name} || (@#{association_name} = HasOneAssociation.new(self, "#{association_name}", #{options.inspect}))
+            def #{@association_name}_association
+              @#{@association_name}_association || (@#{@association_name}_association = DataMapper::Associations::HasOneAssociation::Instance.new(self, #{@association_name.inspect}))
             end
         EOS
-        
       end
       
-      def find
-        return @result unless @result.nil?
-        
-        unless @instance.loaded_set.nil?
-          
-          # Temp variable for the instance variable name.
-          setter_method = "#{@association_name}=".to_sym
-          instance_variable_name = "@#{foreign_key}".to_sym
+      class Instance < Associations::Reference
+      
+        def instance
+          @associated || @associated = begin                    
+            if @instance.loaded_set.nil?
+              nil
+            else
+              # Temp variable for the instance variable name.
+              setter_method = "#{@association_name}=".to_sym
+              instance_variable_name = "@#{association.foreign_key}".to_sym
           
-          set = @instance.loaded_set.group_by { |instance| instance.key }
+              set = @instance.loaded_set.group_by { |instance| instance.key }
           
-          # Fetch the foreign objects for all instances in the current object's loaded-set.
-          @instance.session.all(@associated_class, foreign_key => set.keys).each do |association|
-            set[association.instance_variable_get(instance_variable_name)].first.send(setter_method, association)
+              # Fetch the foreign objects for all instances in the current object's loaded-set.
+              @instance.session.all(association.constant, association.foreign_key => set.keys).each do |assoc|
+                set[assoc.instance_variable_get(instance_variable_name)].first.send(setter_method, assoc)
+              end
+              
+              @associated
+            end
+            
           end
         end
-        
-        return @result
-      end
 
-      def create(options = {})
-        associated = @associated_class.new(options)
-        if associated.save
-          @instance.send("#{@associated_class.foreign_key}=", associated.id)
-          @result = associated
+        def create(options)
+          @associated = association.constant.new(options)
+          if @associated.save
+            @associated.send("#{@associated_class.foreign_key}=", @instance.key)
+          end
         end
-      end
       
-      def build(options = {})
-        @result = @associated_class.new(options)
-      end
-      
-      def set(val)
-        @result = val
-      end
+        def build(options)
+          @associated = association.constant.new(options)
+        end
       
-      def foreign_key
-        @foreign_key ||= (@options[:foreign_key] || @instance.session.mappings[@instance.class].default_foreign_key)
-      end
+        def set(val)
+          @associated = val
+        end
             
-    end
-    
-    module HasOne
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
+      end # class Instance
       
-      module ClassMethods
-        def has_one(association_name, options = {})
-          HasOneAssociation.setup(self, association_name, options)
-        end
-      end
-    end
-    
-  end
-end
+    end # class HasOneAssociation
+  end # module Associations
+end # module DataMapper

data/lib/data_mapper/associations/reference.rb

@@ -0,0 +1,47 @@
+module DataMapper
+  
+  module Associations
+    
+    # Reference is an abstract-class providing the boiler-plate for
+    # the association proxies (ie: HasManyAssociation::Set, or
+    # HasOneAssociation::Instance)
+    # The proxies need to access the defining Association instances
+    # to obtain mapping information. This class provides convenient
+    # access to said Association.
+    #
+    # EXAMPLE:
+    #   class Zoo
+    #     has_many :exhibits
+    #   end
+    # The +has_many+ declaration instantiates a
+    # DataMapper::Associations::HasManyAssociation and adds it to the
+    # DataMapper::Adapters::Sql::Mappings::Table#associations array for
+    # the Table representing Zoo.
+    #
+    #   Zoo.new.exhibits
+    # +exhibits+ above returns an instance of
+    # DataMapper::Associations::HasManyAssociation::Set. This instance
+    # needs to access the actual HasManyAssociation instance in order
+    # to access the mapping information within. The DataMapper::Associations::Reference
+    # abstract-class for the Set provides the Reference#association method in order to
+    # provide easy access to this information.
+    class Reference
+  
+      # +instance+ is a mapped object instance. ie: #<Zoo:0x123456 ...>
+      # +association_name+ is the Symbol used to look up the Association
+      # instance within the DataMapper::Adapters::Sql::Mappings::Table 
+      def initialize(instance, association_name)
+        @instance, @association_name = instance, association_name.to_sym
+        @instance.loaded_associations << self
+      end
+  
+      # #association provides lazily initialized access to the declared
+      # Association.
+      def association
+        @association || (@association = @instance.session.table(@instance.class).associations[@association_name])
+      end
+  
+    end
+  end
+
+end

data/lib/data_mapper/base.rb

@@ -1,8 +1,14 @@
-require 'data_mapper/unit_of_work'
 require 'data_mapper/support/active_record_impersonation'
+require 'data_mapper/support/serialization'
 require 'data_mapper/validations/validation_helper'
 require 'data_mapper/associations'
 require 'data_mapper/callbacks'
+require 'data_mapper/embedded_value'
+
+begin
+  require 'ferret'
+rescue LoadError
+end
 
 module DataMapper
   
@@ -11,56 +17,123 @@ module DataMapper
     # This probably needs to be protected
     attr_accessor :loaded_set
     
-    include UnitOfWork
+    include CallbacksHelper
     include Support::ActiveRecordImpersonation
+    include Support::Serialization
     include Validations::ValidationHelper
     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.inherited(klass)
-      klass.send(:undef_method, :id)
+      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.inherited(subclass)
-          
-          database.schema[subclass.superclass].columns.each do |c|
-            subclass.property(c.name, c.type, c.options)
-            subclass.before_create do
-              @type = self.class
-            end if c.name == :type
+        
+        def self.auto_migrate!
+          if self::subclasses.empty?
+            database.schema[self].drop!
+            database.save(self)
+          else
+            schema = database.schema
+            columns = self::subclasses.inject(schema[self].columns) do |span, subclass|
+              span + schema[subclass].columns
+            end
+            
+            table_name = schema[self].name.to_s
+            table = schema[table_name]
+            columns.each do |column|
+              table.add_column(column.name, column.type, column.options)
+            end
+            
+            table.drop!
+            table.create!
           end
-          
+        end
+        
+        def self.subclasses
+          @subclasses || (@subclasses = [])
+        end
+        
+        def self.inherited(subclass)
+          self::subclasses << subclass
         end
       end
     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)
       
-      unless details.nil?
-        details.reject do |key, value|
-          protected_attribute? key
-        end.each_pair do |key, value|
-          instance_variable_set("@#{key}", value)
-        end
+      case details
+      when Hash then self.attributes = details
+      when DataMapper::Base then self.attributes = details.attributes
+      when NilClass then nil
       end
     end
     
+    # 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
     def self.property(name, type, options = {})
       mapping = database.schema[self].add_column(name, type, options)
       property_getter(name, mapping)
       property_setter(name, mapping)
+      
+      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 } }
+    }
+    
+    def self.embed(class_or_name, &block)
+      EmbeddedValue::define(self, class_or_name, &block)
+    end
+
     def self.property_getter(name, mapping)
       if mapping.lazy?
         class_eval <<-EOS
           def #{name}
-            lazy_load!("#{name}")
+            lazy_load!(#{name.inspect})
+            @#{name}
           end
         EOS
       else
@@ -83,34 +156,114 @@ module DataMapper
       end
     end
     
-    def lazy_load!(name)
-      (class << self; self end).send(:attr_accessor, name)
+    # 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)
+      
+      reset_attribute = lambda do |instance|
+        singleton_class = (class << instance; self end)
+        names.each do |name|
+          singleton_class.send(:attr_accessor, name)
+        end
+      end
       
-      column = session.schema[self.class][name.to_sym]
+      unless new_record? || loaded_set.nil?
+        session.all(
+          self.class,
+          :select => ([:id] + names),
+          :reload => true,
+          :id => loaded_set.map(&:id)
+        ).each(&reset_attribute)
+      else
+        reset_attribute[self]
+      end
       
-      # If the value is already loaded, then we don't need to do it again.
-      value = instance_variable_get(column.instance_variable_name)
-      return value unless value.nil?
+    end
+    
+    def new_record?
+      @new_record.nil? || @new_record
+    end
+    
+    def loaded_attributes
+      pairs = {}
       
-      session.all(self.class, :select => [:id, name], :reload => true, :id => loaded_set.map(&:id)).each do |instance|
-        (class << self; self end).send(:attr_accessor, name)
+      session.table(self).columns.each do |column|
+        pairs[column.name] = instance_variable_get(column.instance_variable_name)
       end
       
-      instance_variable_get(column.instance_variable_name)
+      pairs
     end
-        
+    
     def attributes
-      session.schema[self.class].columns.inject({}) do |values, column|
-        values[column.name] = instance_variable_get(column.instance_variable_name); values
+      pairs = {}
+      
+      session.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
     end
     
+    # Mass-assign mapped fields.
     def attributes=(values_hash)
+      table = session.schema[self.class]
+      
       values_hash.reject do |key, value|
         protected_attribute? key
       end.each_pair do |key, value|
-        symbolic_instance_variable_set(key, value)
+        if column = table[key]
+          instance_variable_set(column.instance_variable_name, value)
+        else
+          send("#{key}=", value)
+        end
+      end
+    end
+    
+    def dirty?(name = nil)
+      if name.nil?
+        session.table(self).columns.any? do |column|
+          if value = self.instance_variable_get(column.instance_variable_name)
+            value.hash != original_hashes[column.name]
+          else
+            false
+          end
+        end || loaded_associations.any? do |loaded_association|
+          if loaded_association.respond_to?(:dirty?)
+            loaded_association.dirty?
+          else
+            false
+          end
+        end
+      else
+        key = name.kind_of?(Symbol) ? name : name.to_sym
+        self.instance_variable_get("@#{name}").hash != original_hashes[key]
+      end
+    end
+
+    def dirty_attributes
+      pairs = {}
+      
+      if new_record?
+        session.table(self).columns.each do |column|
+          unless (value = instance_variable_get(column.instance_variable_name)).nil?
+            pairs[column.name] = value
+          end
+        end
+      else
+        session.table(self).columns.each do |column|
+          if (value = instance_variable_get(column.instance_variable_name)).hash != original_hashes[column.name]
+            pairs[column.name] = value
+          end
+        end
       end
+      
+      pairs
+    end
+    
+    def original_hashes
+      @original_hashes || (@original_hashes = {})
     end
     
     def protected_attribute?(key)
@@ -121,12 +274,33 @@ module DataMapper
       @protected_attributes ||= []
     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.protect(*keys)
       keys.each { |key| protected_attributes << key.to_sym }
     end
     
     def self.foreign_key
-      String::memoized_underscore(self.name) + "_id"
+      Inflector.underscore(self.name) + "_id"
     end
     
     def inspect
@@ -141,6 +315,10 @@ module DataMapper
       "#<%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 session=(value)
       @session = value
     end
@@ -149,6 +327,12 @@ module DataMapper
       @session || ( @session = database )
     end
     
+    def key=(value)
+      key_column = session.schema[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 = session.schema[self.class].key
@@ -156,24 +340,6 @@ module DataMapper
       end
     end
     
-    # Callbacks associated with this class.
-    def self.callbacks
-      @callbacks || ( @callbacks = Callbacks.new )
-    end
-    
-    # Declare helpers for the standard callbacks
-    DataMapper::Callbacks::EVENTS.each do |name|
-      class_eval <<-EOS
-        def self.#{name}(string = nil, &block)
-          if string.nil?
-            callbacks.add(:#{name}, &block)
-          else
-            callbacks.add(:#{name}, string)
-          end
-        end
-      EOS
-    end
-    
   end
   
 end