lotus-model 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: acf5bf11caa86301e6e5335064ca5c5454df5b86
-  data.tar.gz: 0782b930d37c6236c6c676017ae34caf68b1c2d2
+  metadata.gz: 446ed910e7e39e23fe19ceb56cf66ec8bc545145
+  data.tar.gz: 121c4c8b74f095a7a5e07396d6a37f2fdbeb6a5b
 SHA512:
-  metadata.gz: 0299bb1a135bb8f43804f44968126425fde51be8377b035f2635312d49cc42bc2d4ab62374967f3a574007ae5c6f16e43ba5867372c495c05113fe4420126efa
-  data.tar.gz: a69e4eddfb3b10999487d08bf754f6bf413ac487e80ecb1b3d9b5a34f19856e9da9633854a8c987afa5a5f3d74589835dddde4f5a0265e6d0179ff1af72f33a9
+  metadata.gz: 4df597074019ffca04b8552579a0febd2382462ca6a9472be3b99b5a780b590f0485ec9872018a4dd9dcb31b1243f3f4838096aa4b4030882f36b81971b336f3
+  data.tar.gz: 5dd2f57855b6b08011e8b8e230b610b5f3c3a9edfd4d1f89203faa34b08b25664310d4713f44190c9c7aedc85ebf02c907bfa0aaccc2ee69d0dd39aa56077cef

data/CHANGELOG.md

@@ -1,6 +1,13 @@
 # Lotus::Model
 A persistence layer for Lotus
 
+## v0.4.0 - 2015-06-23
+### Added
+- [Luca Guidi] Database migrations
+
+### Changed
+- [Matthew Bellantoni] Made `Repository.execute` not callable from the outside (private Ruby method, public API).
+
 ## v0.3.2 - 2015-05-22
 ### Added
 - [Dmitry Tymchuk & Luca Guidi] Fix for dirty tracking of attributes changed in place (eg. `book.tags << 'non-fiction'`)

data/README.md

@@ -298,6 +298,36 @@ class ArticleRepository
 end
 ```
 
+You can also extract the common logic from your repository into a module to reuse it in other repositories. Here is a pagination example:
+
+```ruby
+module RepositoryHelpers
+  module Pagination
+    def paginate(limit: 10, offset: 0)
+      query do
+        limit(limit).offset(offset)
+      end
+    end
+  end
+end
+
+class ArticleRepository
+  include Lotus::Repository
+  extend RepositoryHelpers::Pagination
+
+  def self.published
+    query do
+      where(published: true)
+    end
+  end
+
+  # other repository-specific methods here
+end
+```
+
+That will allow `.paginate` usage on `ArticleRepository`, for example:
+`ArticleRepository.published.paginate(15, 0)`
+
 **Your models and repositories have to be in the same namespace.** Otherwise `Lotus::Model::Mapper#load!`
 will not initialize your repositories correctly.
 
