datamapper 0.3.2 → 0.9.3

data/example.rb

@@ -1,156 +0,0 @@
-#!/usr/bin/env ruby
-
-ENV['LOG_NAME'] ||= 'example'
-require 'environment'
-
-# Define a fixtures helper method to load up our test data.
-def fixtures(name)
-  entry = YAML::load_file(File.dirname(__FILE__) + "/spec/fixtures/#{name}.yaml")
-  klass = begin
-    Kernel::const_get(Inflector.classify(Inflector.singularize(name)))
-  rescue
-    nil
-  end
-
-  unless klass.nil?
-    database.logger.debug { "AUTOMIGRATE: #{klass}" }
-    klass.auto_migrate!
-
-    (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
-  else
-    table = database.table(name.to_s)
-    table.create! true
-    table.activate_associations!
-
-    #pp database.schema
-
-    (entry.kind_of?(Array) ? entry : [entry]).each do |hash|
-      table.insert(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$/, ''))
-end
-
-require 'irb'
-
-# database { IRB::start }
-IRB::start
-
-if false
-
-# Simple example to setup a database:
-DataMapper::Database.setup({
-  :adapter => 'mysql',
-  :database => 'data_mapper_1',
-  :username => 'root'
-})
-
-class Animal #:nodoc:
-  include DataMapper::Persistence
-  
-  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
-  
-  has_and_belongs_to_many :exhibits
-end
-
-class Exhibit #:nodoc:
-  include DataMapper::Persistence
-
-  property :name, :string
-  belongs_to :zoo
-end
-
-class Zoo #:nodoc:
-  include DataMapper::Persistence
-
-  property :name, :string
-  has_many :exhibits
-end
-
-class Person #:nodoc:
-  include DataMapper::Persistence
-
-  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
-
-# 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,88 +0,0 @@
-# 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.
-unless defined?(DM_PLUGINS_ROOT)
-  $LOAD_PATH.unshift(File.dirname(__FILE__))
-
-  DM_PLUGINS_ROOT = (File.dirname(__FILE__) + '/../plugins')
-end
-
-# Require the basics...
-require 'date'
-require 'time'
-require 'rubygems'
-require 'yaml'
-require 'set'
-require 'fastthread'
-require 'validatable'
-require 'data_mapper/support/object'
-require 'data_mapper/support/blank'
-require 'data_mapper/support/enumerable'
-require 'data_mapper/support/symbol'
-require 'data_mapper/support/string'
-require 'data_mapper/support/silence'
-require 'data_mapper/support/inflector'
-require 'data_mapper/support/errors'
-require 'data_mapper/support/typed_set'
-require 'data_mapper/database'
-require 'data_mapper/persistence'
-require 'data_mapper/base'
-require 'data_mapper/types/string'
-
-
-begin
-  # 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.
-  unless defined?(DM_APP_ROOT)
-    application_root, application_environment = *if 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]
-    
-      config = lambda { |key| current_database_config[key.to_s] || current_database_config[key] }
-    
-      default_database_config = {
-        :adapter  => config[:adapter],
-        :host     => config[:host],
-        :database => config[:database],
-        :username => config[:username],
-        :password => config[:password],
-        :socket => config[:socket]
-      }
-  
-      DataMapper::Database.setup(default_database_config)
-    
-    elsif application_root && FileTest.directory?(application_root + '/config')
-    
-      %w(development testing production).map do |environment|
-        <<-EOS.margin
-          #{environment}:
-            adapter: mysql
-            username: root
-            password:
-            host: localhost
-            database: #{File.dirname(DM_APP_ROOT).split('/').last}_#{environment}
-        EOS
-      end
-    
-      #File::open(application_root + '/config/database.yml')
-    end
-  end
-rescue Exception
-  warn "Could not connect to database specified by database.yml."
-end

data/lib/data_mapper/adapters/abstract_adapter.rb

@@ -1,43 +0,0 @@
-module DataMapper
-  module Adapters
-      
-    class AbstractAdapter
-  
-      # Instantiate an Adapter by passing it a DataMapper::Database
-      # object for configuration.
-      def initialize(configuration)
-        @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
-      
-      def save(database_context, instance)
-        raise NotImplementedError.new
-      end
-      
-      def load(database_context, klass, options)
-        raise NotImplementedError.new
-      end
-      
-      def get(database_context, klass, *keys)
-        raise NotImplementedError.new
-      end
-      
-      def logger
-        @logger || @logger = @configuration.logger
-      end
-      
-    end # class AbstractAdapter
-    
-  end # module Adapters
-end # module DataMapper

data/lib/data_mapper/adapters/data_object_adapter.rb

