friendly_id 5.4.2 → 5.5.0

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

data/test/sequentially_slugged_test.rb

@@ -1,8 +1,8 @@
-require 'helper'
+require "helper"
 
 class Article < ActiveRecord::Base
   extend FriendlyId
-  friendly_id :name, :use => :sequentially_slugged
+  friendly_id :name, use: :sequentially_slugged
 end
 
 class SequentiallySluggedTest < TestCaseClass
@@ -15,27 +15,27 @@ class SequentiallySluggedTest < TestCaseClass
 
   test "should generate numerically sequential slugs" do
     transaction do
-      records = 12.times.map { model_class.create! :name => "Some news" }
+      records = 12.times.map { model_class.create! name: "Some news" }
       assert_equal "some-news", records[0].slug
-      (1...12).each {|i| assert_equal "some-news-#{i + 1}", records[i].slug}
+      (1...12).each { |i| assert_equal "some-news-#{i + 1}", records[i].slug }
     end
   end
 
   test "should cope when slugs are missing from the sequence" do
     transaction do
-      record_1 = model_class.create!(:name => 'A thing')
-      record_2 = model_class.create!(:name => 'A thing')
-      record_3 = model_class.create!(:name => 'A thing')
+      record_1 = model_class.create!(name: "A thing")
+      record_2 = model_class.create!(name: "A thing")
+      record_3 = model_class.create!(name: "A thing")
 
-      assert_equal 'a-thing', record_1.slug
-      assert_equal 'a-thing-2', record_2.slug
-      assert_equal 'a-thing-3', record_3.slug
+      assert_equal "a-thing", record_1.slug
+      assert_equal "a-thing-2", record_2.slug
+      assert_equal "a-thing-3", record_3.slug
 
       record_2.destroy
 
-      record_4 = model_class.create!(:name => 'A thing')
+      record_4 = model_class.create!(name: "A thing")
 
-      assert_equal 'a-thing-4', record_4.slug
+      assert_equal "a-thing-4", record_4.slug
     end
   end
 
@@ -43,32 +43,32 @@ class SequentiallySluggedTest < TestCaseClass
     model_class = Class.new(ActiveRecord::Base) do
       self.table_name = "journalists"
       extend FriendlyId
-      friendly_id :name, :use => :sequentially_slugged, :slug_column => "strange name"
+      friendly_id :name, use: :sequentially_slugged, slug_column: "strange name"
     end
 
     transaction do
-      record_1 = model_class.create! name: "Julian Assange"
-      record_2 = model_class.create! name: "Julian Assange"
+      record_1 = model_class.create! name: "Lois Lane"
+      record_2 = model_class.create! name: "Lois Lane"
 
-      assert_equal 'julian-assange', record_1.attributes["strange name"]
-      assert_equal 'julian-assange-2', record_2.attributes["strange name"]
+      assert_equal "lois-lane", record_1.attributes["strange name"]
+      assert_equal "lois-lane-2", record_2.attributes["strange name"]
     end
   end
 
   test "should correctly sequence slugs that end in a number" do
     transaction do
-      record1 = model_class.create! :name => "Peugeuot 206"
+      record1 = model_class.create! name: "Peugeuot 206"
       assert_equal "peugeuot-206", record1.slug
-      record2 = model_class.create! :name => "Peugeuot 206"
+      record2 = model_class.create! name: "Peugeuot 206"
       assert_equal "peugeuot-206-2", record2.slug
     end
   end
 
   test "should correctly sequence slugs that begin with a number" do
     transaction do
-      record1 = model_class.create! :name => "2010 to 2015 Records"
+      record1 = model_class.create! name: "2010 to 2015 Records"
       assert_equal "2010-to-2015-records", record1.slug
-      record2 = model_class.create! :name => "2010 to 2015 Records"
+      record2 = model_class.create! name: "2010 to 2015 Records"
       assert_equal "2010-to-2015-records-2", record2.slug
     end
   end
