datamapper 0.1.1 → 0.2.0

data/example.rb

@@ -1,33 +1,130 @@
 #!/usr/bin/env ruby
 
-require 'lib/data_mapper'
+ENV['LOG_NAME'] = 'example'
+require 'environment'
 
-ENV['ADAPTER'] ||= 'mysql'
-
-DataMapper::Database.setup do
-  adapter  ENV['ADAPTER']
-  
-  unless ENV['LOGGER'] == 'false'
-    log_stream 'example.log'
-    log_level Logger::DEBUG
-  end
+# Define a fixtures helper method to load up our test data.
+def fixtures(name, force = false)
+  entry = YAML::load_file(File.dirname(__FILE__) + "/spec/fixtures/#{name}.yaml")
+  klass = Kernel::const_get(Inflector.classify(Inflector.singularize(name)))
   
-  database_name = 'data_mapper_1'
+  klass.auto_migrate!
   
-  case ENV['ADAPTER']
-    when 'postgresql' then
-      username 'postgres'
-    when 'mysql' then
-      username 'root'
-    when 'sqlite3' then
-      database_name << '.db'
+  (entry.kind_of?(Array) ? entry : [entry]).each do |hash|
+    if hash['type']
+      Object::const_get(hash['type'])::create(hash)
+    else
+      klass::create(hash)
+    end
   end
+end
+
+# Pre-fill the database so non-destructive tests don't need to reload fixtures.
+Dir[File.dirname(__FILE__) + "/spec/fixtures/*.yaml"].each do |path|
+  fixtures(File::basename(path).sub(/\.yaml$/, ''), true)
+end
+
+require 'irb'
+
+database { IRB::start }
+
+if false
+
+# Simple example to setup a database:
+DataMapper::Database.setup({
+  :adapter => 'mysql',
+  :database => 'data_mapper_1',
+  :username => 'root'
+})
+
+class Animal < DataMapper::Base
+  set_table_name 'animals' # Just as an example. Same inflector as Rails,
+    # so this really isn't necessary.
+    
+  property :name, :string
+  property :notes, :string, :lazy => true
   
-  database database_name
+  has_and_belongs_to_many :exhibits
+end
+
+class Exhibit < DataMapper::Base
+  property :name, :string
+  belongs_to :zoo
+end
+
+class Zoo < DataMapper::Base
+  property :name, :string
+  has_many :exhibits
 end
 
-Dir[File.dirname(__FILE__) + '/spec/models/*.rb'].each do |path|
-  load path
+class Person < DataMapper::Base
+
+  property :name, :string
+  property :age, :integer
+  property :occupation, :string
+  property :notes, :text, :lazy => true
+
+  # Generates Person::Address class:
+  embed :address do
+    property :street, :string
+    property :city, :string
+    property :state, :string, :size => 2
+    property :postal_code, :string
+  end
 end
 
-# p Zoo.all
+# Compatible with ActiveRecord finder syntax:
+Zoo.find(1)
+Zoo.find(:first, :conditions => ['name = ?', 'Galveston'])
+Zoo.find(:all)
+
+# These are options as well:
+Zoo[1]
+Zoo.first(:name => 'Galveston')
+Zoo.all
+
+# Or even this as an alias to ::first:
+Zoo[:name => 'Galveston']
+
+# EmbeddedValues are just nice sugar to partition
+# denormalized data.
+Person.first.address.city
+
+# Remove all data in a table...  
+Person.truncate!
+  
+# Create a new object...
+Person::create(:name => 'Sam', :age => 30, :occupation => 'Software Monkey')
+
+# Saving only updates the values that have changed,
+# and is skipped entirely if the object is not dirty.
+dumbo = Animal.first(:name => 'Elephant')
+dumbo.notes = 'He can fly!'
+dumbo.save # returns true
+dumbo.save # The object is no longer dirty, so returns false
+  
+# DataMapper associations are loaded as sets.
+# Here's the code:
+Zoo.all.each { |zoo| zoo.exhibits.entries }
+# The important bit to understand about the above is that
+# every Zoo that was loaded by Zoo.all has a reference to
+# every other Zoo it was loaded with through Zoo#loaded_set.
+# This is then used to load all other instances in the set
+# when the association of one instance is accessed. So while
+# it looks like we'd run into the dreaded 1+N query problem
+# with the above, we actually avoid it entirely. The above
+# code will only execute two queries. The first to find all
+# zoos, the second to load all exhibits with zoo_id's that
+# are a part of the set of loaded zoos.
+
+
+# Objects within the same session are uniqued, so this is both
+# faster, and fulfills obvious expectations.
+database do
+  Zoo.first == Zoo.first
+end
+
+# DataMapper find_by_sql equivilent
+database.query("SELECT * FROM zoos")
+
+end

