ardb 0.24.0 → 0.25.0

data/lib/ardb/adapter/base.rb

@@ -20,6 +20,25 @@ class Ardb::Adapter::Base
   def create_db(*args); raise NotImplementedError; end
   def drop_db(*args);   raise NotImplementedError; end
 
+  def migrate_db
+    verbose = ENV["MIGRATE_QUIET"].nil?
+    version = ENV["MIGRATE_VERSION"] ? ENV["MIGRATE_VERSION"].to_i : nil
+    migrations_path = Ardb.config.migrations_path
+
+    if defined?(ActiveRecord::Migration::CommandRecorder)
+      require 'ardb/migration_helpers'
+      ActiveRecord::Migration::CommandRecorder.class_eval do
+        include Ardb::MigrationHelpers::RecorderMixin
+      end
+    end
+
+    ActiveRecord::Migrator.migrations_path = migrations_path
+    ActiveRecord::Migration.verbose = verbose
+    ActiveRecord::Migrator.migrate(migrations_path, version) do |migration|
+      ENV["MIGRATE_SCOPE"].blank? || (ENV["MIGRATE_SCOPE"] == migration.scope)
+    end
+  end
+
   def drop_tables(*args); raise NotImplementedError; end
 
   def load_schema

data/lib/ardb/adapter_spy.rb

@@ -17,21 +17,43 @@ module Ardb
 
     module InstanceMethods
 
-      attr_accessor :drop_tables_called_count, :load_schema_called_count
+      attr_accessor :drop_tables_called_count
+      attr_accessor :dump_schema_called_count, :load_schema_called_count
       attr_accessor :drop_db_called_count, :create_db_called_count
+      attr_accessor :migrate_db_called_count
 
       def drop_tables_called_count
         @drop_tables_called_count ||= 0
       end
 
+      def drop_tables_called?
+        self.drop_tables_called_count > 0
+      end
+
       def drop_tables(*args, &block)
         self.drop_tables_called_count += 1
       end
 
+      def dump_schema_called_count
+        @dump_schema_called_count ||= 0
+      end
+
+      def dump_schema_called?
+        self.dump_schema_called_count > 0
+      end
+
+      def dump_schema(*args, &block)
+        self.dump_schema_called_count += 1
+      end
+
       def load_schema_called_count
         @load_schema_called_count ||= 0
       end
 
+      def load_schema_called?
+        self.load_schema_called_count > 0
+      end
+
       def load_schema(*args, &block)
         self.load_schema_called_count += 1
       end
@@ -40,6 +62,10 @@ module Ardb
         @drop_db_called_count ||= 0
       end
 
+      def drop_db_called?
+        self.drop_db_called_count > 0
+      end
+
       def drop_db(*args, &block)
         self.drop_db_called_count += 1
       end
@@ -48,10 +74,26 @@ module Ardb
         @create_db_called_count ||= 0
       end
 
+      def create_db_called?
+        self.create_db_called_count > 0
+      end
+
       def create_db(*args, &block)
         self.create_db_called_count += 1
       end
 
+      def migrate_db_called_count
+        @migrate_db_called_count ||= 0
+      end
+
+      def migrate_db_called?
+        self.migrate_db_called_count > 0
+      end
+
+      def migrate_db(*args, &block)
+        self.migrate_db_called_count += 1
+      end
+
     end
 
   end

data/lib/ardb/has_slug.rb

