mack-data_mapper 0.8.1 → 0.8.2

data/lib/gems/dm-core-0.9.7/lib/dm-core/adapters/in_memory_adapter.rb

@@ -0,0 +1,87 @@
+module DataMapper
+  module Adapters
+    class InMemoryAdapter < AbstractAdapter
+      def initialize(name, uri_or_options)
+        @records = Hash.new { |hash,model| hash[model] = Array.new }
+      end
+
+      def create(resources)
+        resources.each do |resource|
+          @records[resource.model] << resource
+        end.size # just return the number of records
+      end
+
+      def update(attributes, query)
+        read_many(query).each do |resource|
+          attributes.each do |property,value|
+            property.set!(resource, value)
+          end
+        end.size
+      end
+
+      def read_one(query)
+        read(query, query.model, false)
+      end
+
+      def read_many(query)
+        Collection.new(query) do |set|
+          read(query, set, true)
+        end
+      end
+
+      def delete(query)
+        records = @records[query.model]
+
+        read_many(query).each do |resource|
+          records.delete(resource)
+        end.size
+      end
+
+      private
+
+      def read(query, set, many = true)
+        model      = query.model
+        conditions = query.conditions
+
+        match_with = many ? :select : :detect
+
+        # Iterate over the records for this model, and return
+        # the ones that match the conditions
+        result = @records[model].send(match_with) do |resource|
+          conditions.all? do |tuple|
+            operator, property, bind_value = *tuple
+
+            value = property.get!(resource)
+
+            case operator
+              when :eql, :in then equality_comparison(bind_value, value)
+              when :not      then !equality_comparison(bind_value, value)
+              when :like     then Regexp.new(bind_value) =~ value
+              when :gt       then !value.nil? && value >  bind_value
+              when :gte      then !value.nil? && value >= bind_value
+              when :lt       then !value.nil? && value <  bind_value
+              when :lte      then !value.nil? && value <= bind_value
+              else raise "Invalid query operator: #{operator.inspect}"
+            end
+          end
+        end
+
+        return result unless many
+
+        # TODO Sort
+
+        # TODO Limit
+
+        set.replace(result)
+      end
+
+      def equality_comparison(bind_value, value)
+        case bind_value
+          when Array, Range then bind_value.include?(value)
+          when NilClass     then value.nil?
+          else                   bind_value == value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+gem 'do_mysql', '~>0.9.7'
+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/gems/dm-core-0.9.7/lib/dm-core/adapters/postgres_adapter.rb

@@ -0,0 +1,188 @@
+gem 'do_postgres', '~>0.9.7'
+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
+            # 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/gems/dm-core-0.9.7/lib/dm-core/adapters/sqlite3_adapter.rb

@@ -0,0 +1,105 @@
+gem 'do_sqlite3', '~>0.9.7'
+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/gems/dm-core-0.9.7/lib/dm-core/adapters.rb

@@ -0,0 +1,22 @@
+dir = Pathname(__FILE__).dirname.expand_path / 'adapters'
+
+require dir / 'abstract_adapter'
+require dir / 'in_memory_adapter'
+
+# TODO Factor these out into dm-more
+require dir / 'data_objects_adapter'
+begin
+  require dir / 'sqlite3_adapter'
+rescue LoadError
+  # ignore it
+end
+begin
+  require dir / 'mysql_adapter'
+rescue LoadError
+  # ignore it
+end
+begin
+  require dir / 'postgres_adapter'
+rescue LoadError
+  # ignore it
+end

data/lib/gems/dm-core-0.9.7/lib/dm-core/associations/many_to_many.rb

