sam-dm-core 0.9.6

data/lib/dm-core/adapters/mysql_adapter.rb

@@ -0,0 +1,136 @@
+gem 'do_mysql', '>=0.9.5'
+require 'do_mysql'
+
+module DataMapper
+  module Adapters
+    # Options:
+    # host, user, password, database (path), socket(uri query string), port
+    class MysqlAdapter < DataObjectsAdapter
+      module SQL
+        private
+
+        def supports_default_values?
+          false
+        end
+
+        def quote_table_name(table_name)
+          "`#{table_name.gsub('`', '``')}`"
+        end
+
+        def quote_column_name(column_name)
+          "`#{column_name.gsub('`', '``')}`"
+        end
+
+        def quote_column_value(column_value)
+          case column_value
+            when TrueClass  then quote_column_value(1)
+            when FalseClass then quote_column_value(0)
+            else
+              super
+          end
+        end
+      end #module SQL
+
+      include SQL
+
+      # TODO: move to dm-more/dm-migrations
+      module Migration
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def storage_exists?(storage_name)
+          statement = <<-EOS.compress_lines
+            SELECT COUNT(*)
+            FROM `information_schema`.`tables`
+            WHERE `table_type` = 'BASE TABLE'
+            AND `table_schema` = ?
+            AND `table_name` = ?
+          EOS
+
+          query(statement, db_name, storage_name).first > 0
+        end
+
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def field_exists?(storage_name, field_name)
+          statement = <<-EOS.compress_lines
+            SELECT COUNT(*)
+            FROM `information_schema`.`columns`
+            WHERE `table_schema` = ?
+            AND `table_name` = ?
+            AND `column_name` = ?
+          EOS
+
+          query(statement, db_name, storage_name, field_name).first > 0
+        end
+
+        private
+
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def db_name
+          @uri.path.split('/').last
+        end
+
+        module SQL
+          private
+
+          # TODO: move to dm-more/dm-migrations
+          def supports_serial?
+            true
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def create_table_statement(repository, model)
+            "#{super} ENGINE = InnoDB CHARACTER SET #{character_set} COLLATE #{collation}"
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def property_schema_hash(property, model)
+            schema = super
+            schema.delete(:default) if schema[:primitive] == 'TEXT'
+            schema
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def property_schema_statement(schema)
+            statement = super
+            statement << ' AUTO_INCREMENT' if supports_serial? && schema[:serial?]
+            statement
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def character_set
+            @character_set ||= show_variable('character_set_connection') || 'utf8'
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def collation
+            @collation ||= show_variable('collation_connection') || 'utf8_general_ci'
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def show_variable(name)
+            query('SHOW VARIABLES WHERE `variable_name` = ?', name).first.value rescue nil
+          end
+        end # module SQL
+
+        include SQL
+
+        module ClassMethods
+          # TypeMap for MySql databases.
+          #
+          # @return <DataMapper::TypeMap> default TypeMap for MySql databases.
+          #
+          # TODO: move to dm-more/dm-migrations
+          def type_map
+            @type_map ||= TypeMap.new(super) do |tm|
+              tm.map(Integer).to('INT').with(:size => 11)
+              tm.map(TrueClass).to('TINYINT').with(:size => 1)  # TODO: map this to a BIT or CHAR(0) field?
+              tm.map(Object).to('TEXT')
+            end
+          end
+        end # module ClassMethods
+      end # module Migration
+
+      include Migration
+      extend Migration::ClassMethods
+    end # class MysqlAdapter
+  end # module Adapters
+end # module DataMapper

data/lib/dm-core/adapters/postgres_adapter.rb