@@ -77,15 +77,15 @@ class SequentiallySluggedTest < TestCaseClass
     model_class = Class.new(ActiveRecord::Base) do
       self.table_name = "novelists"
       extend FriendlyId
-      friendly_id :name, :use => :sequentially_slugged, :sequence_separator => ':'
+      friendly_id :name, use: :sequentially_slugged, sequence_separator: ":"
     end
 
     transaction do
       record_1 = model_class.create! name: "Julian Barnes"
       record_2 = model_class.create! name: "Julian Barnes"
 
-      assert_equal 'julian-barnes', record_1.slug
-      assert_equal 'julian-barnes:2', record_2.slug
+      assert_equal "julian-barnes", record_1.slug
+      assert_equal "julian-barnes:2", record_2.slug
     end
   end
 
@@ -93,20 +93,20 @@ class SequentiallySluggedTest < TestCaseClass
     model_class = Class.new(ActiveRecord::Base) do
       self.table_name = "cities"
       extend FriendlyId
-      friendly_id :slug_candidates, :use => [ :sequentially_slugged ]
+      friendly_id :slug_candidates, use: [:sequentially_slugged]
 
       def slug_candidates
         [name, [name, code]]
       end
     end
     transaction do
-      record = model_class.create!(:name => nil, :code => nil)
+      record = model_class.create!(name: nil, code: nil)
       assert_nil record.slug
     end
   end
 
   test "should not generate a slug when the sluggable attribute is blank" do
-    record = model_class.create!(:name => '')
+    record = model_class.create!(name: "")
     assert_nil record.slug
   end
 end
@@ -117,7 +117,12 @@ class SequentiallySluggedTestWithHistory < TestCaseClass
 
   class Article < ActiveRecord::Base
     extend FriendlyId
-    friendly_id :name, :use => [:sequentially_slugged, :history]
+    friendly_id :name, use: [:sequentially_slugged, :history]
+  end
+
+  Journalist = Class.new(ActiveRecord::Base) do
+    extend FriendlyId
+    friendly_id :name, use: [:sequentially_slugged, :history], slug_column: "strange name"
   end
 
   def model_class
@@ -126,36 +131,46 @@ class SequentiallySluggedTestWithHistory < TestCaseClass
 
   test "should work with regeneration with history when slug already exists" do
     transaction do
-      record1 = model_class.create! :name => "Test name"
-      record2 = model_class.create! :name => "Another test name"
-      assert_equal 'test-name', record1.slug
-      assert_equal 'another-test-name', record2.slug
+      record1 = model_class.create! name: "Test name"
+      record2 = model_class.create! name: "Another test name"
+      assert_equal "test-name", record1.slug
+      assert_equal "another-test-name", record2.slug
 
       record2.name = "Test name"
       record2.slug = nil
       record2.save!
-      assert_equal 'test-name-2', record2.slug
+      assert_equal "test-name-2", record2.slug
     end
   end
 
   test "should work with regeneration with history when 2 slugs already exists and the second is changed" do
     transaction do
-      record1 = model_class.create! :name => "Test name"
-      record2 = model_class.create! :name => "Test name"
-      record3 = model_class.create! :name => "Another test name"
-      assert_equal 'test-name', record1.slug
-      assert_equal 'test-name-2', record2.slug
-      assert_equal 'another-test-name', record3.slug
+      record1 = model_class.create! name: "Test name"
+      record2 = model_class.create! name: "Test name"
+      record3 = model_class.create! name: "Another test name"
+      assert_equal "test-name", record1.slug
+      assert_equal "test-name-2", record2.slug
+      assert_equal "another-test-name", record3.slug
 
       record2.name = "One more test name"
       record2.slug = nil
       record2.save!
-      assert_equal 'one-more-test-name', record2.slug
+      assert_equal "one-more-test-name", record2.slug
 
       record3.name = "Test name"
       record3.slug = nil
       record3.save!
