friendly_id 5.2.2 → 5.4.0

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
+      record = model_class.create! :name => "123"
+      assert model_class.friendly.exists?("123")
+    end
+  end
+end

data/test/object_utils_test.rb

@@ -14,14 +14,16 @@ class ObjectUtilsTest < TestCaseClass
   end
 
   test "numeric strings are neither friendly nor unfriendly" do
-    assert_equal nil, "1".friendly_id?
-    assert_equal nil, "1".unfriendly_id?
+    assert_nil "1".friendly_id?
+    assert_nil "1".unfriendly_id?
   end
 
   test "ActiveRecord::Base instances should be unfriendly_ids" do
+    FriendlyId.mark_as_unfriendly(ActiveRecord::Base)
+
     model_class = Class.new(ActiveRecord::Base) do
       self.table_name = "authors"
     end
     assert model_class.new.unfriendly_id?
   end
-end
+end

data/test/reserved_test.rb

@@ -62,4 +62,14 @@ class ReservedTest < TestCaseClass
     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
+    end
+
+    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

@@ -2,7 +2,14 @@ require "friendly_id/migration"
 
 module FriendlyId
   module Test
-    class Schema < ActiveRecord::Migration
+    migration_class =
+      if ActiveRecord::VERSION::MAJOR >= 5
+        ActiveRecord::Migration[4.2]
+      else
+        ActiveRecord::Migration
+      end
+
+    class Schema < migration_class
       class << self
         def down
           CreateFriendlyIdSlugs.down
@@ -41,6 +48,12 @@ module FriendlyId
             add_column table_name, :slug, :string
           end
 
+          paranoid_tables.each do |table_name|
+            add_column table_name, :slug, :string
+            add_column table_name, :deleted_at, :datetime
+            add_index table_name, :deleted_at
+          end
+
           # This will be used to test scopes
           add_column :novels, :novelist_id, :integer
           add_column :novels, :publisher_id, :integer
@@ -78,6 +91,10 @@ module FriendlyId
           %w[journalists articles novelists novels manuals cities]
         end
 
+        def paranoid_tables
+          ["paranoid_records"]
+        end
+
         def tables_with_uuid_primary_key
           ["menu_items"]
         end
@@ -91,7 +108,7 @@ module FriendlyId
         end
 
         def tables
-          simple_tables + slugged_tables + scoped_tables
+          simple_tables + slugged_tables + scoped_tables + paranoid_tables
         end
       end
     end

data/test/scoped_test.rb

@@ -81,4 +81,17 @@ class ScopedTest < TestCaseClass
     end
   end
 
+  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")
+      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

@@ -137,4 +137,63 @@ class SequentiallySluggedTestWithHistory < TestCaseClass
       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
+
+      record2.name = "One more test name"
+      record2.slug = nil
+      record2.save!
+      assert_equal 'one-more-test-name', record2.slug
+
+      record3.name = "Test name"
+      record3.slug = nil
+      record3.save!
+      assert_equal 'test-name-3', record3.slug
+    end
+  end
+end
+
+class City < ActiveRecord::Base
+  has_many :restaurants
+end
+
+class Restaurant < ActiveRecord::Base
+  extend FriendlyId
+  belongs_to :city
+  friendly_id :name, :use => [:sequentially_slugged, :scoped, :history], :scope => :city
+end
+
+class SequentiallySluggedTestWithScopedHistory < TestCaseClass
+  include FriendlyId::Test
+  include FriendlyId::Test::Shared::Core
+
+  def model_class
+    Restaurant
+  end
+
+  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
+
+      assert_equal 'test-name', record1.slug
+      assert_equal 'test-name-2', record2.slug
+
+      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
+    end
+  end
 end

data/test/shared.rb

@@ -62,9 +62,9 @@ module FriendlyId
           my_model_class = Class.new(model_class)
           self.class.const_set("Foo", my_model_class)
           with_instance_of my_model_class do |record|
