friendly_id 5.2.4 → 5.5.0

data/test/helper.rb

@@ -1,21 +1,21 @@
 require "bundler/setup"
 
-if ENV['COVERALLS'] || ENV['COVERAGE']
-  require 'simplecov'
-  if ENV['COVERALLS']
-    require 'coveralls'
+if ENV["COVERALLS"] || ENV["COVERAGE"]
+  require "simplecov"
+  if ENV["COVERALLS"]
+    require "coveralls"
     SimpleCov.formatter = Coveralls::SimpleCov::Formatter
   end
   SimpleCov.start do
-    add_filter 'test'
-    add_filter 'friendly_id/migration'
+    add_filter "test"
+    add_filter "friendly_id/migration"
   end
 end
 
 begin
-  require 'minitest'
+  require "minitest"
 rescue LoadError
-  require 'minitest/unit'
+  require "minitest/unit"
 end
 
 begin
@@ -24,9 +24,10 @@ rescue NameError
   TestCaseClass = MiniTest::Unit::TestCase
 end
 
-require "mocha/setup"
+require "mocha/minitest"
 require "active_record"
-require 'active_support/core_ext/time/conversions'
+require "active_support/core_ext/time/conversions"
+require "erb"
 
 I18n.enforce_available_locales = false
 
@@ -38,29 +39,32 @@ if ENV["LOG"]
   ActiveRecord::Base.logger = Logger.new($stdout)
 end
 
-if ActiveSupport::VERSION::STRING >= '4.2'
+if ActiveSupport::VERSION::STRING >= "4.2"
   ActiveSupport.test_order = :random
 end
 
 module FriendlyId
   module Test
-
     def self.included(base)
       if Minitest.respond_to?(:autorun)
         Minitest.autorun
       else
-        require 'minitest/autorun'
+        require "minitest/autorun"
       end
     rescue LoadError
     end
 
     def transaction
-      ActiveRecord::Base.transaction { yield ; raise ActiveRecord::Rollback }
+      ActiveRecord::Base.transaction do
+        yield
+
+        raise ActiveRecord::Rollback
+      end
     end
 
     def with_instance_of(*args)
       model_class = args.shift
-      args[0] ||= {:name => "a b c"}
+      args[0] ||= {name: "a b c"}
       transaction { yield model_class.create!(*args) }
     end
 
@@ -69,8 +73,11 @@ module FriendlyId
 
       def connect
         version = ActiveRecord::VERSION::STRING
-        driver  = FriendlyId::Test::Database.driver
-        engine  = RUBY_ENGINE rescue "ruby"
+        engine = begin
+          RUBY_ENGINE
+        rescue
+          "ruby"
+        end
 
         ActiveRecord::Base.establish_connection config[driver]
         message = "Using #{engine} #{RUBY_VERSION} AR #{version} with #{driver}"
@@ -86,11 +93,17 @@ module FriendlyId
       end
 
       def config
-        @config ||= YAML::load(File.open(File.expand_path("../databases.yml", __FILE__)))
+        @config ||= YAML.safe_load(
+          ERB.new(
+            File.read(File.expand_path("../databases.yml", __FILE__))
+          ).result
+        )
       end
 
       def driver
-        (ENV["DB"] or "sqlite3").downcase
+        db_driver = ENV.fetch("DB", "sqlite3").downcase
+        db_driver = "postgres" if %w[postgresql pg].include?(db_driver)
+        db_driver
       end
 
       def in_memory?
@@ -109,4 +122,4 @@ end
 require "schema"
 require "shared"
 FriendlyId::Test::Database.connect
-at_exit {ActiveRecord::Base.connection.disconnect!}
+at_exit { ActiveRecord::Base.connection.disconnect! }

data/test/history_test.rb

@@ -1,13 +1,12 @@
 require "helper"
 
 class HistoryTest < TestCaseClass
