louisville 0.0.3

data/lib/louisville/extensions/collision.rb

@@ -0,0 +1,87 @@
+#
+# The collision extension handles collisions as part of the save process. It uses a CollisionResolver
+# object to handle the heavy lifting.
+#
+# Provide `collision: true`, or `collision: :name_of_collision_resolver` to your slug() invocation.
+# No options are used.
+#
+
+module Louisville
+  module Extensions
+    module Collision
+
+
+      def self.configure_default_options(options)
+        options[:collision] = :string_sequence if options[:collision] == true
+      end
+
+
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :louisville_slug,                  :resolver
+          alias_method_chain :louisville_slug=,                 :resolver
+          alias_method_chain :louisville_slug_changed?,         :resolver
+          alias_method_chain :validate_louisville_slug,         :resolver
+
+          before_validation :make_louisville_slug_unique, :if => :should_uniquify_louisville_slug?
+        end
+      end
+
+
+      def louisville_slug_with_resolver
+        louisville_collision_resolver.read_slug
+      end
+
+
+
+      protected
+
+
+
+      def louisville_slug_with_resolver=(val)
+        louisville_collision_resolver.assign_slug(val)
+      end
+
+
+      def louisville_slug_changed_with_resolver?
+        louisville_collision_resolver.slug_changed?
+      end
+
+
+      def louisville_collision_resolver
+        @louisville_collision_resolver ||= begin
+          class_name  = louisville_config.options_for(:collision)[:resolver] || louisville_config[:collision]
+          klass       = Louisville::CollisionResolvers.const_get(:"#{class_name.to_s.classify}")
+          klass.new(self, louisville_config.options_for(:collision))
+        end
+      end
+
+
+      def make_louisville_slug_unique
+        return if louisville_collision_resolver.unique?
+
+        self.louisville_slug = louisville_collision_resolver.next_valid_slug
+      end
+
+
+      def should_uniquify_louisville_slug?
+        return false if louisville_config.option?(:setter) && desired_louisville_slug
+
+        louisville_collision_resolver.provides_collision_solution? && louisville_slug_changed?
+      end
+
+
+      def validate_louisville_slug_with_resolver
+        return false unless validate_louisville_slug_without_resolver
+
+        unless louisville_collision_resolver.unique?
+          self.errors.add(louisville_config[:column], :taken)
+          return false
+        end
+
+        true
+      end
+
+    end
+  end
+end

data/lib/louisville/extensions/finder.rb

@@ -0,0 +1,109 @@
+#
+# The finder extension allows your class to use find('slug') to query for your record.
+# If the history extension is enabled it will also query the history table to see if
+# there are any previous slugs that match.
+#
+# The finder option is enabled by default, to disable provide `finder: false` to your slug() invocation.
+# No options are used.
+#
+
+module Louisville
+  module Extensions
+    module Finder
+
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.class_eval do
+          class << self
+            alias_method_chain :relation, :louisville_finder
+
+            if ActiveRecord::VERSION::MAJOR >= 4 && ActiveRecord::VERSION::MINOR >= 2
+              alias_method_chain :find, :louisville_finder
+            end
+
+          end
+        end
+      end
+
+
+
+      module ClassMethods
+
+        def find_with_louisville_finder(*args)
+          return find_without_lousville_finder(*args) if args.length != 1
+
+          id = args[0]
+          id = id.id if ActiveRecord::Base === id
+          return find_without_louisville_finder(*args) if Louisville::Util.numeric?(id)
+
+          relation_with_louisville_finder.find_one(id)
+        end
+
+        private
+
+        def relation_with_louisville_finder
+          rel = relation_without_louisville_finder
+          rel.extend RelationMethods unless rel.respond_to?(:find_one_with_louisville)
+          rel
+        end
+      end
+
+
+
+      module RelationMethods
+
+
+        def find_one(id)
+          id = id.id if ActiveRecord::Base === id
+
+          return super(id) if Louisville::Util.numeric?(id)
+
+          seq_column = "#{louisville_config[:column]}_sequence"
+
+          if self.column_names.include?(seq_column)
+            base, seq = Louisville::Util.slug_parts(id)
+            record = self.where(louisville_config[:column] => base, seq_column => seq).first
+          else
+            record = self.where(louisville_config[:column] => id).first
+          end
+
+          return record if record
+
+          if louisville_config.option?(:history)
+
+            base, seq = Louisville::Util.slug_parts(id)
+
+            record = Louisville::Slug.where(:slug_base => base, :slug_sequence => seq, :sluggable_type => ::Louisville::Util.polymorphic_name(self)).select(:sluggable_id).first
+            super(record.try(:sluggable_id) || id)
+          else
+            return super(id)
+          end
+        end
+
+
+        def exists?(id = :none)
+          id = id.id if ActiveRecord::Base === id
+
+          return super(id) if Louisville::Util.numeric?(id)
+
+          if String === id
+            return true       if super(louisville_config[:column] => id)
+            return super(id)  unless louisville_config.option?(:history)
+
+            base, seq = Louisville::Util.slug_parts(id)
+
+            Louisville::Slug.where(:slug_base => base, :slug_sequence => seq, :sluggable_type => ::Louisville::Util.polymorphic_name(name)).exists?
+
+          elsif ActiveRecord::VERSION::MAJOR == 3
+            return super(id == :none ? false : id)
+          else
+            return super(id)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/louisville/extensions/history.rb

