friendly_id 5.4.2 → 5.5.1

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,7 +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 name: 'foo'
+      assert record.update name: "foo"
     end
   end
 
@@ -80,21 +80,21 @@ 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
+  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'
+      record.name = "current"
       assert record.save
 
       # this feels like a hack. only thing i can get to work with the HistoryTestWithSti
@@ -103,8 +103,8 @@ class HistoryTest < TestCaseClass
       # 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')
+      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
@@ -116,24 +116,24 @@ class HistoryTest < TestCaseClass
 
   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 :name => 'foo', :slug => nil
+      second_record.update name: "foo", slug: nil
       assert_match(/foo-.*/, second_record.slug)
 
-      first_record.update :name => 'another', :slug => nil
+      first_record.update name: "another", slug: nil
       assert_match(/another-.*/, first_record.slug)
     end
   end
@@ -144,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
@@ -170,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?
@@ -181,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
@@ -245,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 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
@@ -266,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
@@ -280,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|
@@ -318,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?
@@ -327,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!
@@ -345,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
@@ -389,10 +385,10 @@ 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
@@ -429,8 +425,8 @@ class ScopedHistoryTest < TestCaseClass
     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

@@ -1,4 +1,4 @@
-require 'helper'
+require "helper"
 
 class NumericSlugTest < TestCaseClass
   include FriendlyId::Test
@@ -10,21 +10,21 @@ class NumericSlugTest < TestCaseClass
 
   test "should generate numeric slugs" do
     transaction do
-      record = model_class.create! :name => "123"
+      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"
+      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
-      record = model_class.create! :name => "123"
+      model_class.create! name: "123"
       assert model_class.friendly.exists?("123")
     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

data/test/scoped_test.rb

@@ -2,14 +2,14 @@ require "helper"
 
 class Novelist < ActiveRecord::Base
   extend FriendlyId
-  friendly_id :name, :use => :slugged
+  friendly_id :name, use: :slugged
 end
 
 class Novel < ActiveRecord::Base
   extend FriendlyId
   belongs_to :novelist
   belongs_to :publisher
-  friendly_id :name, :use => :scoped, :scope => [:publisher, :novelist]
+  friendly_id :name, use: :scoped, scope: [:publisher, :novelist]
 
   def should_generate_new_friendly_id?
     new_record? || super
@@ -21,7 +21,6 @@ class Publisher < ActiveRecord::Base
 end
 
 class ScopedTest < TestCaseClass
-
   include FriendlyId::Test
   include FriendlyId::Test::Shared::Core
 
@@ -37,42 +36,42 @@ class ScopedTest < TestCaseClass
     model_class = Class.new(ActiveRecord::Base) do
       self.abstract_class = true
       extend FriendlyId
-      friendly_id :empty, :use => :scoped, :scope => :dummy
+      friendly_id :empty, use: :scoped, scope: :dummy
     end
     assert_equal ["dummy"], model_class.friendly_id_config.scope_columns
   end
 
   test "should allow duplicate slugs outside scope" do
     transaction do
-      novel1 = Novel.create! :name => "a", :novelist => Novelist.create!(:name => "a")
-      novel2 = Novel.create! :name => "a", :novelist => Novelist.create!(:name => "b")
+      novel1 = Novel.create! name: "a", novelist: Novelist.create!(name: "a")
+      novel2 = Novel.create! name: "a", novelist: Novelist.create!(name: "b")
       assert_equal novel1.friendly_id, novel2.friendly_id
     end
   end
 
   test "should not allow duplicate slugs inside scope" do
     with_instance_of Novelist do |novelist|
-      novel1 = Novel.create! :name => "a", :novelist => novelist
-      novel2 = Novel.create! :name => "a", :novelist => novelist
+      novel1 = Novel.create! name: "a", novelist: novelist
+      novel2 = Novel.create! name: "a", novelist: novelist
       assert novel1.friendly_id != novel2.friendly_id
     end
   end
 
   test "should apply scope with multiple columns" do
     transaction do
-      novelist = Novelist.create! :name => "a"
-      publisher = Publisher.create! :name => "b"
-      novel1 = Novel.create! :name => "c", :novelist => novelist, :publisher => publisher
-      novel2 = Novel.create! :name => "c", :novelist => novelist, :publisher => Publisher.create(:name => "d")
-      novel3 = Novel.create! :name => "c", :novelist => Novelist.create(:name => "e"), :publisher => publisher
-      novel4 = Novel.create! :name => "c", :novelist => novelist, :publisher => publisher
+      novelist = Novelist.create! name: "a"
+      publisher = Publisher.create! name: "b"
+      novel1 = Novel.create! name: "c", novelist: novelist, publisher: publisher
+      novel2 = Novel.create! name: "c", novelist: novelist, publisher: Publisher.create(name: "d")
+      novel3 = Novel.create! name: "c", novelist: Novelist.create(name: "e"), publisher: publisher
+      novel4 = Novel.create! name: "c", novelist: novelist, publisher: publisher
       assert_equal novel1.friendly_id, novel2.friendly_id
       assert_equal novel2.friendly_id, novel3.friendly_id
       assert novel3.friendly_id != novel4.friendly_id
     end
   end
 
-  test 'should allow a record to reuse its own slug' do
+  test "should allow a record to reuse its own slug" do
     with_instance_of(model_class) do |record|
       old_id = record.friendly_id
       record.slug = nil
@@ -83,15 +82,14 @@ class ScopedTest < TestCaseClass
 
   test "should generate new slug when scope changes" do
     transaction do
-      novelist = Novelist.create! :name => "a"
-      publisher = Publisher.create! :name => "b"
-      novel1 = Novel.create! :name => "c", :novelist => novelist, :publisher => publisher
-      novel2 = Novel.create! :name => "c", :novelist => novelist, :publisher => Publisher.create(:name => "d")
+      novelist = Novelist.create! name: "a"
+      publisher = Publisher.create! name: "b"
+      novel1 = Novel.create! name: "c", novelist: novelist, publisher: publisher
+      novel2 = Novel.create! name: "c", novelist: novelist, publisher: Publisher.create(name: "d")
       assert_equal novel1.friendly_id, novel2.friendly_id
       novel2.publisher = publisher
       novel2.save!
       assert novel2.friendly_id != novel1.friendly_id
     end
   end
-
 end