-      assert_equal 'test-name-3', record3.slug
+      assert_equal "test-name-3", record3.slug
+    end
+  end
+
+  test "should cope with strange column names" do
+    transaction do
+      record_1 = Journalist.create! name: "Lois Lane"
+      record_2 = Journalist.create! name: "Lois Lane"
+
+      assert_equal "lois-lane", record_1.attributes["strange name"]
+      assert_equal "lois-lane-2", record_2.attributes["strange name"]
     end
   end
 end
@@ -167,7 +182,7 @@ end
 class Restaurant < ActiveRecord::Base
   extend FriendlyId
   belongs_to :city
-  friendly_id :name, :use => [:sequentially_slugged, :scoped, :history], :scope => :city
+  friendly_id :name, use: [:sequentially_slugged, :scoped, :history], scope: :city
 end
 
 class SequentiallySluggedTestWithScopedHistory < TestCaseClass
@@ -181,19 +196,19 @@ class SequentiallySluggedTestWithScopedHistory < TestCaseClass
   test "should work with regeneration with scoped history" do
     transaction do
       city1 = City.create!
-      city2 = City.create!
-      record1 = model_class.create! :name => "Test name", :city => city1
-      record2 = model_class.create! :name => "Test name", :city => city1
+      City.create!
+      record1 = model_class.create! name: "Test name", city: city1
+      record2 = model_class.create! name: "Test name", city: city1
 
-      assert_equal 'test-name', record1.slug
-      assert_equal 'test-name-2', record2.slug
+      assert_equal "test-name", record1.slug
+      assert_equal "test-name-2", record2.slug
 
-      record2.name = 'Another test name'
+      record2.name = "Another test name"
       record2.slug = nil
       record2.save!
 
-      record3 = model_class.create! :name => "Test name", :city => city1
-      assert_equal 'test-name-3', record3.slug
+      record3 = model_class.create! name: "Test name", city: city1
+      assert_equal "test-name-3", record3.slug
     end
   end
 end

data/test/shared.rb

@@ -1,7 +1,6 @@
 module FriendlyId
   module Test
     module Shared
-
       module Slugged
         test "configuration should have a sequence_separator" do
           assert !model_class.friendly_id_config.sequence_separator.empty?
@@ -18,15 +17,15 @@ module FriendlyId
 
         test "should add a UUID for duplicate friendly ids" do
           with_instance_of model_class do |record|
-            record2 = model_class.create! :name => record.name
-            assert record2.friendly_id.match(/([0-9a-z]+\-){4}[0-9a-z]+\z/)
+            record2 = model_class.create! name: record.name
+            assert record2.friendly_id.match(/([0-9a-z]+-){4}[0-9a-z]+\z/)
           end
         end
 
         test "should not add slug sequence on update after other conflicting slugs were added" do
           with_instance_of model_class do |record|
             old = record.friendly_id
-            model_class.create! :name => record.name
+            model_class.create! name: record.name
             record.save!
             record.reload
             assert_equal old, record.to_param
@@ -35,7 +34,7 @@ module FriendlyId
 
         test "should not change the sequence on save" do
           with_instance_of model_class do |record|
-            record2 = model_class.create! :name => record.name
+            record2 = model_class.create! name: record.name
             friendly_id = record2.friendly_id
             record2.active = !record2.active
             record2.save!
@@ -64,7 +63,7 @@ module FriendlyId
           with_instance_of my_model_class do |record|
             record.update my_model_class.friendly_id_config.slug_column => nil
             record = my_model_class.friendly.find(record.id)
-            record.class.validate Proc.new {errors.add(:name, "FAIL")}
+            record.class.validate proc { errors.add(:name, "FAIL") }
             record.save
             assert_equal record.to_param, record.friendly_id
           end
@@ -84,7 +83,7 @@ module FriendlyId
         end
 
         test "should be findable by friendly id" do
