much-slug 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA256: 
-  metadata.gz: d78584c3013f0453ca63e2a99186b75ff087808b0c650e7db8e0d9bd50a39d66
-  data.tar.gz: e5cf29930b1eedfa95830323de1f5191c938126a456ab655403d8e229048cc85
-SHA512: 
-  metadata.gz: aa0cc8ac3994c4932ca5f02d3a0fb540df1844d53da904daea826759cd35011508226eafcdefe2329e6c4ea9b53a9b75cf17223f8324f5c55e7d86c8f3291d88
-  data.tar.gz: b3d55e93e545e620cd4ccd1af326b9d1354b95a97d02e5b819abd31de4f7c7fe8e7588023bc2ee6abb4fe8b9bc73ea2d83de6c620af89153833e20684b534e1a
+---
+SHA256:
+  metadata.gz: 6372c10543d9dba9890742245b1166dd1465626c4f997c5fdf832edf10f62d9e
+  data.tar.gz: 05071c2003b22836474735f9f0fbb2cfbcb3daabdf197a00e62aba9f51300afb
+SHA512:
+  metadata.gz: 15d9851869d05018c136b65e0d11d91e834ae20af6fe8149b790aeee32607c2a01d2abd24c1f2f987b01c053556d33590768e9a58753163238c856fd1b458ad5
+  data.tar.gz: 91da2c4a9735b817a50238d9ce96842280d9a119c638acbe9188a73a3a7f5708f8af2fa942821c1c6de4ebd056e5806d0582cbb28db920ce77aa9b6bb0aa959a

data/Gemfile

@@ -1,5 +1,7 @@
 source "https://rubygems.org"
 
+ruby "~> 2.4"
+
 gemspec
 
-gem 'pry', "~> 0.9.0"
+gem "pry", "~> 0.12.2"

data/README.md

@@ -4,7 +4,180 @@ Friendly, human-readable identifiers for database records.
 
 ## Usage
 
-TODO: Write code samples and usage instructions here
+MuchSlug creates derived slug values on database records. Typically this means deriving the slug value from record attributes and syncing/caching that value in a dedicated field on the record.
+
+### ActiveRecord
+
+Given a `:slug` field on a record:
+
+```ruby
+class AddSlugToProjects < ActiveRecord::Migration[5.2]
+  def change
+    add_column(:projects, :slug, :string, index: { unique: true })
+  end
+end
+```
+
+Mix-in `MuchSlug::ActiveRecord` and configure:
+
+```ruby
+require "much-slug/activerecord"
+
+class ProjectRecord < ApplicationRecord
+  self.table_name = "projects"
+
+  include MuchSlug::ActiveRecord
+  has_slug(
+    source: -> { "#{self.id}-#{self.name}" },
+  )
+
+  # ...
+end
+```
+
+The record will save slug values as it is saved:
+
+```ruby
+project = ProjectRecord.last
+project.id   # => 123
+project.name # => "Sprockets 2.0"
+project.slug # => nil
+
+# slug values are updated late-bound after record saves
+project.save
+project.slug # => "123-Sprockets-2-0"
+
+project.name = "Widgets For Me"
+project.slug # => "123-Sprockets-2-0"
+project.save
+project.slug # => "123-Widgets-For-Me"
+
+# new Projects also have their slugs assigned once they are saved
+project = Project.new(name: "Do The Things")
+project.slug # => nil
+project.save!
+project.slug # => "124-Do-The-Things"
+```
+
+### Notes
+
+#### Attribute
+
+By default, the record attribute for a slug is `"slug"`. You can override this when configuring slugs:
+
+```ruby
+require "much-slug/activerecord"
+
+class ProjectRecord < ApplicationRecord
+  self.table_name = "projects"
+
+  include MuchSlug::ActiveRecord
+  has_slug(
+    source: -> { "#{self.id}-#{self.name}" },
+  )
+  has_slug(
+    attribute: :full_slug
+    source:    -> { "#{self.id}-#{self.full_name}" },
+  )
+
+  # ...
+end
+```
+
+#### Preprocessor
+
+By default, MuchSlug doesn't pre-process the slug value source before generating the slug value. You can specify a custom pre-processor by passing any Proc-like object:
+
+```ruby
+require "much-slug/activerecord"
+
+class ProjectRecord < ApplicationRecord
+  self.table_name = "projects"
+
+  include MuchSlug::ActiveRecord
+  has_slug(
+    source:       -> { "#{self.id}-#{self.name}" },
+    preprocessor: :downcase
+  )
+  has_slug(
+    attribute:    :full_slug
+    source:       -> { "#{self.id}-#{self.full_name}" },
+    preprocessor: -> { |source_value| source_value[0..30] }
+  )
+
+  # ...
+end
+```
+
+#### Separator
+
+MuchSlug replaces any non-word characters with a separator. This helps make slugs URL-friendly. By default, MuchSlug uses `"-"` for the separator. You can specify a custom separator value when configuring slugs:
+
+```ruby
+require "much-slug/activerecord"
+
+class ProjectRecord < ApplicationRecord
+  self.table_name = "projects"
+
+  include MuchSlug::ActiveRecord
+  has_slug(
+    source:    -> { "#{self.id}.#{self.name}" },
+    separator: "."
+  )
+
+  # ...
+end
+
+project = ProjectRecord.last
+project.id   # => 123
+project.name # => "Sprockets 2.0"
+project.save
+project.slug # => "123.Sprockets.2.0"
+```
+
+#### Allowing Underscores
+
+By default, MuchSlug doesn't allow underscores in source values and treats them like non-word characters. This means it replaces underscores with the separator. You can override this to allow underscores when configuring slugs:
+
+```ruby
+require "much-slug/activerecord"
+
+class ProjectRecord < ApplicationRecord
+  self.table_name = "projects"
+
+  include MuchSlug::ActiveRecord
+  has_slug(
+    source: -> { "#{self.id}-#{self.name}" }
+  )
+  has_slug(
+    attribute:         :full_slug
+    source:            -> { "#{self.id}-#{self.full_name}" },
+    allow_underscores: true
+
+  # ...
+end
+
+project = ProjectRecord.last
+project.id        # => 123
+project.name      # => "SP_2.0"
+project.full_name # => "Sprockets_2.0"
+project.save
+project.slug      # => "123-SP-2-0"
+project.full_slug # => "123-Sprockets_2-0"
+```
+
+#### Manual Slug Updates
+
+Slugs are updated anytime a record is saved with changes that affect the slug. If you want an explicit, intention-revealing way to update the slugs manually, use `MuchSlug.update_slugs`:
+
+```ruby
+project = ProjectRecord.last
+project.id   # => 123
+project.name # => "Sprockets 2.0"
+
+MuchSlug.update_slugs(project)
+project.slug # => "123-Sprockets-2-0"
+```
 
 ## Installation
 

