datamapper 0.3.2 → 0.9.3

data/lib/data_mapper/adapters/sql/quoting.rb

@@ -1,24 +0,0 @@
-module DataMapper
-  module Adapters
-    module Sql
-      
-      # Quoting is a mixin that extends your DataMapper::Database singleton-class
-      # to allow for object-name and value quoting to be exposed to the queries.
-      #
-      # DESIGN: Is there any need for this outside of the query objects? Should
-      # we just include it in our query object subclasses and not rely on a Quoting
-      # mixin being part of the "standard" Adapter interface?
-      module Quoting
-
-        def quote_table_name(name)
-          name.ensure_wrapped_with(self.class::TABLE_QUOTING_CHARACTER)
-        end
-
-        def quote_column_name(name)
-          name.ensure_wrapped_with(self.class::COLUMN_QUOTING_CHARACTER)
-        end
-
-      end # module Quoting
-    end
-  end
-end

data/lib/data_mapper/adapters/sqlite3_adapter.rb

@@ -1,159 +0,0 @@
-require 'data_mapper/adapters/data_object_adapter'
-begin
-  gem 'do_sqlite3', '<= 0.2.5'
-  require 'do_sqlite3'
-rescue LoadError
-  STDERR.puts <<-EOS
-You must install the DataObjects::SQLite3 driver.
-  gem install do_sqlite3
-EOS
-  exit
-end
-
-module DataMapper
-  module Adapters
-    
-    class Sqlite3Adapter < DataObjectAdapter
-      
-      TYPES.merge!({
-        :integer => 'INTEGER'.freeze,
-        :string => 'TEXT'.freeze,
-        :text => 'TEXT'.freeze,
-        :class => 'TEXT'.freeze,
-        :boolean => 'INTEGER'.freeze
-      })
-
-      TABLE_QUOTING_CHARACTER = '"'.freeze
-      COLUMN_QUOTING_CHARACTER = '"'.freeze
-      TRUE_ALIASES << 't'.freeze
-      FALSE_ALIASES << 'f'.freeze
-      
-      def create_connection
-        conn = DataObject::Sqlite3::Connection.new("dbname=#{@configuration.database}")
-        conn.logger = self.logger
-        conn.open if conn.respond_to?(:open)
-        return conn
-      end
-      
-      def batch_insertable?
-        false
-      end
-      
-      module Mappings
-        
-        class Schema
-          def to_tables_sql
-            @to_tables_sql || @to_tables_sql = <<-EOS.compress_lines
-              SELECT "name" 
-              FROM sqlite_master 
-              where "type"= "table"
-              and "name" <> "sqlite_sequence"
-            EOS
-          end
-          alias_method :database_tables, :get_database_tables
-        end # class Schema
-        
-        class Table
-          def to_exists_sql
-            @to_exists_sql || @to_exists_sql = <<-EOS.compress_lines
-              SELECT "name"
-              FROM "#{temporary? ? 'sqlite_temp_master' : 'sqlite_master'}"
-              WHERE "type" = "table"
-                AND "name" = ?
-            EOS
-          end
-          
-          def to_column_exists_sql
-            @to_column_exists_sql || @to_column_exists_sql = <<-EOS.compress_lines
-              PRAGMA TABLE_INFO(?)
-            EOS
-          end
-          
-          def to_truncate_sql
-            "DELETE FROM #{to_sql}"
-          end
-          
-          alias_method :to_columns_sql, :to_column_exists_sql
-          
-          def unquote_default(default)
-            default.gsub(/(^'|'$)/, "") rescue default
-          end
-          
-        end # class Table
-        
-        class Column
-          def serial_declaration
-            "AUTOINCREMENT"
-          end
-          
-          def size
-            nil
-          end
-                    
-          def alter!
-            @adapter.connection do |db|
-              flush_sql_caches!
-              backup_table = @adapter.table("#{@table.name}_backup")
-
-              @table.columns.each do |column|
-                backup_table.add_column(column.name, column.type, column.options)
-              end
-
-              backup_table.temporary = true
-
-              backup_table.create!
-              
-              sql = <<-EOS.compress_lines
-                INSERT INTO #{backup_table.to_sql} SELECT #{@table.columns.map { |c| c.to_sql }.join(', ')} FROM #{@table.to_sql};
-                DROP TABLE #{@table.to_sql};
-                #{@table.to_create_sql};
-                INSERT INTO #{@table.to_sql} SELECT #{backup_table.columns.map { |c| c.to_sql }.join(', ')} FROM #{backup_table.to_sql};
-              EOS
-              
-              sql.split(';').each do |part|
-                db.create_command(part).execute_non_query
-              end
-              
-              backup_table.drop!
-              flush_sql_caches!
-            end
-          end
-          
-          def drop!
-            @adapter.connection do |db|
-              @table.columns.delete(self)
-              flush_sql_caches!
-              
-              backup_table = @adapter.table("#{@table.name}_backup")
-              
-              @table.columns.each do |column|
-                backup_table.add_column(column.name, column.type, column.options)
-              end
-
-              backup_table.temporary = true
-
-              backup_table.create!
-              
-              sql = <<-EOS.compress_lines
-                INSERT INTO #{backup_table.to_sql} SELECT #{@table.columns.map { |c| c.to_sql }.join(', ')} FROM #{@table.to_sql};
-                DROP TABLE #{@table.to_sql};
-                #{@table.to_create_sql};
-                INSERT INTO #{@table.to_sql} SELECT #{backup_table.columns.map { |c| c.to_sql }.join(', ')} FROM #{backup_table.to_sql};
-              EOS
-              
-              sql.split(';').each do |part|
-                db.create_command(part).execute_non_query
-              end
-              
-              backup_table.drop!
-              flush_sql_caches!
-            end
-          end          
-          
-        end # class Column
-      end # module Mappings
-      
-    end # class Sqlite3Adapter
-    
-  end # module Adapters
-end # module DataMapper

