datamapper-dm-core 0.9.11 → 0.10.0

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

@@ -1,189 +1,23 @@
-gem 'do_postgres', '~>0.9.12'
+require DataMapper.root / 'lib' / 'dm-core' / 'adapters' / 'data_objects_adapter'
+
 require 'do_postgres'
 
 module DataMapper
   module Adapters
     class PostgresAdapter < DataObjectsAdapter
-      module SQL
+      module SQL #:nodoc:
         private
 
+        # TODO: document
+        # @api 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 = <<-SQL.compress_lines
-            SELECT COUNT(*)
-            FROM "information_schema"."tables"
-            WHERE "table_type" = 'BASE TABLE'
-            AND "table_schema" = current_schema()
-            AND "table_name" = ?
-          SQL
-
-          query(statement, storage_name).first > 0
-        end
-
-        # TODO: move to dm-more/dm-migrations (if possible)
-        def field_exists?(storage_name, column_name)
-          statement = <<-SQL.compress_lines
-            SELECT COUNT(*)
-            FROM "information_schema"."columns"
-            WHERE "table_schema" = current_schema()
-            AND "table_name" = ?
-            AND "column_name" = ?
-          SQL
-
-          query(statement, storage_name, column_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 "information_schema"."sequences"
-              WHERE "sequence_name" = ?
-              AND "sequence_schema" = current_schema()
-            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
+
+    const_added(:PostgresAdapter)
   end # module Adapters
 end # module DataMapper

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

@@ -1,105 +1,12 @@
-gem 'do_sqlite3', '~>0.9.12'
+require DataMapper.root / 'lib' / 'dm-core' / 'adapters' / 'data_objects_adapter'
+
 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
+
+    const_added(:Sqlite3Adapter)
   end # module Adapters
 end # module DataMapper

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

@@ -0,0 +1,116 @@
+require 'pathname'
+require 'yaml'
+
+module DataMapper
+  module Adapters
+    class YamlAdapter < AbstractAdapter
+      # TODO: document
+      # @api semipublic
+      def create(resources)
+        update_records(resources.first.model) do |records|
+          resources.each do |resource|
+            initialize_serial(resource, records.size.succ)
+            records << resource.attributes(:field)
+          end
+        end
+      end
+
+      # TODO: document
+      # @api semipublic
+      def read(query)
+        query.filter_records(records_for(query.model).dup)
+      end
+
+      # TODO: document
+      # @api semipublic
+      def update(attributes, collection)
+        attributes = attributes_as_fields(attributes)
+
+        update_records(collection.model) do |records|
+          records_to_update = collection.query.filter_records(records.dup)
+          records_to_update.each { |resource| resource.update(attributes) }.size
+        end
+      end
+
+      # TODO: document
+      # @api semipublic
+      def delete(collection)
+        update_records(collection.model) do |records|
+          records_to_delete = collection.query.filter_records(records.dup)
+          records.replace(records - records_to_delete)
+          records_to_delete.size
+        end
+      end
+
+      private
+
+      # TODO: document
+      # @api semipublic
+      def initialize(name, options = {})
+        super
+        (@path = Pathname(@options[:path]).freeze).mkpath
+      end
+
+      # Retrieves all records for a model and yeilds them to a block.
+      #
+      # The block should make any changes to the records in-place. After
+      # the block executes all the records are dumped back to the file.
+      #
+      # @param [Model, #to_s] model
+      #   Used to determine which file to read/write to
+      #
+      # @yieldparam [Hash]
+      #   A hash of record.key => record pairs retrieved from the file
+      #
+      # @api private
+      def update_records(model)
+        records = records_for(model)
+        result = yield records
+        write_records(model, records)
+        result
+      end
+
+      # Read all records from a file for a model
+      #
+      # @param [#storage_name] model
+      #   The model/name to retieve records for
+      #
+      # @api private
+      def records_for(model)
+        file = yaml_file(model)
+        file.readable? && YAML.load_file(file) || []
+      end
+
+      # Writes all records to a file
+      #
+      # @param [#storage_name] model
+      #   The model/name to write the records for
+      #
+      # @param [Hash] records
+      #   A hash of record.key => record pairs to be written
+      #
+      # @api private
+      def write_records(model, records)
+        yaml_file(model).open('w') do |fh|
+          YAML.dump(records, fh)
+        end
+      end
+
+      # Given a model, gives the filename to be used for record storage
+      #
+      # @example
+      #   yaml_file(Article) #=> "/path/to/files/articles.yml"
+      #
+      # @param [#storage_name] model
+      #   The model to be used to determine the file name.
+      #
+      # @api private
+      def yaml_file(model)
+        @path / "#{model.storage_name(name)}.yml"
+      end
+
+    end # class YamlAdapter
+
+    const_added(:YamlAdapter)
+  end # module Adapters
+end # module DataMapper

data/lib/dm-core/adapters.rb

@@ -1,16 +1,135 @@
-dir = Pathname(__FILE__).dirname.expand_path / 'adapters'
-
-require dir / 'abstract_adapter'
-require dir / 'in_memory_adapter'
-
-# NOTE: this is a temporary work-around to the load error problems,
-# and is better fixed in dm-core/next.  The main reason the fix is
-# not applied in dm-core/master is because the change is non-trivial.
-
-%w[ data_objects sqlite3 mysql postgres ].each do |gem|
-  begin
-    require dir / "#{gem}_adapter"
-  rescue LoadError, Gem::Exception
-    # ignore it
-  end
-end
+module DataMapper
+  module Adapters
+    extend Chainable
+    extend Extlib::Assertions
+
+    # Set up an adapter for a storage engine
+    #
+    # @see DataMapper.setup
+    #
+    # @api private
+    def self.new(repository_name, options)
+      options = normalize_options(options)
+      adapter_class(options[:adapter]).new(repository_name, options)
+    end
+
+    class << self
+      private
+
+      # Normalize the arguments passed to new()
+      #
+      # Turns options hash or connection URI into the options hash used
+      # by the adapter.
+      #
+      # @param [Hash, Addressable::URI, String] options
+      #   the options to be normalized
+      #
+      # @return [Mash]
+      #   the options normalized as a Mash
+      #
+      # @api private
+      def normalize_options(options)
+        case options
+          when Hash             then normalize_options_hash(options)
+          when Addressable::URI then normalize_options_uri(options)
+          when String           then normalize_options_string(options)
+          else
+            assert_kind_of 'options', options, Hash, Addressable::URI, String
+        end
+      end
+
+      # Normalize Hash options into a Mash
+      #
+      # @param [Hash] hash
+      #   the hash to be normalized
+      #
+      # @return [Mash]
+      #   the options normalized as a Mash
+      #
+      # @api private
+      def normalize_options_hash(hash)
+        hash.to_mash
+      end
+
+      # Normalize Addressable::URI options into a Mash
+      #
+      # @param [Addressable::URI] uri
+      #   the uri to be normalized
+      #
+      # @return [Mash]
+      #   the options normalized as a Mash
+      #
+      # @api private
+      def normalize_options_uri(uri)
+        options = normalize_options_hash(uri.to_hash)
+
+        # Extract the name/value pairs from the query portion of the
+        # connection uri, and set them as options directly.
+        if options[:query]
+          options.update(uri.query_values)
+        end
+
+        options[:adapter] = options[:scheme]
+
+        options
+      end
+
+      # Normalize String options into a Mash
+      #
+      # @param [String] string
+      #   the string to be normalized
+      #
+      # @return [Mash]
+      #   the options normalized as a Mash
+      #
+      # @api private
+      def normalize_options_string(string)
+        normalize_options_uri(Addressable::URI.parse(string))
+      end
+
+      # Return the adapter class constant
+      #
+      # @param [Symbol] name
+      #   the name of the adapter
+      #
+      # @return [Class]
+      #   the AbstractAdapter subclass
+      #
+      # @api private
+      def adapter_class(name)
+        class_name = (Extlib::Inflection.camelize(name) << 'Adapter').to_sym
+        load_adapter(name) unless const_defined?(class_name)
+        const_get(class_name)
+      end
+
+      # Require the adapter library
+      #
+      # @param [String, Symbol] name
+      #   the name of the adapter
+      #
+      # @return [Boolean]
+      #   true if the adapter is loaded
+      #
+      # @api private
+      def load_adapter(name)
+        assert_kind_of 'name', name, String, Symbol
+
+        lib  = "#{name}_adapter"
+        file = DataMapper.root / 'lib' / 'dm-core' / 'adapters' / "#{lib}.rb"
+
+        if file.file?
+          require file
+        else
+          require lib
+        end
+      end
+    end
+
+    extendable do
+      # TODO: document
+      # @api private
+      def const_added(const_name)
+      end
+    end
+  end # module Adapters
+end # module DataMapper