data/lib/much-slug.rb

@@ -1,4 +1,52 @@
 require "much-slug/version"
+require "much-slug/has_slug_registry"
+require "much-slug/slug"
 
 module MuchSlug
+  def self.default_attribute
+    "slug"
+  end
+
+  def self.default_preprocessor
+    :to_s
+  end
+
+  def self.default_separator
+    "-".freeze
+  end
+
+  def self.default_allow_underscores
+    false
+  end
+
+  def self.update_slugs(record)
+    record.send("much_slug_has_slug_update_slug_values")
+    true
+  end
+
+  def self.has_slug_changed_slug_values(record_instance)
+    record_instance.class.much_slug_has_slug_registry.each do |attribute, entry|
+      # ArgumentError: no receiver given` raised when calling `instance_exec`
+      # on non-lambda Procs, specifically e.g :downcase.to_proc.
+      # Can't call `instance_eval` on stabby lambdas b/c `instance_eval` auto
+      # passes the receiver as the first argument to the block and stabby
+      # lambdas may not expect that and will ArgumentError.
+      slug_source_value =
+        if entry.source_proc.lambda?
+          record_instance.instance_exec(&entry.source_proc)
+        else
+          record_instance.instance_eval(&entry.source_proc)
+        end
+
+      slug_value =
+        Slug.new(
+          slug_source_value,
+          preprocessor:      entry.preprocessor_proc,
+          separator:         entry.separator,
+          allow_underscores: entry.allow_underscores
+        )
+      next if record_instance.send(attribute) == slug_value
+      yield attribute, slug_value
+    end
+  end
 end

data/lib/much-slug/activerecord.rb