@@ -413,6 +443,29 @@ In the example above, we reuse the adapter because the target tables (`people` a
 
 An object that implements an interface for querying the database.
 This interface may vary, according to the adapter's specifications.
+
+Here is common interface for existing class:
+
+  * `.all` - Resolves the query by fetching records from the database and translating them into entities
+  * `.where`, `.and` - Adds a condition that behaves like SQL `WHERE`
+  * `.or` - Adds a condition that behaves like SQL `OR`
+  * `.exclude`, `.not` - Logical negation of a #where condition
+  * `.select` - Selects only the specified columns
+  * `.order`, `.asc` - Specify the ascending order of the records, sorted by the given columns
+  * `.reverse_order`, `.desc` - Specify the descending order of the records, sorted by the given columns
+  * `.limit` - Limit the number of records to return
+  * `.offset` - Specify an `OFFSET` clause. Due to SQL syntax restriction, offset MUST be used with `#limit`
+  * `.sum` - Returns the sum of the values for the given column
+  * `.average`, `.avg` - Returns the average of the values for the given column
+  * `.max` - Returns the maximum value for the given column
+  * `.min` - Returns the minimum value for the given column
+  * `.interval` - Returns the difference between the MAX and MIN for the given column
+  * `.range` - Returns a range of values between the MAX and the MIN for the given column
+  * `.exist?` - Checks if at least one record exists for the current conditions
+  * `.count` - Returns a count of the records for the current conditions
+
+If you need more information regarding those methods, you can use comments from [memory](https://github.com/lotus/model/blob/master/lib/lotus/model/adapters/memory/query.rb#L29) or [sql](https://github.com/lotus/model/blob/master/lib/lotus/model/adapters/sql/query.rb#L28) adapters interface.
+
 Think of an adapter for Redis, it will probably employ different strategies to filter records than an SQL query object.
 
 ### Conventions

data/lib/lotus/model/adapters/sql/query.rb

@@ -207,13 +207,14 @@ module Lotus
           #        .exclude(company: 'enterprise')
           #
           #   # => SELECT * FROM `projects` WHERE (`language` != 'java') AND (`company` != 'enterprise')
+          #
           # @example Expressions
           #
           #   query.exclude{ age > 31 }
           #
           #   # => SELECT * FROM `users` WHERE (`age` <= 31)
           def exclude(condition = nil, &blk)
-            _push_to_conditions(:exclude, condition || blk).inspect
+            _push_to_conditions(:exclude, condition || blk)
             self
           end
 

data/lib/lotus/model/configuration.rb

@@ -10,6 +10,21 @@ module Lotus
     #
     # @since 0.2.0
     class Configuration
+      # Default migrations path
+      #
+      # @since 0.4.0
+      # @api private
+      #
+      # @see Lotus::Model::Configuration#migrations
+      DEFAULT_MIGRATIONS_PATH = Pathname.new('db/migrations').freeze
+
+      # Default schema path
+      #
+      # @since 0.4.0
+      # @api private
+      #
+      # @see Lotus::Model::Configuration#schema
+      DEFAULT_SCHEMA_PATH = Pathname.new('db/schema.sql').freeze
 
       # The persistence mapper
       #
@@ -45,6 +60,8 @@ module Lotus
         @adapter_config = nil
         @mapper = NullMapper.new
         @mapper_config = nil
+        @migrations = DEFAULT_MIGRATIONS_PATH
+        @schema = DEFAULT_SCHEMA_PATH
       end
 
       alias_method :unload!, :reset!
@@ -137,6 +154,77 @@ module Lotus
         @mapper_config = Lotus::Model::Config::Mapper.new(path, &blk)
       end
 
+      # Migrations directory
+      #
+      # It defaults to <tt>db/migrations</tt>.
+      #
+      # @overload migrations
+      #   Get migrations directory
+      #   @return [Pathname] migrations directory
+      #
+      # @overload migrations(path)
+      #   Set migrations directory
+      #   @param path [String,Pathname] the path
+      #   @raise [Errno::ENOENT] if the given path doesn't exist
+      #
+      # @since 0.4.0
+      #
+      # @see Lotus::Model::Migrations::DEFAULT_MIGRATIONS_PATH
+      #
+      # @example Set Custom Path
+      #   require 'lotus/model'
+      #
+      #   Lotus::Model.configure do
+      #     # ...
+      #     migrations 'path/to/migrations'
+      #   end
+      def migrations(path = nil)
+        if path.nil?
+          @migrations
+        else
+          @migrations = root.join(path).realpath
+        end
+      end
+
+      # Schema
+      #
+      # It defaults to <tt>db/schema.sql</tt>.
+      #
+      # @overload schema
+      #   Get schema path
+      #   @return [Pathname] schema path
+      #
+      # @overload schema(path)
+      #   Set schema path
+      #   @param path [String,Pathname] the path
+      #
+      # @since 0.4.0
+      #
+      # @see Lotus::Model::Migrations::DEFAULT_SCHEMA_PATH
+      #
+      # @example Set Custom Path
+      #   require 'lotus/model'
+      #
+      #   Lotus::Model.configure do
+      #     # ...
+      #     schema 'path/to/schema.sql'
+      #   end
+      def schema(path = nil)
+        if path.nil?
+          @schema
+        else
+          @schema = root.join(path)
+        end
+      end
+
+      # Root directory
+      #
+      # @since 0.4.0
+      # @api private
+      def root
+        Lotus.respond_to?(:root) ? Lotus.root : Pathname.pwd
+      end
+
       # Duplicate by copying the settings in a new instance.
       #
       # @return [Lotus::Model::Configuration] a copy of the configuration

data/lib/lotus/model/migrator.rb

@@ -0,0 +1,321 @@
+require 'sequel'
+require 'sequel/extensions/migration'
+require 'lotus/model/migrator/adapter'
+
+module Lotus
+  module Model
+    # Migration error
+    #
+    # @since 0.4.0
+    class MigrationError < ::StandardError
+    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
+    #   Lotus::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
+    #   Lotus::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 [Lotus::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Lotus::Model::Configuration#adapter
+      #
+      # @example
+      #   require 'lotus/model'
+      #   require 'lotus/model/migrator'
+      #
+      #   Lotus::Model.configure do
+      #     # ...
+      #     adapter type: :sql, uri: 'postgres://localhost/foo'
+      #   end
+      #
+      #   Lotus::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 [Lotus::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Lotus::Model::Configuration#adapter
+      #
+      # @example
+      #   require 'lotus/model'
+      #   require 'lotus/model/migrator'
+      #
+      #   Lotus::Model.configure do
+      #     # ...
+      #     adapter type: :sql, uri: 'postgres://localhost/foo'
+      #   end
+      #
+      #   Lotus::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 [Lotus::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Lotus::Model::Configuration#adapter
+      # @see Lotus::Model::Configuration#migrations
+      #
+      # @example Migrate Up
+      #   require 'lotus/model'
+      #   require 'lotus/model/migrator'
+      #
+      #   Lotus::Model.configure do
+      #     # ...
+      #     adapter    type: :sql, uri: 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #   end
+      #
+      #   # Reads all files from "db/migrations" and apply them
+      #   Lotus::Model::Migrator.migrate
+      #
+      # @example Migrate Down
+      #   require 'lotus/model'
+      #   require 'lotus/model/migrator'
+      #
+      #   Lotus::Model.configure do
+      #     # ...
+      #     adapter    type: :sql, uri: 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #   end
+      #
+      #   # Reads all files from "db/migrations" and apply them
+      #   Lotus::Model::Migrator.migrate
+      #
+      #   # Migrate to a specifiy version
+      #   Lotus::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 [Lotus::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Lotus::Model::Configuration#adapter
+      # @see Lotus::Model::Configuration#migrations
+      #
+      # @example Apply Migrations
+      #   require 'lotus/model'
+      #   require 'lotus/model/migrator'
+      #
+      #   Lotus::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"
+      #   Lotus::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 [Lotus::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Lotus::Model::Migrator.apply
+      #
+      # @example Prepare Database
+      #   require 'lotus/model'
+      #   require 'lotus/model/migrator'
+      #
+      #   Lotus::Model.configure do
+      #     # ...
+      #     adapter    type: :sql, uri: 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #   end
+      #
+      #   Lotus::Model::Migrator.prepare # => creates `foo' and run migrations
+      #
+      # @example Prepare Database (with schema dump)
+      #   require 'lotus/model'
+      #   require 'lotus/model/migrator'
+      #
+      #   Lotus::Model.configure do
+      #     # ...
+      #     adapter    type: :sql, uri: 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #     schema     'db/schema.sql'
+      #   end
+      #
+      #   Lotus::Model::Migrator.apply   # => updates schema dump
+      #   Lotus::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
+      #
+      #   Lotus::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
+        )
+      end
+
+      # Lotus::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?
+        migrations.children.any?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+require 'uri'
+require 'shellwords'
+
+module Lotus
+  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 'lotus/model/migrator/sqlite_adapter'
+            SQLiteAdapter
+          when :postgres
+            require 'lotus/model/migrator/postgres_adapter'
+            PostgresAdapter
+          when :mysql
+            require 'lotus/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
+        end
+
+        # Create database.
+        # It must be implemented by subclasses.
+        #
+        # @since 0.4.0
+        # @api private
+        #
+        # @see Lotus::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 Lotus::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 Lotus::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.tables.include?(MIGRATIONS_TABLE)
+
+          if record = @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.4.0
+        # @api private
+        def new_connection
+          uri = URI.parse(@connection.uri)
+          scheme, userinfo, host, port = uri.select(:scheme, :userinfo, :host, :port)
+
+          uri  = "#{ scheme }://"
+          uri += "#{ userinfo }@" unless userinfo.nil?
+          uri += host
+          uri += ":#{ port }" unless port.nil?
+
+          Sequel.connect(uri)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def database
+          escape options.fetch(:database)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def host
+          escape options.fetch(:host)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def port
+          escape options.fetch(:port)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def username
+          escape options.fetch(:user)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def password
+          escape options.fetch(: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 options
+          @connection.opts
+        end
+
+        # @since 0.4.0
+        # @api private
+        def escape(string)
+          Shellwords.escape(string) unless string.nil?
+        end
+      end
+    end
+  end
+end

data/lib/lotus/model/migrator/mysql_adapter.rb

@@ -0,0 +1,64 @@
+module Lotus
+  module Model
+    module Migrator
+      # MySQL adapter
+      #
+      # @since 0.4.0
+      # @api private
+      class MySQLAdapter < Adapter
+        # @since 0.4.0
+        # @api private
+        def create
+          new_connection.run %(CREATE DATABASE #{ database };)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def drop
+          new_connection.run %(DROP DATABASE #{ database };)
+        rescue Sequel::DatabaseError => e
+          message = if e.message.match(/doesn\'t exist/)
+            "Cannot find database: #{ database }"
+          else
+            e.message
+          end
+
+          raise MigrationError.new(message)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump
+          dump_structure
+          dump_migrations_data
+        end
+
+        # @since 0.4.0
+        # @api private
+        def load
+          load_structure
+        end
+
+        private
+
+        # @since 0.4.0
+        # @api private
+        def dump_structure
+          system "mysqldump --user=#{ username } --password=#{ password } --no-data --skip-comments --ignore-table=#{ database }.#{ migrations_table } #{ database } > #{ schema }"
+        end
+
+        # @since 0.4.0
+        # @api private
+        def load_structure
+          system "mysql --user=#{ username } --password=#{ password } #{ database } < #{ escape(schema) }" if schema.exist?
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump_migrations_data
+          system "mysqldump --user=#{ username } --password=#{ password } --skip-comments #{ database } #{ migrations_table } >> #{ schema }"
+        end
+      end
+    end
+  end
+end

data/lib/lotus/model/migrator/postgres_adapter.rb

@@ -0,0 +1,99 @@
+module Lotus
+  module Model
+    module Migrator
+      # PostgreSQL adapter
+      #
+      # @since 0.4.0
+      # @api private
+      class PostgresAdapter < Adapter
+        # @since 0.4.0
+        # @api private
+        HOST     = 'PGHOST'.freeze
+
+        # @since 0.4.0
+        # @api private
+        PORT     = 'PGPORT'.freeze
+
+        # @since 0.4.0
+        # @api private
+        USER     = 'PGUSER'.freeze
+
+        # @since 0.4.0
+        # @api private
+        PASSWORD = 'PGPASSWORD'.freeze
+
+        # @since 0.4.0
+        # @api private
+        def create
+          new_connection.run %(CREATE DATABASE "#{ database }"#{ create_options })
+        end
+
+        # @since 0.4.0
+        # @api private
+        def drop
+          new_connection.run %(DROP DATABASE "#{ database }")
+        rescue Sequel::DatabaseError => e
+          message = if e.message.match(/does not exist/)
+            "Cannot find database: #{ database }"
+          else
+            e.message
+          end
+
+          raise MigrationError.new(message)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump
+          set_environment_variables
+          dump_structure
+          dump_migrations_data
+        end
+
+        # @since 0.4.0
+        # @api private
+        def load
+          set_environment_variables
+          load_structure
+        end
+
+        private
+
+        # @since 0.4.0
+        # @api private
+        def create_options
+          result  = ""
+          result += %( OWNER "#{ username }") unless username.nil?
+          result
+        end
+
+        # @since 0.4.0
+        # @api private
+        def set_environment_variables
+          ENV[HOST]     = host      unless host.nil?
+          ENV[PORT]     = port.to_s unless port.nil?
+          ENV[PASSWORD] = password  unless password.nil?
+          ENV[USER]     = username  unless username.nil?
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump_structure
+          system "pg_dump -i -s -x -O -T #{ migrations_table } -f #{ escape(schema) } #{ database }"
+        end
+
+        # @since 0.4.0
+        # @api private
+        def load_structure
+          system "psql -X -q -f #{ escape(schema) } #{ database }" if schema.exist?
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump_migrations_data
+          system "pg_dump -t #{ migrations_table } #{ database } >> #{ escape(schema) }"
+        end
+      end
+    end
+  end
+end

data/lib/lotus/model/migrator/sqlite_adapter.rb

@@ -0,0 +1,110 @@
+require 'pathname'
+
+module Lotus
+  module Model
+    module Migrator
+      # SQLite3 Migrator
+      #
+      # @since 0.4.0
+      # @api private
+      class SQLiteAdapter < Adapter
+        # No-op for in-memory databases
+        #
+        # @since 0.4.0
+        # @api private
+        module Memory
+          # @since 0.4.0
+          # @api private
+          def create
+          end
+
+          # @since 0.4.0
+          # @api private
+          def drop
+          end
+        end
+
+        # Initialize adapter
+        #
+        # @since 0.4.0
+        # @api private
+        def initialize(connection)
+          super
+          extend Memory if memory?
+        end
+
+        # @since 0.4.0
+        # @api private
+        def create
+          path.dirname.mkpath
+          FileUtils.touch(path)
+        rescue Errno::EACCES
+          raise MigrationError.new("Permission denied: #{ path.sub(/\A\/\//, '') }")
+        end
+
+        # @since 0.4.0
+        # @api private
+        def drop
+          path.delete
+        rescue Errno::ENOENT
+          raise MigrationError.new("Cannot find database: #{ path.sub(/\A\/\//, '') }")
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump
+          dump_structure
+          dump_migrations_data
+        end
+
+        # @since 0.4.0
+        # @api private
+        def load
+          load_structure
+        end
+
+        private
+
+        # @since 0.4.0
+        # @api private
+        def path
+          root.join(
+            @connection.uri.sub(/#{ @connection.adapter_scheme }\:\/\//, '')
+          )
+        end
+
+        # @since 0.4.0
+        # @api private
+        def root
+          Lotus::Model.configuration.root
+        end
+
+        # @since 0.4.0
+        # @api private
+        def memory?
+          uri = path.to_s
+          uri.match(/sqlite\:\/\z/) ||
+            uri.match(/\:memory\:/)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump_structure
+          system "sqlite3 #{ escape(path) } .schema > #{ escape(schema) }"
+        end
+
+        # @since 0.4.0
+        # @api private
+        def load_structure
+          system "sqlite3 #{ escape(path) } < #{ escape(schema) }" if schema.exist?
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump_migrations_data
+          system %(sqlite3 #{ escape(path) } .dump | grep '^INSERT INTO "#{ migrations_table }"' >> #{ escape(schema) })
+        end
+      end
+    end
+  end
+end

data/lib/lotus/model/version.rb

@@ -3,6 +3,6 @@ module Lotus
     # Defines the version
     #
     # @since 0.1.0
-    VERSION = '0.3.2'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

data/lib/lotus/repository.rb

@@ -551,6 +551,7 @@ module Lotus
         end
       end
 
+      private
       # Executes the given raw statement on the adapter.
       #
       # Please note that it's only supported by some databases,
@@ -595,7 +596,6 @@ module Lotus
         @adapter.execute(raw)
       end
 
-      private
       # Fabricates a query and yields the given block to access the low level
       # APIs exposed by the query itself.
       #

data/lotus-model.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   spec.required_ruby_version = '>= 2.0.0'
 
-  spec.add_runtime_dependency 'lotus-utils', '~> 0.4'
+  spec.add_runtime_dependency 'lotus-utils', '~> 0.5'
   spec.add_runtime_dependency 'sequel',      '~> 4.9'
 
   spec.add_development_dependency 'bundler',  '~> 1.6'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lotus-model
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Luca Guidi
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-22 00:00:00.000000000 Z
+date: 2015-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lotus-utils
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -122,6 +122,11 @@ files:
 - lib/lotus/model/mapping/coercer.rb
 - lib/lotus/model/mapping/coercions.rb
 - lib/lotus/model/mapping/collection.rb
+- lib/lotus/model/migrator.rb
+- lib/lotus/model/migrator/adapter.rb
+- lib/lotus/model/migrator/mysql_adapter.rb
+- lib/lotus/model/migrator/postgres_adapter.rb
+- lib/lotus/model/migrator/sqlite_adapter.rb
 - lib/lotus/model/version.rb
 - lib/lotus/repository.rb
 - lotus-model.gemspec
@@ -145,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: A persistence layer for Lotus