@@ -0,0 +1,188 @@
+gem 'do_postgres', '>=0.9.5'
+require 'do_postgres'
+
+module DataMapper
+  module Adapters
+    class PostgresAdapter < DataObjectsAdapter
+      module SQL
+        private
+
+        def supports_returning?
+          true
+        end
+      end #module SQL
+
+      include SQL
+
+      # TODO: move to dm-more/dm-migrations (if possible)
+      module Migration
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def storage_exists?(storage_name)
+          statement = <<-EOS.compress_lines
+            SELECT COUNT(*)
+            FROM "information_schema"."columns"
+            WHERE "table_name" = ?
+            AND "table_schema" = current_schema()
+          EOS
+
+          query(statement, storage_name).first > 0
+        end
+
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def field_exists?(storage_name, column_name)
+          statement = <<-EOS.compress_lines
+            SELECT COUNT(*)
+            FROM "pg_class"
+            JOIN "pg_attribute" ON "pg_class"."oid" = "pg_attribute"."attrelid"
+            WHERE "pg_attribute"."attname" = ?
+            AND "pg_class"."relname" = ?
+            AND "pg_attribute"."attnum" >= 0
+          EOS
+
+          query(statement, column_name, storage_name).first > 0
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def upgrade_model_storage(repository, model)
+          add_sequences(repository, model)
+          super
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def create_model_storage(repository, model)
+          add_sequences(repository, model)
+          without_notices { super }
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def destroy_model_storage(repository, model)
+          return true unless storage_exists?(model.storage_name(repository.name))
+          success = without_notices { super }
+          model.properties(repository.name).each do |property|
+            drop_sequence(repository, property) if property.serial?
+          end
+          success
+        end
+
+        protected
+
+        # TODO: move to dm-more/dm-migrations
+        def create_sequence(repository, property)
+          return if sequence_exists?(repository, property)
+          execute(create_sequence_statement(repository, property))
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def drop_sequence(repository, property)
+          without_notices { execute(drop_sequence_statement(repository, property)) }
+        end
+
+        module SQL
+          private
+
+          # TODO: move to dm-more/dm-migrations
+          def drop_table_statement(repository, model)
+            "DROP TABLE #{quote_table_name(model.storage_name(repository.name))}"
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def without_notices(&block)
+            # execute the block with NOTICE messages disabled
+            begin
+              execute('SET client_min_messages = warning')
+              yield
+            ensure
+              execute('RESET client_min_messages')
+            end
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def add_sequences(repository, model)
+            model.properties(repository.name).each do |property|
+              create_sequence(repository, property) if property.serial?
+            end
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def sequence_name(repository, property)
+            "#{property.model.storage_name(repository.name)}_#{property.field(repository.name)}_seq"
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def sequence_exists?(repository, property)
+            statement = <<-EOS.compress_lines
+              SELECT COUNT(*)
+              FROM "pg_class"
+              WHERE "relkind" = 'S' AND "relname" = ?
+            EOS
+
+            query(statement, sequence_name(repository, property)).first > 0
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def create_sequence_statement(repository, property)
+            "CREATE SEQUENCE #{quote_column_name(sequence_name(repository, property))}"
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def drop_sequence_statement(repository, property)
+            "DROP SEQUENCE IF EXISTS #{quote_column_name(sequence_name(repository, property))}"
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def property_schema_statement(schema)
+            statement = super
+
+            if schema.has_key?(:sequence_name)
+              statement << " DEFAULT nextval('#{schema[:sequence_name]}') NOT NULL"
+            end
+
+            statement
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def property_schema_hash(repository, property)
+            schema = super
+
+            if property.serial?
+              schema.delete(:default)  # the sequence will be the default
+              schema[:sequence_name] = sequence_name(repository, property)
+            end
+
+            # TODO: see if TypeMap can be updated to set specific attributes to nil
+            # for different adapters.  precision/scale are perfect examples for
+            # Postgres floats
+
+            # Postgres does not support precision and scale for Float
+            if property.primitive == Float
+              schema.delete(:precision)
+              schema.delete(:scale)
+            end
+
+            schema
+          end
+        end # module SQL
+
+        include SQL
+
+        module ClassMethods
+          # TypeMap for PostgreSQL databases.
+          #
+          # @return <DataMapper::TypeMap> default TypeMap for PostgreSQL databases.
+          #
+          # TODO: move to dm-more/dm-migrations
+          def type_map
+            @type_map ||= TypeMap.new(super) do |tm|
+              tm.map(DateTime).to('TIMESTAMP')
+              tm.map(Integer).to('INT4')
+              tm.map(Float).to('FLOAT8')
+            end
+          end
+        end # module ClassMethods
+      end # module Migration
+
+      include Migration
+      extend Migration::ClassMethods
+    end # class PostgresAdapter
+  end # module Adapters
+end # module DataMapper

data/lib/dm-core/adapters/sqlite3_adapter.rb