data/lib/data_mapper.rb

@@ -1,35 +1,55 @@
+# This file begins the loading sequence.
+#
+# Quick Overview:
+# * Requires set, fastthread, support libs, and base
+# * Sets the applications root and environment for compatibility with rails or merb
+# * Checks for the database.yml and loads it if it exists
+# * Sets up the database using the config from the yaml file or from the environment
+# * 
+
 # This line just let's us require anything in the +lib+ sub-folder
 # without specifying a full path.
+
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
+DM_PLUGINS_ROOT = (File.dirname(__FILE__) + '/../plugins')
+
 # Require the basics...
+require 'yaml'
 require 'set'
 require 'fastthread'
 require 'data_mapper/support/blank'
 require 'data_mapper/support/enumerable'
 require 'data_mapper/support/symbol'
 require 'data_mapper/support/string'
-require 'data_mapper/support/proc'
 require 'data_mapper/support/inflector'
-require 'data_mapper/support/struct'
 require 'data_mapper/database'
 require 'data_mapper/base'
 
-# This block of code is for compatibility with Ruby On Rails' database.yml
+# This block of code is for compatibility with Ruby On Rails' or Merb's database.yml
 # file, allowing you to simply require the data_mapper.rb in your
 # Rails application's environment.rb to configure the DataMapper.
-if defined? RAILS_ENV
-  require 'yaml'
+
+application_root, application_environment = *if defined?(MERB_ROOT)
+  [MERB_ROOT, MERB_ENV]
+elsif defined?(RAILS_ROOT)
+  [RAILS_ROOT, RAILS_ENV]
+end
+
+DM_APP_ROOT = application_root || Dir::pwd
+
+if application_root && File.exists?(application_root + '/config/database.yml')
+  
+  database_configurations = YAML::load_file(application_root + '/config/database.yml')
+  current_database_config = database_configurations[application_environment] || database_configurations[application_environment.to_sym]
+  
+  default_database_config = {
+    :adapter  => current_database_config['adapter'] || current_database_config[:adapter],
+    :host     => current_database_config['host'] || current_database_config[:host],
+    :database => current_database_config['database'] || current_database_config[:database],
+    :username => current_database_config['username'] || current_database_config[:username],
+    :password => current_database_config['password'] || current_database_config[:password]
+  }
   
-  rails_config = YAML::load_file(RAILS_ROOT + '/config/database.yml')
-  current_config = rails_config[RAILS_ENV.to_s]
-
-  DataMapper::Database.setup do
-    adapter   current_config['adapter']
-    host      current_config['host']
-    database  current_config['database']
-    username  current_config['username']
-    password  current_config['password']
-    cache WeakHash::Factory
-  end
+  DataMapper::Database.setup(default_database_config)
 end

data/lib/data_mapper/adapters/abstract_adapter.rb

@@ -9,6 +9,14 @@ module DataMapper
         @configuration = configuration
       end
       