-            record.update_attributes my_model_class.friendly_id_config.slug_column => nil
+            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[:name] = "FAIL"}
+            record.class.validate Proc.new {errors.add(:name, "FAIL")}
             record.save
             assert_equal record.to_param, record.friendly_id
           end
@@ -132,7 +132,7 @@ module FriendlyId
         test "updating record's other values should not change the friendly_id" do
           with_instance_of model_class do |record|
             old = record.friendly_id
-            record.update_attributes! :active => false
+            record.update! active: false
             assert model_class.friendly.find old
           end
         end
@@ -174,7 +174,7 @@ module FriendlyId
         end
 
         test "should return nil for to_param with a new record" do
-          assert_equal nil, model_class.new.to_param
+          assert_nil model_class.new.to_param
         end
       end
     end

data/test/simple_i18n_test.rb

@@ -91,14 +91,14 @@ class SimpleI18nTest < TestCaseClass
   class RegressionTest < TestCaseClass
     include FriendlyId::Test
 
-    test "should not overwrite other locale's slugs on update_attributes" do
+    test "should not overwrite other locale's slugs on update" do
       transaction do
         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_attributes :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

data/test/slugged_test.rb

@@ -92,7 +92,7 @@ class SluggedTest < TestCaseClass
     end
   end
 
-  test "should not set slug on create if unrelated validations fail" do
+  test "should set slug on create if unrelated validations fail" do
     klass = Class.new model_class do
       validates_presence_of :active
       friendly_id :name, :use => :slugged
@@ -106,11 +106,30 @@ class SluggedTest < TestCaseClass
       instance = klass.new :name => 'foo'
       refute instance.save
       refute instance.valid?
+      assert_equal 'foo', instance.slug
+    end
+  end
+
+  test "should not set slug on create if slug validation fails" do
+    klass = Class.new model_class do
+      validates_presence_of :active
+      validates_length_of :slug, :minimum => 2
+      friendly_id :name, :use => :slugged
+
+      def self.name
+        "Journalist"
+      end
+    end
+
+    transaction do
+      instance = klass.new :name => 'x'
+      refute instance.save
+      refute instance.valid?
       assert_nil instance.slug
     end
   end
 
-  test "should not set slug on create if unrelated validations fail with custom slug_column" do
+  test "should set slug on create if unrelated validations fail with custom slug_column" do
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = 'authors'
       extend FriendlyId
@@ -126,11 +145,31 @@ class SluggedTest < TestCaseClass
       instance = klass.new :name => 'foo'
       refute instance.save
       refute instance.valid?
+      assert_equal 'foo', instance.subdomain
+    end
+  end
+
+  test "should not set slug on create if custom slug column validations fail" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'authors'
+      extend FriendlyId
+      validates_length_of :subdomain, :minimum => 2
+      friendly_id :name, :use => :slugged, :slug_column => :subdomain
+
+      def self.name
+        "Author"
+      end
+    end
+
+    transaction do
+      instance = klass.new :name => 'x'
+      refute instance.save
+      refute instance.valid?
       assert_nil instance.subdomain
     end
   end
 
-  test "should not update slug on save if unrelated validations fail" do
+  test "should keep new slug on save if unrelated validations fail" do
     klass = Class.new model_class do
       validates_presence_of :active
       friendly_id :name, :use => :slugged
@@ -149,10 +188,31 @@ class SluggedTest < TestCaseClass
       instance.active = nil
       refute instance.save
       refute instance.valid?
-      assert_equal 'foo', instance.slug
+      assert_equal 'foobar', instance.slug
     end
   end
 
+  test "should not update slug on save if slug validations fail" do
+    klass = Class.new model_class do
+      validates_length_of :slug, :minimum => 2
+      friendly_id :name, :use => :slugged
+
+      def self.name
+        "Journalist"
+      end
+    end
+
+    transaction do
+      instance = klass.new :name => 'foo', :active => true
+      assert instance.save
+      assert instance.valid?
+      instance.name = 'x'
+      instance.slug = nil
+      instance.active = nil
+      refute instance.save
+      assert_equal 'foo', instance.slug
+    end
+  end
 end
 
 class SlugGeneratorTest < TestCaseClass
