datamapper 0.1.0 → 0.1.1

data/lib/data_mapper/associations.rb

@@ -1,4 +1,5 @@
 require 'data_mapper/associations/has_many_association'
+require 'data_mapper/associations/advanced_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'
@@ -9,6 +10,7 @@ module DataMapper
     def self.included(base)
       base.class_eval do
         include DataMapper::Associations::HasMany
+        include DataMapper::Associations::AdvancedHasMany
         include DataMapper::Associations::BelongsTo
         include DataMapper::Associations::HasOne
         include DataMapper::Associations::HasAndBelongsToMany

data/lib/data_mapper/associations/advanced_has_many_association.rb

@@ -0,0 +1,55 @@
+module DataMapper
+  module Associations
+    
+    class AdvancedHasManyAssociation
+      include Enumerable
+      
+      def initialize(klass, association_name, options)
+        @association_name = association_name.to_sym
+        @options = options
+
+        # Define the association instance method (i.e. Project#tasks)
+        klass.class_eval <<-EOS
+          def #{association_name}
+            @#{association_name} || (@#{association_name} = HasManyAssociation.new(self, "#{association_name}", #{options.inspect}))
+          end
+        EOS
+      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 = (@options[:foreign_key] || @instance.session.schema[@instance.class].default_foreign_key))
+      end
+
+    end
+    
+    module AdvancedHasMany
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def advanced_has_many(association_name, options = {})
+          database.schema[self].associations << AdvancedHasManyAssociation.new(self, association_name, options)
+        end
+      end
+    end
+    
+  end
+end

data/lib/data_mapper/associations/belongs_to_association.rb

@@ -60,10 +60,10 @@ module DataMapper
           setter_method = "#{@association_name}=".to_sym
           instance_variable_name = "@#{foreign_key}".to_sym
           
-          set = @instance.loaded_set.instances.group_by { |instance| instance.instance_variable_get(instance_variable_name) }
+          set = @instance.loaded_set.group_by { |instance| instance.instance_variable_get(instance_variable_name) }
           
           # Fetch the foreign objects for all instances in the current object's loaded-set.
-          @instance.session.find(@associated_class, :all, :id => set.keys).each do |owner|
+          @instance.session.all(@associated_class, :id => set.keys).each do |owner|
             set[owner.key].each do |instance|
               instance.send(setter_method, owner)
             end

data/lib/data_mapper/associations/has_many_association.rb

@@ -22,7 +22,7 @@ module DataMapper
       end
       
       def self.setup(klass, association_name, options)
-        
+
         # Define the association instance method (i.e. Project#tasks)
         klass.class_eval <<-EOS
           def #{association_name}
@@ -57,10 +57,10 @@ module DataMapper
           # Temp variable for the instance variable name.
           instance_variable_name = "@#{foreign_key}".to_sym
           
-          set = @instance.loaded_set.instances.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.find(@associated_class, :all, foreign_key.to_sym => set.keys).group_by do |association|
+          @instance.session.all(@associated_class, foreign_key.to_sym => set.keys).group_by do |association|
             association.instance_variable_get(instance_variable_name)
           end.each_pair do |id, results|
             set[id].first.send(@association_name).set(results)

data/lib/data_mapper/associations/has_one_association.rb

@@ -58,10 +58,10 @@ module DataMapper
           setter_method = "#{@association_name}=".to_sym
           instance_variable_name = "@#{foreign_key}".to_sym
           
-          set = @instance.loaded_set.instances.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.find(@associated_class, :all, foreign_key => set.keys).each do |association|
+          @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)
           end
         end

data/lib/data_mapper/base.rb

@@ -1,8 +1,8 @@
 require 'data_mapper/unit_of_work'
-require 'data_mapper/extensions/active_record_impersonation'
-require 'data_mapper/extensions/callback_helpers'
+require 'data_mapper/support/active_record_impersonation'
 require 'data_mapper/validations/validation_helper'
 require 'data_mapper/associations'
+require 'data_mapper/callbacks'
 
 module DataMapper
   
@@ -12,9 +12,8 @@ module DataMapper
     attr_accessor :loaded_set
     
     include UnitOfWork
-    include Extensions::ActiveRecordImpersonation
-    include Extensions::CallbackHelpers
-    include Extensions::ValidationHelper
+    include Support::ActiveRecordImpersonation
+    include Validations::ValidationHelper
     include Associations
     
     def self.inherited(klass)
@@ -93,7 +92,7 @@ module DataMapper
       value = instance_variable_get(column.instance_variable_name)
       return value unless value.nil?
       
