ardb 0.27.0 → 0.27.1

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  data.tar.gz: bd6e2e2855ebc107bc3da24642e8a996da2fa06b
+  metadata.gz: fb550afe9e0c76af643938e94fb4fcab9fe1afeb
+SHA512: 
+  data.tar.gz: bdd10e94e00e33f2800be95666efed91518da00f3109e73e1878e341fa6ad5a384f5a7d78f5ebaa07b7ed136bd6b122fdd29dea43c2242c746986a71d9fb092e
+  metadata.gz: 51e6669ff3c303a14bcec3e5eb15c0dbb7442216257a1479421588de0a4e675eb9dc54bd068d9519b9dc1bbbccbf8756cba59d563529fa6dff6ad71d2debccd1

data/lib/ardb.rb

@@ -23,6 +23,7 @@ module Ardb
   end
 
   def self.init(establish_connection = true)
+    require 'ardb/require_autoloaded_active_record_files'
     require self.config.db_file
     validate!
     Adapter.init

data/lib/ardb/has_slug.rb

@@ -13,8 +13,7 @@ module Ardb
       extend ClassMethods
       include InstanceMethods
 
-      @ardb_has_slug_config = {}
-
+      @ardb_has_slug_configs = Hash.new{ |h, k| h[k] = {} }
     end
 
     module ClassMethods
@@ -23,8 +22,8 @@ module Ardb
         options ||= {}
         raise(ArgumentError, "a source must be provided") unless options[:source]
 