@@ -0,0 +1,104 @@
+module Ardb
+
+  module HasSlug
+
+    DEFAULT_ATTRIBUTE    = :slug
+    DEFAULT_PREPROCESSOR = :downcase
+    DEFAULT_SEPARATOR    = '-'.freeze
+
+    def self.included(klass)
+      klass.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+
+        @ardb_has_slug_config = {}
+
+      end
+    end
+
+    module ClassMethods
+
+      def has_slug(options = nil)
+        options ||= {}
+        raise(ArgumentError, "a source must be provided") unless options[:source]
+
+        @ardb_has_slug_config.merge!({
+          :attribute         => options[:attribute] || DEFAULT_ATTRIBUTE,
+          :source_proc       => options[:source].to_proc,
+          :preprocessor_proc => (options[:preprocessor] || DEFAULT_PREPROCESSOR).to_proc,
+          :separator         => options[:separator] || DEFAULT_SEPARATOR,
+          :allow_underscores => !!options[:allow_underscores]
+        })
+
+        # since the slug isn't written till an after callback we can't always
+        # validate presence of it
+        validates_presence_of(self.ardb_has_slug_config[:attribute], :on => :update)
+        validates_uniqueness_of(self.ardb_has_slug_config[:attribute], {
+          :case_sensitive => true,
+          :scope          => options[:unique_scope]
+        })
+
+        after_create :ardb_has_slug_generate_slug
+        after_update :ardb_has_slug_generate_slug
+      end
+
+      def ardb_has_slug_config
+        @ardb_has_slug_config
+      end
+
+    end
+
+    module InstanceMethods
+
+      private
+
+      def reset_slug
+        self.send("#{self.class.ardb_has_slug_config[:attribute]}=", nil)
+      end
+
+      def ardb_has_slug_generate_slug
+        attr_name = self.class.ardb_has_slug_config[:attribute]
+        slug_source = if !self.send(attr_name) || self.send(attr_name).to_s.empty?
+          self.instance_eval(&self.class.ardb_has_slug_config[:source_proc])
+        else
+          self.send(attr_name)
+        end
+
+        generated_slug = Slug.new(slug_source, {
+          :preprocessor      => self.class.ardb_has_slug_config[:preprocessor_proc],
+          :separator         => self.class.ardb_has_slug_config[:separator],
+          :allow_underscores => self.class.ardb_has_slug_config[:allow_underscores]
+        })
+        return if self.send(attr_name) == generated_slug
+        self.send("#{attr_name}=", generated_slug)
+        self.update_column(attr_name, generated_slug)
+      end
+
+    end
+
+    module Slug
+      DEFAULT_PREPROCESSOR = proc{ |slug| slug } # no-op
+
+      def self.new(string, options = nil)
+        options ||= {}
+        preprocessor       = options[:preprocessor] || DEFAULT_PREPROCESSOR
+        separator          = options[:separator] || DEFAULT_SEPARATOR
+        allow_underscores  = options[:allow_underscores]
+        regexp_escaped_sep = Regexp.escape(separator)
+
+        slug = preprocessor.call(string.to_s)
+        # Turn unwanted chars into the separator
+        slug.gsub!(/[^\w#{regexp_escaped_sep}]+/, separator)
+        # Turn underscores into the separator, unless allowing
+        slug.gsub!(/_/, separator) unless allow_underscores
+        # No more than one of the separator in a row.
+        slug.gsub!(/#{regexp_escaped_sep}{2,}/, separator)
+        # Remove leading/trailing separator.
+        slug.gsub!(/\A#{regexp_escaped_sep}|#{regexp_escaped_sep}\z/, '')
+        slug
+      end
+    end
+
+  end
+
+end

data/lib/ardb/runner/create_command.rb

@@ -3,19 +3,21 @@ require 'ardb/runner'
 
 class Ardb::Runner::CreateCommand
 
-  def initialize
+  def initialize(out_io = nil, err_io = nil)
+    @out_io = out_io || $stdout
+    @err_io = err_io || $stderr
     @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
   end
 
   def run
     begin
       @adapter.create_db
-      $stdout.puts "created #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
+      @out_io.puts "created #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
     rescue Ardb::Runner::CmdError => e
       raise e
-    rescue Exception => e
-      $stderr.puts e
-      $stderr.puts "error creating #{Ardb.config.db.database.inspect} database"
+    rescue StandardError => e
+      @err_io.puts e
+      @err_io.puts "error creating #{Ardb.config.db.database.inspect} database"
       raise Ardb::Runner::CmdFail
     end
   end

data/lib/ardb/runner/drop_command.rb

@@ -3,19 +3,21 @@ require 'ardb/runner'
 
 class Ardb::Runner::DropCommand
 
-  def initialize
+  def initialize(out_io = nil, err_io = nil)
+    @out_io = out_io || $stdout
+    @err_io = err_io || $stderr
     @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
   end
 
   def run
     begin
       @adapter.drop_db
-      $stdout.puts "dropped #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
+      @out_io.puts "dropped #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
     rescue Ardb::Runner::CmdError => e
       raise e
-    rescue Exception => e
-      $stderr.puts e
-      $stderr.puts "error dropping #{Ardb.config.db.database.inspect} database"
+    rescue StandardError => e
+      @err_io.puts e
+      @err_io.puts "error dropping #{Ardb.config.db.database.inspect} database"
       raise Ardb::Runner::CmdFail
     end
   end

data/lib/ardb/runner/migrate_command.rb

@@ -1,47 +1,28 @@
 require 'fileutils'
 require 'active_record'
 require 'ardb/runner'
-require 'ardb/migration_helpers'
 
 class Ardb::Runner::MigrateCommand
 
-  attr_reader :migrations_path, :version, :verbose
-
-  def initialize
+  def initialize(out_io = nil, err_io = nil)
+    @out_io = out_io || $stdout
+    @err_io = err_io || $stderr
     @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
-    @migrations_path = Ardb.config.migrations_path
-    @version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
-    @verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
   end
 
   def run
     begin
       Ardb.init
-      migrate_the_db
+      @adapter.migrate_db
+      @adapter.dump_schema
     rescue Ardb::Runner::CmdError => e
       raise e
-    rescue Exception => e
-      $stderr.puts "error migrating #{Ardb.config.db.database.inspect} database"
-      $stderr.puts e
-      $stderr.puts e.backtrace
+    rescue StandardError => e
+      @err_io.puts "error migrating #{Ardb.config.db.database.inspect} database"
+      @err_io.puts e
+      @err_io.puts e.backtrace
       raise Ardb::Runner::CmdFail
     end
   end
 
-  def migrate_the_db
-    if defined?(ActiveRecord::Migration::CommandRecorder)
-      ActiveRecord::Migration::CommandRecorder.class_eval do
-        include Ardb::MigrationHelpers::RecorderMixin
-      end
-    end
-
-    ActiveRecord::Migrator.migrations_path = @migrations_path
-    ActiveRecord::Migration.verbose = @verbose
-    ActiveRecord::Migrator.migrate(@migrations_path, @version) do |migration|
-      ENV["SCOPE"].blank? || (ENV["SCOPE"] == migration.scope)
-    end
-
-    @adapter.dump_schema
-  end
-
 end

data/lib/ardb/test_helpers.rb

@@ -16,9 +16,42 @@ module Ardb::TestHelpers
     Ardb.adapter.load_schema
   end
 
-  def reset_db!
-    Ardb.adapter.drop_db
+  def create_db!
     Ardb.adapter.create_db
+  end
+
+  def create_db
+    @create_db ||= begin
+      self.create_db!
+      true
+    end
+  end
+
+  def drop_db!
+    Ardb.adapter.drop_db
+  end
+
+  def drop_db
+    @drop_db ||= begin
+      self.drop_db!
+      true
+    end
+  end
+
+  def migrate_db!
+    Ardb.adapter.migrate_db
+  end
+
+  def migrate_db
+    @migrate_db ||= begin
+      self.migrate_db!
+      true
+    end
+  end
+
+  def reset_db!
+    self.drop_db!
+    self.create_db!
     self.load_schema
   end
 

data/lib/ardb/use_db_default.rb

@@ -16,7 +16,7 @@ module Ardb
 
     module ClassMethods
 
-      def use_db_default_attrs
+      def ardb_use_db_default_attrs
         @ardb_use_db_default_attrs
       end
 
@@ -35,7 +35,7 @@ module Ardb
         # this allows the attr to be defaulted by the DB, this keeps
         # activerecord from adding the attr into the sql `INSERT`, which will
         # make the DB default its value
-        unchanged_names = self.class.use_db_default_attrs.reject do |name|
+        unchanged_names = self.class.ardb_use_db_default_attrs.reject do |name|
           self.send("#{name}_changed?")
         end
         unchanged_names.each{ |name| @attributes.delete(name) }

data/lib/ardb/version.rb

@@ -1,3 +1,3 @@
 module Ardb
-  VERSION = "0.24.0"
+  VERSION = "0.25.0"
 end

data/test/unit/adapter/base_tests.rb

@@ -13,7 +13,7 @@ class Ardb::Adapter::Base
     should have_readers :config_settings, :database
     should have_readers :ruby_schema_path, :sql_schema_path
     should have_imeths :foreign_key_add_sql, :foreign_key_drop_sql
-    should have_imeths :create_db, :drop_db
+    should have_imeths :create_db, :drop_db, :migrate_db
     should have_imeths :load_schema, :load_ruby_schema, :load_sql_schema
     should have_imeths :dump_schema, :dump_ruby_schema, :dump_sql_schema
 
@@ -51,6 +51,43 @@ class Ardb::Adapter::Base
 
   end
 
+  class MigrateDbTests < UnitTests
+    desc "`migrate_db`"
+    setup do
+      ENV["MIGRATE_VERSION"] = Factory.integer.to_s if Factory.boolean
+      ENV["MIGRATE_QUIET"]   = Factory.boolean.to_s if Factory.boolean
+
+      @migrator_called_with = []
+      Assert.stub(ActiveRecord::Migrator, :migrate) do |*args|
+        @migrator_called_with = args
+      end
+
+      @adapter.migrate_db
+    end
+
+    should "add the Ardb MigrationHelper Recorder to the ActiveRecord Command Recorder" do
+      exp = Ardb::MigrationHelpers::RecorderMixin
+      assert_includes exp, ActiveRecord::Migration::CommandRecorder
+    end
+
+    should "set the ActiveRecord Migrator's migrations path" do
+      exp = Ardb.config.migrations_path
+      assert_equal exp, ActiveRecord::Migrator.migrations_path
+    end
+
+    should "set the ActiveRecord Migration's verbose" do
+      exp = ENV["MIGRATE_QUIET"].nil?
+      assert_equal exp, ActiveRecord::Migration.verbose
+    end
+
+    should "call the ActiveRecord Migrator's migrate" do
+      version = ENV.key?("MIGRATE_VERSION") ? ENV["MIGRATE_VERSION"].to_i : nil
+      exp = [Ardb.config.migrations_path, version]
+      assert_equal exp, @migrator_called_with
+    end
+
+  end
+
   class LoadAndDumpSchemaTests < UnitTests
     setup do
       @orig_stdout = $stdout.dup

data/test/unit/adapter_spy_tests.rb

@@ -14,9 +14,16 @@ module Ardb::AdapterSpy
     end
     subject{ @adapter }
 
-    should have_accessors :drop_tables_called_count, :load_schema_called_count
+    should have_accessors :drop_tables_called_count
+    should have_accessors :dump_schema_called_count, :load_schema_called_count
     should have_accessors :drop_db_called_count, :create_db_called_count
-    should have_imeths :drop_tables, :load_schema, :drop_db, :create_db
+    should have_accessors :migrate_db_called_count
+    should have_imeths :drop_tables_called?, :drop_tables
+    should have_imeths :dump_schema_called?, :dump_schema
+    should have_imeths :load_schema_called?, :load_schema
+    should have_imeths :drop_db_called?, :drop_db
+    should have_imeths :create_db_called?, :create_db
+    should have_imeths :migrate_db_called?, :migrate_db
 
     should "included the record spy instance methods" do
       assert_includes Ardb::AdapterSpy::InstanceMethods, subject.class
@@ -24,23 +31,43 @@ module Ardb::AdapterSpy
 
     should "default all call counts to zero" do
       assert_equal 0, subject.drop_tables_called_count
+      assert_equal 0, subject.dump_schema_called_count
       assert_equal 0, subject.load_schema_called_count
       assert_equal 0, subject.drop_db_called_count
       assert_equal 0, subject.create_db_called_count
+      assert_equal 0, subject.migrate_db_called_count
     end
 
-    should "add a call count when each method is called" do
+    should "know if and how many times a method is called" do
+      assert_equal false, subject.drop_tables_called?
       subject.drop_tables
       assert_equal 1, subject.drop_tables_called_count
+      assert_equal true, subject.drop_tables_called?
 
+      assert_equal false, subject.dump_schema_called?
+      subject.dump_schema
+      assert_equal 1, subject.dump_schema_called_count
+      assert_equal true, subject.dump_schema_called?
+
+      assert_equal false, subject.load_schema_called?
       subject.load_schema
       assert_equal 1, subject.load_schema_called_count
+      assert_equal true, subject.load_schema_called?
 
+      assert_equal false, subject.drop_db_called?
       subject.drop_db
       assert_equal 1, subject.drop_db_called_count
+      assert_equal true, subject.drop_db_called?
 
+      assert_equal false, subject.create_db_called?
       subject.create_db
       assert_equal 1, subject.create_db_called_count
+      assert_equal true, subject.create_db_called?
+
+      assert_equal false, subject.migrate_db_called?
+      subject.migrate_db
+      assert_equal 1, subject.migrate_db_called_count
+      assert_equal true, subject.migrate_db_called?
     end
 
   end

data/test/unit/has_slug_tests.rb

@@ -0,0 +1,308 @@
+require 'assert'
+require 'ardb/has_slug'
+
+require 'ardb/record_spy'
+
+module Ardb::HasSlug
+
+  class UnitTests < Assert::Context
+    desc "Ardb::HasSlug"
+    setup do
+      source_attribute = @source_attribute = Factory.string.to_sym
+      slug_attribute   = @slug_attribute   = Factory.string.to_sym
+      @record_class = Ardb::RecordSpy.new do
+        include Ardb::HasSlug
+        attr_accessor source_attribute, slug_attribute
+        attr_reader :slug_db_column_name, :slug_db_column_value
+
+        def update_column(name, value)
+          @slug_db_column_name  = name
+          @slug_db_column_value = value
+        end
+      end
+    end
+    subject{ @record_class }
+
+    NON_WORD_CHARS = ((' '..'/').to_a + (':'..'@').to_a + ('['..'`').to_a +
+                     ('{'..'~').to_a - ['-', '_']).freeze
+
+    should have_imeths :has_slug
+    should have_imeths :ardb_has_slug_config
+
+    should "know its default attribute, preprocessor and separator" do
+      assert_equal :slug,     DEFAULT_ATTRIBUTE
+      assert_equal :downcase, DEFAULT_PREPROCESSOR
+      assert_equal '-',       DEFAULT_SEPARATOR
+    end
+
+    should "not have any has-slug config by default" do
+      assert_equal({}, subject.ardb_has_slug_config)
+    end
+
+    should "default the has slug config using `has_slug`" do
+      subject.has_slug :source => @source_attribute
+      string = Factory.string
+      record = subject.new.tap{ |r| r.send("#{@source_attribute}=", string) }
+
+      assert_equal DEFAULT_ATTRIBUTE, subject.ardb_has_slug_config[:attribute]
+      assert_equal DEFAULT_SEPARATOR, subject.ardb_has_slug_config[:separator]
+      assert_false subject.ardb_has_slug_config[:allow_underscores]
+
+      source_proc = subject.ardb_has_slug_config[:source_proc]
+      assert_instance_of Proc, source_proc
+      exp = record.send(@source_attribute)
+      assert_equal exp, record.instance_eval(&source_proc)
+
+      upcase_string = string.upcase
+      preprocessor_proc = subject.ardb_has_slug_config[:preprocessor_proc]
+      assert_instance_of Proc, preprocessor_proc
+      exp = upcase_string.send(DEFAULT_PREPROCESSOR)
+      assert_equal exp, preprocessor_proc.call(upcase_string)
+    end
+
+    should "allow customizing the has slug config using `has_slug`" do
+      separator        = NON_WORD_CHARS.choice
+      allow_underscore = Factory.boolean
+      subject.has_slug({
+        :attribute         => @slug_attribute,
+        :source            => @source_attribute,
+        :preprocessor      => :upcase,
+        :separator         => separator,
+        :allow_underscores => allow_underscore
+      })
+
+      assert_equal @slug_attribute,  subject.ardb_has_slug_config[:attribute]
+      assert_equal separator,        subject.ardb_has_slug_config[:separator]
+      assert_equal allow_underscore, subject.ardb_has_slug_config[:allow_underscores]
+
+      value = Factory.string.downcase
+      preprocessor_proc = subject.ardb_has_slug_config[:preprocessor_proc]
+      assert_instance_of Proc, preprocessor_proc
+      assert_equal value.upcase, preprocessor_proc.call(value)
+    end
+
+    should "add validations using `has_slug`" do
+      subject.has_slug :source => @source_attribute
+
+      validation = subject.validations.find{ |v| v.type == :presence }
+      assert_not_nil validation
+      assert_equal [subject.ardb_has_slug_config[:attribute]], validation.columns
+      assert_equal :update, validation.options[:on]
+
+      validation = subject.validations.find{ |v| v.type == :uniqueness }
+      assert_not_nil validation
+      assert_equal [subject.ardb_has_slug_config[:attribute]], validation.columns
+      assert_equal true, validation.options[:case_sensitive]
+      assert_nil validation.options[:scope]
+    end
+
+    should "allow customizing its validations using `has_slug`" do
+      unique_scope = Factory.string.to_sym
+      subject.has_slug({
+        :source       => @source_attribute,
+        :unique_scope => unique_scope
+      })
+
+      validation = subject.validations.find{ |v| v.type == :uniqueness }
+      assert_not_nil validation
+      assert_equal unique_scope, validation.options[:scope]
+    end
+
+    should "add callbacks using `has_slug`" do
+      subject.has_slug :source => @source_attribute
+
+      callback = subject.callbacks.find{ |v| v.type == :after_create }
+      assert_not_nil callback
+      assert_equal [:ardb_has_slug_generate_slug], callback.args
+
+      callback = subject.callbacks.find{ |v| v.type == :after_update }
+      assert_not_nil callback
+      assert_equal [:ardb_has_slug_generate_slug], callback.args
+    end
+
+    should "raise an argument error if `has_slug` isn't passed a source" do
+      assert_raises(ArgumentError){ subject.has_slug }
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @preprocessor      = [:downcase, :upcase, :capitalize].choice
+      @separator         = NON_WORD_CHARS.choice
+      @allow_underscores = Factory.boolean
+      @record_class.has_slug({
+        :attribute         => @slug_attribute,
+        :source            => @source_attribute,
+        :preprocessor      => @preprocessor,
+        :separator         => @separator,
+        :allow_underscores => @allow_underscores,
+      })
+
+      @record = @record_class.new
+
+      # create a string that has mixed case and an underscore so we can test
+      # that it uses the preprocessor and allow underscores options when
+      # generating a slug
+      @source_value = "#{Factory.string.downcase}_#{Factory.string.upcase}"
+      @record.send("#{@source_attribute}=", @source_value)
+    end
+    subject{ @record }
+
+    should "reset its slug using `reset_slug`" do
+      subject.send("#{@slug_attribute}=", Factory.slug)
+      assert_not_nil subject.send(@slug_attribute)
+      subject.instance_eval{ reset_slug }
+      assert_nil subject.send(@slug_attribute)
+    end
+
+    should "default its slug attribute using `ardb_has_slug_generate_slug`" do
+      subject.instance_eval{ ardb_has_slug_generate_slug }
+
+      exp = Slug.new(@source_value, {
+        :preprocessor      => @preprocessor.to_proc,
+        :separator         => @separator,
+        :allow_underscores => @allow_underscores
+      })
+      assert_equal exp,             subject.send(@slug_attribute)
+      assert_equal @slug_attribute, subject.slug_db_column_name
+      assert_equal exp,             subject.slug_db_column_value
+    end
+
+    should "slug its slug attribute value if set using `ardb_has_slug_generate_slug`" do
+      @record.send("#{@slug_attribute}=", @source_value)
+      # change the source attr to some random value, to avoid a false positive
+      @record.send("#{@source_attribute}=", Factory.string)
+      subject.instance_eval{ ardb_has_slug_generate_slug }
+
+      exp = Slug.new(@source_value, {
+        :preprocessor      => @preprocessor.to_proc,
+        :separator         => @separator,
+        :allow_underscores => @allow_underscores
+      })
+      assert_equal exp,             subject.send(@slug_attribute)
+      assert_equal @slug_attribute, subject.slug_db_column_name
+      assert_equal exp,             subject.slug_db_column_value
+    end
+
+    should "slug its source even if its already a valid slug using `ardb_has_slug_generate_slug`" do
+      slug_source = Factory.slug
+      @record.send("#{@source_attribute}=", slug_source)
+      # ensure the preprocessor doesn't change our source
+      Assert.stub(slug_source, @preprocessor){ slug_source }
+
+      subject.instance_eval{ ardb_has_slug_generate_slug }
+
+      exp = Slug.new(slug_source, {
+        :preprocessor      => @preprocessor.to_proc,
+        :separator         => @separator,
+        :allow_underscores => @allow_underscores
+      })
+      assert_equal exp,             subject.send(@slug_attribute)
+      assert_equal @slug_attribute, subject.slug_db_column_name
+      assert_equal exp,             subject.slug_db_column_value
+    end
+
+    should "not set its slug if it hasn't changed using `ardb_has_slug_generate_slug`" do
+      generated_slug = Slug.new(@source_value, {
+        :preprocessor      => @preprocessor.to_proc,
+        :separator         => @separator,
+        :allow_underscores => @allow_underscores
+      })
+      @record.send("#{@slug_attribute}=", generated_slug)
+      subject.instance_eval{ ardb_has_slug_generate_slug }
+
+      assert_nil subject.slug_db_column_name
+      assert_nil subject.slug_db_column_value
+    end
+
+  end
+
+  class SlugTests < UnitTests
+    desc "Slug"
+    subject{ Slug }
+
+    should have_imeths :new
+
+    should "know its default preprocessor" do
+      assert_instance_of Proc, Slug::DEFAULT_PREPROCESSOR
+      string = Factory.string
+      assert_same string, Slug::DEFAULT_PREPROCESSOR.call(string)
+    end
+
+    should "not change strings that are made up of valid chars" do
+      string = Factory.string
+      assert_equal string, subject.new(string)
+      string = "#{Factory.string}-#{Factory.string.upcase}"
+      assert_equal string, subject.new(string)
+    end
+
+    should "turn invalid chars into a separator" do
+      string = Factory.integer(3).times.map do
+        "#{Factory.string(3)}#{NON_WORD_CHARS.choice}#{Factory.string(3)}"
+      end.join(NON_WORD_CHARS.choice)
+      assert_equal string.gsub(/[^\w]+/, '-'), subject.new(string)
+    end
+
+    should "allow passing a custom preprocessor proc" do
+      string = "#{Factory.string}-#{Factory.string.upcase}"
+      slug = subject.new(string, :preprocessor => :downcase.to_proc)
+      assert_equal string.downcase, slug
+
+      preprocessor = proc{ |s| s.gsub(/[A-Z]/, 'a') }
+      slug = subject.new(string, :preprocessor => preprocessor)
+      assert_equal preprocessor.call(string), slug
+    end
+
+    should "allow passing a custom separator" do
+      separator = NON_WORD_CHARS.choice
+
+      invalid_char = (NON_WORD_CHARS - [separator]).choice
+      string = "#{Factory.string}#{invalid_char}#{Factory.string}"
+      slug = subject.new(string, :separator => separator)
+      assert_equal string.gsub(/[^\w]+/, separator), slug
+
+      # it won't change the separator in the strings
+      string = "#{Factory.string}#{separator}#{Factory.string}"
+      assert_equal string, subject.new(string, :separator => separator)
+
+      # it will change the default separator now
+      string = "#{Factory.string}-#{Factory.string}"
+      slug = subject.new(string, :separator => separator)
+      assert_equal string.gsub('-', separator), slug
+    end
+
+    should "change underscores into its separator unless allowed" do
+      string = "#{Factory.string}_#{Factory.string}"
+      assert_equal string.gsub('_', '-'), subject.new(string)
+
+      slug = subject.new(string, :allow_underscores => false)
+      assert_equal string.gsub('_', '-'), slug
+
+      assert_equal string, subject.new(string, :allow_underscores => true)
+    end
+
+    should "not allow multiple separators in a row" do
+      string = "#{Factory.string}--#{Factory.string}"
+      assert_equal string.gsub(/-{2,}/, '-'), subject.new(string)
+
+      # remove separators that were added from changing invalid chars
+      invalid_chars = (Factory.integer(3) + 1).times.map{ NON_WORD_CHARS.choice }.join
+      string = "#{Factory.string}#{invalid_chars}#{Factory.string}"
+      assert_equal string.gsub(/[^\w]+/, '-'), subject.new(string)
+    end
+
+    should "remove leading and trailing separators" do
+      string = "-#{Factory.string}-#{Factory.string}-"
+      assert_equal string[1..-2], subject.new(string)
+
+      # remove separators that were added from changing invalid chars
+      invalid_char = NON_WORD_CHARS.choice
+      string = "#{invalid_char}#{Factory.string}-#{Factory.string}#{invalid_char}"
+      assert_equal string[1..-2], subject.new(string)
+    end
+
+  end
+
+end

data/test/unit/runner/connect_command_tests.rb

@@ -1,7 +1,7 @@
 require 'assert'
 require 'ardb/runner/connect_command'
 
-class Ardb::Runner::CreateCommand
+class Ardb::Runner::ConnectCommand
 
   class UnitTests < Assert::Context
     desc "Ardb::Runner::ConnectCommand"

data/test/unit/runner/create_command_tests.rb

@@ -1,4 +1,5 @@
 require 'assert'
+require 'ardb/adapter_spy'
 require 'ardb/runner/create_command'
 
 class Ardb::Runner::CreateCommand
@@ -6,12 +7,61 @@ class Ardb::Runner::CreateCommand
   class UnitTests < Assert::Context
     desc "Ardb::Runner::CreateCommand"
     setup do
-      @cmd = Ardb::Runner::CreateCommand.new
+      @command_class = Ardb::Runner::CreateCommand
     end
-    subject{ @cmd }
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @adapter_spy = Class.new{ include Ardb::AdapterSpy }.new
+      Assert.stub(Ardb::Adapter, Ardb.config.db.adapter.to_sym){ @adapter_spy }
+
+      # provide an output and error IO to avoid using $stdout/$stderr in tests
+      out_io = err_io = StringIO.new
+      @command = @command_class.new(out_io, err_io)
+    end
+    subject{ @command }
 
     should have_imeths :run
 
   end
 
+  class RunTests < InitTests
+    desc "and run"
+    setup do
+      @command.run
+    end
+
+    should "create the db via the adapter" do
+      assert_equal true, @adapter_spy.create_db_called?
+    end
+
+  end
+
+  class RunWithCmdErrorTests < InitTests
+    desc "and run with command errors"
+    setup do
+      Assert.stub(@adapter_spy, :create_db){ raise Ardb::Runner::CmdError.new }
+    end
+
+    should "not handle the error" do
+      assert_raises(Ardb::Runner::CmdError){ subject.run }
+    end
+
+  end
+
+  class RunWithUnspecifiedErrorTests < InitTests
+    desc "and run with a standard error"
+    setup do
+      Assert.stub(@adapter_spy, :create_db){ raise StandardError.new }
+    end
+
+    should "raise a CmdFail error" do
+      assert_raises(Ardb::Runner::CmdFail){ subject.run }
+    end
+
+  end
+
 end

data/test/unit/runner/drop_command_tests.rb

@@ -1,4 +1,5 @@
 require 'assert'
+require 'ardb/adapter_spy'
 require 'ardb/runner/drop_command'
 
 class Ardb::Runner::DropCommand
@@ -6,12 +7,62 @@ class Ardb::Runner::DropCommand
   class UnitTests < Assert::Context
     desc "Ardb::Runner::DropCommand"
     setup do
-      @cmd = Ardb::Runner::DropCommand.new
+      @command_class = Ardb::Runner::DropCommand
     end
-    subject{ @cmd }
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @adapter_spy = Class.new{ include Ardb::AdapterSpy }.new
+      Assert.stub(Ardb::Adapter, Ardb.config.db.adapter.to_sym){ @adapter_spy }
+
+      # provide an output and error IO to avoid using $stdout/$stderr in tests
+      out_io = err_io = StringIO.new
+      @command = @command_class.new(out_io, err_io)
+    end
+    subject{ @command }
 
     should have_imeths :run
 
   end
 
+  class RunTests < InitTests
+    desc "and run"
+    setup do
+      @command.run
+    end
+
+    should "drop the db via the adapter" do
+      assert_equal true, @adapter_spy.drop_db_called?
+    end
+
+  end
+
+  class RunWithCmdErrorTests < InitTests
+    desc "and run with command errors"
+    setup do
+      Assert.stub(@adapter_spy, :drop_db){ raise Ardb::Runner::CmdError.new }
+    end
+
+    should "not handle the error" do
+      assert_raises(Ardb::Runner::CmdError){ subject.run }
+    end
+
+  end
+
+  class RunWithUnspecifiedErrorTests < InitTests
+    desc "and run with a standard error"
+    setup do
+      Assert.stub(@adapter_spy, :drop_db){ raise StandardError.new }
+    end
+
+    should "raise a CmdFail error" do
+      assert_raises(Ardb::Runner::CmdFail){ subject.run }
+    end
+
+  end
+
 end
+

data/test/unit/runner/migrate_command_tests.rb

@@ -1,4 +1,5 @@
 require 'assert'
+require 'ardb/adapter_spy'
 require 'ardb/runner/migrate_command'
 
 class Ardb::Runner::MigrateCommand
@@ -6,54 +7,64 @@ class Ardb::Runner::MigrateCommand
   class UnitTests < Assert::Context
     desc "Ardb::Runner::MigrateCommand"
     setup do
-      @cmd = Ardb::Runner::MigrateCommand.new
+      @command_class = Ardb::Runner::MigrateCommand
     end
-    subject{ @cmd }
 
-    should have_readers :migrations_path, :version, :verbose
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @adapter_spy = Class.new{ include Ardb::AdapterSpy }.new
+      Assert.stub(Ardb::Adapter, Ardb.config.db.adapter.to_sym){ @adapter_spy }
 
-    should "use the config's migrations path" do
-      assert_equal Ardb.config.migrations_path, subject.migrations_path
+      @ardb_init_called = false
+      Assert.stub(Ardb, :init){ @ardb_init_called = true }
+
+      # provide an output and error IO to avoid using $stdout/$stderr in tests
+      out_io = err_io = StringIO.new
+      @command = @command_class.new(out_io, err_io)
     end
+    subject{ @command }
+
+    should have_imeths :run
 
-    should "not target a specific version by default" do
-      assert_nil subject.version
+  end
+
+  class RunTests < InitTests
+    desc "and run"
+    setup do
+      @command.run
     end
 
-    should "be verbose by default" do
-      assert subject.verbose
+    should "initialize Ardb, migrate the db and dump schema via the adapter" do
+      assert_equal true, @ardb_init_called
+      assert_equal true, @adapter_spy.migrate_db_called?
+      assert_equal true, @adapter_spy.dump_schema_called?
     end
 
   end
 
-  class VersionTests < UnitTests
-    desc "with a version ENV setting"
+  class RunWithCmdErrorTests < InitTests
+    desc "and run with command errors"
     setup do
-      ENV["VERSION"] = '12345'
-      @cmd = Ardb::Runner::MigrateCommand.new
-    end
-    teardown do
-      ENV["VERSION"] = nil
+      Assert.stub(@adapter_spy, :migrate_db){ raise Ardb::Runner::CmdError.new }
     end
 
-    should "should target the given version" do
-      assert_equal 12345, subject.version
+    should "not handle the error" do
+      assert_raises(Ardb::Runner::CmdError){ subject.run }
     end
 
   end
 
-  class VerboseTests < UnitTests
-    desc "with a verbose ENV setting"
+  class RunWithUnspecifiedErrorTests < InitTests
+    desc "and run with a standard error"
     setup do
-      ENV["VERBOSE"] = 'no'
-      @cmd = Ardb::Runner::MigrateCommand.new
-    end
-    teardown do
-      ENV["VERBOSE"] = nil
+      Assert.stub(@adapter_spy, :migrate_db){ raise StandardError.new }
     end
 
-    should "turn off verbose mode if not set to 'true'" do
-      assert_not subject.verbose
+    should "raise a CmdFail error" do
+      assert_raises(Ardb::Runner::CmdFail){ subject.run }
     end
 
   end

data/test/unit/test_helpers_tests.rb

@@ -1,4 +1,5 @@
 require 'assert'
+require 'ardb/adapter_spy'
 require 'ardb/test_helpers'
 
 module Ardb::TestHelpers
@@ -7,7 +8,9 @@ module Ardb::TestHelpers
     desc "Ardb test helpers"
     subject{ Ardb::TestHelpers }
 
-    should have_imeths :drop_tables, :load_schema, :reset_db, :reset_db!
+    should have_imeths :drop_tables, :load_schema
+    should have_imeths :create_db!, :create_db, :drop_db!, :drop_db
+    should have_imeths :migrate_db!, :migrate_db, :reset_db, :reset_db!
 
   end
 
@@ -45,6 +48,69 @@ module Ardb::TestHelpers
 
   end
 
+  class CreateDbTests < UsageTests
+    desc "create db method"
+
+    should "tell the adapter to create the db only once" do
+      assert_equal 0, @adapter_spy.create_db_called_count
+      subject.create_db
+      assert_equal 1, @adapter_spy.create_db_called_count
+      subject.create_db
+      assert_equal 1, @adapter_spy.create_db_called_count
+    end
+
+    should "force the adapter to create a db" do
+      assert_equal 0, @adapter_spy.create_db_called_count
+      subject.create_db!
+      assert_equal 1, @adapter_spy.create_db_called_count
+      subject.create_db!
+      assert_equal 2, @adapter_spy.create_db_called_count
+    end
+
+  end
+
+  class DropDbTests < UsageTests
+    desc "drop db methods"
+
+    should "tell the adapter to drop the db only once" do
+      assert_equal 0, @adapter_spy.drop_db_called_count
+      subject.drop_db
+      assert_equal 1, @adapter_spy.drop_db_called_count
+      subject.drop_db
+      assert_equal 1, @adapter_spy.drop_db_called_count
+    end
+
+    should "force the adapter to drop a db" do
+      assert_equal 0, @adapter_spy.drop_db_called_count
+      subject.drop_db!
+      assert_equal 1, @adapter_spy.drop_db_called_count
+      subject.drop_db!
+      assert_equal 2, @adapter_spy.drop_db_called_count
+    end
+
+  end
+
+  class MigrateDbTests < UsageTests
+    desc "migrate db methods"
+
+    should "tell the adapter to migrate the db only once" do
+      assert_equal 0, @adapter_spy.migrate_db_called_count
+      subject.migrate_db
+      assert_equal 1, @adapter_spy.migrate_db_called_count
+      subject.migrate_db
+      assert_equal 1, @adapter_spy.migrate_db_called_count
+    end
+
+    should "force the adapter to migrate a db" do
+      assert_equal 0, @adapter_spy.migrate_db_called_count
+      subject.migrate_db!
+      assert_equal 1, @adapter_spy.migrate_db_called_count
+      subject.migrate_db!
+      assert_equal 2, @adapter_spy.migrate_db_called_count
+    end
+
+  end
+
   class ResetDbTests < UsageTests
     desc "reset db methods"
 

data/test/unit/use_db_default_tests.rb

@@ -15,36 +15,36 @@ module Ardb::UseDbDefault
     end
     subject{ @record_class }
 
-    should have_imeths :use_db_default, :use_db_default_attrs
+    should have_imeths :use_db_default, :ardb_use_db_default_attrs
 
     should "know its use db default attrs" do
-      assert_equal [], subject.use_db_default_attrs
+      assert_equal [], subject.ardb_use_db_default_attrs
     end
 
     should "add use db default attributes using `use_db_default`" do
       attr_name = Factory.string
       subject.use_db_default(attr_name)
-      assert_includes attr_name, subject.use_db_default_attrs
+      assert_includes attr_name, subject.ardb_use_db_default_attrs
 
       attr_names = [Factory.string, Factory.string.to_sym]
       subject.use_db_default(*attr_names)
       attr_names.each do |attr_name|
-        assert_includes attr_name.to_s, subject.use_db_default_attrs
+        assert_includes attr_name.to_s, subject.ardb_use_db_default_attrs
       end
     end
 
     should "not add duplicate attributes using `use_db_default`" do
       attr_name = Factory.string
       subject.use_db_default(attr_name)
-      assert_equal [attr_name], subject.use_db_default_attrs
+      assert_equal [attr_name], subject.ardb_use_db_default_attrs
 
       subject.use_db_default(attr_name)
-      assert_equal [attr_name], subject.use_db_default_attrs
+      assert_equal [attr_name], subject.ardb_use_db_default_attrs
 
       more_attr_names = [attr_name, Factory.string]
       subject.use_db_default(*more_attr_names)
       exp = ([attr_name] + more_attr_names).uniq
-      assert_equal exp, subject.use_db_default_attrs
+      assert_equal exp, subject.ardb_use_db_default_attrs
     end
 
     should "add an around create callback" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ardb
 version: !ruby/object:Gem::Version 
-  hash: 127
+  hash: 123
   prerelease: 
   segments: 
   - 0
-  - 24
+  - 25
   - 0
-  version: 0.24.0
+  version: 0.25.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2015-10-22 00:00:00 Z
+date: 2015-12-03 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -118,6 +118,7 @@ files:
 - lib/ardb/adapter/sqlite.rb
 - lib/ardb/adapter_spy.rb
 - lib/ardb/cli.rb
+- lib/ardb/has_slug.rb
 - lib/ardb/migration_helpers.rb
 - lib/ardb/record_spy.rb
 - lib/ardb/relation_spy.rb
@@ -141,6 +142,7 @@ files:
 - test/unit/adapter_spy_tests.rb
 - test/unit/ardb_tests.rb
 - test/unit/config_tests.rb
+- test/unit/has_slug_tests.rb
 - test/unit/migration_helpers_tests.rb
 - test/unit/record_spy_tests.rb
 - test/unit/relation_spy_tests.rb
@@ -194,7 +196,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.8.29
 signing_key: 
 specification_version: 3
 summary: Activerecord database tools.
@@ -208,6 +210,7 @@ test_files:
 - test/unit/adapter_spy_tests.rb
 - test/unit/ardb_tests.rb
 - test/unit/config_tests.rb
+- test/unit/has_slug_tests.rb
 - test/unit/migration_helpers_tests.rb
 - test/unit/record_spy_tests.rb
 - test/unit/relation_spy_tests.rb