-
   include FriendlyId::Test
   include FriendlyId::Test::Shared::Core
 
   class Manual < ActiveRecord::Base
     extend FriendlyId
-    friendly_id :name, :use => [:slugged, :history]
+    friendly_id :name, use: [:slugged, :history]
   end
 
   def model_class
@@ -15,7 +14,7 @@ class HistoryTest < TestCaseClass
   end
 
   test "should insert record in slugs table on create" do
-    with_instance_of(model_class) {|record| assert record.slugs.any?}
+    with_instance_of(model_class) { |record| assert record.slugs.any? }
   end
 
   test "should not create new slug record if friendly_id is not changed" do
@@ -52,8 +51,9 @@ class HistoryTest < TestCaseClass
 
   test "should create slug records on each change" do
     transaction do
-      record = model_class.create! :name => "hello"
+      model_class.create! name: "hello"
       assert_equal 1, FriendlyId::Slug.count
+
       record = model_class.friendly.find("hello")
       record.name = "hello again"
       record.slug = nil
@@ -65,8 +65,7 @@ class HistoryTest < TestCaseClass
   test "should not be read only when found by slug" do
     with_instance_of(model_class) do |record|
       refute model_class.friendly.find(record.friendly_id).readonly?
-      assert record.update_attribute :name, 'foo'
-      assert record.update_attributes name: 'foo'
+      assert record.update name: "foo"
     end
   end
 
@@ -81,38 +80,60 @@ class HistoryTest < TestCaseClass
 
   test "should handle renames" do
     with_instance_of(model_class) do |record|
-      record.name = 'x'
+      record.name = "x"
       record.slug = nil
       assert record.save
-      record.name = 'y'
+      record.name = "y"
       record.slug = nil
       assert record.save
-      record.name = 'x'
+      record.name = "x"
+      record.slug = nil
+      assert record.save
+    end
+  end
+
+  test "should maintain history even if current slug is not the most recent one" do
+    with_instance_of(model_class) do |record|
+      record.name = "current"
+      assert record.save
+
+      # this feels like a hack. only thing i can get to work with the HistoryTestWithSti
+      # test cases. (Editorialist vs Journalist.)
+      sluggable_type = FriendlyId::Slug.first.sluggable_type
+      # create several slugs for record
+      # current slug does not have max id
+      FriendlyId::Slug.delete_all
+      FriendlyId::Slug.create(sluggable_type: sluggable_type, sluggable_id: record.id, slug: "current")
+      FriendlyId::Slug.create(sluggable_type: sluggable_type, sluggable_id: record.id, slug: "outdated")
+
+      record.reload
       record.slug = nil
       assert record.save
+
+      assert_equal 2, FriendlyId::Slug.count
     end
   end
 
   test "should not create new slugs that match old slugs" do
     transaction do
-      first_record = model_class.create! :name => "foo"
+      first_record = model_class.create! name: "foo"
       first_record.name = "bar"
       first_record.save!
-      second_record = model_class.create! :name => "foo"
+      second_record = model_class.create! name: "foo"
       assert second_record.slug != "foo"
       assert_match(/foo-.+/, second_record.slug)
     end
   end
 
-  test 'should not fail when updating historic slugs' do
+  test "should not fail when updating historic slugs" do
     transaction do
-      first_record = model_class.create! :name => "foo"
-      second_record = model_class.create! :name => 'another'
+      first_record = model_class.create! name: "foo"
+      second_record = model_class.create! name: "another"
 
-      second_record.update_attributes :name => 'foo', :slug => nil
+      second_record.update name: "foo", slug: nil
       assert_match(/foo-.*/, second_record.slug)
 
-      first_record.update_attributes :name => 'another', :slug => nil
+      first_record.update name: "another", slug: nil
       assert_match(/another-.*/, first_record.slug)
     end
   end
@@ -123,25 +144,23 @@ class HistoryTest < TestCaseClass
       second_record = model_class.create! name: "bar"
 
       first_record.update! slug: "not_foo"
