much-slug 0.1.0 → 0.1.1

data/test/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # this file is automatically required when you run `assert`
 # put any test helpers here
 
@@ -5,17 +7,8 @@
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
 # require pry for debugging (`binding.pry`)
-require 'pry'
-
-require 'test/support/factory'
-
-# 1.8.7 backfills
+require "pry"
 
-# Array#sample
-if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
-  class Array
-    alias_method :sample, :choice
-  end
-end
+require "test/support/factory"
 
 # TODO: put test helpers here...

data/test/support/factory.rb

@@ -1,15 +1,16 @@
-require 'assert/factory'
+# frozen_string_literal: true
+
+require "assert/factory"
 
 module Factory
   extend Assert::Factory
 
   def self.non_word_chars
-    ( (" ".."/").to_a +
+    ((" ".."/").to_a +
       (":".."@").to_a +
       ("[".."`").to_a +
       ("{".."~").to_a -
       ["-", "_"]
     ).freeze
   end
-
 end

data/test/unit/activerecord_tests.rb

@@ -1,18 +1,39 @@
+# frozen_string_literal: true
+
 require "assert"
 require "much-slug/activerecord"
 
-require "much-plugin"
 require "ardb/record_spy"
 
 module MuchSlug::ActiveRecord
   class UnitTests < Assert::Context
     desc "MuchSlug::ActiveRecord"
+    subject{ unit_module }
+
+    let(:unit_module){ MuchSlug::ActiveRecord }
+  end
+
+  class ReceiverTests < UnitTests
+    desc "receiver"
+    subject{ receiver_class }
+
     setup do
-      source_attribute = @source_attribute = Factory.string.to_sym
-      slug_attribute   = @slug_attribute   = Factory.string
-      @record_class = Ardb::RecordSpy.new do
+      Assert.stub_tap_on_call(
+        receiver_class.much_slug_has_slug_registry,
+        :register,
+      ) do |_, call|
+        @register_call = call
+      end
+    end
+
+    let(:receiver_class) do
+      attr_source_attribute = source_attribute
+      attr_slug_attribute   = slug_attribute
+
+      Ardb::RecordSpy.new do
         include MuchSlug::ActiveRecord
-        attr_accessor source_attribute, slug_attribute, MuchSlug.default_attribute
+        attr_accessor attr_source_attribute, attr_slug_attribute
+        attr_accessor MuchSlug.default_attribute
         attr_reader :slug_db_column_updates
         attr_reader :save_called, :save_bang_called
 
@@ -21,208 +42,222 @@ module MuchSlug::ActiveRecord
           @slug_db_column_updates << args
         end
       end
-
-      @has_slug_attribute = Factory.string
-      @has_slug_preprocessor = :downcase
-      @has_slug_separator = Factory.non_word_chars.sample
-      @has_slug_allow_underscores = Factory.boolean
-
-      Assert.stub_tap(@record_class.much_slug_has_slug_registry, :register) { |**kargs|
-        @register_called_with = kargs
-      }
     end
-    subject{ @record_class }
+    let(:source_attribute){ Factory.symbol }
+    let(:slug_attribute){ Factory.string }
+
+    let(:has_slug_attribute){ Factory.string }
+    let(:has_slug_preprocessor){ :downcase }
+    let(:has_slug_separator){ Factory.non_word_chars.sample }
+    let(:has_slug_allow_underscores){ Factory.boolean }
 
     should have_imeths :has_slug
     should have_imeths :much_slug_has_slug_registry
 
     should "not have any has_slug registry entries by default" do
-      assert_kind_of MuchSlug::HasSlugRegistry, subject.much_slug_has_slug_registry
-      assert_empty subject.much_slug_has_slug_registry
+      assert_that(subject.much_slug_has_slug_registry)
+        .is_an_instance_of(MuchSlug::HasSlugRegistry)
+      assert_that(subject.much_slug_has_slug_registry.empty?).is_true
     end
 
     should "register a new has_slug entry using `has_slug`" do
       subject.has_slug(
-        source: @source_attribute,
-        attribute: @has_slug_attribute,
-        preprocessor: @has_slug_preprocessor,
-        separator: @has_slug_separator,
-        allow_underscores: @has_slug_allow_underscores
+        source:            source_attribute,
+        attribute:         has_slug_attribute,
+        preprocessor:      has_slug_preprocessor,
+        separator:         has_slug_separator,
+        allow_underscores: has_slug_allow_underscores,
       )
 
-      exp_kargs = {
-        attribute: @has_slug_attribute,
-        source: @source_attribute,
-        preprocessor: @has_slug_preprocessor,
-        separator: @has_slug_separator,
-        allow_underscores: @has_slug_allow_underscores
-      }
-      assert_equal exp_kargs, @register_called_with
+      assert_that(@register_call.kargs)
+        .equals(
+          attribute:         has_slug_attribute,
+          source:            source_attribute,
+          preprocessor:      has_slug_preprocessor,
+          separator:         has_slug_separator,
+          allow_underscores: has_slug_allow_underscores,
+        )
     end
 
     should "add validations using `has_slug`" do
       subject.has_slug(
-        source: @source_attribute,
-        attribute: @has_slug_attribute
+        source:    source_attribute,
+        attribute: has_slug_attribute,
       )
-      exp_attr_name = @has_slug_attribute
 
       validation = subject.validations.find{ |v| v.type == :presence }
-      assert_not_nil validation
-      assert_equal [exp_attr_name], validation.columns
-      assert_equal :update, validation.options[:on]
+      assert_that(validation).is_not_nil
+      assert_that(validation.columns).equals([has_slug_attribute])
+      assert_that(validation.options[:on]).equals(:update)
 
       validation = subject.validations.find{ |v| v.type == :uniqueness }
-      assert_not_nil validation
-      assert_equal [exp_attr_name], validation.columns
-      assert_equal true, validation.options[:case_sensitive]
-      assert_nil validation.options[:scope]
-      assert_equal true, validation.options[:allow_nil]
-      assert_equal true, validation.options[:allow_blank]
+      assert_that(validation).is_not_nil
+      assert_that(validation.columns).equals([has_slug_attribute])
+      assert_that(validation.options[:case_sensitive]).is_true
+      assert_that(validation.options[:scope]).is_nil
+      assert_that(validation.options[:allow_nil]).is_true
+      assert_that(validation.options[:allow_blank]).is_true
     end
 
     should "not add a unique validation if skipping unique validation" do
       subject.has_slug(
-        source: @source_attribute,
-        attribute: @has_slug_attribute,
-        skip_unique_validation: true
+        source:                 source_attribute,
+        attribute:              has_slug_attribute,
+        skip_unique_validation: true,
       )
 
       validation = subject.validations.find{ |v| v.type == :uniqueness }
-      assert_nil validation
+      assert_that(validation).is_nil
     end
 
     should "allow customizing its validations using `has_slug`" do
       unique_scope = Factory.string.to_sym
       subject.has_slug(
-        source: @source_attribute,
-        attribute: @has_slug_attribute,
-        unique_scope: unique_scope
+        source:       source_attribute,
+        attribute:    has_slug_attribute,
+        unique_scope: unique_scope,
       )
 
       validation = subject.validations.find{ |v| v.type == :uniqueness }
-      assert_not_nil validation
-      assert_equal unique_scope, validation.options[:scope]
+      assert_that(validation).is_not_nil
+      assert_that(validation.options[:scope]).equals(unique_scope)
     end
 
     should "add callbacks using `has_slug`" do
-      subject.has_slug(source: @source_attribute)
+      subject.has_slug(source: source_attribute)
 
       callback = subject.callbacks.find{ |v| v.type == :after_create }
-      assert_not_nil callback
-      assert_equal [:much_slug_has_slug_update_slug_values], callback.args
+      assert_that(callback).is_not_nil
+      assert_that(callback.args)
+        .equals([:much_slug_has_slug_update_slug_values])
 
       callback = subject.callbacks.find{ |v| v.type == :after_update }
-      assert_not_nil callback
-      assert_equal [:much_slug_has_slug_update_slug_values], callback.args
+      assert_that(callback).is_not_nil
+      assert_that(callback.args)
+        .equals([:much_slug_has_slug_update_slug_values])
     end
 
     should "raise an argument error if `has_slug` isn't passed a source" do
-      assert_raises(ArgumentError){ subject.has_slug }
+      assert_that{
+        subject.has_slug
+      }.raises(ArgumentError)
     end
   end
 
-  class InitTests < UnitTests
+  class ReceiverInitTests < ReceiverTests
     desc "when init"
+    subject{ receiver }
+
     setup do
-      @preprocessor      = [:downcase, :upcase, :capitalize].sample
-      @separator         = Factory.non_word_chars.sample
-      @allow_underscores = Factory.boolean
-
-      @registered_default_attribute =
-        @record_class.has_slug(source: @source_attribute)
-
-      source_attribute = @source_attribute
-      @registered_custom_attribute =
-        @record_class.has_slug(
-          source:            -> { self.send(source_attribute) },
-          attribute:         @slug_attribute,
-          preprocessor:      @preprocessor,
-          separator:         @separator,
-          allow_underscores: @allow_underscores
-        )
+      registered_default_attribute
+      registered_custom_attribute
 
-      @record = @record_class.new
+      subject.public_send("#{source_attribute}=", source_value)
+    end
 
-      # 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)
+    let(:receiver){ receiver_class.new }
 
-      @exp_default_slug =
-        MuchSlug::Slug.new(
-          @source_value,
-          preprocessor:      MuchSlug.default_preprocessor.to_proc,
-          separator:         MuchSlug.default_separator,
-          allow_underscores: false
-        )
-      @exp_custom_slug =
-        MuchSlug::Slug.new(
-          @source_value,
-          preprocessor:      @preprocessor.to_proc,
-          separator:         @separator,
-          allow_underscores: @allow_underscores
-        )
+    let(:registered_default_attribute) do
+      receiver_class.has_slug(source: source_attribute)
+    end
+    let(:registered_custom_attribute) do
+      block_source_attribute = source_attribute
+
+      receiver_class.has_slug(
+        source:            ->{ public_send(block_source_attribute) },
+        attribute:         slug_attribute,
+        preprocessor:      preprocessor,
+        separator:         separator,
+        allow_underscores: allow_underscores,
+      )
+    end
+    let(:preprocessor){ [:downcase, :upcase, :capitalize].sample }
+    let(:separator){ Factory.non_word_chars.sample }
+    let(:allow_underscores){ Factory.boolean }
+
+    # 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
+    let(:source_value) do
+      "#{Factory.string.downcase}_#{Factory.string.upcase}"
+    end
+
+    let(:exp_default_slug) do
+      MuchSlug::Slug.new(
+        source_value,
+        preprocessor:      MuchSlug.default_preprocessor.to_proc,
+        separator:         MuchSlug.default_separator,
+        allow_underscores: false,
+      )
+    end
+    let(:exp_custom_slug) do
+      MuchSlug::Slug.new(
+        source_value,
+        preprocessor:      preprocessor.to_proc,
+        separator:         separator,
+        allow_underscores: allow_underscores,
+      )
     end
-    subject{ @record }
 
     should "default its slug attribute" do
-      assert_equal MuchSlug.default_attribute, @registered_default_attribute
-      assert_equal @slug_attribute, @registered_custom_attribute
+      assert_that(registered_default_attribute)
+        .equals(MuchSlug.default_attribute)
+      assert_that(registered_custom_attribute).equals(slug_attribute)
 
       subject.instance_eval{ much_slug_has_slug_update_slug_values }
-      assert_equal 2, subject.slug_db_column_updates.size
+      assert_that(subject.slug_db_column_updates.size).equals(2)
 
-      exp = @exp_default_slug
-      assert_equal exp, subject.send(MuchSlug.default_attribute)
-      assert_includes [MuchSlug.default_attribute, exp], subject.slug_db_column_updates
+      assert_that(subject.public_send(MuchSlug.default_attribute))
+        .equals(exp_default_slug)
+      assert_that(subject.slug_db_column_updates)
+        .includes([MuchSlug.default_attribute, exp_default_slug])
 
-      exp = @exp_custom_slug
-      assert_equal exp, subject.send(@slug_attribute)
-      assert_includes [@slug_attribute, exp], subject.slug_db_column_updates
+      assert_that(subject.public_send(slug_attribute)).equals(exp_custom_slug)
+      assert_that(subject.slug_db_column_updates)
+        .includes([slug_attribute, exp_custom_slug])
     end
 
     should "not set its slug if it hasn't changed" do
-      subject.send("#{MuchSlug.default_attribute}=", @exp_default_slug)
-      subject.send("#{@slug_attribute}=",   @exp_custom_slug)
+      subject.public_send("#{MuchSlug.default_attribute}=", exp_default_slug)
+      subject.public_send("#{slug_attribute}=", exp_custom_slug)
 
       subject.instance_eval{ much_slug_has_slug_update_slug_values }
-      assert_nil subject.slug_db_column_updates
+      assert_that(subject.slug_db_column_updates).is_nil
     end
 
     should "slug its source even if its already a valid slug" do
       slug_source = Factory.slug
-      subject.send("#{@source_attribute}=", slug_source)
+      subject.public_send("#{source_attribute}=", slug_source)
       # ensure the preprocessor doesn't change our source
-      Assert.stub(slug_source, @preprocessor){ slug_source }
+      Assert.stub(slug_source, preprocessor){ slug_source }
 
       subject.instance_eval{ much_slug_has_slug_update_slug_values }
 
       exp =
         MuchSlug::Slug.new(
           slug_source,
-          preprocessor:      @preprocessor.to_proc,
-          separator:         @separator,
-          allow_underscores: @allow_underscores
+          preprocessor:      preprocessor.to_proc,
+          separator:         separator,
+          allow_underscores: allow_underscores,
         )
-      assert_equal exp, subject.send(@slug_attribute)
-      assert_includes [@slug_attribute, exp], subject.slug_db_column_updates
+      assert_that(subject.public_send(slug_attribute)).equals(exp)
+      assert_that(subject.slug_db_column_updates)
+        .includes([slug_attribute, exp])
     end
 
     should "manually update slugs" do
-      result = MuchSlug.update_slugs(@record)
-
-      assert_true result
-      assert_equal 2, subject.slug_db_column_updates.size
-
-      exp = @exp_default_slug
-      assert_equal exp, subject.send(MuchSlug.default_attribute)
-      assert_includes [MuchSlug.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
+      result = MuchSlug.update_slugs(subject)
+      assert_that(result).is_true
+      assert_that(subject.slug_db_column_updates.size).equals(2)
+
+      assert_that(subject.public_send(MuchSlug.default_attribute))
+        .equals(exp_default_slug)
+      assert_that(subject.slug_db_column_updates)
+        .includes([MuchSlug.default_attribute, exp_default_slug])
+
+      assert_that(subject.public_send(slug_attribute)).equals(exp_custom_slug)
+      assert_that(subject.slug_db_column_updates)
+        .includes([slug_attribute, exp_custom_slug])
     end
   end
 end

data/test/unit/has_slug_registry_tests.rb

@@ -1,95 +1,90 @@
+# frozen_string_literal: true
+
 require "assert"
 require "much-slug/has_slug_registry"
 
 class MuchSlug::HasSlugRegistry
   class UnitTests < Assert::Context
     desc "MuchSlug::HasSlugRegistry"
-    setup do
-      @class = MuchSlug::HasSlugRegistry
-    end
-    subject{ @class }
+    subject{ unit_class }
 
-    should "subclass Hash" do
-      assert subject < ::Hash
+    let(:unit_class){ MuchSlug::HasSlugRegistry }
+
+    should "be a Hash" do
+      assert_that(subject < ::Hash).is_true
     end
   end
 
   class InitTests < UnitTests
     desc "when init"
-    setup do
-      @attribute = Factory.string.to_sym
-      @source = :to_s
-      @preprocessor = :downcase
-      @separator = "|"
-      @allow_underscores = Factory.boolean
-
-      @registry = @class.new
-    end
-    subject{ @registry }
+    subject{ unit_class.new }
+
+    let(:attribute){ Factory.symbol }
+    let(:source){ :to_s }
+    let(:preprocessor){ :downcase }
+    let(:separator){ "|" }
+    let(:allow_underscores){ Factory.boolean }
 
     should have_imeths :register
 
     should "default empty entries for unregisterd attributes" do
-      entry = subject[Factory.string]
-      assert_kind_of @class::Entry, entry
+      assert_that(subject[Factory.string]).is_an_instance_of(unit_class::Entry)
     end
 
     should "register new entries" do
       registered_attribute =
         subject.register(
-          attribute: @attribute,
-          source: @source,
-          preprocessor: @preprocessor,
-          separator: @separator,
-          allow_underscores: @allow_underscores
+          attribute:         attribute,
+          source:            source,
+          preprocessor:      preprocessor,
+          separator:         separator,
+          allow_underscores: allow_underscores,
         )
 
-      assert_equal @attribute.to_s, registered_attribute
+      assert_that(registered_attribute).equals(attribute.to_s)
 
       entry = subject[registered_attribute]
-      assert_kind_of @class::Entry, entry
-      assert_equal @source.to_proc, entry.source_proc
-      assert_equal @preprocessor.to_proc, entry.preprocessor_proc
-      assert_equal @separator, entry.separator
-      assert_equal @allow_underscores, entry.allow_underscores
+      assert_that(entry).is_an_instance_of(unit_class::Entry)
+      assert_that(entry.source_proc).equals(source.to_proc)
+      assert_that(entry.preprocessor_proc).equals(preprocessor.to_proc)
+      assert_that(entry.separator).equals(separator)
+      assert_that(entry.allow_underscores).equals(allow_underscores)
 
-      assert_same entry, subject[registered_attribute]
+      assert_that(subject[registered_attribute]).is(entry)
     end
 
     should "default registered settings if none are provided" do
       registered_attribute =
         subject.register(
-          attribute: nil,
-          source: @source,
-          preprocessor: nil,
-          separator: nil,
-          allow_underscores: nil
+          attribute:         nil,
+          source:            source,
+          preprocessor:      nil,
+          separator:         nil,
+          allow_underscores: nil,
         )
 
-      assert_equal MuchSlug.default_attribute.to_s, registered_attribute
+      assert_that(registered_attribute).equals(MuchSlug.default_attribute.to_s)
 
       entry = subject[registered_attribute]
-      assert_equal MuchSlug.default_preprocessor.to_proc, entry.preprocessor_proc
-      assert_equal MuchSlug.default_separator, entry.separator
-      assert_equal MuchSlug.default_allow_underscores, entry.allow_underscores
+      assert_that(entry.preprocessor_proc)
+        .equals(MuchSlug.default_preprocessor.to_proc)
+      assert_that(entry.separator).equals(MuchSlug.default_separator)
+      assert_that(entry.allow_underscores)
+        .equals(MuchSlug.default_allow_underscores)
     end
   end
 
   class EntryUnitTests < UnitTests
     desc "Entry"
-    setup do
-      @entry_class = MuchSlug::HasSlugRegistry::Entry
-    end
-    subject{ @entry_class }
+
+    let(:entry_class){ MuchSlug::HasSlugRegistry::Entry }
   end
 
   class EntryInitTests < EntryUnitTests
     desc "when init"
-    setup do
-      @entry = @entry_class.new
-    end
-    subject{ @entry }
+    subject{ entry_class.new }
 
-    should have_accessors :source_proc, :preprocessor_proc, :separator, :allow_underscores
+    should have_accessors :source_proc, :preprocessor_proc, :separator
+    should have_accessors :allow_underscores
   end
 end