hanami-model 0.0.0 → 0.6.0

data/lib/hanami/model/mapping/collection_coercer.rb

@@ -0,0 +1,79 @@
+module Hanami
+  module Model
+    module Mapping
+      # Translates values from/to the database with the corresponding Ruby type.
+      #
+      # @api private
+      # @since 0.1.0
+      class CollectionCoercer
+        # Initialize a coercer for the given collection.
+        #
+        # @param collection [Hanami::Model::Mapping::Collection] the collection
+        #
+        # @api private
+        # @since 0.1.0
+        def initialize(collection)
+          @collection = collection
+          _compile!
+        end
+
+        # Translates the given entity into a format compatible with the database.
+        #
+        # @param entity [Object] the entity
+        #
+        # @return [Hash]
+        #
+        # @api private
+        # @since 0.1.0
+        def to_record(entity)
+        end
+
+        # Translates the given record into a Ruby object.
+        #
+        # @param record [Hash]
+        #
+        # @return [Object]
+        #
+        # @api private
+        # @since 0.1.0
+        def from_record(record)
+        end
+
+        private
+        # Compile itself for performance boost.
+        #
+        # @api private
+        # @since 0.1.0
+        def _compile!
+          code = @collection.attributes.map do |_,attr|
+            %{
+            def deserialize_#{ attr.mapped }(value)
+              #{ attr.load_coercer }(value)
+            end
+            }
+          end.join("\n")
+
+          instance_eval <<-EVAL, __FILE__, __LINE__
+            def to_record(entity)
+              if entity.id
+                Hash[#{ @collection.attributes.map{|name,attr| ":#{ attr.mapped },#{ attr.dump_coercer }(entity.#{name})"}.join(',') }]
+              else
+                Hash[].tap do |record|
+                  #{ @collection.attributes.reject{|name,_| name == @collection.identity }.map{|name,attr| "value = #{ attr.dump_coercer }(entity.#{name}); record[:#{attr.mapped}] = value unless value.nil?"}.join('; ') }
+                end
+              end
+            end
+
+            def from_record(record)
+              ::#{ @collection.entity }.new(
+                Hash[#{ @collection.attributes.map{|name,attr| ":#{name},#{attr.load_coercer}(record[:#{attr.mapped}])"}.join(',') }]
+              )
+            end
+
+            #{ code }
+          EVAL
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/migrator.rb

@@ -0,0 +1,324 @@
+require 'sequel'
+require 'sequel/extensions/migration'
+require 'hanami/model/migrator/connection'
+require 'hanami/model/migrator/adapter'
+
+module Hanami
+  module Model
+    # Migration error
+    #
+    # @since 0.4.0
+    class MigrationError < Hanami::Model::Error
+    end
+
+    # Define a migration
+    #
+    # It must define an up/down strategy to write schema changes (up) and to
+    # rollback them (down).
+    #
+    # We can use <tt>up</tt> and <tt>down</tt> blocks for custom strategies, or
+    # only one <tt>change</tt> block that automatically implements "down" strategy.
+    #
+    # @param blk [Proc] a block that defines up/down or change database migration
+    #
+    # @since 0.4.0
+    #
+    # @example Use up/down blocks
+    #   Hanami::Model.migration do
+    #     up do
+    #       create_table :books do
+    #         primary_key :id
+    #         column :book, String
+    #       end
+    #     end
+    #
+    #     down do
+    #       drop_table :books
+    #     end
+    #   end
+    #
+    # @example Use change block
+    #   Hanami::Model.migration do
+    #     change do
+    #       create_table :books do
+    #         primary_key :id
+    #         column :book, String
+    #       end
+    #     end
+    #
+    #     # DOWN strategy is automatically generated
+    #   end
+    def self.migration(&blk)
+      Sequel.migration(&blk)
+    end
+
+    # Database schema migrator
+    #
+    # @since 0.4.0
+    module Migrator
+      # Create database defined by current configuration.
+      #
+      # It's only implemented for the following databases:
+      #
+      #   * SQLite3
+      #   * PostgreSQL
+      #   * MySQL
+      #
+      # @raise [Hanami::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Hanami::Model::Configuration#adapter
+      #
+      # @example
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter type: :sql, uri: 'postgres://localhost/foo'
+      #   end
+      #
+      #   Hanami::Model::Migrator.create # Creates `foo' database
+      def self.create
+        adapter(connection).create
+      end
+
+      # Drop database defined by current configuration.
+      #
+      # It's only implemented for the following databases:
+      #
+      #   * SQLite3
+      #   * PostgreSQL
+      #   * MySQL
+      #
+      # @raise [Hanami::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Hanami::Model::Configuration#adapter
+      #
+      # @example
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter type: :sql, uri: 'postgres://localhost/foo'
+      #   end
+      #
+      #   Hanami::Model::Migrator.drop # Drops `foo' database
+      def self.drop
+        adapter(connection).drop
+      end
+
+      # Migrate database schema
+      #
+      # It's possible to migrate "down" by specifying a version
+      # (eg. <tt>"20150610133853"</tt>)
+      #
+      # @param version [String,NilClass] target version
+      #
+      # @raise [Hanami::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Hanami::Model::Configuration#adapter
+      # @see Hanami::Model::Configuration#migrations
+      #
+      # @example Migrate Up
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter    type: :sql, uri: 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #   end
+      #
+      #   # Reads all files from "db/migrations" and apply them
+      #   Hanami::Model::Migrator.migrate
+      #
+      # @example Migrate Down
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter    type: :sql, uri: 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #   end
+      #
+      #   # Reads all files from "db/migrations" and apply them
+      #   Hanami::Model::Migrator.migrate
+      #
+      #   # Migrate to a specifiy version
+      #   Hanami::Model::Migrator.migrate(version: "20150610133853")
+      def self.migrate(version: nil)
+        version = Integer(version) unless version.nil?
+
+        Sequel::Migrator.run(connection, migrations, target: version, allow_missing_migration_files: true) if migrations?
+      rescue Sequel::Migrator::Error => e
+        raise MigrationError.new(e.message)
+      end
+
+      # Migrate, dump schema, delete migrations.
+      #
+      # This is an experimental feature.
+      # It may change or be removed in the future.
+      #
+      # Actively developed applications accumulate tons of migrations.
+      # In the long term they are hard to maintain and slow to execute.
+      #
+      # "Apply" feature solves this problem.
+      #
+      # It keeps an updated SQL file with the structure of the database.
+      # This file can be used to create fresh databases for developer machines
+      # or during testing. This is faster than to run dozen or hundred migrations.
+      #
+      # When we use "apply", it eliminates all the migrations that are no longer
+      # necessary.
+      #
+      # @raise [Hanami::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Hanami::Model::Configuration#adapter
+      # @see Hanami::Model::Configuration#migrations
+      #
+      # @example Apply Migrations
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter    type: :sql, uri: 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #     schema     'db/schema.sql'
+      #   end
+      #
+      #   # Reads all files from "db/migrations" and apply and delete them.
+      #   # It generates an updated version of "db/schema.sql"
+      #   Hanami::Model::Migrator.apply
+      def self.apply
+        migrate
+        adapter(connection).dump
+        delete_migrations
+      end
+
+      # Prepare database: drop, create, load schema (if any), migrate.
+      #
+      # This is designed for development machines and testing mode.
+      # It works faster if used with <tt>apply</tt>.
+      #
+      # @raise [Hanami::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Hanami::Model::Migrator.apply
+      #
+      # @example Prepare Database
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter    type: :sql, uri: 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #   end
+      #
+      #   Hanami::Model::Migrator.prepare # => creates `foo' and run migrations
+      #
+      # @example Prepare Database (with schema dump)
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter    type: :sql, uri: 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #     schema     'db/schema.sql'
+      #   end
+      #
+      #   Hanami::Model::Migrator.apply   # => updates schema dump
+      #   Hanami::Model::Migrator.prepare # => creates `foo', load schema and run pending migrations (if any)
+      def self.prepare
+        drop rescue nil
+        create
+        adapter(connection).load
+        migrate
+      end
+
+      # Return current database version timestamp
+      #
+      # If no migrations were ran, it returns <tt>nil</tt>.
+      #
+      # @return [String,NilClass] current version, if previously migrated
+      #
+      # @since 0.4.0
+      #
+      # @example
+      #   # Given last migrations is:
+      #   #  20150610133853_create_books.rb
+      #
+      #   Hanami::Model::Migrator.version # => "20150610133853"
+      def self.version
+        adapter(connection).version
+      end
+
+      private
+
+      # Loads an adapter for the given connection
+      #
+      # @since 0.4.0
+      # @api private
+      def self.adapter(connection)
+        Adapter.for(connection)
+      end
+
+      # Delete all the migrations
+      #
+      # @since 0.4.0
+      # @api private
+      def self.delete_migrations
+        migrations.each_child(&:delete)
+      end
+
+      # Database connection
+      #
+      # @since 0.4.0
+      # @api private
+      def self.connection
+        Sequel.connect(
+          configuration.adapter.uri
+        )
+      rescue Sequel::AdapterNotFound
+        raise MigrationError.new("Current adapter (#{ configuration.adapter.type }) doesn't support SQL database operations.")
+      end
+
+      # Hanami::Model configuration
+      #
+      # @since 0.4.0
+      # @api private
+      def self.configuration
+        Model.configuration
+      end
+
+      # Migrations directory
+      #
+      # @since 0.4.0
+      # @api private
+      def self.migrations
+        configuration.migrations
+      end
+
+      # Check if there are migrations
+      #
+      # @since 0.4.0
+      # @api private
+      def self.migrations?
+        Dir["#{ migrations }/*.rb"].any?
+      end
+    end
+  end
+end

data/lib/hanami/model/migrator/adapter.rb

@@ -0,0 +1,170 @@
+require 'uri'
+require 'shellwords'
+
+module Hanami
+  module Model
+    module Migrator
+      # Migrator base adapter
+      #
+      # @since 0.4.0
+      # @api private
+      class Adapter
+        # Migrations table to store migrations metadata.
+        #
+        # @since 0.4.0
+        # @api private
+        MIGRATIONS_TABLE = :schema_migrations
+
+        # Migrations table version column
+        #
+        # @since 0.4.0
+        # @api private
+        MIGRATIONS_TABLE_VERSION_COLUMN = :filename
+
+        # Loads and returns a specific adapter for the given connection.
+        #
+        # @since 0.4.0
+        # @api private
+        def self.for(connection)
+          case connection.database_type
+          when :sqlite
+            require 'hanami/model/migrator/sqlite_adapter'
+            SQLiteAdapter
+          when :postgres
+            require 'hanami/model/migrator/postgres_adapter'
+            PostgresAdapter
+          when :mysql
+            require 'hanami/model/migrator/mysql_adapter'
+            MySQLAdapter
+          else
+            self
+          end.new(connection)
+        end
+
+        # Initialize an adapter
+        #
+        # @since 0.4.0
+        # @api private
+        def initialize(connection)
+          @connection = Connection.new(connection)
+        end
+
+        # Create database.
+        # It must be implemented by subclasses.
+        #
+        # @since 0.4.0
+        # @api private
+        #
+        # @see Hanami::Model::Migrator.create
+        def create
+          raise MigrationError.new("Current adapter (#{ connection.database_type }) doesn't support create.")
+        end
+
+        # Drop database.
+        # It must be implemented by subclasses.
+        #
+        # @since 0.4.0
+        # @api private
+        #
+        # @see Hanami::Model::Migrator.drop
+        def drop
+          raise MigrationError.new("Current adapter (#{ connection.database_type }) doesn't support drop.")
+        end
+
+        # Load database schema.
+        # It must be implemented by subclasses.
+        #
+        # @since 0.4.0
+        # @api private
+        #
+        # @see Hanami::Model::Migrator.prepare
+        def load
+          raise MigrationError.new("Current adapter (#{ connection.database_type }) doesn't support load.")
+        end
+
+        # Database version.
+        #
+        # @since 0.4.0
+        # @api private
+        def version
+          return unless connection.adapter_connection.tables.include?(MIGRATIONS_TABLE)
+
+          if record = connection.adapter_connection[MIGRATIONS_TABLE].order(MIGRATIONS_TABLE_VERSION_COLUMN).last
+            record.fetch(MIGRATIONS_TABLE_VERSION_COLUMN).scan(/\A[\d]{14}/).first.to_s
+          end
+        end
+
+        private
+
+        # @since 0.5.0
+        # @api private
+        attr_reader :connection
+
+        # Returns a database connection
+        #
+        # Given a DB connection URI we can connect to a specific database or not, we need this when creating
+        # or droping a database. Important to notice that we can't always open a _global_ DB connection,
+        # because most of the times application's DB user has no rights to do so.
+        #
+        # @param global [Boolean] determine whether or not a connection should specify an database.
+        #
+        # @since 0.5.0
+        # @api private
+        #
+        def new_connection(global: false)
+          uri = global ? connection.global_uri : connection.uri
+
+          Sequel.connect(uri)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def database
+          escape connection.database
+        end
+
+        # @since 0.4.0
+        # @api private
+        def port
+          escape connection.port
+        end
+
+        # @since 0.4.0
+        # @api private
+        def host
+          escape connection.host
+        end
+
+        # @since 0.4.0
+        # @api private
+        def username
+          escape connection.user
+        end
+
+        # @since 0.4.0
+        # @api private
+        def password
+          escape connection.password
+        end
+
+        # @since 0.4.0
+        # @api private
+        def schema
+          Model.configuration.schema
+        end
+
+        # @since 0.4.0
+        # @api private
+        def migrations_table
+          escape MIGRATIONS_TABLE
+        end
+
+        # @since 0.4.0
+        # @api private
+        def escape(string)
+          Shellwords.escape(string) unless string.nil?
+        end
+      end
+    end
+  end
+end