-      second_record.update! slug: "foo" #now both records have used foo; second_record most recently
+      second_record.update! slug: "foo" # now both records have used foo; second_record most recently
       second_record.update! slug: "not_bar"
 
       assert_equal model_class.friendly.find("foo"), second_record
     end
   end
 
-  test 'should name table according to prefix and suffix' do
+  test "should name table according to prefix and suffix" do
     transaction do
-      begin
-        prefix = "prefix_"
-        without_prefix = FriendlyId::Slug.table_name
-        ActiveRecord::Base.table_name_prefix = prefix
-        FriendlyId::Slug.reset_table_name
-        assert_equal prefix + without_prefix, FriendlyId::Slug.table_name
-      ensure
-        ActiveRecord::Base.table_name_prefix = ""
-        FriendlyId::Slug.table_name = without_prefix
-      end
+      prefix = "prefix_"
+      without_prefix = FriendlyId::Slug.table_name
+      ActiveRecord::Base.table_name_prefix = prefix
+      FriendlyId::Slug.reset_table_name
+      assert_equal prefix + without_prefix, FriendlyId::Slug.table_name
+    ensure
+      ActiveRecord::Base.table_name_prefix = ""
+      FriendlyId::Slug.table_name = without_prefix
     end
   end
 end
@@ -149,7 +168,7 @@ end
 class HistoryTestWithAutomaticSlugRegeneration < HistoryTest
   class Manual < ActiveRecord::Base
     extend FriendlyId
-    friendly_id :name, :use => [:slugged, :history]
+    friendly_id :name, use: [:slugged, :history]
 
     def should_generate_new_friendly_id?
       slug.blank? or name_changed?
@@ -160,62 +179,61 @@ class HistoryTestWithAutomaticSlugRegeneration < HistoryTest
     Manual
   end
 
-  test 'should allow reversion back to a previously used slug' do
-    with_instance_of(model_class, name: 'foo') do |record|
-      record.name = 'bar'
+  test "should allow reversion back to a previously used slug" do
+    with_instance_of(model_class, name: "foo") do |record|
+      record.name = "bar"
       record.save!
-      assert_equal 'bar', record.friendly_id
-      record.name = 'foo'
+      assert_equal "bar", record.friendly_id
+      record.name = "foo"
       record.save!
-      assert_equal 'foo', record.friendly_id
+      assert_equal "foo", record.friendly_id
     end
   end
 end
 
 class DependentDestroyTest < TestCaseClass
-
   include FriendlyId::Test
 
   class FalseManual < ActiveRecord::Base
-    self.table_name = 'manuals'
+    self.table_name = "manuals"
 
     extend FriendlyId
-    friendly_id :name, :use => :history, :dependent => false
+    friendly_id :name, use: :history, dependent: false
   end
 
   class DefaultManual < ActiveRecord::Base
-    self.table_name = 'manuals'
+    self.table_name = "manuals"
 
     extend FriendlyId
-    friendly_id :name, :use => :history
+    friendly_id :name, use: :history
   end
 
-  test 'should allow disabling of dependent destroy' do
+  test "should allow disabling of dependent destroy" do
     transaction do
-      assert FriendlyId::Slug.find_by_slug('foo').nil?
-      l = FalseManual.create! :name => 'foo'
-      assert FriendlyId::Slug.find_by_slug('foo').present?
+      assert FriendlyId::Slug.find_by_slug("foo").nil?
+      l = FalseManual.create! name: "foo"
+      assert FriendlyId::Slug.find_by_slug("foo").present?
       l.destroy
-      assert FriendlyId::Slug.find_by_slug('foo').present?
+      assert FriendlyId::Slug.find_by_slug("foo").present?
     end
   end
 
-  test 'should dependently destroy by default' do
+  test "should dependently destroy by default" do
     transaction do