-      session.find(self.class, :all, :select => [:id, name], :reload => true, :id => loaded_set.instances.map(&:id)).each do |instance|
+      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)
       end
       
@@ -127,7 +126,7 @@ module DataMapper
     end
     
     def self.foreign_key
-      Inflector.underscore(self.name) + "_id"
+      String::memoized_underscore(self.name) + "_id"
     end
     
     def inspect
@@ -147,14 +146,34 @@ module DataMapper
     end
     
     def session
-      @session ||= database
+      @session || ( @session = database )
     end
     
     def key
-      key_column = session.schema[self.class].key
-      key_column.type_cast_value(instance_variable_get(key_column.instance_variable_name))
+      @__key || @__key = begin
+        key_column = session.schema[self.class].key
+        key_column.type_cast_value(instance_variable_get(key_column.instance_variable_name))
+      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

data/lib/data_mapper/callbacks.rb

@@ -12,7 +12,10 @@ module DataMapper
       ]
       
     def initialize
-      @callbacks = Hash.new { |h,k| h[k.to_sym] = [] }
+      @callbacks = Hash.new do |h,k|
+        raise 'Callback names must be Symbols' unless k.kind_of?(Symbol)
+        h[k] = []
+      end
     end
     
     alias ruby_method_missing method_missing

data/lib/data_mapper/database.rb

@@ -1,6 +1,5 @@
 require 'logger'
 require 'data_mapper/session'
-require 'data_mapper/mappings/schema'
 
 # Delegates to DataMapper::database.
 # Will not overwrite if a method of the same name is pre-defined.
@@ -18,11 +17,12 @@ module DataMapper
   #   a new Session.
   def self.database(name = :default)
     unless block_given?
-      Database.context.last || Session.new(Database[name])
+      Database.context.last || Session.new(Database[name].adapter)
     else
-      Database.context.push(Session.new(Database[name]))
-      yield Database.context.last
+      Database.context.push(Session.new(Database[name].adapter))
+      result = yield(Database.context.last)
       Database.context.pop
+      result
     end
   end
   
@@ -51,28 +51,8 @@ module DataMapper
     
     def initialize(name)
       @name = name
-    end 
-    
-    # Shortcut to adapter.class::Queries::FooStatement.new
-    def method_missing(sym, *args)
-      return super if sym.to_s !~ /_statement$/
-      @adapter.class::Queries.const_get(Inflector.classify(sym.to_s)).new(self, *args)
-    end
-    
-    def syntax(token)
-      @adapter.class::SYNTAX[token]
-    end
-    
-    def [](klass_or_table_name)
-      schema[klass_or_table_name]
-    end
-    
-    def schema
-      @schema ||= Mappings::Schema.new(self)
     end
     
-    class ConditionEscapeError < StandardError; end
-    
     attr_reader :name
     
     def adapter(value = nil)
@@ -80,12 +60,9 @@ module DataMapper
       
       raise ArgumentError.new('The adapter is readonly after being set') unless @adapter.nil?
       
-      require "data_mapper/adapters/#{Inflector.underscore(value)}_adapter"
+      require "data_mapper/adapters/#{String::memoized_underscore(value)}_adapter"
       adapter_class = Adapters::const_get(Inflector.classify(value) + "Adapter")
       
-      (class << self; self end).send(:include, adapter_class::Quoting)
-      (class << self; self end).send(:include, adapter_class::Coersion)
-      
       @adapter = adapter_class.new(self)
     end
     
@@ -94,6 +71,9 @@ module DataMapper
     def username(value = nil); value.nil? ? @username : @username = value end
     def password(value = nil); value.nil? ? (@password || '') : @password = value end
     
+    # single_threaded mode is disabled by default currently since it's buggy.
+    def single_threaded(value = nil); value.nil? ? (@single_threaded.nil? ? @single_threaded = false : @single_threaded) : @single_threaded = value end
+    
     def log(value = nil)
       @log = value unless value.nil?
 
@@ -116,19 +96,6 @@ module DataMapper
       @log_stream = value
     end
     
-    def connection
-      @adapter.connection do |db|
-        results = yield(db)
-      end
-    end
-    
-    def query(sql)
-      connection { |db| db.query(sql) }
-    end
-    
-    def execute(sql)
-      connection { |db| db.execute(sql) }
-    end
   end
   
 end

data/lib/data_mapper/identity_map.rb

@@ -1,20 +1,40 @@
 require 'data_mapper/support/weak_hash'
 
 module DataMapper
+  
+  # Tracks objects to help ensure that each object gets loaded only once.
+  # See: http://www.martinfowler.com/eaaCatalog/identityMap.html
   class IdentityMap
     
     def initialize