@@ -0,0 +1,147 @@
+require File.join(File.dirname(__FILE__), "one_to_many")
+module DataMapper
+  module Associations
+    module ManyToMany
+      extend Assertions
+
+      # Setup many to many relationship between two models
+      # -
+      # @api private
+      def self.setup(name, model, options = {})
+        assert_kind_of 'name',    name,    Symbol
+        assert_kind_of 'model',   model,   Model
+        assert_kind_of 'options', options, Hash
+
+        repository_name = model.repository.name
+
+        model.class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}(query = {})
+            #{name}_association.all(query)
+          end
+
+          def #{name}=(children)
+            #{name}_association.replace(children)
+          end
+
+          private
+
+          def #{name}_association
+            @#{name}_association ||= begin
+              unless relationship = model.relationships(#{repository_name.inspect})[#{name.inspect}]
+                raise ArgumentError, "Relationship #{name.inspect} does not exist in \#{model}"
+              end
+              association = Proxy.new(relationship, self)
+              parent_associations << association
+              association
+            end
+          end
+        EOS
+
+        opts = options.dup
+        opts.delete(:through)
+        opts[:child_model]              ||= opts.delete(:class_name)  || Extlib::Inflection.classify(name)
+        opts[:parent_model]             =   model
+        opts[:repository_name]          =   repository_name
+        opts[:remote_relationship_name] ||= opts.delete(:remote_name) || Extlib::Inflection.tableize(opts[:child_model])
+        opts[:parent_key]               =   opts[:parent_key]
+        opts[:child_key]                =   opts[:child_key]
+        opts[:mutable]                  =   true
+
+        names        = [ opts[:child_model], opts[:parent_model].name ].sort
+        model_name   = names.join.gsub("::", "")
+        storage_name = Extlib::Inflection.tableize(Extlib::Inflection.pluralize(names[0]) + names[1])
+
+        opts[:near_relationship_name] = Extlib::Inflection.tableize(model_name).to_sym
+
+        model.has(model.n, opts[:near_relationship_name])
+
+        relationship = model.relationships(repository_name)[name] = RelationshipChain.new(opts)
+
+        unless Object.const_defined?(model_name)
+          model = DataMapper::Model.new(storage_name)
+
+          model.class_eval <<-EOS, __FILE__, __LINE__
+            def self.name; #{model_name.inspect} end
+            def self.default_repository_name; #{repository_name.inspect} end
+            def self.many_to_many; true end
+          EOS
+
+          names.each do |n|
+            model.belongs_to(Extlib::Inflection.underscore(n).gsub("/", "_").to_sym, :class_name => n)
+          end
+
+          Object.const_set(model_name, model)
+        end
+
+        relationship
+      end
+
+      class Proxy < DataMapper::Associations::OneToMany::Proxy
+        def delete(resource)
+          through = near_association.get(*(@parent.key + resource.key))
+          near_association.delete(through)
+          orphan_resource(super)
+        end
+
+        def clear
+          near_association.clear
+          super
+        end
+
+        def destroy
+          near_association.destroy
+          super
+        end
+
+        def save
+        end
+
+        private
+
+        def new_child(attributes)
+          remote_relationship.parent_model.new(attributes)
+        end
+
+        def relate_resource(resource)
+          assert_mutable
+          add_default_association_values(resource)
+          @orphans.delete(resource)
+
+          # TODO: fix this so it does not automatically save on append, if possible
+          resource.save if resource.new_record?
+          through_resource = @relationship.child_model.new
+          @relationship.child_key.zip(@relationship.parent_key) do |child_key,parent_key|
+            through_resource.send("#{child_key.name}=", parent_key.get(@parent))
+          end
+          remote_relationship.child_key.zip(remote_relationship.parent_key) do |child_key,parent_key|
+            through_resource.send("#{child_key.name}=", parent_key.get(resource))
+          end
+          near_association << through_resource
+
+          resource
+        end
+
+        def orphan_resource(resource)
+          assert_mutable
+          @orphans << resource
+          resource
+        end
+
+        def assert_mutable
+        end
+
+        def remote_relationship
+          @remote_relationship ||= @relationship.send(:remote_relationship)
+        end
+
+        def near_association
+          @near_association ||= @parent.send(near_relationship_name)
+        end
+
+        def near_relationship_name
+          @near_relationship_name ||= @relationship.send(:instance_variable_get, :@near_relationship_name)
+        end
+      end # class Proxy
+    end # module ManyToMany
+  end # module Associations
+end # module DataMapper