-      assert FriendlyId::Slug.find_by_slug('baz').nil?
-      l = DefaultManual.create! :name => 'baz'
-      assert FriendlyId::Slug.find_by_slug('baz').present?
+      assert FriendlyId::Slug.find_by_slug("baz").nil?
+      l = DefaultManual.create! name: "baz"
+      assert FriendlyId::Slug.find_by_slug("baz").present?
       l.destroy
-      assert FriendlyId::Slug.find_by_slug('baz').nil?
+      assert FriendlyId::Slug.find_by_slug("baz").nil?
     end
   end
 end
 
-if ActiveRecord::VERSION::STRING >= '5.0'
+if ActiveRecord::VERSION::STRING >= "5.0"
   class HistoryTestWithParanoidDeletes < HistoryTest
     class ParanoidRecord < ActiveRecord::Base
       extend FriendlyId
-      friendly_id :name, :use => :history, :dependent => false
+      friendly_id :name, use: :history, dependent: false
 
       default_scope { where(deleted_at: nil) }
     end
@@ -224,19 +242,19 @@ if ActiveRecord::VERSION::STRING >= '5.0'
       ParanoidRecord
     end
 
-    test 'slug should have a sluggable even when soft deleted by a library' do
+    test "slug should have a sluggable even when soft deleted by a library" do
       transaction do
-        assert FriendlyId::Slug.find_by_slug('paranoid').nil?
-        record = model_class.create(name: 'paranoid')
-        assert FriendlyId::Slug.find_by_slug('paranoid').present?
+        assert FriendlyId::Slug.find_by_slug("paranoid").nil?
+        record = model_class.create(name: "paranoid")
+        assert FriendlyId::Slug.find_by_slug("paranoid").present?
 
-        record.update_attribute(:deleted_at, Time.now)
+        record.update deleted_at: Time.now
 
-        orphan_slug = FriendlyId::Slug.find_by_slug('paranoid')
-        assert orphan_slug.present?, 'Orphaned slug should exist'
+        orphan_slug = FriendlyId::Slug.find_by_slug("paranoid")
+        assert orphan_slug.present?, "Orphaned slug should exist"
 
         assert orphan_slug.valid?, "Errors: #{orphan_slug.errors.full_messages}"
-        assert orphan_slug.sluggable.present?, 'Orphaned slug should still find corresponding paranoid sluggable'
+        assert orphan_slug.sluggable.present?, "Orphaned slug should still find corresponding paranoid sluggable"
       end
     end
   end
@@ -245,7 +263,7 @@ end
 class HistoryTestWithSti < HistoryTest
   class Journalist < ActiveRecord::Base
     extend FriendlyId
-    friendly_id :name, :use => [:slugged, :history]
+    friendly_id :name, use: [:slugged, :history]
   end
 
   class Editorialist < Journalist
@@ -259,16 +277,15 @@ end
 class HistoryTestWithFriendlyFinders < HistoryTest
   class Journalist < ActiveRecord::Base
     extend FriendlyId
-    friendly_id :name, :use => [:slugged, :finders, :history]
+    friendly_id :name, use: [:slugged, :finders, :history]
   end
 
   class Restaurant < ActiveRecord::Base
     extend FriendlyId
     belongs_to :city
-    friendly_id :name, :use => [:slugged, :history, :finders]
+    friendly_id :name, use: [:slugged, :history, :finders]
   end
 
-
   test "should be findable by old slugs" do
     [Journalist, Restaurant].each do |model_class|
       with_instance_of(model_class) do |record|
@@ -297,7 +314,7 @@ class HistoryTestWithFindersBeforeHistory < HistoryTest
 
     belongs_to :novelist
 
-    friendly_id :name, :use => [:finders, :history]
+    friendly_id :name, use: [:finders, :history]
 
     def should_generate_new_friendly_id?
       slug.blank? || name_changed?