-          with_instance_of(model_class) {|record| assert model_class.friendly.find record.friendly_id}
+          with_instance_of(model_class) { |record| assert model_class.friendly.find record.friendly_id }
         end
 
         test "should exist? by friendly id" do
@@ -92,19 +91,19 @@ module FriendlyId
             assert model_class.friendly.exists? record.id
             assert model_class.friendly.exists? record.id.to_s
             assert model_class.friendly.exists? record.friendly_id
-            assert model_class.friendly.exists?({:id => record.id})
-            assert model_class.friendly.exists?(['id = ?', record.id])
+            assert model_class.friendly.exists?({id: record.id})
+            assert model_class.friendly.exists?(["id = ?", record.id])
             assert !model_class.friendly.exists?(record.friendly_id + "-hello")
             assert !model_class.friendly.exists?(0)
           end
         end
 
         test "should be findable by id as integer" do
-          with_instance_of(model_class) {|record| assert model_class.friendly.find record.id.to_i}
+          with_instance_of(model_class) { |record| assert model_class.friendly.find record.id.to_i }
         end
 
         test "should be findable by id as string" do
-          with_instance_of(model_class) {|record| assert model_class.friendly.find record.id.to_s}
+          with_instance_of(model_class) { |record| assert model_class.friendly.find record.id.to_s }
         end
 
         test "should treat numeric part of string as an integer id" do
@@ -116,16 +115,16 @@ module FriendlyId
         end
 
         test "should be findable by numeric friendly_id" do
-          with_instance_of(model_class, :name => "206") {|record| assert model_class.friendly.find record.friendly_id}
+          with_instance_of(model_class, name: "206") { |record| assert model_class.friendly.find record.friendly_id }
         end
 
         test "to_param should return the friendly_id" do
-          with_instance_of(model_class) {|record| assert_equal record.friendly_id, record.to_param}
+          with_instance_of(model_class) { |record| assert_equal record.friendly_id, record.to_param }
         end
 
         if ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR < 2
           test "should be findable by themselves" do
-            with_instance_of(model_class) {|record| assert_equal record, model_class.friendly.find(record)}
+            with_instance_of(model_class) { |record| assert_equal record, model_class.friendly.find(record) }
           end
         end
 
@@ -138,11 +137,11 @@ module FriendlyId
         end
 
         test "instances found by a single id should not be read-only" do
-          with_instance_of(model_class) {|record| assert !model_class.friendly.find(record.friendly_id).readonly?}
+          with_instance_of(model_class) { |record| assert !model_class.friendly.find(record.friendly_id).readonly? }
         end
 
         test "failing finds with unfriendly_id should raise errors normally" do
-          assert_raises(ActiveRecord::RecordNotFound) {model_class.friendly.find 0}
+          assert_raises(ActiveRecord::RecordNotFound) { model_class.friendly.find 0 }
         end
 
         test "should return numeric id if the friendly_id is nil" do

data/test/simple_i18n_test.rb

@@ -5,7 +5,7 @@ class SimpleI18nTest < TestCaseClass
 
   class Journalist < ActiveRecord::Base
     extend FriendlyId
-    friendly_id :name, :use => :simple_i18n
+    friendly_id :name, use: :simple_i18n
   end
 
   def setup
@@ -13,8 +13,9 @@ class SimpleI18nTest < TestCaseClass
   end
 
   test "friendly_id should return the current locale's slug" do
-    journalist = Journalist.new(:name => "John Doe")
+    journalist = Journalist.new(name: "John Doe")
     journalist.slug_es = "juan-fulano"
+    journalist.slug_fr_ca = "jean-dupont"
     journalist.valid?
     I18n.with_locale(I18n.default_locale) do
       assert_equal "john-doe", journalist.friendly_id
@@ -22,17 +23,20 @@ class SimpleI18nTest < TestCaseClass
     I18n.with_locale(:es) do
       assert_equal "juan-fulano", journalist.friendly_id
     end