@@ -0,0 +1,65 @@
+require "much-plugin"
+require "much-slug"
+
+module MuchSlug
+  module ActiveRecord
+    include MuchPlugin
+
+    plugin_included do
+      @much_slug_has_slug_registry = MuchSlug::HasSlugRegistry.new
+    end
+
+    plugin_class_methods do
+      def has_slug(
+            source:,
+            attribute: nil,
+            preprocessor: nil,
+            separator: nil,
+            allow_underscores: nil,
+            skip_unique_validation: false,
+            unique_scope: nil)
+        registered_attribute =
+          self.much_slug_has_slug_registry.register(
+            attribute: attribute,
+            source: source,
+            preprocessor: preprocessor,
+            separator: separator,
+            allow_underscores: allow_underscores,
+          )
+
+        # since the slug isn't written until an after callback we can't always
+        # validate presence of it
+        validates_presence_of(registered_attribute, :on => :update)
+
+        unless skip_unique_validation
+          validates_uniqueness_of(registered_attribute, {
+            :case_sensitive => true,
+            :scope          => unique_scope,
+            :allow_nil      => true,
+            :allow_blank    => true
+          })
+        end
+
+        after_create :much_slug_has_slug_update_slug_values
+        after_update :much_slug_has_slug_update_slug_values
+
+        registered_attribute
+      end
+
+      def much_slug_has_slug_registry
+        @much_slug_has_slug_registry
+      end
+    end
+
+    plugin_instance_methods do
+      private
+
+      def much_slug_has_slug_update_slug_values
+        MuchSlug.has_slug_changed_slug_values(self) do |attribute, slug_value|
+          self.send("#{attribute}=", slug_value)
+          self.update_column(attribute, slug_value)
+        end
+      end
+    end
+  end
+end

data/lib/much-slug/has_slug_registry.rb

@@ -0,0 +1,32 @@
+require "much-slug"
+
+module MuchSlug
+  class HasSlugRegistry < ::Hash
+    def initialize
+      super{ |h, k| h[k] = Entry.new }
+    end
+
+    def register(
+          attribute:,
+          source:,
+          preprocessor:,
+          separator:,
+          allow_underscores:)
+      (attribute || MuchSlug.default_attribute).to_s.tap do |a|
+        if allow_underscores.nil?
+          allow_underscores = MuchSlug.default_allow_underscores
+        end
+
+        entry = self[a]
+        entry.source_proc       = source.to_proc
+        entry.preprocessor_proc = (preprocessor || MuchSlug.default_preprocessor).to_proc
+        entry.separator         = separator || MuchSlug.default_separator
+        entry.allow_underscores = !!allow_underscores
+      end
+    end
+
+    class Entry
+      attr_accessor :source_proc, :preprocessor_proc, :separator, :allow_underscores
+    end
+  end
+end

data/lib/much-slug/slug.rb

@@ -0,0 +1,18 @@
+module MuchSlug
+  module Slug
+    def self.new(string, preprocessor:, separator:, allow_underscores: true)
+      regexp_escaped_sep = Regexp.escape(separator)
+
+      slug = preprocessor.call(string.to_s.dup)
+      # 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

data/lib/much-slug/version.rb

@@ -1,3 +1,3 @@
 module MuchSlug
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/much-slug.gemspec

@@ -18,6 +18,10 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert", ["~> 2.16.5"])
+  gem.required_ruby_version = "~> 2.4"
 
+  gem.add_dependency("much-plugin", ["~> 0.2.1"])
+
+  gem.add_development_dependency("assert", ["~> 2.18.1"])
+  gem.add_development_dependency("ardb",   ["~> 0.28.3"])
 end

data/test/support/factory.rb

@@ -3,4 +3,13 @@ require 'assert/factory'
 module Factory
   extend Assert::Factory
 
+  def self.non_word_chars
+    ( (" ".."/").to_a +
+      (":".."@").to_a +
+      ("[".."`").to_a +
+      ("{".."~").to_a -
+      ["-", "_"]
+    ).freeze
+  end
+
 end

data/test/unit/activerecord_tests.rb