@@ -306,8 +323,8 @@ class HistoryTestWithFindersBeforeHistory < HistoryTest
 
   test "should be findable by old slug through has_many association" do
     transaction do
-      novelist = Novelist.create!(:name => "Stephen King")
-      novel = novelist.novels.create(:name => "Rita Hayworth and Shawshank Redemption")
+      novelist = Novelist.create!(name: "Stephen King")
+      novel = novelist.novels.create(name: "Rita Hayworth and Shawshank Redemption")
       slug = novel.slug
       novel.name = "Shawshank Redemption"
       novel.save!
@@ -324,7 +341,7 @@ end
 class Restaurant < ActiveRecord::Base
   extend FriendlyId
   belongs_to :city
-  friendly_id :name, :use => [:scoped, :history], :scope => :city
+  friendly_id :name, use: [:scoped, :history], scope: :city
 end
 
 class ScopedHistoryTest < TestCaseClass
@@ -368,21 +385,48 @@ class ScopedHistoryTest < TestCaseClass
         record.slug = nil
         record.save!
 
-        second_record = model_class.create! :city => city, :name => 'x'
+        second_record = model_class.create! city: city, name: "x"
         assert_match(/x-.+/, second_record.friendly_id)
 
-        third_record = model_class.create! :city => city, :name => 'y'
+        third_record = model_class.create! city: city, name: "y"
         assert_match(/y-.+/, third_record.friendly_id)
       end
     end
   end
 
+  test "should record history when scope changes" do
+    transaction do
+      city1 = City.create!
+      city2 = City.create!
+      with_instance_of(Restaurant) do |record|
+        record.name = "x"
+        record.slug = nil
+
+        record.city = city1
+        record.save!
+        assert_equal("city_id:#{city1.id}", record.slugs.reload.first.scope)
+        assert_equal("x", record.slugs.reload.first.slug)
+
+        record.city = city2
+        record.save!
+        assert_equal("city_id:#{city2.id}", record.slugs.reload.first.scope)
+
+        record.name = "y"
+        record.slug = nil
+        record.city = city1
+        record.save!
+        assert_equal("city_id:#{city1.id}", record.slugs.reload.first.scope)
+        assert_equal("y", record.slugs.reload.first.slug)
+      end
+    end
+  end
+
   test "should allow equal slugs in different scopes" do
     transaction do
       city = City.create!
       second_city = City.create!
-      record = model_class.create! :city => city, :name => 'x'
-      second_record = model_class.create! :city => second_city, :name => 'x'
+      record = model_class.create! city: city, name: "x"
+      second_record = model_class.create! city: second_city, name: "x"
 
       assert_equal record.slug, second_record.slug
     end

data/test/numeric_slug_test.rb

@@ -0,0 +1,31 @@
+require "helper"
+
+class NumericSlugTest < TestCaseClass
+  include FriendlyId::Test
+  include FriendlyId::Test::Shared::Core
+
+  def model_class
+    Article
+  end
+
+  test "should generate numeric slugs" do
+    transaction do
+      record = model_class.create! name: "123"
+      assert_equal "123", record.slug
+    end
+  end
+
+  test "should find by numeric slug" do
+    transaction do
+      record = model_class.create! name: "123"
+      assert_equal model_class.friendly.find("123").id, record.id
+    end
+  end
+
+  test "should exist? by numeric slug" do
+    transaction do
+      model_class.create! name: "123"
+      assert model_class.friendly.exists?("123")
+    end
+  end
+end

data/test/object_utils_test.rb

@@ -1,8 +1,6 @@
 require "helper"
 
-
 class ObjectUtilsTest < TestCaseClass
-
   include FriendlyId::Test
 
   test "strings with letters are friendly_ids" do

data/test/reserved_test.rb

@@ -1,12 +1,11 @@
 require "helper"
 
 class ReservedTest < TestCaseClass
-
   include FriendlyId::Test
 
   class Journalist < ActiveRecord::Base
     extend FriendlyId
