communard 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 803308ca6f5424ff74123dcbb892f6ef6b76ecd0
-  data.tar.gz: 310a953d2846d2f7f0b7f0188ae69c84635260d9
+SHA256:
+  metadata.gz: 94f9d91890f50281fc8ce1d4678153cf2aff2c2068c00166774aeeafe80dfb16
+  data.tar.gz: cd21196d14631a2e3eda1435e16c4fd4afdabc1da2ab16d0d198290c1275e153
 SHA512:
-  metadata.gz: bcd25b010ae79cc52aa3c50cea57d74072d924f68b3d84873d7399396052305d67beacf728d920e788ea7c0ca11bcd870cb6d036b5994938dc28e3eaa85f0f3d
-  data.tar.gz: e5c9d2270735b60a121e5057215f7d359268472398e16f4101bd605c09bb509f64162d9f1cedfaba4fe216be5f9b6b37befe056383a9148925287b5e66ca7223
+  metadata.gz: 4968eb2fb22782695eb7335028f0d8fb76d58a3bb4fe437ec3e3da75fb8b1edc74cc66a8b2fceeabbad8c6c44aa7adf8c206566ba08fed93552ec8fe356521ae
+  data.tar.gz: 55000cbc291e4ca20050c1fff461b709f689aeea3a17f28d922ec8c69220d042dbd22ff628f5be8ce2889594ab9c0d8fa652ac82b9b60c6113d16d3e278e7101

data/README.md

@@ -2,9 +2,6 @@
 
 Communard adds some conventions from [ActiveRecord][ar] to [Sequel][sq].
 
-This means you can use `config/database.yml` and `db/migrate` again, so you
-don't have to change deployment scripts that are made for ActiveRecord.
-
 Sequel doesn't provide the exact same functionality as ActiveRecord. Communard
 doesn't try to make Sequel quack like ActiveRecord, it just tries to help with
 some (not all) setup.
@@ -31,25 +28,15 @@ $ gem install communard
 
 ## Usage
 
-### Connecting to the database
-
-To get a database connection:
-
-``` ruby
-DB = Communard.connect
-```
-
-The `DB` object will be familiar to you if you've ever read the Sequel documentation.
-
-Note: Communard doesn't remember your connection.
-
 ### Rake integration
 
 To add most Rake tasks, add this to your `Rakefile` or to `lib/tasks/communard.rake`:
 
 ``` ruby
 require "communard/rake"
-Communard::Rake.add_tasks
+namespace :db do
+  Communard::Rake.add_tasks
+end
 ```
 
 This will add the most used rake tasks, like `db:create`, `db:migrate`, and `db:setup`.
@@ -60,34 +47,68 @@ To see them all:
 $ rake -T db
 ```
 
+`Communard::Rake.add_tasks` accepts the same configuration options as
+`Sequel.connect`. It doesn't immediately make a connection, only when needed.
+
+The default connection string is `ENV["DATABASE_URL"]`, so if you use that,
+there is no need to configure anything.
+
+Other configuration options, can be set via a block:
+
+``` ruby
+namespace :db do
+  Communard::Rake.add_tasks do |config|
+
+    # Change where the application is located, defaults to Dir.pwd
+    config.root_path = Dir.pwd
+
+    # Automatically generate schema (default: false)
+    config.dump_after_migrating = false
+
+    # Dump types in native format (default) or Ruby (more portable)
+    config.same_db = true
+
+    # Add a logger
+    config.logger = Logger.new("log/migrations.log")
+
+  end
+end
+```
+
+Example with using `config/database.yml`:
+
+``` ruby
+namespace :db do
+  environment = ENV["RAILS_ENV"] || "development"
+  all_config = YAML.load_file("config/database.yml")
+  Communard::Rake.add_tasks(config.fetch(environment))
+end
+```
+
+Note about test environment: Communard doesn't try to create a test database
+like ActiveRecord does. The only rake task that attempts to do that is
+`rake db:test:prepare`. It respawns rake with different environment variables
+set. Your mileage may vary.
+
 ### Migrations
 
 To generate a migration:
 
 ```