-        @ardb_has_slug_config.merge!({
-          :attribute         => options[:attribute] || DEFAULT_ATTRIBUTE,
+        attribute = (options[:attribute] || DEFAULT_ATTRIBUTE).to_sym
+        @ardb_has_slug_configs[attribute].merge!({
           :source_proc       => options[:source].to_proc,
           :preprocessor_proc => (options[:preprocessor] || DEFAULT_PREPROCESSOR).to_proc,
           :separator         => options[:separator] || DEFAULT_SEPARATOR,
@@ -33,18 +32,18 @@ module Ardb
 
         # 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], {
+        validates_presence_of(attribute, :on => :update)
+        validates_uniqueness_of(attribute, {
           :case_sensitive => true,
           :scope          => options[:unique_scope]
         })
 
-        after_create :ardb_has_slug_generate_slug
-        after_update :ardb_has_slug_generate_slug
+        after_create :ardb_has_slug_generate_slugs
+        after_update :ardb_has_slug_generate_slugs
       end
 
-      def ardb_has_slug_config
-        @ardb_has_slug_config
+      def ardb_has_slug_configs
+        @ardb_has_slug_configs
       end
 
     end
@@ -53,37 +52,37 @@ module Ardb
 
       private
 
-      def reset_slug
-        self.send("#{self.class.ardb_has_slug_config[:attribute]}=", nil)
+      def reset_slug(attribute = nil)
+        attribute ||= DEFAULT_ATTRIBUTE
+        self.send("#{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)
+      def ardb_has_slug_generate_slugs
+        self.class.ardb_has_slug_configs.each do |attr_name, config|
+          slug_source = if !self.send(attr_name) || self.send(attr_name).to_s.empty?
+            self.instance_eval(&config[:source_proc])
+          else
+            self.send(attr_name)
+          end
+
+          generated_slug = Slug.new(slug_source, {
+            :preprocessor      => config[:preprocessor_proc],
+            :separator         => config[:separator],
+            :allow_underscores => config[:allow_underscores]
+          })
+          next if self.send(attr_name) == generated_slug
+          self.send("#{attr_name}=", generated_slug)
+          self.update_column(attr_name, generated_slug)
         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
+        preprocessor       = options[:preprocessor]
+        separator          = options[:separator]
         allow_underscores  = options[:allow_underscores]
         regexp_escaped_sep = Regexp.escape(separator)
 

data/lib/ardb/require_autoloaded_active_record_files.rb

@@ -0,0 +1,69 @@
+# ActiveRecord makes use of autoload to load some of its components as-needed.
+# This doesn't work well with threaded environments, and causes uninitialized
+# constants. To avoid this, this file manually requires the following files that
+# are not required using `require 'active_record'`. Trying to automatically
+# require every file in ActiveRecord is slow and inefficient. Many of the files
+# fail to require and there are some we don't want to require. Thus, this is a
+# manual list of requires.
+
+# To re-build this list of requires, run the following:
+#   bundle exec ruby script/determine_autoloaded_active_record_files.rb
+
+# For compatibility, we require active record first
+require 'active_record'
+
+require 'active_record/aggregations'
+require 'active_record/associations'
+require 'active_record/associations/alias_tracker'
+require 'active_record/associations/association'
+require 'active_record/associations/association_scope'
+require 'active_record/associations/belongs_to_association'
+require 'active_record/associations/belongs_to_polymorphic_association'
+require 'active_record/associations/builder/association'
+require 'active_record/associations/builder/belongs_to'
+require 'active_record/associations/builder/collection_association'
+require 'active_record/associations/builder/has_and_belongs_to_many'
+require 'active_record/associations/builder/has_many'
+require 'active_record/associations/builder/has_one'
+require 'active_record/associations/collection_association'
+require 'active_record/associations/collection_proxy'
+require 'active_record/associations/has_and_belongs_to_many_association'
+require 'active_record/associations/has_many_association'
+require 'active_record/associations/has_many_through_association'
+require 'active_record/associations/has_one_association'
+require 'active_record/associations/has_one_through_association'
+require 'active_record/associations/join_dependency'
+require 'active_record/associations/join_dependency/join_association'
+require 'active_record/associations/join_dependency/join_base'
+require 'active_record/associations/preloader'
+require 'active_record/associations/preloader/association'
+require 'active_record/associations/preloader/belongs_to'
+require 'active_record/associations/preloader/collection_association'
+require 'active_record/associations/preloader/has_and_belongs_to_many'
+require 'active_record/associations/preloader/has_many'
+require 'active_record/associations/preloader/has_many_through'
+require 'active_record/associations/preloader/has_one'
+require 'active_record/associations/preloader/has_one_through'
+require 'active_record/attribute_assignment'
+require 'active_record/attribute_methods/before_type_cast'
+require 'active_record/attribute_methods/deprecated_underscore_read'
+require 'active_record/attribute_methods/dirty'
+require 'active_record/attribute_methods/primary_key'
+require 'active_record/attribute_methods/query'
+require 'active_record/attribute_methods/read'
+require 'active_record/attribute_methods/serialization'
+require 'active_record/attribute_methods/time_zone_conversion'
+require 'active_record/autosave_association'
+require 'active_record/base'
+require 'active_record/dynamic_finder_match'
+require 'active_record/dynamic_scope_match'
+require 'active_record/observer'
+require 'active_record/relation'
+require 'active_record/relation/predicate_builder'
+require 'active_record/result'
+
+# There are also issues with requiring ActiveSupport. This doesn't require every
+# ActiveSupport file though, only ones we've seen cause problems.
+require 'active_support'
+
+require 'active_support/multibyte/chars'

data/lib/ardb/version.rb

@@ -1,3 +1,3 @@
 module Ardb
-  VERSION = "0.27.0"
+  VERSION = "0.27.1"
 end

data/script/determine_autoloaded_active_record_files.rb

@@ -0,0 +1,91 @@
+require 'active_record'
+
+# this can be slow, this is one of the reasons this shouldn't be done during
+# the startup of our apps
+gemspec = Gem.loaded_specs['activerecord']
+
+puts "Looking at files in: "
+puts "  #{gemspec.lib_dirs_glob.inspect}"
+
+paths = Dir["#{gemspec.lib_dirs_glob}/**/*.rb"]
+
+# these are regexs for files we want to ignore requiring. for example,
+# generators fail when we try to require them. the others are pieces of active
+# record we don't use in a production environment
+ignored_regexes = [
+  /rails\/generators/,
+  /active_record\/railtie/,
+  /active_record\/migration/,
+  /active_record\/fixtures/,
+  /active_record\/schema/,
+  /active_record\/connection_adapters/,
+  /active_record\/test_case/,
+  /active_record\/coders\/yaml_column/
+]
+
+Result = Struct.new(:file, :state, :reason)
+
+already_required     = []
+needs_to_be_required = []
+ignored              = []
+errored              = []
+
+paths.sort.each do |full_path|
+  relative_path_with_rb = full_path.gsub("#{gemspec.lib_dirs_glob}/", '')
+  relative_path = relative_path_with_rb.gsub(/\.rb\z/, '')
+
+  result = Result.new(relative_path)
+
+  # see if it's ignored
+  ignored_regexes.each do |regex|
+    if relative_path =~ regex
+      result.state  = :ignored
+      result.reason = "matched #{regex}"
+      break
+    end
+  end
+  if result.state == :ignored
+    ignored << result
+    next
+  end
+
+  # try requiring the file
+  begin
+    if result.state = require(relative_path)
+      needs_to_be_required << result
+    else
+      already_required << result
+    end
+  rescue LoadError, SyntaxError => exception
+    result.state  = :errored
+    result.reason = "#{exception.class}: #{exception.message}"
+    errored << result
+  end
+end
+
+puts "Results\n"
+
+puts "Ignored:"
+ignored.each do |result|
+  puts "  #{result.file}"
+  puts "    #{result.reason}"
+end
+puts "\n"
+
+puts "Errored:"
+errored.each do |result|
+  puts "  #{result.file}"
+  puts "    #{result.reason}"
+end
+puts "\n"
+
+puts "Already Required:"
+already_required.each do |result|
+  puts "  #{result.file}"
+end
+puts "\n"
+
+puts "Needs To Be Required:\n"
+needs_to_be_required.each do |result|
+  puts "require '#{result.file}'"
+end

data/test/unit/has_slug_tests.rb

@@ -13,12 +13,12 @@ module Ardb::HasSlug
       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
+        attr_accessor source_attribute, slug_attribute, DEFAULT_ATTRIBUTE
+        attr_reader :slug_db_column_updates
 
-        def update_column(name, value)
-          @slug_db_column_name  = name
-          @slug_db_column_value = value
+        def update_column(*args)
+          @slug_db_column_updates ||= []
+          @slug_db_column_updates << args
         end
       end
     end
@@ -28,10 +28,10 @@ module Ardb::HasSlug
                      ('{'..'~').to_a - ['-', '_']).freeze
 
     should have_imeths :has_slug
-    should have_imeths :ardb_has_slug_config
+    should have_imeths :ardb_has_slug_configs
 
     should "use much-plugin" do
-      assert_includes MuchPlugin, Ardb::UseDbDefault
+      assert_includes MuchPlugin, Ardb::HasSlug
     end
 
     should "know its default attribute, preprocessor and separator" do
@@ -40,8 +40,8 @@ module Ardb::HasSlug
       assert_equal '-',       DEFAULT_SEPARATOR
     end
 
-    should "not have any has-slug config by default" do
-      assert_equal({}, subject.ardb_has_slug_config)
+    should "not have any has-slug configs by default" do
+      assert_equal({}, subject.ardb_has_slug_configs)
     end
 
     should "default the has slug config using `has_slug`" do
@@ -49,17 +49,17 @@ module Ardb::HasSlug
       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]
+      config = subject.ardb_has_slug_configs[DEFAULT_ATTRIBUTE]
+      assert_equal DEFAULT_SEPARATOR, config[:separator]
+      assert_false config[:allow_underscores]
 
-      source_proc = subject.ardb_has_slug_config[:source_proc]
+      source_proc = 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]
+      preprocessor_proc = config[:preprocessor_proc]
       assert_instance_of Proc, preprocessor_proc
       exp = upcase_string.send(DEFAULT_PREPROCESSOR)
       assert_equal exp, preprocessor_proc.call(upcase_string)
@@ -76,27 +76,28 @@ module Ardb::HasSlug
         :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]
+      config = subject.ardb_has_slug_configs[@slug_attribute]
+      assert_equal separator,        config[:separator]
+      assert_equal allow_underscore, config[:allow_underscores]
 
       value = Factory.string.downcase
-      preprocessor_proc = subject.ardb_has_slug_config[:preprocessor_proc]
+      preprocessor_proc = 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
+      exp_attr_name = DEFAULT_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 [exp_attr_name], 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 [exp_attr_name], validation.columns
       assert_equal true, validation.options[:case_sensitive]
       assert_nil validation.options[:scope]
     end
@@ -118,11 +119,11 @@ module Ardb::HasSlug
 
       callback = subject.callbacks.find{ |v| v.type == :after_create }
       assert_not_nil callback
-      assert_equal [:ardb_has_slug_generate_slug], callback.args
+      assert_equal [:ardb_has_slug_generate_slugs], callback.args
 
       callback = subject.callbacks.find{ |v| v.type == :after_update }
       assert_not_nil callback
-      assert_equal [:ardb_has_slug_generate_slug], callback.args
+      assert_equal [:ardb_has_slug_generate_slugs], callback.args
     end
 
     should "raise an argument error if `has_slug` isn't passed a source" do
@@ -137,6 +138,8 @@ module Ardb::HasSlug
       @preprocessor      = [:downcase, :upcase, :capitalize].choice
       @separator         = NON_WORD_CHARS.choice
       @allow_underscores = Factory.boolean
+
+      @record_class.has_slug(:source => @source_attribute)
       @record_class.has_slug({
         :attribute         => @slug_attribute,
         :source            => @source_attribute,
@@ -152,112 +155,121 @@ module Ardb::HasSlug
       # generating a slug
       @source_value = "#{Factory.string.downcase}_#{Factory.string.upcase}"
       @record.send("#{@source_attribute}=", @source_value)
+
+      @exp_default_slug = Slug.new(@source_value, {
+        :preprocessor => DEFAULT_PREPROCESSOR.to_proc,
+        :separator    => DEFAULT_SEPARATOR
+      })
+      @exp_custom_slug = Slug.new(@source_value, {
+        :preprocessor      => @preprocessor.to_proc,
+        :separator         => @separator,
+        :allow_underscores => @allow_underscores
+      })
     end
     subject{ @record }
 
     should "reset its slug using `reset_slug`" do
+      # reset the default attribute
+      subject.send("#{DEFAULT_ATTRIBUTE}=", Factory.slug)
+      assert_not_nil subject.send(DEFAULT_ATTRIBUTE)
+      subject.instance_eval{ reset_slug }
+      assert_nil subject.send(DEFAULT_ATTRIBUTE)
+
+      # reset a custom attribute
       subject.send("#{@slug_attribute}=", Factory.slug)
       assert_not_nil subject.send(@slug_attribute)
-      subject.instance_eval{ reset_slug }
+      sa = @slug_attribute
+      subject.instance_eval{ reset_slug(sa) }
       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 }
+    should "default its slug attribute" do
+      subject.instance_eval{ ardb_has_slug_generate_slugs }
+      assert_equal 2, subject.slug_db_column_updates.size
 
-      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
+      exp = @exp_default_slug
+      assert_equal exp, subject.send(DEFAULT_ATTRIBUTE)
+      assert_includes [DEFAULT_ATTRIBUTE, exp], subject.slug_db_column_updates
+
+      exp = @exp_custom_slug
+      assert_equal exp,                    subject.send(@slug_attribute)
+      assert_includes [@slug_attribute, exp], subject.slug_db_column_updates
+    end
+
+    should "not set its slug if it hasn't changed" do
+      @record.send("#{DEFAULT_ATTRIBUTE}=", @exp_default_slug)
+      @record.send("#{@slug_attribute}=",   @exp_custom_slug)
+
+      subject.instance_eval{ ardb_has_slug_generate_slugs }
+      assert_nil subject.slug_db_column_updates
     end
 
-    should "slug its slug attribute value if set using `ardb_has_slug_generate_slug`" do
+    should "slug its slug attribute value if set" 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 }
+      subject.instance_eval{ ardb_has_slug_generate_slugs }
 
-      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
+      exp = @exp_custom_slug
+      assert_equal exp, subject.send(@slug_attribute)
+      assert_includes [@slug_attribute, exp], subject.slug_db_column_updates
     end
 
-    should "slug its source even if its already a valid slug using `ardb_has_slug_generate_slug`" do
+    should "slug its source even if its already a valid 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 }
+      subject.instance_eval{ ardb_has_slug_generate_slugs }
 
       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
+      assert_equal exp, subject.send(@slug_attribute)
+      assert_includes [@slug_attribute, exp], subject.slug_db_column_updates
     end
 
   end
 
   class SlugTests < UnitTests
     desc "Slug"
+    setup do
+      @no_op_pp = proc{ |slug| slug }
+      @args = {
+        :preprocessor => @no_op_pp,
+        :separator    => '-'
+      }
+    end
     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)