-    friendly_id :slug_candidates, :use => [:slugged, :reserved], :reserved_words => %w(new edit)
+    friendly_id :slug_candidates, use: [:slugged, :reserved], reserved_words: %w[new edit]
 
     after_validation :move_friendly_id_error_to_name
 
@@ -24,9 +23,9 @@ class ReservedTest < TestCaseClass
   end
 
   test "should reserve words" do
-    %w(new edit NEW Edit).each do |word|
+    %w[new edit NEW Edit].each do |word|
       transaction do
-        assert_raises(ActiveRecord::RecordInvalid) {model_class.create! :name => word}
+        assert_raises(ActiveRecord::RecordInvalid) { model_class.create! name: word }
       end
     end
   end
@@ -43,7 +42,7 @@ class ReservedTest < TestCaseClass
 
   test "should reject reserved candidates" do
     transaction do
-      record = model_class.new(:name => 'new')
+      record = model_class.new(name: "new")
       def record.slug_candidates
         [:name, "foo"]
       end
@@ -54,22 +53,21 @@ class ReservedTest < TestCaseClass
 
   test "should be invalid if all candidates are reserved" do
     transaction do
-      record = model_class.new(:name => 'new')
+      record = model_class.new(name: "new")
       def record.slug_candidates
         ["edit", "new"]
       end
-      assert_raises(ActiveRecord::RecordInvalid) {record.save!}
+      assert_raises(ActiveRecord::RecordInvalid) { record.save! }
     end
   end
 
   test "should optionally treat reserved words as conflict" do
     klass = Class.new(model_class) do
-      friendly_id :slug_candidates, :use => [:slugged, :reserved], :reserved_words => %w(new edit), :treat_reserved_as_conflict => true
+      friendly_id :slug_candidates, use: [:slugged, :reserved], reserved_words: %w[new edit], treat_reserved_as_conflict: true
     end
 
-    with_instance_of(klass, name: 'new') do |record|
-      assert_match(/new-([0-9a-z]+\-){4}[0-9a-z]+\z/, record.slug)
+    with_instance_of(klass, name: "new") do |record|
+      assert_match(/new-([0-9a-z]+-){4}[0-9a-z]+\z/, record.slug)
     end
   end
-
 end

data/test/schema.rb

@@ -25,7 +25,7 @@ module FriendlyId
 
           tables.each do |table_name|
             create_table table_name do |t|
-              t.string  :name
+              t.string :name
               t.boolean :active
             end
           end
@@ -41,7 +41,7 @@ module FriendlyId
 
           slugged_tables.each do |table_name|
             add_column table_name, :slug, :string
-            add_index  table_name, :slug, :unique => true if 'novels' != table_name
+            add_index table_name, :slug, unique: true if table_name != "novels"
           end
 
           scoped_tables.each do |table_name|
@@ -57,7 +57,7 @@ module FriendlyId
           # This will be used to test scopes
           add_column :novels, :novelist_id, :integer
           add_column :novels, :publisher_id, :integer
-          add_index :novels, [:slug, :publisher_id, :novelist_id], :unique => true
+          add_index :novels, [:slug, :publisher_id, :novelist_id], unique: true
 
           # This will be used to test column name quoting
           add_column :journalists, "strange name", :string
@@ -69,6 +69,7 @@ module FriendlyId
           add_column :journalists, "slug_en", :string
           add_column :journalists, "slug_es", :string
           add_column :journalists, "slug_de", :string
+          add_column :journalists, "slug_fr_ca", :string
 
           # This will be used to test relationships
           add_column :books, :author_id, :integer
@@ -77,7 +78,7 @@ module FriendlyId
           add_column :restaurants, :city_id, :integer
 
           # Used to test candidates
-          add_column :cities, :code, :string, :limit => 3
+          add_column :cities, :code, :string, limit: 3
 
           # Used as a non-default slug_column
           add_column :authors, :subdomain, :string