-      @cache = Hash.new { |h,k| h[k] = Support::WeakHash.new }
+      # WeakHash is much more expensive, and not necessary if the IdentityMap is tied to Session instead of Database.
+      # @cache = Hash.new { |h,k| h[k] = Support::WeakHash.new }
+      @cache = Hash.new { |h,k| h[k] = Hash.new }
     end
 
+    # Pass a Class and a key, and to retrieve an instance.
+    # If the instance isn't found, nil is returned.
     def get(klass, key)
       @cache[klass][key]
     end
 
+    # Pass an instance to add it to the IdentityMap.
+    # The instance must have an assigned key.
     def set(instance)
-      raise "Can't store an instance with a nil key in the IdentityMap" if instance.key == nil
+      instance_key = instance.key
+      raise "Can't store an instance with a nil key in the IdentityMap" if instance_key.nil?
         
-      @cache[instance.class][instance.key] = instance
+      @cache[instance.class][instance_key] = instance
+    end
+    
+    # Remove an instance from the IdentityMap.
+    def delete(instance)
+      @cache[instance.class].delete(instance.key)
+    end
+    
+    # Clears a particular set of classes from the IdentityMap.
+    def clear!(klass)
+      @cache.delete(klass)
     end
     
   end

data/lib/data_mapper/session.rb

@@ -1,240 +1,88 @@
-require 'data_mapper/loaded_set'
 require 'data_mapper/identity_map'
 
 module DataMapper
   
   class Session
-    
-    FIND_OPTIONS = [
-        :select, :limit, :class, :include, :reload, :conditions, :order
-      ]
       
     class MaterializationError < StandardError
     end
     
-    def initialize(database)
-      @database = database
+    attr_reader :adapter
+    
+    def initialize(adapter)
+      @adapter = adapter
     end
     
     def identity_map
       @identity_map || ( @identity_map = IdentityMap.new )
     end
     
-    def find(klass, type_or_id, options = {}, &b)
-      options.merge! b.to_hash if block_given?
+    def first(klass, *args, &b)
+      id = nil
+      options = nil
       
-      results = case type_or_id
-        when :first then
-          first(@database.select_statement(options.merge(:class => klass, :limit => 1)))
-        when :all then
-          all(@database.select_statement(options.merge(:class => klass)))
+      if args.empty? # No id, no options
+        options = { :limit => 1 }
+      elsif args.size == 2 && args.last.kind_of?(Hash) # id AND options
+        options = args.last.merge(:id => args.first)
+      elsif args.size == 1 # id OR options
+        if args.first.kind_of?(Hash)
+          options = args.first.merge(:limit => 1) # no id, add limit
         else
-          first(@database.select_statement(options.merge(:class => klass, :id => type_or_id)))
-      end
-      
-      case results
-        when Array then results.each { |instance| instance.session = self }
-        when Base then results.session = self
-      end
-      return results
-    end
-    
-    def first(options)
-      if options.has_id? && !options.reload?
-        instance = identity_map.get(options.klass, options.instance_id)
-        return instance unless instance.nil?
-      end
-      
-      reader = @database.query(options)
-      instance = reader.eof? ? nil : load(options, reader.next)
-      reader.close
-      return instance
-    rescue DatabaseError => de
-      de.options = options
-      raise de
-    end
-    
-    def all(options)
-      set = LoadedSet.new(@database)
-      reader = @database.query(options)
-      instances = reader.map do |hash|
-        load(options, hash, set)
-      end
-      reader.close
-      return instances
-    rescue => error
-      @database.log.error(error)
-      raise error
-    end
-    
-    def load(options, hash, set = LoadedSet.new(@database))
-            
-      instance_class = unless hash['type'].nil?
-        Kernel::const_get(hash['type'])
+          options = { :id => args.first } # no options, set id
+        end
       else
-        options.klass
+        raise ArgumentError.new('Session#first takes a class, and optional type_or_id and/or options arguments')
       end
       
-      mapping = @database[instance_class]
+      options.merge!(b.to_hash) if block_given?
       