+      assert_equal string, subject.new(string, @args)
+
       string = "#{Factory.string}-#{Factory.string.upcase}"
-      assert_equal string, subject.new(string)
+      assert_equal string, subject.new(string, @args)
     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)
+      assert_equal string.gsub(/[^\w]+/, '-'), subject.new(string, @args)
     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
+      exp = string.downcase
+      assert_equal exp, subject.new(string, @args.merge(:preprocessor => :downcase.to_proc))
 
       preprocessor = proc{ |s| s.gsub(/[A-Z]/, 'a') }
-      slug = subject.new(string, :preprocessor => preprocessor)
-      assert_equal preprocessor.call(string), slug
+      exp = preprocessor.call(string)
+      assert_equal exp, subject.new(string, @args.merge(:preprocessor => preprocessor))
     end
 
     should "allow passing a custom separator" do
@@ -265,47 +277,48 @@ module Ardb::HasSlug
 
       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
+      exp = string.gsub(/[^\w]+/, separator)
+      assert_equal exp, subject.new(string, @args.merge(:separator => separator))
 
       # it won't change the separator in the strings
       string = "#{Factory.string}#{separator}#{Factory.string}"
-      assert_equal string, subject.new(string, :separator => separator)
+      exp = string
+      assert_equal string, subject.new(string, @args.merge(: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
+      exp = string.gsub('-', separator)
+      assert_equal exp, subject.new(string, @args.merge(:separator => separator))
     end
 
     should "change underscores into its separator unless allowed" do
       string = "#{Factory.string}_#{Factory.string}"
-      assert_equal string.gsub('_', '-'), subject.new(string)
+      assert_equal string.gsub('_', '-'), subject.new(string, @args)
 
-      slug = subject.new(string, :allow_underscores => false)
-      assert_equal string.gsub('_', '-'), slug
+      exp = string.gsub('_', '-')
+      assert_equal exp, subject.new(string, @args.merge(:allow_underscores => false))
 
-      assert_equal string, subject.new(string, :allow_underscores => true)
+      assert_equal string, subject.new(string, @args.merge(: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)
+      assert_equal string.gsub(/-{2,}/, '-'), subject.new(string, @args)
 
       # 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)
+      assert_equal string.gsub(/[^\w]+/, '-'), subject.new(string, @args)
     end
 
     should "remove leading and trailing separators" do
       string = "-#{Factory.string}-#{Factory.string}-"
-      assert_equal string[1..-2], subject.new(string)
+      assert_equal string[1..-2], subject.new(string, @args)
 
       # 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)
+      assert_equal string[1..-2], subject.new(string, @args)
     end
 
   end

metadata

@@ -1,13 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ardb
 version: !ruby/object:Gem::Version 
-  hash: 115
-  prerelease: 
-  segments: 
-  - 0
-  - 27
-  - 0
-  version: 0.27.0
+  version: 0.27.1
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,98 +10,67 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2015-12-18 00:00:00 Z
+date: 2016-03-09 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
+  name: assert
+  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 29
-        segments: 
-        - 2
-        - 15
         version: "2.15"
   type: :development
-  name: assert
   version_requirements: *id001
-  prerelease: false
 - !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 3
-        - 2
+      - &id003 !ruby/object:Gem::Version 
         version: "3.2"
   type: :runtime
-  name: activerecord
   version_requirements: *id002
-  prerelease: false
 - !ruby/object:Gem::Dependency 
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 3
-        - 2
-        version: "3.2"
-  type: :runtime
   name: activesupport
-  version_requirements: *id003
   prerelease: false
-- !ruby/object:Gem::Dependency 
   requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 9
-        segments: 
-        - 0
-        - 1
-        version: "0.1"
+      - *id003
   type: :runtime
-  name: much-plugin
   version_requirements: *id004
-  prerelease: false
 - !ruby/object:Gem::Dependency 
+  name: much-plugin
+  prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 1
-        - 1
-        version: "1.1"
+        version: "0.1"
   type: :runtime
-  name: ns-options
   version_requirements: *id005
-  prerelease: false
 - !ruby/object:Gem::Dependency 
+  name: ns-options
+  prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 3
-        - 0
-        version: "3.0"
+        version: "1.1"
   type: :runtime
-  name: scmd
   version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: scmd
   prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id007
 description: Activerecord database tools.
 email: 
 - kelly@kellyredding.com
@@ -140,11 +103,13 @@ files:
 - lib/ardb/migration_helpers.rb
 - lib/ardb/record_spy.rb
 - lib/ardb/relation_spy.rb
+- lib/ardb/require_autoloaded_active_record_files.rb
 - lib/ardb/root_path.rb
 - lib/ardb/test_helpers.rb
 - lib/ardb/use_db_default.rb
 - lib/ardb/version.rb
 - log/.gitkeep
+- script/determine_autoloaded_active_record_files.rb
 - test/helper.rb
 - test/support/factory.rb
 - test/unit/adapter/base_tests.rb
@@ -179,35 +144,28 @@ files:
 homepage: http://github.com/redding/ardb
 licenses: 
 - MIT
+metadata: {}
+
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
-  - - ">="
+  - &id008 
+    - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  - *id008
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Activerecord database tools.
 test_files: 
 - test/helper.rb