@@ -0,0 +1,228 @@
+require "assert"
+require "much-slug/activerecord"
+
+require "much-plugin"
+require "ardb/record_spy"
+
+module MuchSlug::ActiveRecord
+  class UnitTests < Assert::Context
+    desc "MuchSlug::ActiveRecord"
+    setup do
+      source_attribute = @source_attribute = Factory.string.to_sym
+      slug_attribute   = @slug_attribute   = Factory.string
+      @record_class = Ardb::RecordSpy.new do
+        include MuchSlug::ActiveRecord
+        attr_accessor source_attribute, slug_attribute, MuchSlug.default_attribute
+        attr_reader :slug_db_column_updates
+        attr_reader :save_called, :save_bang_called
+
+        def update_column(*args)
+          @slug_db_column_updates ||= []
+          @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 }
+
+    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
+    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
+      )
+
+      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
+    end
+
+    should "add validations using `has_slug`" do
+      subject.has_slug(
+        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]
+
+      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]
+    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
+      )
+
+      validation = subject.validations.find{ |v| v.type == :uniqueness }
+      assert_nil validation
+    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
+      )
+
+      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 [:much_slug_has_slug_update_slug_values], callback.args
+
+      callback = subject.callbacks.find{ |v| v.type == :after_update }
+      assert_not_nil callback
+      assert_equal [:much_slug_has_slug_update_slug_values], 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].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
+        )
+
+      @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)
+
+      @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
+        )
+    end
+    subject{ @record }
+
+    should "default its slug attribute" do
+      assert_equal MuchSlug.default_attribute, @registered_default_attribute
+      assert_equal @slug_attribute, @registered_custom_attribute
+
+      subject.instance_eval{ much_slug_has_slug_update_slug_values }
+      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
+    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.instance_eval{ much_slug_has_slug_update_slug_values }
+      assert_nil subject.slug_db_column_updates
+    end
+
+    should "slug its source even if its already a valid slug" do
+      slug_source = Factory.slug
+      subject.send("#{@source_attribute}=", slug_source)
+      # ensure the preprocessor doesn't change our 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
+        )
+      assert_equal exp, subject.send(@slug_attribute)
+      assert_includes [@slug_attribute, exp], subject.slug_db_column_updates
+    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
+    end
+  end
+end

data/test/unit/has_slug_registry_tests.rb

@@ -0,0 +1,95 @@
+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 }
+
+    should "subclass Hash" do
+      assert subject < ::Hash
+    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 }
+
+    should have_imeths :register
+
+    should "default empty entries for unregisterd attributes" do
+      entry = subject[Factory.string]
+      assert_kind_of @class::Entry, entry
+    end
+
+    should "register new entries" do
+      registered_attribute =
+        subject.register(
+          attribute: @attribute,
+          source: @source,
+          preprocessor: @preprocessor,
+          separator: @separator,
+          allow_underscores: @allow_underscores
+        )
+
+      assert_equal @attribute.to_s, registered_attribute
+
+      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_same entry, subject[registered_attribute]
+    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
+        )
+
+      assert_equal MuchSlug.default_attribute.to_s, registered_attribute
+
+      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
+    end
+  end
+
+  class EntryUnitTests < UnitTests
+    desc "Entry"
+    setup do
+      @entry_class = MuchSlug::HasSlugRegistry::Entry
+    end
+    subject{ @entry_class }
+  end
+
+  class EntryInitTests < EntryUnitTests
+    desc "when init"
+    setup do
+      @entry = @entry_class.new
+    end
+    subject{ @entry }
+
+    should have_accessors :source_proc, :preprocessor_proc, :separator, :allow_underscores
+  end
+end

data/test/unit/much-slug_tests.rb

@@ -0,0 +1,23 @@
+require "assert"
+require "much-slug"
+
+module MuchSlug
+  class UnitTests < Assert::Context
+    desc "MuchSlug"
+    setup do
+      @module = MuchSlug
+    end
+    subject{ @module }
+
+    should have_imeths :default_attribute, :default_preprocessor
+    should have_imeths :default_separator, :default_allow_underscores
+    should have_imeths :update_slugs
+
+    should "know its default settings" do
+      assert_equal "slug", subject.default_attribute
+      assert_equal :to_s, subject.default_preprocessor
+      assert_equal "-", subject.default_separator
+      assert_equal false, subject.default_allow_underscores
+    end
+  end
+end

data/test/unit/slug_tests.rb