@@ -419,6 +479,110 @@ class FailedValidationAfterUpdateRegressionTest < TestCaseClass
 
 end
 
+class ToParamTest < TestCaseClass
+
+  include FriendlyId::Test
+
+  class Journalist < ActiveRecord::Base
+    extend FriendlyId
+    validates_presence_of :active
+    validates_length_of :slug, :minimum => 2
+    friendly_id :name, :use => :slugged
+
+    attr_accessor :to_param_in_callback
+
+    after_save do
+      self.to_param_in_callback = to_param
+    end
+  end
+
+  test "to_param should return nil if record is unpersisted" do
+    assert_nil Journalist.new.to_param
+  end
+
+  test "to_param should return original slug if record failed validation" do
+    journalist = Journalist.new :name => 'Clark Kent', :active => nil
+    refute journalist.save
+    assert_equal 'clark-kent', journalist.to_param
+  end
+
+  test "to_param should clear slug attributes if slug attribute fails validation" do
+    journalist = Journalist.new :name => 'x', :active => true
+    refute journalist.save
+    assert_nil journalist.to_param
+  end
+
+  test "to_param should clear slug attribute if slug attribute fails validation and unrelated validation fails" do
+    journalist = Journalist.new :name => 'x', :active => nil
+    refute journalist.save
+    assert_nil journalist.to_param
+  end
+
+  test "to_param should use slugged attribute if record saved successfully" do
+    transaction do
+      journalist = Journalist.new :name => 'Clark Kent', :active => true
+      assert journalist.save
+      assert_equal 'clark-kent', journalist.to_param
+    end
+  end
+
+  test "to_param should use new slug if existing record changes but fails to save" do
+    transaction do
+      journalist = Journalist.new :name => 'Clark Kent', :active => true
+      assert journalist.save
+      journalist.name = 'Superman'
+      journalist.slug = nil
+      journalist.active = nil
+      refute journalist.save
+      assert_equal 'superman', journalist.to_param
+    end
+  end
+
+  test "to_param should use original slug if new slug attribute is not valid" do
+    transaction do
+      journalist = Journalist.new :name => 'Clark Kent', :active => true
+      assert journalist.save
+      journalist.name = 'x'
+      journalist.slug = nil
+      journalist.active = nil
+      refute journalist.save
+      assert_equal 'clark-kent', journalist.to_param
+    end
+  end
+
+  test "to_param should use new slug if existing record changes successfully" do
+    transaction do
+      journalist = Journalist.new :name => 'Clark Kent', :active => true
+      assert journalist.save
+      journalist.name = 'Superman'
+      journalist.slug = nil
+      assert journalist.save
+      assert_equal 'superman', journalist.to_param
+    end
+  end
+
+  test "to_param should use new slug within callbacks if new record is saved successfully" do
+    transaction do
+      journalist = Journalist.new :name => 'Clark Kent', :active => true
+      assert journalist.save
+      assert_equal 'clark-kent', journalist.to_param_in_callback, "value of to_param in callback should use the new slug value"
+    end
+  end
+
+  test "to_param should use new slug within callbacks if existing record changes successfully" do
+    transaction do
+      journalist = Journalist.new :name => 'Clark Kent', :active => true
+      assert journalist.save
+      assert journalist.valid?
+      journalist.name = 'Superman'
+      journalist.slug = nil
+      assert journalist.save, "save should be successful"
+      assert_equal 'superman', journalist.to_param_in_callback, "value of to_param in callback should use the new slug value"
+    end
+  end
+
+end
+
 class ConfigurableRoutesTest < TestCaseClass
   include FriendlyId::Test