@@ -1,480 +0,0 @@
-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'
-require 'data_mapper/query'
-
-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
-
-      SYNTAX = {
-        :now => 'NOW()'.freeze
-      }
-
-      def initialize(configuration)
-        super
-        @connection_pool = Support::ConnectionPool.new { create_connection }
-      end
-
-      def activated?
-        @activated
-      end
-
-      def activate!
-        @activated = true
-        schema.activate!
-      end
-
-      def create_connection
-        raise NotImplementedError.new
-      end
-
-      def batch_insertable?
-        true
-      end
-
-      # Yields an available connection. Flushes the connection-pool and reconnects
-      # if the connection returns an error.
-      def connection
-        begin
-          # Yield the appropriate connection
-          @connection_pool.hold { |active_connection| yield(active_connection) }
-        rescue => execution_error
-          # Log error on failure
-          logger.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.
-          flush_connections!
-
-          raise execution_error
-        end
-      end
-
-      # Close any open connections.
-      def flush_connections!          
-        @connection_pool.available_connections.each do |active_connection|
-          begin
-            active_connection.close
-          rescue => close_connection_error
-            # An error on closing the connection is almost expected
-            # if the socket is broken.
-            logger.warn { close_connection_error }
-          end
-        end
-
-        # Reopen fresh connections.
-        @connection_pool.instance_variable_set('@created_count', 0)
-        @connection_pool.available_connections.clear
-      end
-
-      def transaction(&block)
-        raise NotImplementedError.new
-      end
-
-      def query(*args)
-        db = create_connection
-
-        command = db.create_command(args.shift)
-
-        reader = command.execute_reader(*args)
-        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
-
-        return results
-      rescue => e
-        logger.error { e }
-        raise e
-      ensure
-        reader.close if reader
-        db.close
-      end
-
-      def execute(*args)
-        db = create_connection
-        command = db.create_command(args.shift)
-        return command.execute_non_query(*args)
-      rescue => e
-        logger.error { e }
-        raise e
-      ensure
-        db.close
-      end
-
-      def handle_error(error)
-        raise error
-      end
-
-      def schema
-        @schema || ( @schema = self.class::Mappings::Schema.new(self, @configuration.database) )
-      end
-
-      def column_exists_for_table?(table_name, column_name)
-        connection do |db|
-          table = self.table(table_name)
-          command = db.create_command(table.to_column_exists_sql)
-          command.execute_reader(table.name, column_name, table.schema.name) do |reader|
-            reader.any? { reader.item(1) == column_name.to_s }
-          end
-        end
-      end
-
-      def delete(database_context, instance)
-        table = self.table(instance)
-
-        if instance.is_a?(Class)
-          table.delete_all!
-        else
-          callback(instance, :before_destroy)
-
-          table.associations.each do |association|
-            instance.send(association.name).deactivate unless association.is_a?(::DataMapper::Associations::BelongsToAssociation)
-          end
-
-          if table.paranoid?
-            instance.instance_variable_set(table.paranoid_column.instance_variable_name, Time::now)
-            instance.save
-          else
-            if connection do |db|
-                command = db.create_command("DELETE FROM #{table.to_sql} WHERE #{table.key.to_sql} = ?")
-                command.execute_non_query(instance.key).to_i > 0
-              end # connection do...end # if continued below:
-              instance.instance_variable_set(:@new_record, true)
-              instance.database_context = database_context
-              instance.original_values.clear
-              database_context.identity_map.delete(instance)
-              callback(instance, :after_destroy)
-            end
-          end
-        end
-      end
-
-      def save(database_context, instance, validate = true, cleared = Set.new)
-        case instance
-        when Class then
-          table(instance).create!
-          table(instance).activate_associations!
-        when Mappings::Table then instance.create!
-        when DataMapper::Persistence then
-          event = instance.new_record? ? :create : :update
-
-          return false if (validate && !instance.validate_recursively(event, Set.new)) || cleared.include?(instance)
-          cleared << instance
-
-          callback(instance, :before_save)
-
-          return true unless instance.new_record? || instance.dirty?
-
-          result = send(event, database_context, instance)
-
-          instance.database_context = database_context
-          instance.attributes.each_pair do |name, value|
-            instance.original_values[name] = value
-          end
-
-          instance.loaded_associations.each do |association|
-            association.save_without_validation(database_context, cleared) if association.dirty?
-          end
-
-          callback(instance, :after_save)
-          result
-        end
-      rescue => error
-        logger.error(error)
-        raise error
-      end
-
-      def save_without_validation(database_context, instance, cleared = Set.new)
-        save(database_context, instance, false, cleared)
-      end
-
-      def update(database_context, instance)
-        callback(instance, :before_update)
-
-        instance = update_magic_properties(database_context, instance)
-
-        table = self.table(instance)
-        attributes = instance.dirty_attributes
-        parameters = []
-
-        unless attributes.empty?
-          sql = "UPDATE " << table.to_sql << " SET "
-
-          sql << attributes.map do |key, value|
-            parameters << value
-            "#{table[key].to_sql} = ?"
-          end.join(', ')
-
-          sql << " WHERE #{table.key.to_sql} = ?"
-          parameters << instance.key
-
-          result = connection do |db|
-            db.create_command(sql).execute_non_query(*parameters)
-          end
-
-          # BUG: do_mysql returns inaccurate affected row counts for UPDATE statements.
-          if true || result.to_i > 0
-            callback(instance, :after_update)
-            return true
-          else
-            return false
-          end
-        else
-          true
-        end
-      end
-
-      def empty_insert_sql
-        "DEFAULT VALUES"
-      end
-
-      def create(database_context, instance)
-        callback(instance, :before_create)
-
-        instance = update_magic_properties(database_context, instance)
-
-        table = self.table(instance)
-        attributes = instance.dirty_attributes
-
-        if table.multi_class?
-          instance.instance_variable_set(
-            table[:type].instance_variable_name,
-            attributes[:type] = instance.class.name
-          )
-        end
-
-        keys = []
-        values = []
-        attributes.each_pair do |key, value|
-          raise ArgumentError.new("#{value.inspect} is not a valid value for #{key.inspect}") if value.is_a?(Array)
-
-          keys << table[key].to_sql
-          values << value
-        end
-
-        sql = if keys.size > 0
-          "INSERT INTO #{table.to_sql} (#{keys.join(', ')}) VALUES ?"
-        else
-          "INSERT INTO #{table.to_sql} #{self.empty_insert_sql}"
-        end
-
-        result = connection do |db|
-          db.create_command(sql).execute_non_query(values)
-        end
-
-        if result.to_i > 0
-          instance.instance_variable_set(:@new_record, false)
-          instance.key = result.last_insert_row if table.key.serial? && !attributes.include?(table.key.name)
-          database_context.identity_map.set(instance)
-          callback(instance, :after_create)
-          return true
-        else
-          return false
-        end
-      end
-
-      MAGIC_PROPERTIES = {
-        :updated_at => lambda { self.updated_at = Time::now },
-        :updated_on => lambda { self.updated_on = Date::today },
-        :created_at => lambda { self.created_at ||= Time::now },
-        :created_on => lambda { self.created_on ||= Date::today }
-      }
-
-      def update_magic_properties(database_context, instance)
-        instance.class.properties.find_all { |property| MAGIC_PROPERTIES.has_key?(property.name) }.each do |property|
-          instance.instance_eval(&MAGIC_PROPERTIES[property.name])
-        end
-        instance
-      end
-
-      def load(database_context, klass, options)
-        self.class::Commands::LoadCommand.new(self, database_context, klass, options).call
-      end
-
-      def get(database_context, klass, keys)
-        table = self.table(klass)
-        instance_id = table.key.type_cast_value(keys.first)
-        instance = database_context.identity_map.get(klass, instance_id)
-
-        return instance if instance
-
-        column_indexes = {}
-        select_columns = []
-
-        table.columns.each_with_index do |column, i|
-          column_indexes[column] = i
-          select_columns << column.to_sql
-        end
-
-        sql = "SELECT #{select_columns.join(', ')} FROM #{table.to_sql} WHERE #{table.keys.map { |key| "#{key.to_sql} = ?" }.join(' AND ')}"
-
-        connection do |db|
-          reader = nil
-          begin
-            reader = db.create_command(sql).execute_reader(*keys)
-
-            if reader.has_rows?
-
-              instance_type = klass
-
-              if table.multi_class? && table.type_column
-                value = reader.item(column_indexes[table.type_column])
-                instance_type = table.type_column.type_cast_value(value) unless value.blank?
-              end
-
-              if instance.nil?
-                instance = instance_type.allocate()
-                instance.instance_variable_set(:@__key, instance_id)
-                instance.instance_variable_set(:@new_record, false)
-                database_context.identity_map.set(instance)
-              elsif instance.new_record?
-                instance.instance_variable_set(:@__key, instance_id)
-                instance.instance_variable_set(:@new_record, false)
-                database_context.identity_map.set(instance)
-              end
-
-              instance.database_context = database_context
-
-              instance_type.callbacks.execute(:before_materialize, instance)
-
-              originals = instance.original_values
-
-              column_indexes.each_pair do |column, i|
-                value = column.type_cast_value(reader.item(i))
-                instance.instance_variable_set(column.instance_variable_name, value)
-
-                case value
-                  when String, Date, Time then originals[column.name] = value.dup
-                  else originals[column.name] = value
-                end
-              end
-
-              instance.loaded_set = [instance]
-
-              instance_type.callbacks.execute(:after_materialize, instance)
-            end # if reader.has_rows?
-          ensure
-            reader.close if reader && reader.open?
-          end
-        end # connection
-
-        return instance
-      end
-
-      def table(instance)
-        case instance
-        when DataMapper::Adapters::Sql::Mappings::Table then instance
-        when DataMapper::Persistence 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
-
-      # 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)
-        base.const_set('SYNTAX', SYNTAX.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,
-        :boolean => 'boolean'.freeze,
-        :object => 'text'.freeze
-      }
-
-      include Sql
-      include Quoting
-      include Coersion
-
-    end # class DoAdapter
-
-  end # module Adapters
-end # module DataMapper