@@ -0,0 +1,104 @@
+require "assert"
+require "much-slug/slug"
+
+module MuchSlug::Slug
+  class UnitTests < Assert::Context
+    desc "MuchSlug::Slug"
+    setup do
+      @no_op_pp = proc{ |slug| slug }
+      @separator = "-"
+      @args = {
+        :preprocessor => @no_op_pp,
+        :separator    => @separator
+      }
+
+      @module = MuchSlug::Slug
+    end
+    subject{ @module }
+
+    should have_imeths :new
+
+    should "always dup the given string" do
+      string = Factory.string
+      assert_not_same string, subject.new(string, **@args)
+    end
+
+    should "not change strings that are made up of valid chars" do
+      string = Factory.string
+      assert_equal string, subject.new(string, **@args)
+
+      string = "#{Factory.string}#{@separator}#{Factory.string.upcase}"
+      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)}#{Factory.non_word_chars.sample}#{Factory.string(3)}"
+      end.join(Factory.non_word_chars.sample)
+      assert_equal string.gsub(/[^\w]+/, @separator), subject.new(string, **@args)
+    end
+
+    should "allow passing a custom preprocessor proc" do
+      string = "#{Factory.string}#{@separator}#{Factory.string.upcase}"
+      exp = string.downcase
+      args = @args.merge(:preprocessor => :downcase.to_proc)
+      assert_equal exp, subject.new(string, **args)
+
+      preprocessor = proc{ |s| s.gsub(/[A-Z]/, "a") }
+      exp = preprocessor.call(string)
+      args = @args.merge(:preprocessor => preprocessor)
+      assert_equal exp, subject.new(string, **args)
+    end
+
+    should "allow passing a custom separator" do
+      separator = Factory.non_word_chars.sample
+
+      invalid_char = (Factory.non_word_chars - [separator]).sample
+      string = "#{Factory.string}#{invalid_char}#{Factory.string}"
+      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}"
+      exp = string
+      assert_equal string, subject.new(string, **@args.merge(:separator => separator))
+
+      # it will change the default separator now
+      string = "#{Factory.string}#{@separator}#{Factory.string}"
+      exp = string.gsub(@separator, separator)
+      assert_equal exp, subject.new(string, **@args.merge(:separator => separator))
+    end
+
+    should "change underscores into its separator if not allowed" do
+      string = "#{Factory.string}#{@separator}#{Factory.string}"
+      assert_equal string, subject.new(string, **@args)
+
+      exp = string.gsub("_", @separator)
+      assert_equal exp, subject.new(string, **@args.merge(:allow_underscores => false))
+
+      assert_equal string, subject.new(string, **@args.merge(:allow_underscores => true))
+    end
+
+    should "not allow multiple separators in a row" do
+      string = "#{Factory.string}#{@separator}#{@separator}#{Factory.string}"
+      assert_equal string.gsub(/-{2,}/, @separator), subject.new(string, **@args)
+
+      # remove separators that were added from changing invalid chars
+      invalid_chars =
+        (Factory.integer(3) + 1).times.map{ Factory.non_word_chars.sample }.join
+      string = "#{Factory.string}#{invalid_chars}#{Factory.string}"
+      assert_equal string.gsub(/[^\w]+/, @separator), subject.new(string, **@args)
+    end
+
+    should "remove leading and trailing separators" do
+      string = "-#{Factory.string}#{@separator}#{Factory.string}-"
+      assert_equal string[1..-2], subject.new(string, **@args)
+
+      # remove separators that were added from changing invalid chars
+      invalid_char = Factory.non_word_chars.sample
+      string =
+        "#{invalid_char}#{Factory.string}#{@separator}#{Factory.string}#{invalid_char}"
+      assert_equal string[1..-2], subject.new(string, **@args)
+    end
+  end
+end

metadata

@@ -1,75 +1,111 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: much-slug
-version: !ruby/object:Gem::Version 
-  version: 0.0.1
+version: !ruby/object:Gem::Version
+  version: 0.1.0
 platform: ruby
-authors: 
+authors:
 - Kelly Redding
 - Collin Redding
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2018-10-06 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2020-02-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: much-plugin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
   name: assert
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.18.1
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 2.16.5
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.18.1
+- !ruby/object:Gem::Dependency
+  name: ardb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.28.3
   type: :development
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.28.3
 description: Friendly, human-readable identifiers for database records.
-email: 
+email:
 - kelly@kellyredding.com
 - collin.redding@me.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
+- ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
 - lib/much-slug.rb
+- lib/much-slug/activerecord.rb
+- lib/much-slug/has_slug_registry.rb
+- lib/much-slug/slug.rb
 - lib/much-slug/version.rb
 - log/.gitkeep
 - much-slug.gemspec
 - test/helper.rb
 - test/support/factory.rb
+- test/unit/activerecord_tests.rb
+- test/unit/has_slug_registry_tests.rb
+- test/unit/much-slug_tests.rb
+- test/unit/slug_tests.rb
 - tmp/.gitkeep
 homepage: https://github.com/redding/much-slug
-licenses: 
+licenses:
 - MIT
 metadata: {}
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - &id002 
-    - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - *id002
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Friendly, human-readable identifiers for database records.
-test_files: 
+test_files:
 - test/helper.rb
 - test/support/factory.rb
+- test/unit/activerecord_tests.rb
+- test/unit/has_slug_registry_tests.rb
+- test/unit/much-slug_tests.rb
+- test/unit/slug_tests.rb