@@ -0,0 +1,59 @@
+#
+# The history extension stores previous slug values in the `slugs` table.
+# It provides instances with a `historical_slugs` association that return Louisville::Slug records.
+# Whenever a slug is changed the previous value is added to the table, the current value is never
+# present in the history table.
+#
+# Provide `history: true` to your slug() invocation.
+# No options are used.
+#
+
+module Louisville
+  module Extensions
+    module History
+
+
+      def self.included(base)
+        base.class_eval do
+
+          # provide an association for easy lookup, joining, etc.
+          has_many :historical_slugs, :class_name => 'Louisville::Slug', :dependent => :destroy, :as => :sluggable
+
+          # If our slug has changed we should manage the history.
+          after_save :delete_matching_historical_slug,  :if => :louisville_slug_changed?
+          after_save :generate_historical_slug,         :if => :louisville_slug_changed?
+        end
+      end
+
+
+
+      protected
+
+
+
+      # First, we delete any previous slugs that this record owned that match the current slug.
+      # This allows a record to return to a previous slug without duplication in the history table.
+      def delete_matching_historical_slug
+        current_value = self.louisville_slug
+
+        return unless current_value
+
+        base, seq = Louisville::Util.slug_parts(current_value)
+
+        self.historical_slugs.where(:slug_base => base, :slug_sequence => seq).delete_all
+      end
+
+
+      # Then we generate a new historical slug for the previous value (if there is one).
+      def generate_historical_slug
+        previous_value = self.send("#{louisville_config[:column]}_was")
+
+        return unless previous_value
+
+        base, seq = Louisville::Util.slug_parts(previous_value)
+
+        self.historical_slugs.create(:slug_base => base, :slug_sequence => seq)
+      end
+    end
+  end
+end

data/lib/louisville/extensions/setter.rb

@@ -0,0 +1,44 @@
+#
+# Enables the slug to be dictated by a setter on the instance. If a setter is provided the collision
+# extension will not uniquify but rather add a validation error.
+#
+# Provide `setter: true` or `setter: :name_of_accessor` to your slug() invocation.
+# No options are used.
+#
+
+module Louisville
+  module Extensions
+    module Setter
+
+
+      def self.configure_default_options(options)
+        options[:setter] = "desired_#{options[:column]}" if options[:setter] == true
+      end
+
+
+      def self.included(base)
+        base.class_eval do
+          attr_accessor :desired_louisville_slug
+          alias_method :"#{louisville_config[:setter]}=", :desired_louisville_slug=
+
+          if respond_to?(:accessible_attributes) && accessible_attributes.any?
+            attr_accessible :desired_louisville_slug, louisville_config[:setter].to_sym
+          end
+
+          alias_method_chain :extract_louisville_slug_value_from_field, :setter
+        end
+      end
+
+
+
+      protected
+
+
+
+      def extract_louisville_slug_value_from_field_with_setter
+        self.desired_louisville_slug || extract_louisville_slug_value_from_field_without_setter
+      end
+
+    end
+  end
+end

data/lib/louisville/slug.rb

@@ -0,0 +1,8 @@
+module Louisville
+  class Slug < ActiveRecord::Base
+    self.table_name = :slugs
+
+    validates :sluggable_type, :sluggable_id, :slug_base, :slug_sequence, :presence => true
+    validates :slug_base, :uniqueness => {:scope => [:sluggable_id, :sluggable_type, :slug_sequence]}
+  end
+end

data/lib/louisville/slugger.rb