+      def index_path
+        @configuration.index_path
+      end
+      
+      def name
+        @configuration.name
+      end
+      
       def delete(instance_or_klass, options = nil)
         raise NotImplementedError.new
       end

data/lib/data_mapper/adapters/data_object_adapter.rb

@@ -0,0 +1,360 @@
+require 'data_mapper/adapters/abstract_adapter'
+require 'data_mapper/adapters/sql/commands/load_command'
+require 'data_mapper/adapters/sql/coersion'
+require 'data_mapper/adapters/sql/quoting'
+require 'data_mapper/adapters/sql/mappings/schema'
+require 'data_mapper/support/connection_pool'
+
+module DataMapper
+  
+  # An Adapter is really a Factory for three types of object,
+  # so they can be selectively sub-classed where needed.
+  # 
+  # The first type is a Query. The Query is an object describing
+  # the database-specific operations we wish to perform, in an
+  # abstract manner. For example: While most if not all databases
+  # support a mechanism for limiting the size of results returned,
+  # some use a "LIMIT" keyword, while others use a "TOP" keyword.
+  # We can set a SelectStatement#limit field then, and allow
+  # the adapter to override the underlying SQL generated.
+  # Refer to DataMapper::Queries.
+  #
+  # The final type provided is a DataMapper::Transaction.
+  # Transactions are duck-typed Connections that span multiple queries.
+  #
+  # Note: It is assumed that the Adapter implements it's own
+  # ConnectionPool if any since some libraries implement their own at
+  # a low-level, and it wouldn't make sense to pay a performance
+  # cost twice by implementing a secondary pool in the DataMapper itself.
+  # If the library being adapted does not provide such functionality,
+  # DataMapper::Support::ConnectionPool can be used.
+  module Adapters
+      
+    # You must inherit from the DoAdapter, and implement the
+    # required methods to adapt a database library for use with the DataMapper.
+    #
+    # NOTE: By inheriting from DoAdapter, you get a copy of all the
+    # standard sub-modules (Quoting, Coersion and Queries) in your own Adapter.
+    # You can extend and overwrite these copies without affecting the originals.
+    class DataObjectAdapter < AbstractAdapter
+      
+      $LOAD_PATH << (DM_PLUGINS_ROOT + '/dataobjects')
+      
+      FIND_OPTIONS = [
+        :select, :offset, :limit, :class, :include, :shallow_include, :reload, :conditions, :order, :intercept_load
+      ]
+      
+      TABLE_QUOTING_CHARACTER = '`'.freeze
+      COLUMN_QUOTING_CHARACTER = '`'.freeze
+      
+      def initialize(configuration)
+        super
+
+        unless @configuration.single_threaded?
+          @connection_pool = Support::ConnectionPool.new { create_connection }
+        end
+      end
+      
+      def create_connection
+        raise NotImplementedError.new
+      end
+      
+      # Yields an available connection. Flushes the connection-pool and reconnects
+      # if the connection returns an error.
+      def connection
+        begin
+          # Yield the appropriate connection
+          if @configuration.single_threaded?
+            yield(@active_connection || @active_connection = create_connection)
+          else
+            @connection_pool.hold { |active_connection| yield(active_connection) }
+          end
+        rescue => execution_error
+          # Log error on failure
+          @configuration.log.error(execution_error)
+          
+          # Close all open connections, assuming that if one
+          # had an error, it's likely due to a lost connection,
+          # in which case all connections are likely broken.
+          begin
+            if @configuration.single_threaded?
+              @active_connection.close
+            else
+              @connection_pool.available_connections.each do |active_connection|
+                active_connection.close
+              end
+            end
+          rescue => close_connection_error
+            # An error on closing the connection is almost expected
+            # if the socket is broken.
+            @configuration.log.warn(close_connection_error)
+          end
+          
+          # Reopen fresh connections.
+          if @configuration.single_threaded?
+            @active_connection = create_connection
+          else
+            @connection_pool.available_connections.clear
+          end
+          
+          raise execution_error
+        end
+      end
+        
+      def transaction(&block)
+        raise NotImplementedError.new
+      end
+      
+      def execute(*args)
+        connection do |db|
+          sql = escape_sql(*args)
+          log.debug { sql }
+          result = nil
+          
+          command = db.create_command(sql)
+          
+          if block_given?
+            reader = command.execute_reader
+            result = yield(reader)
+            reader.close
+          else
+            result = command.execute_non_query
+          end
+          
+          result
+        end
+      rescue => e
+        handle_error(e)
+      end
+      
+      def query(*args)
+        execute(*args) do |reader|
+          fields = reader.fields.map { |field| Inflector.underscore(field).to_sym }
+
+          results = []
+          
+          if fields.size > 1
+            struct = Struct.new(*fields)
+            
+            reader.each do
+              results << struct.new(*reader.current_row)
+            end
+          else
+            reader.each do
+              results << reader.item(0)
+            end
+          end
+          
+          results
+        end
+      end      
+      
+      def handle_error(error)
+        raise error
+      end
+      
+      def schema
+        @schema || ( @schema = Mappings::Schema.new(self, @configuration.database) )
+      end
+      
+      def table_exists?(name)
+        execute(table(name).to_exists_sql) { |reader| reader.has_rows? }
+      end
+      
+      def truncate(session, name)
+        result = execute("TRUNCATE TABLE #{table(name).to_sql}")
+        session.identity_map.clear!(name)
+        result.to_i > 0
+      end
+      
+      def drop(session, name)
+        result = execute("DROP TABLE #{table(name).to_sql}")
+        session.identity_map.clear!(name)
+        true
+      end
+      
+      def create_table(name)
+        execute(table(name).to_create_table_sql); true
+      end
+      
+      def delete(session, instance)
+        table = self.table(instance)
+        
+        if instance.is_a?(Class)
+          execute("DELETE FROM #{table.to_sql}")
+          session.identity_map.clear!(instance)
+        else
+          callback(instance, :before_destroy)
+          
+          if execute("DELETE FROM #{table.to_sql} WHERE #{table.key.to_sql} = #{quote_value(instance.key)}").to_i > 0
+            instance.instance_variable_set(:@new_record, true)
+            instance.session = session
+            instance.original_hashes.clear
+            session.identity_map.delete(instance)
+            callback(instance, :after_destroy)
+          end          
+        end
+      end
+      
+      def save(session, instance)
+        case instance
+        when Class, Mappings::Table then create_table(instance)
+        when DataMapper::Base then
+          return false unless instance.dirty? && instance.valid?
+          
+          callback(instance, :before_save)
+          
+          table = self.table(instance)
+          attributes = instance.dirty_attributes
+          
+          unless attributes.empty?
+            attributes[:type] = instance.class.name if table.multi_class?
+          
+            # INSERT
+            result = if instance.new_record?
+              callback(instance, :before_create)
+
+              keys = []
+              values = []
+              attributes.each_pair do |key, value|
+                keys << table[key].to_sql
+                values << value
+              end
+            
+              # Formatting is a bit off here, but it looks nicer in the log this way.
+              insert_id = execute("INSERT INTO #{table.to_sql} (#{keys.join(', ')}) VALUES (#{values.map { |v| quote_value(v) }.join(', ')})").last_insert_row
+              instance.instance_variable_set(:@new_record, false)
+              instance.key = insert_id if table.key.serial? && !attributes.include?(table.key.name)
+              session.identity_map.set(instance)
+              callback(instance, :after_create)
+            # UPDATE
+            else            
+              callback(instance, :before_update)
+            
+              sql = "UPDATE " << table.to_sql << " SET "
+        
+              sql << attributes.map do |key, value|
+                "#{table[key].to_sql} = #{quote_value(value)}"
+              end.join(', ')
+        
+              sql << " WHERE #{table.key.to_sql} = " << quote_value(instance.key)
+            
+              execute(sql).to_i > 0 && callback(instance, :after_update)
+            end
+          end # unless attributes.empty?
+          
+          instance.attributes.each_pair do |name, value|
+            instance.original_hashes[name] = value.hash
+          end
+          
+          instance.loaded_associations.each do |association|
+            association.save if association.respond_to?(:save)
+          end
+          
+          instance.session = session
+          callback(instance, :after_save)
+          result
+        end
+      rescue => error
+        log.error(error)
+        raise error
+      end
+      
+      def load(session, klass, options)
+        self.class::Commands::LoadCommand.new(self, session, klass, options).call
+      end
+      
+      def count(klass_or_instance, options)
+        query("SELECT COUNT(*) AS row_count FROM " + table(klass_or_instance).to_sql).first.to_i
+      end
+      
+      def table(instance)
+        case instance
+        when DataMapper::Adapters::Sql::Mappings::Table then instance
+        when DataMapper::Base then schema[instance.class]
+        when Class, String then schema[instance]
+        else raise "Don't know how to map #{instance.inspect} to a table."
+        end
+      end
+      
+      def callback(instance, callback_name)
+        instance.class.callbacks.execute(callback_name, instance)
+      end
+      
+      # Escape a string of SQL with a set of arguments.
+      # The first argument is assumed to be the SQL to escape,
+      # the remaining arguments (if any) are assumed to be
+      # values to escape and interpolate.
+      #
+      # ==== Examples
+      #   escape_sql("SELECT * FROM zoos")
+      #   # => "SELECT * FROM zoos"
+      # 
+      #   escape_sql("SELECT * FROM zoos WHERE name = ?", "Dallas")
+      #   # => "SELECT * FROM zoos WHERE name = `Dallas`"
+      #
+      #   escape_sql("SELECT * FROM zoos WHERE name = ? AND acreage > ?", "Dallas", 40)
+      #   # => "SELECT * FROM zoos WHERE name = `Dallas` AND acreage > 40"
+      # 
+      # ==== Warning
+      # This method is meant mostly for adapters that don't support
+      # bind-parameters.
+      def escape_sql(*args)
+        sql = args.shift
+      
+        unless args.empty?
+          sql.gsub!(/\?/) do |x|
+            quote_value(args.shift)
+          end
+        end
+        
+        sql
+      end
+      
+      # This callback copies and sub-classes modules and classes
+      # in the DoAdapter to the inherited class so you don't
+      # have to copy and paste large blocks of code from the
+      # DoAdapter.
+      # 
+      # Basically, when inheriting from the DoAdapter, you
+      # aren't just inheriting a single class, you're inheriting
+      # a whole graph of Types. For convenience.
+      def self.inherited(base)
+        
+        commands = base.const_set('Commands', Module.new)
+
+        Sql::Commands.constants.each do |name|
+          commands.const_set(name, Class.new(Sql::Commands.const_get(name)))
+        end
+        
+        mappings = base.const_set('Mappings', Module.new)
+        
+        Sql::Mappings.constants.each do |name|
+          mappings.const_set(name, Class.new(Sql::Mappings.const_get(name)))
+        end
+        
+        base.const_set('TYPES', TYPES.dup)
+        base.const_set('FIND_OPTIONS', FIND_OPTIONS.dup)
+        
+        super
+      end
+      
+      TYPES = {
+        :integer => 'int'.freeze,
+        :string => 'varchar'.freeze,
+        :text => 'text'.freeze,
+        :class => 'varchar'.freeze,
+        :decimal => 'decimal'.freeze,
+        :float => 'float'.freeze,
+        :datetime => 'datetime'.freeze,
+        :date => 'date'.freeze
+      }
+
+      include Sql
+      include Quoting
+      include Coersion
+      
+    end # class DoAdapter
+    
+  end # module Adapters
+end # module DataMapper