sequel_tools 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b25c97f4906a511718907a4eed3dd0961f546b81
+  data.tar.gz: 2d97d6cc1192d996208546842fcd1ba0090fd9b1
+SHA512:
+  metadata.gz: 7be946fb5573e87ffb93a02ebc9b5b1dc497953117ad720df53c73ba028517ad63dfdf2c7a42b061e60aa188f1e0cb9705f6be63814dbedce3d05603a4c349fa
+  data.tar.gz: 837f5ad9998ec57cf5faf1750940831d9033c224638a2247f578bb5e05e0ce833e1344f50d633350d3afd9c81a4f88e1f4e32888875ea3e80af67b66df0ad3fc

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/spec/sample_project/db/migrations/
+/spec/sample_project/db/seeds.rb
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: scripts/ci/travis-build.sh
+#before_install: gem install bundler -v 1.16.0

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen-string-literal: true
+
+source 'https://rubygems.org'
+
+#git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in sequel_tools.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    sequel_tools (0.1.0)
+      sequel
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    pg (0.21.0)
+    rake (12.3.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+    sequel (5.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  pg
+  rake
+  rspec
+  sequel_tools!
+
+BUNDLED WITH
+   1.16.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Rodrigo Rosenfeld Rosas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,99 @@
+# SequelTools
+
+SequelTools brings some tooling around Sequel migrations and database management, providing tasks
+to create, drop and migrate the database, plus dumping and restoring from the last migrated schema.
+It can also display which migrations are applied and which ones are missing. It's highly
+customizable and supports multiple databases or environments. It integrates well with Rake as well.
+
+Currently only PostgreSQL is supported out-of-the-box for some tasks, but it should allow you to
+specify the database vendor specific commands to support your vendor of choice without requiring
+changes to SequelTools itself. Other vendors can be supported through additional gems or you may
+want to submit pull requests for your preferred DB vendor if you prefer so that it would be
+supported out-of-the-box by this gem.
+
+The idea behind SequelTools is to create a collection of supported actions, which depend on the
+database adapter/vendor. Those supported actions can then be translated to Rake tasks as a possible
+interface.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sequel_tools'
+```
+
+And then execute:
+
+    bundle
+
+## Usage
+
+Here's a sample Rakefile supporting migrate actions:
+
+```ruby
+require 'bundler/setup'
+require 'sequel_tools'
+
+base_config = SequelTools.base_config(
+  project_root: File.expand_path(__dir__),
+  dbadapter: 'postgres',
+  dbname: 'mydb',
+  username: 'myuser',
+  password: 'secret',
+  maintenancedb: 'postgres' # for tasks such as creating the database
+)
+
+namespace 'db' do
+  SequelTools.inject_rake_tasks base_config.merge(dump_schema_on_migrate: true), self
+end
+
+namespace 'dbtest' do
+  SequelTools.inject_rake_tasks base_config.merge(dbname: 'mydb_test'), self
+end
+```
+
+Then you are able to run several tasks (`rake -T` will list all supported):
+
+    rake db:create
+    rake db:new_migration[migration_name]
+    rake db:migrate
+    rake dbtest:setup
+
+## Development and running tests
+
+The tests assume the database `sequel_tools_test_pw` exists and can be only accessed using a
+username and password. It also assumes a valid user/passwd is `user_tools_user/secret`. The
+database `sequel_tools_test` is also required to exist and it should be possible to access it
+using the `trust` authentication method, without requiring a password. You may achieve that by
+adding these lines to the start of your `pg_hba.conf`:
+
+```
+host sequel_tools_test_pw   all 127.0.0.1/32 md5
+host sequel_tools_test      all 127.0.0.1/32 trust
+```
+
+Then feel free to run the tests:
+
+    bundle exec rspec
+
+The default strategy is a safe one, which uses `Open3.capture3` to actually run
+`bundle exec rake ...` whenever we want to test the Rake integration and we do that many times
+in the tests. Running `bundle exec` is slow, so it adds a lot to the test suite total execution
+time. Alternatively, although less robust, you may run the tests using a fork-rake approach,
+which avoids calling `bundle exec` each time we want to run a Rake task. Just define
+the `FORK_RAKE` environment variable:
+
+    FORK_RAKE=1 bundle exec rspec
+
+In my environment this would complete the full suite in about half the time.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+[https://github.com/rosenfeld/sequel_tools](https://github.com/rosenfeld/sequel_tools).
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen-string-literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sequel_tools"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sequel_tools.rb

@@ -0,0 +1,42 @@
+# frozen-string-literal: true
+
+require 'sequel_tools/version'
+
+module SequelTools
+  DEFAULT_CONFIG = {
+    project_root: nil,
+    pg_dump: 'pg_dump', # command used to run pg_dump
+    maintenancedb: 'postgres', # DB to connect to for creating/dropping databases
+    db_migrations_location: 'db/migrations',
+    schema_location: 'db/migrations/schema.sql',
+    seeds_location: 'db/seeds.rb',
+    dbname: nil,
+    dbhost: 'localhost',
+    dbadapter: 'postgres',
+    dbport: nil,
+    username: nil,
+    password: nil,
+    dump_schema_on_migrate: false,
+  } # unfrozen on purpose so that one might want to update the defaults
+
+  REQUIRED_KEYS = [ :project_root, :dbadapter, :dbname, :username ]
+  class MissingConfigError < StandardError; end
+  def self.base_config(extra_config = {})
+    config = DEFAULT_CONFIG.merge extra_config
+    REQUIRED_KEYS.each do |key|
+      raise MissingConfigError, "Expected value for #{key} config is missing" if config[key].nil?
+    end
+    [:db_migrations_location, :schema_location, :seeds_location].each do |k|
+      config[k] = File.expand_path config[k], config[:project_root]
+    end
+    config
+  end
+
+  def self.inject_rake_tasks(config = {}, rake_context)
+    require_relative 'sequel_tools/actions_manager'
+    require_relative 'sequel_tools/all_actions'
+    actions_manager = ActionsManager.new config
+    actions_manager.load_all
+    actions_manager.export_as_rake_tasks rake_context
+  end
+end

data/lib/sequel_tools/actions/connect_db.rb

@@ -0,0 +1,10 @@
+# frozen-string-literal: true
+
+require 'sequel'
+require_relative '../actions_manager'
+
+SequelTools::ActionsManager::Action.register :connect_db, nil do |args, context|
+  next if context[:db]
+  context[:db] = Sequel.connect context[:uri_builder].call context[:config]
+end
+

data/lib/sequel_tools/actions/create_db.rb

@@ -0,0 +1,21 @@
+# frozen-string-literal: true
+
+require 'sequel'
+require_relative '../actions_manager'
+
+class SequelTools::ActionsManager
+  Action.register :create, 'Create database' do |args, context|
+    begin
+      Action[:connect_db].run({}, context)
+    rescue
+      c = context[:config]
+      db = Sequel.connect context[:uri_builder].call(c, c[:maintenancedb])
+      db << "create database #{c[:dbname]}"
+      db.disconnect
+    else
+      puts 'Database already exists - aborting'
+      exit 1
+    end
+  end
+end
+

data/lib/sequel_tools/actions/down.rb

@@ -0,0 +1,14 @@
+# frozen-string-literal: true
+
+require 'sequel'
+require_relative '../actions_manager'
+require_relative '../migration_utils'
+
+class SequelTools::ActionsManager
+  desc = 'Run specified migration down if not already applied'
+  Action.register :down, desc, arg_names: [ :version ] do |args, context|
+    MigrationUtils.apply_migration context, args[:version], :down
+    Action[:schema_dump].run({}, context) if context[:config][:dump_schema_on_migrate]
+  end
+end
+

data/lib/sequel_tools/actions/drop_db.rb

@@ -0,0 +1,22 @@
+# frozen-string-literal: true
+
+require 'sequel'
+require_relative '../actions_manager'
+
+class SequelTools::ActionsManager
+  Action.register :drop, 'Drop database' do |args, context|
+    begin
+      Action[:connect_db].run({}, context)
+    rescue
+      puts 'Database does not exist - aborting.'
+      exit 1
+    else
+      context.delete(:db).disconnect
+      c = context[:config]
+      db = Sequel.connect context[:uri_builder].call(c, c[:maintenancedb])
+      db << "drop database #{c[:dbname]}"
+      db.disconnect
+    end
+  end
+end
+

data/lib/sequel_tools/actions/migrate.rb

@@ -0,0 +1,19 @@
+# frozen-string-literal: true
+
+require 'sequel'
+require_relative '../actions_manager'
+
+class SequelTools::ActionsManager
+  desc = 'Migrate to specified version (last by default)'
+  Action.register :migrate, desc, arg_names: [ :version ] do |args, context|
+    Action[:connect_db].run({}, context)
+    db = context[:db]
+    config = context[:config]
+    Sequel.extension :migration unless Sequel.respond_to? :migration
+    options = {}
+    options[:target] = args[:version].to_i if args[:version]
+    Sequel::Migrator.run db, config[:db_migrations_location], options
+    Action[:schema_dump].run({}, context) if config[:dump_schema_on_migrate]
+  end
+end
+

data/lib/sequel_tools/actions/new_migration.rb

@@ -0,0 +1,28 @@
+# frozen-string-literal: true
+
+require_relative '../actions_manager'
+
+class SequelTools::ActionsManager
+  desc = 'Creates a new migration'
+  Action.register :new_migration, desc, arg_names: [ :name ] do |args, context|
+    (puts 'Migration name is missing - aborting'; exit 1) unless name = args[:name]
+    require 'time'
+    migrations_path = context[:config][:db_migrations_location]
+    filename = "#{migrations_path}/#{Time.now.strftime '%Y%m%d%H%M%S'}_#{name}.rb"
+    File.write filename, <<~MIGRATIONS_TEMPLATE_END
+      # documentation available at http://sequel.jeremyevans.net/rdoc/files/doc/migration_rdoc.html
+      Sequel.migration do
+        change do
+          # create_table(:table_name) do
+          #   primary_key :id
+          #   String :name, null: false
+          # end
+        end
+        # or call up{} and down{}
+      end
+    MIGRATIONS_TEMPLATE_END
+    puts "The new migration file was created under #{filename.inspect}"
+  end
+end
+
+

data/lib/sequel_tools/actions/redo.rb

@@ -0,0 +1,14 @@
+# frozen-string-literal: true
+
+require 'sequel'
+require_relative '../actions_manager'
+
+class SequelTools::ActionsManager
+  desc = 'Run specified migration down and up (redo)'
+  Action.register :redo, desc, arg_names: [ :version ] do |args, context|
+    Action[:down].run(args, context)
+    Action[:up].run(args, context)
+    Action[:schema_dump].run({}, context) if context[:config][:dump_schema_on_migrate]
+  end
+end
+

data/lib/sequel_tools/actions/reset.rb

@@ -0,0 +1,18 @@
+# frozen-string-literal: true
+
+require_relative '../actions_manager'
+
+class SequelTools::ActionsManager
+  desc = 'Recreate database from scratch by running all migrations and seeds in a new database'
+  Action.register :reset, desc, arg_names: [ :version ] do |args, context|
+    begin
+      Action[:drop].run({}, context)
+    rescue
+    end
+    Action[:create].run({}, context)
+    Action[:migrate].run({}, context)
+    Action[:seed].run({}, context)
+  end
+end
+
+

data/lib/sequel_tools/actions/rollback.rb

@@ -0,0 +1,17 @@
+# frozen-string-literal: true
+
+require 'sequel'
+require_relative '../actions_manager'
+require_relative '../migration_utils'
+
+class SequelTools::ActionsManager
+  Action.register :rollback, 'Rollback last applied migration' do |args, context|
+    unless last_found_migration = MigrationUtils.last_found_migration(context)
+      puts 'No existing migrations are applied - cannot rollback'
+      exit 1
+    end
+    MigrationUtils.apply_migration context, last_found_migration, :down
+    Action[:schema_dump].run({}, context) if context[:config][:dump_schema_on_migrate]
+  end
+end
+

data/lib/sequel_tools/actions/schema_dump.rb

@@ -0,0 +1,22 @@
+# frozen-string-literal: true
+
+require_relative '../actions_manager'
+
+class SequelTools::ActionsManager
+  Action.register :schema_dump, 'Store current db schema' do |args, context|
+    begin
+      Action[:connect_db].run({}, context)
+    rescue
+      puts 'Database does not exist - aborting.'
+      exit 1
+    else
+      c = context[:config]
+      unless action = Action[:"schema_dump_#{c[:dbadapter]}"]
+        puts "Dumping the db schema is not currently supported for #{c[:dbadapter]}. Aborting"
+        exit 1
+      end
+      action.run({}, context)
+    end
+  end
+end
+

data/lib/sequel_tools/actions/schema_dump_postgres.rb

@@ -0,0 +1,32 @@
+# frozen-string-literal: true
+
+require_relative '../actions_manager'
+require_relative '../pg_helper'
+
+class SequelTools::ActionsManager
+  Action.register :schema_dump_postgres, nil do |args, context|
+    c = context[:config]
+    pg_dump = c[:pg_dump]
+    schema_location = c[:schema_location]
+
+    stdout, stderr, success = PgHelper.run_pg_command c, "#{pg_dump} -s"
+    return unless success
+    content = stdout
+    if content =~ /schema_(migrations|info)/
+      stdout, stderr, success =
+        PgHelper.run_pg_command c, "#{pg_dump} -a -t schema_migrations -t schema_info --inserts"
+      unless success
+        puts 'failed to dump data for schema_migrations and schema_info. Aborting.'
+        exit 1
+      end
+      # to make it easier to see the git diffs and to reduce conflicts when working in separate
+      # branches, we use a separate line for each value in schema_migrations:
+      regex = /(?<=INSERT INTO schema_migrations VALUES \()(.*?)(?=\))/i
+      migration_data = stdout.sub(regex){ |m| "\n  #{m.split(',').join(",\n  ")}\n" }
+      content = [content, migration_data].join "\n\n"
+    end
+    require 'fileutils'
+    FileUtils.mkdir_p File.dirname schema_location
+    File.write schema_location, content
+  end
+end

data/lib/sequel_tools/actions/schema_load.rb

@@ -0,0 +1,23 @@
+# frozen-string-literal: true
+
+require_relative '../actions_manager'
+
+class SequelTools::ActionsManager
+  description = 'Populates an empty database with previously dumped schema' 
+  Action.register :schema_load, description do |args, context|
+    begin
+      Action[:connect_db].run({}, context)
+    rescue
+      puts 'Database does not exist - aborting.'
+      exit 1
+    else
+      schema_location = context[:config][:schema_location]
+      unless File.exist? schema_location
+        puts "Schema file '#{schema_location}' does not exist. Aborting."
+        exit 1
+      end
+      context[:db] << File.read(schema_location)
+    end
+  end
+end
+

data/lib/sequel_tools/actions/seed.rb

@@ -0,0 +1,20 @@
+# frozen-string-literal: true
+
+require_relative '../actions_manager'
+
+class SequelTools::ActionsManager
+  Action.register :seed, 'Load seeds from seeds.rb' do |args, context|
+    begin
+      Action[:connect_db].run({}, context)
+    rescue
+      puts 'Database does not exist - aborting.'
+      exit 1
+    else
+      if File.exist?(seeds_location = context[:config][:seeds_location])
+        ::DB = context[:db]
+        load seeds_location
+      end
+    end
+  end
+end
+

data/lib/sequel_tools/actions/setup.rb

@@ -0,0 +1,20 @@
+# frozen-string-literal: true
+
+require_relative '../actions_manager'
+
+class SequelTools::ActionsManager
+  description = 'Creates and populates a database with previously dumped schema and seeds'
+  Action.register :setup, description do |args, context|
+    begin
+      Action[:connect_db].run({}, context)
+    rescue
+      Action[:create].run({}, context)
+      Action[:schema_load].run({}, context)
+      Action[:seed].run({}, context)
+    else
+      puts 'Database already exists - aborting.'
+      exit 1
+    end
+  end
+end
+

data/lib/sequel_tools/actions/status.rb

@@ -0,0 +1,26 @@
+# frozen-string-literal: true
+
+require 'sequel'
+require_relative '../actions_manager'
+require_relative '../migration_utils'
+
+class SequelTools::ActionsManager
+  description = 'Show migrations status (applied and missing in migrations path vs unapplied)'
+  Action.register :status, description do |args, context|
+    unapplied, files_missing = MigrationUtils.migrations_differences context
+    path = context[:config][:db_migrations_location]
+    unless files_missing.empty?
+      puts "The following migrations were applied to the database but can't be found in #{path}:"
+      puts files_missing.map{|fn| "  - #{fn}" }.join("\n")
+      puts
+    end
+    if unapplied.empty?
+      puts 'No pending migrations in the database' if files_missing.empty?
+    else
+      puts 'Unapplied migrations:'
+      puts unapplied.map{|fn| "  - #{fn}" }.join("\n")
+      puts
+    end
+  end
+end
+

data/lib/sequel_tools/actions/up.rb

@@ -0,0 +1,14 @@
+# frozen-string-literal: true
+
+require 'sequel'
+require_relative '../actions_manager'
+require_relative '../migration_utils'
+
+class SequelTools::ActionsManager
+  desc = 'Run specified migration up if not already applied'
+  Action.register :up, desc, arg_names: [ :version ] do |args, context|
+    MigrationUtils.apply_migration context, args[:version], :up
+    Action[:schema_dump].run({}, context) if context[:config][:dump_schema_on_migrate]
+  end
+end
+

data/lib/sequel_tools/actions/version.rb

@@ -0,0 +1,13 @@
+# frozen-string-literal: true
+
+require 'sequel'
+require_relative '../actions_manager'
+require_relative '../migration_utils'
+
+class SequelTools::ActionsManager
+  Action.register :version, 'Displays current version' do |args, context|
+    puts MigrationUtils.current_version(context) || 'No migrations applied'
+  end
+end
+
+

data/lib/sequel_tools/actions_manager.rb

@@ -0,0 +1,88 @@
+# frozen-string-literal: true
+
+module SequelTools
+  class ActionsManager
+    attr_reader :actions, :context
+
+    URI_BUILDER = ->(config, dbname = config[:dbname]) do
+      c = config
+      uri_parts = [ "#{c[:dbadapter]}://" ]
+      if user = c[:username]
+        uri_parts << user
+        uri_parts << ':' << c[:password] if c[:password]
+        uri_parts << '@'
+      end
+      uri_parts << c[:dbhost]
+      uri_parts << ':' << c[:dbport] if c[:dbport]
+      uri_parts << '/' << dbname
+      uri_parts.join('')
+    end
+
+    def initialize(config)
+      @actions = []
+      @context = { config: config, uri_builder: URI_BUILDER }
+    end
+
+    def load_all
+      @actions.concat Action.registered
+    end
+
+    def export_as_rake_tasks(rake_context)
+      actions.each do |action|
+        ctx = context
+        rake_context.instance_eval do
+          desc action.description unless action.description.nil?
+          task action.name, action.arg_names do |t, args|
+            action.run args, ctx
+          end
+        end
+      end
+    end
+
+    class Action
+      attr_reader :name, :description, :arg_names, :block
+
+      def initialize(name, description, arg_names: [], &block)
+        @name, @description, @arg_names, @block = name, description, arg_names, block
+      end
+
+      def run(args, context)
+        @block.call args, context
+      end
+
+      @@registered = []
+      @@registered_by_name = {}
+      class AlreadyRegisteredAction < StandardError; end
+      def self.register(name, description, arg_names: [], &block)
+        if @@registered_by_name[name]
+          raise AlreadyRegisteredAction, "Attempt to register #{name} twice"
+        end
+        @@registered <<
+          (@@registered_by_name[name] = Action.new name, description, arg_names: arg_names, &block)
+      end
+
+      def self.registered
+        @@registered
+      end
+
+      def self.[](name)
+        @@registered_by_name[name]
+      end
+
+      def self.unregister(name)
+        return unless action = @@registered_by_name.delete(name)
+        @@registered.delete action
+        action
+      end
+
+      def self.replace(name, description, arg_names: [], &block)
+        unregister name
+        register name, description, arg_names: arg_names, &block
+      end
+
+      def self.register_action(action)
+        register action.name, action.description, arg_names: action.arg_names, &action.block
+      end
+    end
+  end
+end

data/lib/sequel_tools/all_actions.rb

@@ -0,0 +1,19 @@
+# frozen-string-literal: true
+
+require_relative 'actions/connect_db'
+require_relative 'actions/create_db'
+require_relative 'actions/drop_db'
+require_relative 'actions/schema_dump_postgres'
+require_relative 'actions/schema_dump'
+require_relative 'actions/schema_load'
+require_relative 'actions/new_migration'
+require_relative 'actions/migrate'
+require_relative 'actions/reset'
+require_relative 'actions/setup'
+require_relative 'actions/seed'
+require_relative 'actions/up'
+require_relative 'actions/down'
+require_relative 'actions/redo'
+require_relative 'actions/version'
+require_relative 'actions/rollback'
+require_relative 'actions/status'

data/lib/sequel_tools/migration_utils.rb

@@ -0,0 +1,52 @@
+# frozen-string-literal: true
+
+require_relative 'actions_manager'
+require 'sequel'
+
+class MigrationUtils
+  def self.apply_migration(context, version, direction)
+    ( puts 'migration version is missing - aborting.'; exit 1 ) if version.nil?
+    filename = "#{File.basename version, '.rb'}.rb"
+    migrator = find_migrator context, direction
+    migrator.migration_tuples.delete_if{|(m, fn, dir)| fn != filename }
+    unless (size = migrator.migration_tuples.size) == 1
+      puts "Expected a single unapplied migration for #{filename} but found #{size}. Aborting."
+      exit 1
+    end
+    migrator.run
+  end
+
+  def self.find_migrator(context, direction = :up)
+    Sequel.extension :migration unless Sequel.respond_to? :migration
+    SequelTools::ActionsManager::Action[:connect_db].run({}, context) unless context[:db]
+    options = { allow_missing_migration_files: true }
+    options[:target] = 0 if direction == :down
+    config = context[:config]
+    Sequel::Migrator.migrator_class(config[:db_migrations_location]).
+      new(context[:db], config[:db_migrations_location], options)
+  end
+
+  def self.current_version(context)
+    migrator = find_migrator(context)
+    migrator.ds.order(Sequel.desc(migrator.column)).get migrator.column
+  end
+
+  def self.last_found_migration(context)
+    migrations_path = context[:config][:db_migrations_location]
+    migrator = find_migrator(context)
+    migrator.ds.order(Sequel.desc(migrator.column)).select_map(migrator.column).find do |fn|
+      File.exist?("#{migrations_path}/#{fn}")
+    end
+  end
+
+  def self.migrations_differences(context)
+    config = context[:config]
+    migrations_path = config[:db_migrations_location]
+    existing = Dir["#{migrations_path}/*.rb"].map{|fn| File.basename fn }.sort
+    migrator = find_migrator context
+    migrated = migrator.ds.select_order_map(migrator.column)
+    unapplied = existing - migrated
+    files_missing = migrated - existing
+    [ unapplied, files_missing ]
+  end
+end

data/lib/sequel_tools/pg_helper.rb

@@ -0,0 +1,24 @@
+# frozen-string-literal: true
+
+class PgHelper
+  def self.run_pg_command(config, cmd, connect_database: nil)
+    require 'open3'
+    require 'tempfile'
+    Tempfile.open 'pgpass' do |file|
+      c = config
+      file.chmod 0600
+      file.write "#{c[:dbhost]}:#{c[:dbport]}:#{c[:dbname]}:#{c[:username]}:#{c[:password]}"
+      file.close
+      env = {
+        'PGDATABASE' => connect_database || c[:dbname],
+        'PGHOST' => c[:dbhost],
+        'PGPORT' => c[:dbport].to_s,
+        'PGUSER' => c[:username],
+        'PGPASSFILE' => file.path
+      }
+      stdout, stderr, status = Open3.capture3 env, cmd
+      puts "#{cmd} failed: #{[stderr, stdout].join "\n\n"}" if status != 0
+      [ stdout, stderr, status == 0 ]
+    end
+  end
+end

data/lib/sequel_tools/version.rb

@@ -0,0 +1,5 @@
+# frozen-string-literal: true
+
+module SequelTools
+  VERSION = '0.1.0'
+end

data/scripts/ci/travis-build.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+# This script enable PG 9.6, creates the sequel_tools_test_pw database, which can be only
+# accessed using a password through localhost, and the sequel_tools_test database which can be
+# accessed using the trust method. It also creates the sequel_tools_user user with password
+# 'secret'. This way we can test accessing the database both using a username and password or
+# other methods defined by pg_hba.conf, such as trust, which doesn't require a password.
+
+sudo /etc/init.d/postgresql stop
+PGVERSION=9.6
+PGHBA=/etc/postgresql/$PGVERSION/main/pg_hba.conf
+sudo bash -c "sed -i '1i host sequel_tools_test_pw all 127.0.0.1/32 md5' $PGHBA"
+sudo /etc/init.d/postgresql start $PGVERSION
+psql -c "create user sequel_tools_user superuser password 'secret'" postgres
+psql -U sequel_tools_user -c "create database sequel_tools_test" postgres
+psql -U sequel_tools_user -c "create database sequel_tools_test_pw" postgres

data/sequel_tools.gemspec

@@ -0,0 +1,39 @@
+# frozen-string-literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sequel_tools/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sequel_tools'
+  spec.version       = SequelTools::VERSION
+  spec.authors       = ['Rodrigo Rosenfeld Rosas']
+  spec.email         = ['rr.rosas@gmail.com']
+
+  spec.summary       = %q{Add Rake tasks to manage Sequel migrations}
+  spec.description   = <<~DESCRIPTION_END
+    Offer tooling for common database operations, such as running Sequel migrations, store and
+    load from the database schema, rollback, redo some migration, rerun all migrations, display
+    applied and missing migrations. It allows integration with Rake, while being lazily evaluated
+    to not slow down other Rake tasks. It's also configurable in order to support more actions
+    and database vendors. Some tasks are currently implemented for PostgreSQL only for the time
+    being out of the box. It should be possible to complement this gem with another one to
+    support other database vendors, while taking advantage of the build blocks provided by this
+    tool set.
+  DESCRIPTION_END
+  spec.homepage      = 'https://github.com/rosenfeld/sequel_tools'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^spec/})
+  end
+  #spec.bindir        = 'exe'
+  #spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'sequel'
+  spec.add_development_dependency 'pg'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: sequel_tools
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rodrigo Rosenfeld Rosas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Offer tooling for common database operations, such as running Sequel migrations, store and
+  load from the database schema, rollback, redo some migration, rerun all migrations, display
+  applied and missing migrations. It allows integration with Rake, while being lazily evaluated
+  to not slow down other Rake tasks. It's also configurable in order to support more actions
+  and database vendors. Some tasks are currently implemented for PostgreSQL only for the time
+  being out of the box. It should be possible to complement this gem with another one to
+  support other database vendors, while taking advantage of the build blocks provided by this
+  tool set.
+email:
+- rr.rosas@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/sequel_tools.rb
+- lib/sequel_tools/actions/connect_db.rb
+- lib/sequel_tools/actions/create_db.rb
+- lib/sequel_tools/actions/down.rb
+- lib/sequel_tools/actions/drop_db.rb
+- lib/sequel_tools/actions/migrate.rb
+- lib/sequel_tools/actions/new_migration.rb
+- lib/sequel_tools/actions/redo.rb
+- lib/sequel_tools/actions/reset.rb
+- lib/sequel_tools/actions/rollback.rb
+- lib/sequel_tools/actions/schema_dump.rb
+- lib/sequel_tools/actions/schema_dump_postgres.rb
+- lib/sequel_tools/actions/schema_load.rb
+- lib/sequel_tools/actions/seed.rb
+- lib/sequel_tools/actions/setup.rb
+- lib/sequel_tools/actions/status.rb
+- lib/sequel_tools/actions/up.rb
+- lib/sequel_tools/actions/version.rb
+- lib/sequel_tools/actions_manager.rb
+- lib/sequel_tools/all_actions.rb
+- lib/sequel_tools/migration_utils.rb
+- lib/sequel_tools/pg_helper.rb
+- lib/sequel_tools/version.rb
+- scripts/ci/travis-build.sh
+- sequel_tools.gemspec
+homepage: https://github.com/rosenfeld/sequel_tools
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Add Rake tasks to manage Sequel migrations
+test_files: []