+    I18n.with_locale(:"fr-CA") do
+      assert_equal "jean-dupont", journalist.friendly_id
+    end
   end
 
   test "should create record with slug in column for the current locale" do
     I18n.with_locale(I18n.default_locale) do
-      journalist = Journalist.new(:name => "John Doe")
+      journalist = Journalist.new(name: "John Doe")
       journalist.valid?
       assert_equal "john-doe", journalist.slug_en
       assert_nil journalist.slug_es
     end
     I18n.with_locale(:es) do
-      journalist = Journalist.new(:name => "John Doe")
+      journalist = Journalist.new(name: "John Doe")
       journalist.valid?
       assert_equal "john-doe", journalist.slug_es
       assert_nil journalist.slug_en
@@ -41,7 +45,7 @@ class SimpleI18nTest < TestCaseClass
 
   test "to_param should return the numeric id when there's no slug for the current locale" do
     transaction do
-      journalist = Journalist.new(:name => "Juan Fulano")
+      journalist = Journalist.new(name: "Juan Fulano")
       I18n.with_locale(:es) do
         journalist.save!
         assert_equal "juan-fulano", journalist.to_param
@@ -52,7 +56,7 @@ class SimpleI18nTest < TestCaseClass
 
   test "should set friendly id for locale" do
     transaction do
-      journalist = Journalist.create!(:name => "John Smith")
+      journalist = Journalist.create!(name: "John Smith")
       journalist.set_friendly_id("Juan Fulano", :es)
       journalist.save!
       assert_equal "juan-fulano", journalist.slug_es
@@ -65,7 +69,7 @@ class SimpleI18nTest < TestCaseClass
   test "set friendly_id should fall back default locale when none is given" do
     transaction do
       journalist = I18n.with_locale(:es) do
-        Journalist.create!(:name => "Juan Fulano")
+        Journalist.create!(name: "Juan Fulano")
       end
       journalist.set_friendly_id("John Doe")
       journalist.save!
@@ -75,9 +79,9 @@ class SimpleI18nTest < TestCaseClass
 
   test "should sequence localized slugs" do
     transaction do
-      journalist = Journalist.create!(:name => "John Smith")
+      journalist = Journalist.create!(name: "John Smith")
       I18n.with_locale(:es) do
-        Journalist.create!(:name => "Juan Fulano")
+        Journalist.create!(name: "Juan Fulano")
       end
       journalist.set_friendly_id("Juan Fulano", :es)
       journalist.save!
@@ -93,12 +97,12 @@ class SimpleI18nTest < TestCaseClass
 
     test "should not overwrite other locale's slugs on update" do
       transaction do
-        journalist = Journalist.create!(:name => "John Smith")
+        journalist = Journalist.create!(name: "John Smith")
         journalist.set_friendly_id("Juan Fulano", :es)
         journalist.save!
         assert_equal "john-smith", journalist.to_param
         journalist.slug = nil
-        journalist.update :name => "Johnny Smith"
+        journalist.update name: "Johnny Smith"
         assert_equal "johnny-smith", journalist.to_param
         I18n.with_locale(:es) do
           assert_equal "juan-fulano", journalist.to_param
@@ -114,11 +118,17 @@ class SimpleI18nTest < TestCaseClass
       end
     end
 
+    test "should add locale to slug column for a locale with a region subtag" do
+      I18n.with_locale :"fr-CA" do
+        assert_equal "slug_fr_ca", Journalist.friendly_id_config.slug_column
+      end
+    end
+
     test "should add locale to non-default slug column and non-default locale" do
       model_class = Class.new(ActiveRecord::Base) do
         self.abstract_class = true
         extend FriendlyId
-        friendly_id :name, :use => :simple_i18n, :slug_column => :foo
+        friendly_id :name, use: :simple_i18n, slug_column: :foo
       end
       I18n.with_locale :es do
         assert_equal "foo_es", model_class.friendly_id_config.slug_column