data/lib/data_mapper/associations.rb

@@ -1,106 +0,0 @@
-require 'data_mapper/associations/reference'
-require 'data_mapper/associations/has_many_association'
-require 'data_mapper/associations/belongs_to_association'
-require 'data_mapper/associations/has_and_belongs_to_many_association'
-
-module DataMapper
-  module Associations
-    
-    # Extends +base+ with methods for setting up associations between different models.
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-    
-    module ClassMethods
-      # Adds the following methods for query of a single associated object:
-      # * <tt>collection(</tt> - returns a set containing the associated objects. Returns
-      #   an empty set if no objects are found.
-      # * <tt>collection << object</tt> - adds an object to the collection.
-      # * <tt>collection = [objects]</tt> - replaces the collections content by deleting and
-      #   adding objects as appropriate.
-      # * <tt>collection.empty?</tt> - returns +true+ if there is no associated objects.
-      # * <tt>collection.size</tt> - returns the number of associated objects.
-      #
-      # Options are:
-      # * <tt>:class</tt> - specify the class name of the association. So has_many :animals will by
-      #   default be linked to the Animal class, but if you want the association to use a
-      #   different class, you'll have to specify it with this option. DM also lets you specify
-      #   this with <tt>:class_name</tt>, for AR compability.
-      # * <tt>:foreign_key</tt> - specify the foreign key used for the association. By default
-      #   this is guessed to be the name of this class in lower-case and _id suffixed.
-      # * <tt>:dependent</tt> - if set to :destroy, the associated objects have their destroy! methods
-      #   called in a chain meaning all callbacks are also called for each object.
-      #   if set to :delete, the associated objects are deleted from the database
-      #   without their callbacks being triggered.
-      #   if set to :protect and the collection is not empty an AssociatedProtectedError will be raised.
-      #   if set to :nullify, the associated objects foreign key is set to NULL.
-      #   default is :nullify
-      #
-      # Option examples:
-      #   has_many :favourite_fruits, :class => 'Fruit', :dependent => :destroy
-      def has_many(association_name, options = {})
-        database.schema[self].associations << HasManyAssociation.new(self, association_name, options)
-      end
-      
-      # Adds the following methods for query of a single associated object:
-      # * <tt>association(</tt> - returns the associated object. Returns an empty set if no
-      #   object is found.
-      # * <tt>association=(associate)</tt> - assigns the associate object, extracts the
-      #   primary key, and sets it as the foreign key.
-      # * <tt>association.nil?</tt> - returns +true+ if there is no associated object.
-      #
-      # The declaration can also include an options hash to specialize the behavior of the
-      # association.
-      #
-      # Options are:
-      # * <tt>:class</tt> - specify the class name of the association. So has_one :animal will by
-      #   default be linked to the Animal class, but if you want the association to use a
-      #   different class, you'll have to specify it with this option. DM also lets you specify
-      #   this with <tt>:class_name</tt>, for AR compability.
-      # * <tt>:foreign_key</tt> - specify the foreign key used for the association. By default
-      #   this is guessed to be the name of this class in lower-case and _id suffixed.
-      # * <tt>:dependent</tt> - has_one is secretly a has_many so this option performs the same
-      #   as the has_many
-      #
-      # Option examples:
-      #   has_one :favourite_fruit, :class => 'Fruit', :foreign_key => 'devourer_id'
-      def has_one(association_name, options = {})
-        database.schema[self].associations << HasManyAssociation.new(self, association_name, options)
-      end
-      
-      # Adds the following methods for query of a single associated object:
-      # * <tt>association(</tt> - returns the associated object. Returns an empty set if no
-      #   object is found.
-      # * <tt>association=(associate)</tt> - assigns the associate object, extracts the
-      #   primary key, and sets it as the foreign key.
-      # * <tt>association.nil?</tt> - returns +true+ if there is no associated object.
-      # * <tt>build_association</tt> - builds a new object of the associated type, without
-      #   saving it to the database.
-      # * <tt>create_association</tt> - creates and saves a new object of the associated type.
-      def belongs_to(association_name, options = {})
-        database.schema[self].associations << BelongsToAssociation.new(self, association_name, options)
-      end
-      
-      # Associates two classes via an intermediate join table.
-      #
-      # Options are:
-      # * <tt>:dependent</tt> - if set to :destroy, the associated objects have their destroy! methods
-      #   called in a chain meaning all callbacks are also called for each object.  Beware that this
-      #   is a cascading delete and will affect all records that have a remote relationship with the
-      #   record being destroyed!
-      #   if set to :delete, the associated objects are deleted from the database without their
-      #   callbacks being triggered.  This does NOT cascade the deletes.  All associated objects will
-      #   have their relationships removed from other records before being deleted.  The record calling
-      #   destroy will only delete those records directly associated to it.
-      #   if set to :protect and the collection is not empty an AssociatedProtectedError will be raised.
-      #   if set to :nullify, the join table will have the relationship records removed which is
-      #   effectively nullifying the foreign key.
-      #   default is :nullify
-      def has_and_belongs_to_many(association_name, options = {})
-        database.schema[self].associations << HasAndBelongsToManyAssociation.new(self, association_name, options)
-      end
-      
-    end
-    
-  end
-end