-$ bundle exec communard --generate-migration create_posts
+$ communard migration create_posts
 ```
 
 Communard doesn't support more arguments, like the Rails generator does. You'll
 have to edit the generated migration file yourself.
 
-### Configuration
-
-There are a couple of configuration options available. They can be set by giving
-a block to `connect` or `add_tasks`. Under normal circumstances you don't need
-to set them.
-
-``` ruby
-DB = Communard.connect { |config|
-  config.root        = Rails.root
-  config.logger      = Rails.logger
-  config.environment = Rails.env.to_s
-}
-```
+Communard supports both timestamps and integer versions. It automatically
+detects which type you have. If you have no migrations yet and want to use
+timestamps, add `--timestamps`. Read more about how to choose in the
+[Sequel docs][tm].
 
 ## Contributing
 
-1. Fork it ( https://github.com/yourkarma/communard/fork )
+1. Fork it ( https://github.com/iain/communard/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
@@ -95,3 +116,4 @@ DB = Communard.connect { |config|
 
 [ar]: http://rubyonrails.org
 [sq]: http://sequel.jeremyevans.net
+[tm]: http://sequel.jeremyevans.net/rdoc/files/doc/migration_rdoc.html#label-How+to+choose

data/bin/communard

@@ -1,26 +1,54 @@
 #!/usr/bin/env ruby
 
-require "communard"
-require "optparse"
+command = ARGV.shift
 
-parser = OptionParser.new do |opts|
+case command
 
-  opts.on "-m", "--generate-migration NAME", "Generates a migration" do |name|
-    Communard.context.generate_migration(name: name)
-    exit
-  end
+when nil, "-h", "--help", "help"
+  puts "Usage: communard migration NAME"
+  exit
+
+when "-v", "--version"
+  require "communard"
+  puts Communard::VERSION
+  exit
+
+when "migration", "-m", "--generate-migration", "m"
+  migration_name = ARGV.shift
+
+  require "optparse"
+  require "pathname"
+  require "fileutils"
+
+  migrations_dir = Pathname(Dir.pwd).join("db/migrate")
+  FileUtils.mkdir_p(migrations_dir)
+
+  migration_files = Pathname.glob(migrations_dir.join("*.rb")).map { |f| f.basename.to_s }
 
-  opts.on_tail "-v", "--version" do
-    puts "Communard version #{Communard::VERSION}"
-    exit
+  if (conflict = migration_files.find { |f| f.match?(/\A\d+_#{migration_name}.rb\z/) })
+    abort "Migration with same name already exists: #{conflict}"
   end
 
-  opts.on_tail "-h", "--help" do
-    puts parser
-    exit
+  options = {}
+
+  OptionParser.new do |opts|
+    opts.on "--[no-]timestamps", "Use timestamps for versions" do |bool|
+      options[:use_timestamps] = bool
+    end
+  end.parse!
+
+  versions = migration_files.map { |file| file.to_s.split("_", 2).first.to_i }
+
+  if !options.has_key?(:use_timestamps)
+    options[:use_timestamps] = versions.any? { |v| v > 20000101 }
   end
 
-end
-parser.parse!
+  version = options[:use_timestamps] ? Time.now.strftime("%Y%m%d%H%M%S") : "%03d" % (versions.max.to_i + 1)
+
+  filename = migrations_dir.join("#{version}_#{migration_name}.rb")
 
-puts parser
+  File.open(filename, "w") { |f| f.puts "Sequel.migration do\n\n  change do\n  end\n\nend" }
+  puts "Migration generated: #{filename.relative_path_from(Pathname(Dir.pwd))}"
+else
+  abort "Unknown command: #{command}"
+end

data/communard.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["iain@iain.nl"]
   spec.summary       = %q{Adds some conventions from ActiveRecord to Sequel.}
   spec.description   = %q{Adds some conventions from ActiveRecord to Sequel.}
-  spec.homepage      = "https://github.com/yourkarma/communard"
+  spec.homepage      = "https://github.com/iain/communard"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "sequel", "~> 4.13"
+  spec.add_dependency "sequel", "~> 5.2"
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"

data/lib/communard/commands.rb

@@ -0,0 +1,156 @@
+require "forwardable"
+
+module Communard
+  class Commands
+
+    extend Forwardable
+
+    attr_reader :configuration
+
+    def_delegators :configuration,
+                   :connection,
+                   :adapter,
+                   :database_name,
+                   :options,
+                   :root_path
+
+    def initialize(configuration)
+      @configuration = configuration
+      Sequel.extension :migration, :core_extensions
+    end
+
+    def create_database
+      return if adapter == "sqlite"
+      run_without_database("CREATE DATABASE %{database_name}")
+    rescue Sequel::DatabaseError => error
+      if error.message.to_s =~ /database (.*) already exists/
+        configuration.default_logger.warn "Database #{$1} already exists."
+      else
+        raise
+      end
+    end
+
+    def drop_database
+      if adapter == "sqlite"
+        file = database_name
+        File.rm(file) if File.exist?(file)
+      else
+        run_without_database("DROP DATABASE IF EXISTS %{database_name}")
+      end
+    end
+
+    def migrate(target: nil)
+      target = Integer(target) if target
+      migrator(target: target, current: nil).run
+      dump_schema if target.nil? && configuration.dump_after_migrating
+    end
+
+    def seed
+      load seeds_file if seeds_file.exist?
+    end
+
+    def rollback(step: 1)
+      target = applied_migrations[-step - 1]
+      if target
+        migrate(target: target.split(/_/, 2).first)
+      else
+        fail ArgumentError, "Cannot roll back to #{step}"
+      end
+    end
+
+    def load_schema
+      migration = instance_eval(schema_file.read, schema_file.expand_path.to_s, 1)
+      conn = configuration.silent_connection
+      migration.apply(conn, :up)
+    end
+
+    def dump_schema
+      conn = configuration.silent_connection
+      conn.extension :schema_dumper
+      schema = conn.dump_schema_migration(same_db: configuration.same_db)
+      schema_file.open("w") { |f| f.puts schema.gsub(/^\s+$/m, "").gsub(/:(\w+)=>/, '\1: ') }
+    end
+
+    def status
+      results = Hash.new { |h, k| h[k] = Status.new(k, false, false) }
+      available = Pathname.glob(migrations_dir.join("*.rb")).map(&:basename).map(&:to_s)
+      available.each { |migration| results[migration].available = true }
+      applied_migrations(available).each { |migration| results[migration].applied = true }
+
+      $stdout.puts
+      $stdout.puts "database: #{connection.opts.fetch(:database)}"
+      $stdout.puts
+      $stdout.puts " Status   Migration ID    Migration Name"
+      $stdout.puts "--------------------------------------------------"
+      results.values.sort.each do |result|
+        $stdout.puts "  %-7s %-15s %s" % [ result.status, result.id, result.name ]
+      end
+      $stdout.puts
+    end
+
+    def run_without_database(query)
+      opts = options.dup
+      database_name = opts.delete("database")
+      if adapter == "postgres"
+        opts["database"]           = "postgres"
+        opts["schema_search_path"] = "public"
+      end
+      conn = Sequel.connect(opts)
+      conn.run(query % { database_name: database_name })
+    end
+
+    private
+
+    def applied_migrations(available)
+      m = migrator(allow_missing_migration_files: true)
+      if m.is_a?(Sequel::IntegerMigrator)
+        available.select { |f| f.split("_", 2).first.to_i <= m.current }
+      else
+        instance.applied_migrations
+      end
+    end
+
+    def migrator(opts = {})
+      migrator = Sequel::Migrator.migrator_class(migrations_dir)
+      migrator.new(connection, migrations_dir, opts)
+    end
+
+    def schema_file
+      root_path.join("db/schema.rb")
+    end
+
+    def seeds_file
+      root_path.join("db/seeds.rb")
+    end
+
+    def migrations_dir
+      root_path.join("db/migrate")
+    end
+
+    Status = Struct.new(:file, :applied, :available) do
+
+      def <=>(other)
+        id <=> other.id
+      end
+
+      def status
+        return "????" unless available
+        applied ? " up " : "down"
+      end
+
+      def id
+        splitted.first
+      end
+
+      def name
+        splitted.last.capitalize.tr("_", " ").sub(/\.rb$/, "")
+      end
+
+      def splitted
+        file.split(/_/, 2)
+      end
+
+    end
+
+  end
+end

data/lib/communard/configuration.rb

@@ -1,52 +1,97 @@
+require "pathname"
+require "logger"
+require "uri"
+
 module Communard
   class Configuration
 
-    attr_accessor :environment, :root, :dump_same_db, :loggers, :sql_log_level, :log_warn_duration
+    attr_reader :options
+
+    def initialize(conn_string = ENV["DATABASE_URL"], opts = Sequel::OPTS)
+      @conn_string = conn_string
+      @opts = opts
+
+      case conn_string
+      when String
+        uri = URI.parse(conn_string)
+        @options = {
+          "adapter"  => uri.scheme,
+          "user"     => uri.user,
+          "password" => uri.password,
+          "port"     => uri.port,
+          "host"     => uri.hostname,
+          "database" => (m = %r{/(.*)}.match(uri.path)) && (m[1]),
+        }
+      when Hash
+        @options = conn_string.map { |k, v| [ k.to_s, v ] }.to_h
+      else
+        raise ArgumentError, "Sequel::Database.connect takes either a Hash or a String, given: #{conn_string.inspect}"
+      end
+
+      self.root_path = Dir.pwd
+      self.logger = nil
+      self.dump_after_migrating = true
+      self.same_db = true
 
-    def initialize
-      self.environment       = ENV["RACK_ENV"] || ENV["RUBY_ENV"] || ENV["RACK_ENV"] || "development"
-      self.root              = Pathname(Dir.pwd)
-      self.logger            = stdout_logger
-      self.log_level         = :info
-      self.dump_same_db      = false
-      self.sql_log_level     = :debug
-      self.log_warn_duration = 0.5
       yield self if block_given?
     end
 
-    def dump_same_db!
-      self.dump_same_db = true
-    end
+    attr_accessor :logger
+
+    attr_accessor :same_db
+
+    attr_accessor :dump_after_migrating
 
-    def logger=(logger)
-      self.loggers = [logger]
+    attr_reader :root_path
+
+    def root_path=(path)
+      @root_path = Pathname(path)
     end
 
-    def loggers
-      Array(@loggers).compact
+    def connection
+      Sequel.connect(@conn_string, @opts).tap { |c|
+        c.loggers = [logger, default_logger].compact
+        c.sql_log_level = :debug
+      }
     end
 
-    def log_level=(level)
-      real_level = ::Logger.const_get(level.to_s.upcase)
-      loggers.each do |logger|
-        logger.level = real_level
-      end
+    def silent_connection
+      Sequel.connect(@conn_string, @opts).tap { |c|
+        c.loggers = [logger].compact
+      }
     end
 
-    def stdout_logger(out = $stdout)
+    def default_logger(out = $stdout)
       ::Logger.new(out).tap { |l|
         alternate = 0
         l.formatter = Proc.new { |sev, _, _, msg|
           alternate = ((alternate + 1) % 2)
-          color = case sev
-          when "INFO" then 35 + alternate
-          when "DEBUG" then 90
-          else 31
+          msg = if sev == "DEBUG"
+                  "       #{msg}"
+                else
+                  "[#{sev}] #{msg}"
+                end
+          if out.tty?
+            color = case sev
+                    when "INFO" then 35 + alternate
+                    when "DEBUG" then 30
+                    else 31
+                    end
+            "\e[#{color}m#{msg}\e[0m\n"
+          else
+            "#{msg}\n"
           end
-          "\e[#{color}m[#{sev}]\e[0m #{msg}\n"
         }
       }
     end
 
+    def adapter
+      options.fetch("adapter")
+    end
+
+    def database_name
+      options.fetch("database")
+    end
+
   end
 end

data/lib/communard/rake.rb

@@ -5,83 +5,87 @@ module Communard
 
     extend ::Rake::DSL if defined?(::Rake::DSL)
 
-    def self.add_tasks(ns = :db, &block)
-
-      namespace ns do
-        task :_load_communard do
-          @_communard_context = Communard.context(&block)
-        end
+    def self.add_tasks(*args, &block)
+      task :_load_communard do
+        @_communard_commands = Communard.commands(*args, &block)
+      end
 
-        desc "Creates the database, migrate the schema, and loads seed data"
-        task :setup => [:create, :migrate, :seed, "db:test:prepare"]
+      desc "Creates the database, migrate the schema, and loads seed data"
+      task setup: ["db:create", "db:migrate", "db:seed", "db:test:prepare"]
 
-        desc "Creates the database"
-        task :create => :_load_communard do
-          @_communard_context.create_database
-        end
+      desc "Creates the database"
+      task create: :_load_communard do
+        @_communard_commands.create_database
+      end
 
-        desc "Drops the database"
-        task :drop => :_load_communard do
-          @_communard_context.drop_database
-        end
+      desc "Drops the database"
+      task drop: :_load_communard do
+        @_communard_commands.drop_database
+      end
 
-        desc "Drops and creates the database"
-        task :reset => [:drop, :setup]
+      desc "Drops and creates the database"
+      task reset: ["db:drop", "db:setup"]
 
-        desc "Migrate the database"
-        task :migrate => :_load_communard do
-          target = ENV["VERSION"] || ENV["TARGET"]
-          @_communard_context.migrate(target: target)
-        end
+      desc "Migrate the database"
+      task migrate: :_load_communard do
+        target = ENV["TARGET"]
+        @_communard_commands.migrate(target: target)
+      end
 
-        desc "Load the seed data from db/seeds.rb"
-        task :seed => :_load_communard do
-          @_communard_context.seed
-        end
+      desc "Load the seed data from db/seeds.rb"
+      task seed: :_load_communard do
+        @_communard_commands.seed
+      end
 
-        desc "Rolls the schema back to the previous version"
-        task :rollback => :_load_communard do
-          step = Integer(ENV["STEP"] || 1)
-          @_communard_context.rollback(step: step)
-        end
+      desc "Rolls the schema back to the previous version"
+      task rollback: :_load_communard do
+        step = Integer(ENV["STEP"] || 1)
+        @_communard_commands.rollback(step: step)
+      end
 
-        namespace :test do
-          desc "Cleans the test database"
-          task :prepare => :_load_communard do
-            context = @_communard_context
-            context.drop_database(env: "test")
-            context.create_database(env: "test")
-            context.migrate(env: "test")
-          end
+      namespace :test do
+        desc "Cleans the test database"
+        task prepare: :_load_communard do
+          env = {
+            "RACK_ENV"     => "test",
+            "RAILS_ENV"    => "test",
+            "RUBY_ENV"     => "test",
+            "DATABASE_URL" => nil,
+          }
+          Process.spawn(env, $PROGRAM_NAME, "db:drop", "db:create", "db:schema:load")
+          _pid, status = Process.wait2
+          fail "Failed to re-create test database" if status.exitstatus != 0
         end
+      end
 
-        namespace :migrate do
+      namespace :migrate do
 
-          desc "Redo the last migration"
-          task :redo => :_load_communard do
-            context = @_communard_context
-            context.rollback
-            context.migrate
-          end
+        desc "Redo the last migration"
+        task redo: :_load_communard do
+          commands = @_communard_commands
+          commands.rollback
+          commands.migrate
+        end
 
-          desc "Display status of migrations"
-          task :status, :_load_communard do
-            @_communard_context.status
-          end
+        desc "Display status of migrations"
+        task status: :_load_communard do
+          @_communard_commands.status
         end
 
-        namespace :schema do
+        desc "Drop and recreate database with migrations"
+        task reset: ["db:drop", "db:create", "db:migrate"]
+      end
 
-          desc "Load the schema from db/schema.rb"
-          task :load => :_load_communard do
-            @_communard_context.load_schema
-          end
+      namespace :schema do
 
-          desc "Dumps the schema to db/schema.rb"
-          task :dump => :_load_communard do
-            @_communard_context.dump_schema
-          end
+        desc "Load the schema from db/schema.rb"
+        task load: :_load_communard do
+          @_communard_commands.load_schema
+        end
 
+        desc "Dumps the schema to db/schema.rb"
+        task dump: :_load_communard do
+          @_communard_commands.dump_schema
         end
 
       end

data/lib/communard/version.rb

@@ -1,3 +1,5 @@
 module Communard
-  VERSION = "0.0.5"
+
+  VERSION = "0.1.0"
+
 end

data/lib/communard.rb

@@ -1,24 +1,17 @@
-require "sequel"
-require "logger"
-require "pathname"
+require "sequel/core"
 
 require "communard/version"
-require "communard/maintenance"
 require "communard/configuration"
-require "communard/context"
+require "communard/commands"
 
 module Communard
 
-  def self.connect(&block)
-    context(&block).connect
+  def self.commands(*args, &block)
+    Commands.new(configuration(*args, &block))
   end
 
-  def self.context(&block)
-    Context.new(configuration(&block))
-  end
-
-  def self.configuration(&block)
-    Configuration.new(&block)
+  def self.configuration(*args, &block)
+    Configuration.new(*args, &block)
   end
 
 end

data/spec/integration_spec.rb

@@ -3,57 +3,34 @@ require "yaml"
 RSpec.describe "Integration", type: :aruba do
 
   example "SQLite" do
-    run_tests(
-      "adapter"  => "sqlite",
-      "database" => "db/test.sqlite3",
-      "pool"     => 5,
-      "timeout"  => 5000,
-    )
+    run_tests("sqlite://db/test.sqlite3")
   end
 
   example "PostgreSQL" do
-    run_tests(
-      "adapter"  => "postgres",
-      "database" => "communard_test",
-      "pool"     => 5,
-      "timeout"  => 5000,
-    )
+    run_tests("postgresql://localhost:5432/communard_test")
   end
 
   example "MySQL" do
-    run_tests(
-      "adapter"  => "mysql2",
-      "database" => "communard_test",
-      "username" => "root",
-      "pool"     => 5,
-      "timeout"  => 5000,
-    )
+    run_tests("mysql2://root@localhost:3306/communard_test")
   end
 
-
   def run_tests(database_config)
-
-    write_file "config/database.yml", { "development" => database_config }.to_yaml
-
     write_file "Rakefile", <<-FILE.gsub(/^\s{6}/, "")
       $LOAD_PATH.unshift(File.expand_path("../../../lib", __FILE__))
-      require "yaml"
       require "communard/rake"
-      Communard::Rake.add_tasks
+      namespace :db do
+        Communard::Rake.add_tasks("#{database_config}")
+      end
     FILE
 
-    run_simple "bundle exec communard --generate-migration create_posts"
+    run_simple "bundle exec communard migration create_posts"
 
-    file = Dir[absolute_path("db/migrate/*_create_posts.rb")].first
+    glob = Dir[expand_path("db/migrate/*_create_posts.rb")]
+    file = glob.first
 
-    expect(File.read(file)).to eq <<-FILE.gsub(/^\s{6}/, "").chomp
-      Sequel.migration do
-        change do
-        end
-      end
-    FILE
+    expect(File.read(file)).to eq "Sequel.migration do\n\n  change do\n  end\n\nend\n"
 
-    write_file file, <<-FILE.gsub(/^\s{6}/, "")
+    write_file "db/migrate/#{File.basename(file)}", <<-FILE.gsub(/^\s{6}/, "")
       Sequel.migration do
         change do
           create_table :posts do
@@ -64,31 +41,11 @@ RSpec.describe "Integration", type: :aruba do
       end
     FILE
 
-    run_simple "rake db:drop"
-
-    run_simple "rake db:create"
+    run_simple "bundle exec rake db:drop"
 
-    run_simple "rake db:migrate"
+    run_simple "bundle exec rake db:create"
 
-    write_file "app.rb", <<-FILE.gsub(/^\s{6}/, "")
-      $LOAD_PATH.unshift(File.expand_path("../../../lib", __FILE__))
-      require "yaml"
-      require "communard"
-
-      db = Communard.connect
-      posts = db[:posts]
-
-      4.times do
-        posts.insert(name: "hello world")
-      end
-
-      puts "Post count: '\#{posts.count}'"
-    FILE
-
-    run_simple "ruby app.rb"
-
-    assert_partial_output("Post count: '4'", all_stdout)
+    run_simple "bundle exec rake db:migrate"
   end
 
-
 end

data/spec/spec_helper.rb

@@ -1,22 +1,12 @@
-require 'aruba/api'
-require 'aruba/reporting'
+require "aruba"
 
 RSpec.configure do |config|
   config.disable_monkey_patching!
   config.include Aruba::Api, type: :aruba
 
-  config.before :each do
-    next unless self.class.include?(Aruba::Api)
+  config.before :each, type: :aruba do
     restore_env
-    clean_current_dir
-
-    if ENV["DEBUG"] == "true"
-      @announce_stdout = true
-      @announce_stderr = true
-      @announce_cmd = true
-      @announce_dir = true
-      @announce_env = true
-    end
+    setup_aruba
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: communard
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - iain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-17 00:00:00.000000000 Z
+date: 2017-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.13'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.13'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -139,14 +139,13 @@ files:
 - bin/communard
 - communard.gemspec
 - lib/communard.rb
+- lib/communard/commands.rb
 - lib/communard/configuration.rb
-- lib/communard/context.rb
-- lib/communard/maintenance.rb
 - lib/communard/rake.rb
 - lib/communard/version.rb
 - spec/integration_spec.rb
 - spec/spec_helper.rb
-homepage: https://github.com/yourkarma/communard
+homepage: https://github.com/iain/communard
 licenses:
 - MIT
 metadata: {}
@@ -166,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.7.1
 signing_key: 
 specification_version: 4
 summary: Adds some conventions from ActiveRecord to Sequel.

data/lib/communard/context.rb

@@ -1,118 +0,0 @@
-module Communard
-  class Context
-
-    attr_reader :configuration
-
-    def initialize(configuration)
-      @configuration = configuration
-    end
-
-    def connect(opts = options)
-      ::Sequel.connect(opts).tap do |connection|
-        connection.loggers = loggers
-        connection.sql_log_level = configuration.sql_log_level
-        connection.log_warn_duration = configuration.log_warn_duration
-      end
-    end
-
-    def generate_migration(name: nil)
-      fail ArgumentError, "Name is required" if name.to_s == ""
-      require "fileutils"
-      underscore = name.
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        tr("-", "_").
-        downcase
-      filename = root.join("db/migrate/#{Time.now.strftime("%Y%m%d%H%M%S")}_#{underscore}.rb")
-      FileUtils.mkdir_p(File.dirname(filename))
-      File.open(filename, "w") { |f| f << "Sequel.migration do\n  change do\n  end\nend" }
-      puts "#{filename} created"
-    end
-
-    def create_database(env: environment)
-      unless adapter(env: env) == "sqlite"
-        run_without_database("CREATE DATABASE %{database_name}", env: env)
-      end
-    rescue Sequel::DatabaseError => error
-      if /database (.*) already exists/ === error.message
-        loggers.each { |logger| logger.info "Database #{$1} already exists, which is fine." }
-      else
-        raise
-      end
-    end
-
-    def drop_database(env: environment)
-      fail ArgumentError, "Don't drop the production database, you monkey!" if env.to_s == "production"
-      if adapter(env: env) == "sqlite"
-        file = options(env: env).fetch("database")
-        if File.exist?(file)
-          File.rm(file)
-        end
-      else
-        run_without_database("DROP DATABASE IF EXISTS %{database_name}", env: env)
-      end
-    end
-
-    def migrate(target: nil, env: environment)
-      maintenance(env: env).migrate(target: target, dump_same_db: configuration.dump_same_db)
-    end
-
-    def seed(env: environment)
-      maintenance(env: env).seed
-    end
-
-    def rollback(step: 1, env: environment)
-      maintenance(env: env).rollback(step: step, dump_same_db: configuration.dump_same_db)
-    end
-
-    def load_schema(env: environment)
-      maintenance(env: env).load_schema
-    end
-
-    def dump_schema(env: environment)
-      maintenance(env: env).dump_schema(dump_same_db: configuration.dump_same_db)
-    end
-
-    def status(env: environment)
-      maintenance(env: env).status
-    end
-
-    def run_without_database(cmd, env: environment)
-      opts = options(env: env).dup
-      database_name = opts.delete("database")
-      if opts.fetch("adapter") == "postgres"
-        opts["database"]           = "postgres"
-        opts["schema_search_path"] = "public"
-      end
-      connection = connect(opts)
-      connection.run(cmd % { database_name: database_name })
-    end
-
-    def options(env: environment)
-      YAML.load_file(root.join("config/database.yml")).fetch(env.to_s)
-    end
-
-    private
-
-    def maintenance(env: environment)
-      Maintenance.new(connection: connect(options(env: env)), root: root)
-    end
-
-    def environment
-      configuration.environment
-    end
-
-    def root
-      configuration.root
-    end
-
-    def loggers
-      configuration.loggers
-    end
-
-    def adapter(env: environment)
-      options(env: env).fetch("adapter").to_s
-    end
-
-  end
-end

data/lib/communard/maintenance.rb

@@ -1,102 +0,0 @@
-module Communard
-  class Maintenance
-
-    attr_reader :connection, :root
-
-    def initialize(connection: nil, root: nil)
-      ::Sequel.extension :migration, :core_extensions
-      @connection = connection
-      @root       = root
-    end
-
-    def migrate(target: nil, dump_same_db: false)
-      target = Integer(target) if target
-      ::Sequel::Migrator.run(connection, migrations, target: target, allow_missing_migration_files: true)
-      dump_schema(dump_same_db: dump_same_db)
-    end
-
-    def seed
-      load seeds_file if seeds_file.exist?
-    end
-
-    def rollback(step: 1, dump_same_db: false)
-      target = applied_migrations[-step - 1]
-      if target
-        migrate(target: target.split(/_/, 2).first, dump_same_db: dump_same_db)
-      else
-        fail ArgumentError, "Cannot roll back that far"
-      end
-    end
-
-    def load_schema
-      migration = instance_eval(schema_file.read, schema_file.expand_path.to_s, 1)
-      migration.apply(connection, :up)
-    end
-
-    def dump_schema(dump_same_db: false)
-      connection.extension :schema_dumper
-      schema = connection.dump_schema_migration(same_db: dump_same_db)
-      schema_file.open("w") { |f| f << schema.gsub(/\s+$/m, "") }
-    end
-
-    def status
-      results = Hash.new { |h,k| h[k] = Status.new(k, false, false) }
-      available = Pathname.glob(migrations.join("*.rb")).map(&:basename).map(&:to_s).reverse
-      available.each { |migration| results[migration].available = true }
-      applied_migrations.each { |migration| results[migration].applied = true }
-
-      puts
-      puts "database: #{connection.opts.fetch(:database)}"
-      puts
-      puts " Status   Migration ID    Migration Name"
-      puts "--------------------------------------------------"
-      results.values.sort.each do |result|
-        puts "  #{result.status}    #{result.id}  #{result.name}"
-      end
-      puts
-    end
-
-    private
-
-    def applied_migrations
-      ::Sequel::Migrator.migrator_class(migrations).new(connection, migrations, allow_missing_migration_files: true).applied_migrations
-    end
-
-    def schema_file
-      root.join("db/schema.rb")
-    end
-
-    def seeds_file
-      root.join("db/seeds.rb")
-    end
-
-    def migrations
-      root.join("db/migrate")
-    end
-
-    Status = Struct.new(:file, :applied, :available) do
-
-      def <=>(other)
-        id <=> other.id
-      end
-
-      def status
-        available ? applied ? " up " : "down" : "????"
-      end
-
-      def id
-        splitted.first
-      end
-
-      def name
-        splitted.last.capitalize.gsub("_", " ").sub(/\.rb$/, "")
-      end
-
-      def splitted
-        file.split(/_/, 2)
-      end
-
-    end
-
-  end
-end