@@ -0,0 +1,103 @@
+module Louisville
+  module Slugger
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+
+        before_validation :apply_louisville_slug
+
+        validate :validate_louisville_slug, :if => :needs_to_validate_louisville_slug?
+      end
+    end
+
+
+
+    module ClassMethods
+
+      def slug(field, options = {})
+        @louisville_slugger = ::Louisville::Config.new(field, options)
+        @louisville_slugger.hook!(self)
+        @louisville_slugger
+      end
+
+      def louisville_config
+        @louisville_slugger || (superclass.respond_to?(:louisville_config) ? superclass.louisville_config : nil)
+      end
+
+    end
+
+
+
+    def louisville_slug
+      self.send(louisville_config[:column])
+    end
+
+
+    def louisville_config
+      self.class.louisville_config
+    end
+
+
+
+    protected
+
+
+
+    def louisville_slug=(val)
+      self.send("#{louisville_config[:column]}=", val)
+    end
+
+
+    def louisville_slug_changed?
+      self.send("#{louisville_config[:column]}_changed?")
+    end
+
+
+    def apply_louisville_slug
+      value = extract_louisville_slug_value_from_field
+      value = sanitize_louisville_slug(value) if value
+
+      # the value may have changed but the parameterized value may be the same
+      # charlie vs Charlie.
+      if self.louisville_slug
+        base = Louisville::Util.slug_base(self.louisville_slug)
+
+        # if the base hasn't changed let's not set the value since doing so may incur extra cost.
+        # namely, the numeric_sequence resolver would have to determine and apply the sequence.
+        if base != value
+          self.louisville_slug = value
+        end
+
+      else
+        self.louisville_slug = value
+      end
+    end
+
+
+    def sanitize_louisville_slug(value)
+      value.parameterize
+    end
+
+
+    def extract_louisville_slug_value_from_field
+      self.send(louisville_config[:field])
+    end
+
+
+    def validate_louisville_slug
+
+      if louisville_slug.blank?
+        errors.add(louisville_config[:column], :blank)
+        return false
+      end
+
+      true
+    end
+
+    def needs_to_validate_louisville_slug?
+      new_record? || louisville_slug_changed?
+    end
+
+  end
+end

data/lib/louisville/util.rb

@@ -0,0 +1,39 @@
+module Louisville
+  class Util
+
+
+    SLUG_MATCHER = /^(.+)--([\d]+)$/
+
+
+    class << self
+
+      def numeric?(id)
+        Integer === id || !!(id.to_s =~ /^[\d]+$/)
+      end
+
+
+      def slug_base(compare)
+        compare =~ SLUG_MATCHER
+        $1 || compare
+      end
+
+
+      def slug_sequence(compare)
+        compare =~ SLUG_MATCHER
+        [$2.to_i, 1].max
+      end
+
+
+      def slug_parts(compare)
+        [slug_base(compare), slug_sequence(compare)]
+      end
+
+
+      def polymorphic_name(klass)
+        klass.base_class.sti_name
+      end
+
+    end
+
+  end
+end

data/lib/louisville/version.rb