@@ -0,0 +1,105 @@
+gem 'do_sqlite3', '>=0.9.5'
+require 'do_sqlite3'
+
+module DataMapper
+  module Adapters
+    class Sqlite3Adapter < DataObjectsAdapter
+      module SQL
+        private
+
+        def quote_column_value(column_value)
+          case column_value
+            when TrueClass  then quote_column_value('t')
+            when FalseClass then quote_column_value('f')
+            else
+              super
+          end
+        end
+      end # module SQL
+
+      include SQL
+
+      # TODO: move to dm-more/dm-migrations (if possible)
+      module Migration
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def storage_exists?(storage_name)
+          query_table(storage_name).size > 0
+        end
+
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def field_exists?(storage_name, column_name)
+          query_table(storage_name).any? do |row|
+            row.name == column_name
+          end
+        end
+
+        private
+
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def query_table(table_name)
+          query('PRAGMA table_info(?)', table_name)
+        end
+
+        module SQL
+#          private  ## This cannot be private for current migrations
+
+          # TODO: move to dm-more/dm-migrations
+          def supports_serial?
+            sqlite_version >= '3.1.0'
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def create_table_statement(repository, model)
+            statement = <<-EOS.compress_lines
+              CREATE TABLE #{quote_table_name(model.storage_name(repository.name))}
+              (#{model.properties_with_subclasses(repository.name).map { |p| property_schema_statement(property_schema_hash(repository, p)) } * ', '}
+            EOS
+
+            # skip adding the primary key if one of the columns is serial.  In
+            # SQLite the serial column must be the primary key, so it has already
+            # been defined
+            unless model.properties(repository.name).any? { |p| p.serial? }
+              if (key = model.properties(repository.name).key).any?
+                statement << ", PRIMARY KEY(#{key.map { |p| quote_column_name(p.field(repository.name)) } * ', '})"
+              end
+            end
+
+            statement << ')'
+            statement
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def property_schema_statement(schema)
+            statement = super
+            statement << ' PRIMARY KEY AUTOINCREMENT' if supports_serial? && schema[:serial?]
+            statement
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def sqlite_version
+            @sqlite_version ||= query('SELECT sqlite_version(*)').first
+          end
+        end # module SQL
+
+        include SQL
+
+        module ClassMethods
+          # TypeMap for SQLite 3 databases.
+          #
+          # @return <DataMapper::TypeMap> default TypeMap for SQLite 3 databases.
+          #
+          # TODO: move to dm-more/dm-migrations
+          def type_map
+            @type_map ||= TypeMap.new(super) do |tm|
+              tm.map(Integer).to('INTEGER')
+              tm.map(Class).to('VARCHAR')
+            end
+          end
+        end # module ClassMethods
+      end # module Migration
+
+      include Migration
+      extend Migration::ClassMethods
+    end # class Sqlite3Adapter
+  end # module Adapters
+end # module DataMapper

data/lib/dm-core/associations.rb

@@ -0,0 +1,199 @@
+dir = Pathname(__FILE__).dirname.expand_path / 'associations'
+
+require dir / 'relationship'
+require dir / 'relationship_chain'
+require dir / 'many_to_many'
+require dir / 'many_to_one'
+require dir / 'one_to_many'
+require dir / 'one_to_one'
+
+module DataMapper
+  module Associations
+    include Assertions
+
+    class ImmutableAssociationError < RuntimeError
+    end
+
+    class UnsavedParentError < RuntimeError
+    end
+
+    # Returns all relationships that are many-to-one for this model.
+    #
+    # Used to find the relationships that require properties in any Repository.
+    #
+    # Example:
+    # class Plur
+    #   include DataMapper::Resource
+    #   def self.default_repository_name
+    #     :plur_db
+    #   end
+    #   repository(:plupp_db) do
+    #     has 1, :plupp
+    #   end
+    # end
+    #
+    # This resource has a many-to-one to the Plupp resource residing in the :plupp_db repository,
+    # but the Plur resource needs the plupp_id property no matter what repository itself lives in,
+    # ie we need to create that property when we migrate etc.
+    #
+    # Used in DataMapper::Model.properties_with_subclasses
+    #
+    # @api private
+    def many_to_one_relationships
+      relationships unless @relationships # needs to be initialized!
+      @relationships.values.collect do |rels| rels.values end.flatten.select do |relationship| relationship.child_model == self end
+    end
+
+    def relationships(repository_name = default_repository_name)
+      @relationships ||= Hash.new { |h,k| h[k] = k == Repository.default_name ? {} : h[Repository.default_name].dup }
+      @relationships[repository_name]
+    end
+
+    def n
+      1.0/0
+    end
+
+    ##
+    # A shorthand, clear syntax for defining one-to-one, one-to-many and
+    # many-to-many resource relationships.
+    #
+    # @example [Usage]
+    #   * has 1, :friend                          # one friend
+    #   * has n, :friends                         # many friends
+    #   * has 1..3, :friends
+    #                         # many friends (at least 1, at most 3)
+    #   * has 3, :friends
+    #                         # many friends (exactly 3)
+    #   * has 1, :friend, :class_name => 'User'
+    #                         # one friend with the class name User
+    #   * has 3, :friends, :through => :friendships
+    #                         # many friends through the friendships relationship
+    #   * has n, :friendships => :friends
+    #                         # identical to above example
+    #
+    # @param cardinality [Integer, Range, Infinity]
+    #   cardinality that defines the association type and constraints
+    # @param name <Symbol>  the name that the association will be referenced by
+    # @param opts <Hash>    an options hash
+    #
+    # @option :through[Symbol]  A association that this join should go through to form
+    #       a many-to-many association
+    # @option :class_name[String] The name of the class to associate with, if omitted
+    #       then the association name is assumed to match the class name
+    # @option :remote_name[Symbol] In the case of a :through option being present, the
+    #       name of the relationship on the other end of the :through-relationship
+    #       to be linked to this relationship.
+    #
+    # @return [DataMapper::Association::Relationship] the relationship that was
+    #   created to reflect either a one-to-one, one-to-many or many-to-many
+    #   relationship
+    # @raise [ArgumentError] if the cardinality was not understood. Should be a
+    #   Integer, Range or Infinity(n)
+    #
+    # @api public
+    def has(cardinality, name, options = {})
+
+      # NOTE: the reason for this fix is that with the ability to pass in two
+      # hashes into has() there might be instances where people attempt to
+      # pass in the options into the name part and not know why things aren't
+      # working for them.
+      if name.kind_of?(Hash)
+        name_through, through = name.keys.first, name.values.first
+        cardinality_string = cardinality.to_s == 'Infinity' ? 'n' : cardinality.inspect
+        warn("In #{self.name} 'has #{cardinality_string}, #{name_through.inspect} => #{through.inspect}' is deprecated. Use 'has #{cardinality_string}, #{name_through.inspect}, :through => #{through.inspect}' instead")
+      end
+
+      options = options.merge(extract_min_max(cardinality))
+      options = options.merge(extract_throughness(name))
+
+      # do not remove this. There is alot of confusion on people's
+      # part about what the first argument to has() is.  For the record it
+      # is the min cardinality and max cardinality of the association.
+      # simply put, it constraints the number of resources that will be
+      # returned by the association.  It is not, as has been assumed,
+      # the number of results on the left and right hand side of the
+      # reltionship.
+      if options[:min] == n && options[:max] == n
+        raise ArgumentError, 'Cardinality may not be n..n.  The cardinality specifies the min/max number of results from the association', caller
+      end
+
+      klass = options[:max] == 1 ? OneToOne : OneToMany
+      klass = ManyToMany if options[:through] == DataMapper::Resource
+      relationship = klass.setup(options.delete(:name), self, options)
+
+      # Please leave this in - I will release contextual serialization soon
+      # which requires this -- guyvdb
+      # TODO convert this to a hook in the plugin once hooks work on class
+      # methods
+      self.init_has_relationship_for_serialization(relationship) if self.respond_to?(:init_has_relationship_for_serialization)
+
+      relationship
+    end
+
+    ##
+    # A shorthand, clear syntax for defining many-to-one resource relationships.
+    #
+    # @example [Usage]
+    #   * belongs_to :user                          # many_to_one, :friend
+    #   * belongs_to :friend, :class_name => 'User'  # many_to_one :friends
+    #
+    # @param name [Symbol] The name that the association will be referenced by
+    # @see #has
+    #
+    # @return [DataMapper::Association::ManyToOne] The association created
+    #   should not be accessed directly
+    #
+    # @api public
+    def belongs_to(name, options={})
+      relationship = ManyToOne.setup(name, self, options)
+      # Please leave this in - I will release contextual serialization soon
+      # which requires this -- guyvdb
+      # TODO convert this to a hook in the plugin once hooks work on class
+      # methods
+      self.init_belongs_relationship_for_serialization(relationship) if self.respond_to?(:init_belongs_relationship_for_serialization)
+
+      relationship
+    end
+
+    private
+
+    def extract_throughness(name)
+      assert_kind_of 'name', name, Hash, Symbol
+
+      case name
+        when Hash
+          unless name.keys.size == 1
+            raise ArgumentError, "name must have only one key, but had #{name.keys.size}", caller(2)
+          end
+
+          { :name => name.keys.first, :through => name.values.first }
+        when Symbol
+          { :name => name }
+      end
+    end
+
+    # A support method form converting Integer, Range or Infinity values into a
+    # { :min => x, :max => y } hash.
+    #
+    # @api private
+    def extract_min_max(constraints)
+      assert_kind_of 'constraints', constraints, Integer, Range unless constraints == n
+
+      case constraints
+        when Integer
+          { :min => constraints, :max => constraints }
+        when Range
+          if constraints.first > constraints.last
+            raise ArgumentError, "Constraint min (#{constraints.first}) cannot be larger than the max (#{constraints.last})"
+          end
+
+          { :min => constraints.first, :max => constraints.last }
+        when n
+          { :min => 0, :max => n }
+      end
+    end
+  end # module Associations
+
+  Model.append_extensions DataMapper::Associations
+
+end # module DataMapper