-      instance_id = mapping.key.type_cast_value(hash['id'])      
-      instance = identity_map.get(instance_class, instance_id)
-      
-      if instance.nil? || options.reload?
-        instance ||= instance_class.new        
-        instance.class.callbacks.execute(:before_materialize, instance)
-        
-        instance.instance_variable_set(:@new_record, false)
-        hash.each_pair do |name_as_string,raw_value|
-          name = name_as_string.to_sym
-          if column = mapping.find_by_column_name(name)
-            value = column.type_cast_value(raw_value)
-            instance.instance_variable_set(column.instance_variable_name, value)
-          else
-            instance.instance_variable_set("@#{name}", value)
-          end
-          instance.original_hashes[name] = value.hash
-        end
-
-        instance.class.callbacks.execute(:after_materialize, instance)
-        
-        identity_map.set(instance)
-      end
-      
-      instance.instance_variable_set(:@loaded_set, set)
-      set.instances << instance
-      return instance
-    end
-    
-    def save(instance)
-      return false unless instance.dirty?
-      instance.class.callbacks.execute(:before_save, instance)
-      result = instance.new_record? ? insert(instance) : update(instance)
-      instance.session = self
-      instance.class.callbacks.execute(:after_save, instance)
-      result.success?
+      @adapter.load(self, klass, options)
     end
     
-    def insert(instance, inserted_id = nil)
-      instance.class.callbacks.execute(:before_create, instance)
-      result = @database.execute(@database.insert_statement(instance))
-      
-      if result.success?
-        instance.instance_variable_set(:@new_record, false)
-        instance.instance_variable_set(:@id, inserted_id || result.last_inserted_id)
-        calculate_original_hashes(instance)
-        identity_map.set(instance)
-        instance.class.callbacks.execute(:after_create, instance)
-      end
-      
-      return result
-    rescue => error
-      @database.log.error(error)
-      raise error
+    def all(klass, options = {})
+      @adapter.load(self, klass, options)
     end
     
-    def update(instance)
-      instance.class.callbacks.execute(:before_update, instance)
-      result = @database.execute(@database.update_statement(instance))
-      calculate_original_hashes(instance)
-      instance.class.callbacks.execute(:after_update, instance)
-      return result
-    rescue => error
-      @database.log.error(error)
-      raise error
+    def save(instance)
+      @adapter.save(self, instance)
     end
     
     def destroy(instance)
-      instance.class.callbacks.execute(:before_destroy, instance)
-      result = @database.execute(@database.delete_statement(instance))
-      if result.success?
-        instance.instance_variable_set(:@new_record, true)
-        instance.original_hashes.clear
-        instance.class.callbacks.execute(:after_destroy, instance)
-      end
-      return result.success?
-    rescue => error
-      @database.log.error(error)
-      raise error
+      @adapter.delete(instance, :session => self)
     end
     
     def delete_all(klass)
-      @database.execute(@database.delete_statement(klass))
+      @adapter.delete(klass, :session => self)
     end
     
     def truncate(klass)
-      @database.connection do |db|
-        db.execute(@database.truncate_table_statement(klass))
-      end
+      @adapter.delete(klass, :truncate => true, :session => self)
     end
     
     def create_table(klass)
-      @database.connection do |db|
-        db.execute(@database.create_table_statement(klass))
-      end unless table_exists?(klass)
+      @adapter[klass].create!
     end
     
     def drop_table(klass)
-      @database.connection do |db|
-        db.execute(@database.drop_table_statement(klass))
-      end if table_exists?(klass)
+      @adapter[klass].drop!
     end
     
     def table_exists?(klass)
-      reader = @database.connection do |db|
-        db.query(@database.table_exists_statement(klass))
-      end
-      result = !reader.eof?
-      reader.close
-      result
+      @adapter[klass].exists?
     end
     
-    def query(*args)
-      sql = args.shift
-      
-      unless args.empty?
-        sql.gsub!(/\?/) do |x|
-          @database.quote_value(args.shift)
-        end
-      end
-
-      reader = @database.connection do |db|
-        db.query(sql)
-      end
-      
-      columns = reader.columns.keys
-      klass = Struct.new(*columns.map { |c| c.to_sym })
-      
-      rows = reader.map do |row|
-        klass.new(*columns.map { |c| row[c] })
-      end
-      
-      reader.close
-      return rows
+    def query(*args)      
+      @adapter.query(*args)
     end
     
     def schema
-      @database.schema
+      @adapter.schema
     end
     
     def log
-      @database.log
-    end
-    
-    private
-    
-    # Make sure this uses the factory changes later...
-    def type_cast_value(klass, name, raw_value)
-      @database[klass][name].type_cast_value(raw_value)
-    end
-    
-    # Calculates the original hashes for each value
-    # in an instance's set of attributes, and adds
-    # them to the original_hashes hash.
-    def calculate_original_hashes(instance)
-      instance.attributes.each_pair do |name, value|
-        instance.original_hashes[name] = value.hash
-      end
+      @adapter.log
     end
+
   end
 end