@@ -0,0 +1,13 @@
+module Louisville
+  module VERSION
+
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 3
+    PRE = nil
+
+    def self.to_s
+      [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+    end
+  end
+end

data/lib/louisville.rb

@@ -0,0 +1,28 @@
+require "louisville/version"
+
+module Louisville
+  
+  autoload :Config,   'louisville/config'
+  autoload :Slug,     'louisville/slug'
+  autoload :Slugger,  'louisville/slugger'
+  autoload :Util,     'louisville/util'
+  
+  module Extensions
+
+    autoload :Collision,  'louisville/extensions/collision'
+    autoload :Finder,     'louisville/extensions/finder'
+    autoload :History,    'louisville/extensions/history'
+    autoload :Setter,     'louisville/extensions/setter'
+
+  end
+
+  module CollisionResolvers
+
+    autoload :Abstract,         'louisville/collision_resolvers/abstract'
+    autoload :None,             'louisville/collision_resolvers/none'
+    autoload :NumericSequence,  'louisville/collision_resolvers/numeric_sequence'
+    autoload :StringSequence,   'louisville/collision_resolvers/string_sequence'
+
+  end
+
+end

data/louisville.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'louisville/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "louisville"
+  gem.version       = Louisville::VERSION
+  gem.authors       = ["Mike Nelson"]
+  gem.email         = ["mike@mnelson.io"]
+  gem.description   = %q{A simple and extensible slugging library for ActiveRecord.}
+  gem.summary       = %q{Simple and Extensible Slugging}
+  gem.homepage      = "http://github.com/mnelson/louisville"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'activerecord', '>= 3.0'
+end

data/spec/collision_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Louisville::Extensions::Collision do
+
+  class MinimalCollisionUser < ActiveRecord::Base
+    self.table_name = :users
+
+    include Louisville::Slugger
+
+    slug :name, :collision => :none
+  end
+
+  class MinimalCollisionSequenceUser < ActiveRecord::Base
+    self.table_name = :users
+
+    include Louisville::Slugger
+
+    slug :name, :collision => :string_sequence, :setter => true
+
+  end
+
+  let(:mcu) { MinimalCollisionUser.new }
+  let(:mcsu) { MinimalCollisionSequenceUser.new }
+  let(:resolver) {
+    mcsu.send(:louisville_collision_resolver)
+  }
+
+  it 'should ensure the slug is unique' do
+    mcu.name = 'pete'
+    expect(mcu.save).to eq(true)
+
+    u2 = MinimalCollisionUser.new
+    u2.name = 'pete'
+    expect(u2.save).to eq(false)
+
+    expect(u2.errors[:slug].to_s).to match(/has already been taken/)
+  end
+
+  it 'should choose a collision resolver based on the config' do
+    expect(resolver).to be_a(Louisville::CollisionResolvers::StringSequence)
+  end
+
+  it 'should override the slug reader to read from the resolver' do
+    expect(resolver).to receive(:read_slug).once
+    mcsu.louisville_slug
+  end
+
+  it 'should override the slug writer to apply via the resolver' do
+    expect(resolver).to receive(:assign_slug).with('test').once
+    mcsu.send(:louisville_slug=, 'test')
+  end
+
+  context "#should_uniquify_louisville_slug?" do
+
+    it 'should not uniquify if the resolver does not provide a solution' do
+      resolver = double(:provides_collision_solution? => false)
+      allow(mcu).to receive(:louisville_collision_resolver){ resolver }
+      allow(mcu).to receive(:louisville_slug_changed?){ true }
+      expect(mcu.send(:should_uniquify_louisville_slug?)).to eq(false)
+    end
+
+    it 'should uniquify if the resolver provides a solution' do
+      resolver = double(:provides_collision_solution? => true)
+      allow(mcu).to receive(:louisville_collision_resolver){ resolver }
+      allow(mcu).to receive(:louisville_slug_changed?){ true }
+      expect(mcu.send(:should_uniquify_louisville_slug?)).to eq(true)
+    end
+
+    it 'should not uniquify if the setter extension is used and present' do
+      allow(mcsu).to receive(:louisville_slug_changed?){ true }
+      expect(mcsu.send(:should_uniquify_louisville_slug?)).to eq(true)
+      mcsu.desired_slug = 'test'
+      expect(mcsu.send(:should_uniquify_louisville_slug?)).to eq(false)
+    end
+
+  end
+
+  context "collision resolver utilities" do
+    it "should choose the correct 'latest' slug" do
+      expect(resolver.send(:provide_latest_slug, 'dog-b--4', 'dog-b--10')).to eq('dog-b--10')
+    end
+  end
+
+end

data/spec/column_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe 'Louisville::Slugger column variations' do
+
+  class ColumnVariationUser < ActiveRecord::Base
+    self.table_name = :users
+
+    include Louisville::Slugger
+
+    slug :name, :column => :other_slug, :history => true
+  end
+
+  it 'should use the provided column as the storage location' do
+    u = ColumnVariationUser.new
+    u.name = 'bob'
+    expect(u.save).to eq(true)
+
+    expect(u.slug).to eq(nil)
+    expect(u.other_slug).to eq('bob')
+    expect(u.other_slug_sequence).to eq(1)
+  end
+
+
+  it 'should not impact the history columns' do
+    u = ColumnVariationUser.new
+    u.name = 'bill'
+    expect(u.save).to eq(true)
+
+    u.name = 'billy'
+    expect(u.save).to eq(true)
+
+    history = Louisville::Slug.last
+
+    expect(history.slug_base).to eq('bill')
+    expect(history.slug_sequence).to eq(1)
+
+    expect(ColumnVariationUser.find('billy')).to eq(u)
+    expect(ColumnVariationUser.find('bill')).to eq(u)
+  end
+end