data/lib/data_mapper/associations/belongs_to_association.rb

@@ -1,160 +0,0 @@
-require 'data_mapper/associations/has_n_association'
-
-module DataMapper
-  module Associations
-
-    class BelongsToAssociation < HasNAssociation
-
-      def define_accessor(klass)
-        klass.class_eval <<-EOS
-
-          def create_#{@association_name}(options = {})
-            #{@association_name}_association.create(options)
-          end
-
-          def build_#{@association_name}(options = {})
-            #{@association_name}_association.build(options)
-          end
-
-          def #{@association_name}
-            #{@association_name}_association.instance
-          end
-
-          def #{@association_name}=(value)
-            #{@association_name}_association.set(value)
-          end
-
-          private
-            def #{@association_name}_association
-              @#{@association_name} || (@#{@association_name} = DataMapper::Associations::BelongsToAssociation::Instance.new(self, #{@association_name.inspect}))
-            end
-        EOS
-      end
-
-      # Reverse the natural order for BelongsToAssociations
-      alias constant associated_constant
-      def associated_constant
-        @constant
-      end
-
-      def foreign_key_name
-        @foreign_key_name || @foreign_key_name = (@options[:foreign_key] || "#{name}_#{key_table.key.name}".to_sym)
-      end
-
-      def complementary_association
-        @complementary_association || begin
-          @complementary_association = key_table.associations.find do |mapping|
-            mapping.is_a?(HasManyAssociation) &&
-            mapping.foreign_key_column.name == foreign_key_column.name &&
-            mapping.associated_table.name == associated_table.name
-          end
-
-          if @complementary_association
-            class << self
-              attr_accessor :complementary_association
-            end
-          end
-
-          return @complementary_association
-        end
-      end
-
-      def to_sql # :nodoc:
-        "JOIN #{key_table.to_sql} ON #{foreign_key_column.to_sql(true)} = #{primary_key_column.to_sql(true)}"
-      end
-
-      class Instance < Associations::Reference
-
-        def dirty?(cleared = ::Set.new)
-          @associated && (@new_member || @key_not_set)
-        end
-
-        def validate_recursively(event, cleared)
-          @associated.nil? || cleared.include?(@associated) || @associated.validate_recursively(event, cleared)
-        end
-
-        def save_without_validation(database_context, cleared)
-          @new_member = false
-          unless @associated.nil?
-            @instance.instance_variable_set(
-              association.foreign_key_column.instance_variable_name,
-              @associated.key
-            )
-            @instance.database_context.adapter.save_without_validation(database_context, @instance, cleared)
-          end
-        end
-
-        def reload!
-          @new_member = false
-          @associated = nil
-          instance
-        end
-
-        def instance
-          @associated || @associated = begin
-            if @instance.loaded_set.nil?
-              nil
-            else
-
-              # Temp variable for the instance variable name.
-              fk = association.foreign_key_column.to_sym
-
-              set = @instance.loaded_set.group_by { |instance| instance.send(fk) }
-
-              @instance.database_context.all(association.constant, association.associated_table.key.to_sym => set.keys).each do |assoc|
-                set[assoc.key].each do |primary_instance|
-                  primary_instance.send("#{@association_name}_association").shallow_append(assoc)
-                end
-              end
-
-              @associated
-            end
-          end
-        end
-
-        def create(options)
-          @associated = association.associated_constant.create(options)
-        end
-
-        def build(options)
-          @associated = association.associated_constant.new(options)
-        end
-
-        def setter_method
-          "#{@association_name}=".to_sym
-        end
-
-        def set(member)
-          shallow_append(member)
-
-          if complement = association.complementary_association
-            member.send(complement.name).shallow_append(@instance)
-          end
-
-          return self
-        end
-
-        def shallow_append(val)
-          raise RecursionError.new if val == @instance
-          @instance.instance_variable_set(association.foreign_key_column.instance_variable_name, val.key)
-          @associated = val
-          @key_not_set = true if val.key.nil?
-          return self
-        end
-
-        def deactivate
-        end
-
-        private
-
-        def ensure_foreign_key!
-          if @associated
-            @instance.instance_variable_set(association.foreign_key.instance_variable_name, @associated.key)
-          end
-        end
-
-      end # class Instance
-    end
-
-  end
-end