friendly_id 5.2.3 → 5.4.0

data/test/history_test.rb

@@ -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
 
@@ -93,6 +92,28 @@ class HistoryTest < TestCaseClass
     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"
@@ -109,10 +130,10 @@ class HistoryTest < TestCaseClass
       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
@@ -172,7 +193,7 @@ class HistoryTestWithAutomaticSlugRegeneration < HistoryTest
   end
 end
 
-class DependentDestroyTest < HistoryTest
+class DependentDestroyTest < TestCaseClass
 
   include FriendlyId::Test
 
@@ -211,6 +232,37 @@ class DependentDestroyTest < HistoryTest
   end
 end
 
+if ActiveRecord::VERSION::STRING >= '5.0'
+  class HistoryTestWithParanoidDeletes < HistoryTest
+    class ParanoidRecord < ActiveRecord::Base
+      extend FriendlyId
+      friendly_id :name, :use => :history, :dependent => false
+
+      default_scope { where(deleted_at: nil) }
+    end
+
+    def model_class
+      ParanoidRecord
+    end
+
+    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?
+
+        record.update deleted_at: Time.now
+
+        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'
+      end
+    end
+  end
+end
+
 class HistoryTestWithSti < HistoryTest
   class Journalist < ActiveRecord::Base
     extend FriendlyId
@@ -248,7 +300,7 @@ class HistoryTestWithFriendlyFinders < HistoryTest
         begin
           assert model_class.find(old_friendly_id)
           assert model_class.exists?(old_friendly_id), "should exist? by old id for #{model_class.name}"
-        rescue ActiveRecord::RecordNotFound => e
+        rescue ActiveRecord::RecordNotFound
           flunk "Could not find record by old id for #{model_class.name}"
         end
       end
@@ -346,6 +398,33 @@ class ScopedHistoryTest < TestCaseClass
     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!
@@ -356,4 +435,4 @@ class ScopedHistoryTest < TestCaseClass
       assert_equal record.slug, second_record.slug
     end
   end
-end
+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
+      record = model_class.create! :name => "123"
+      assert model_class.friendly.exists?("123")
+    end
+  end
+end

data/test/object_utils_test.rb

@@ -19,6 +19,8 @@ class ObjectUtilsTest < TestCaseClass
   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

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,7 +62,7 @@ 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.add(:name, "FAIL")}
             record.save
@@ -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

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
 

data.tar.gz.sig

@@ -0,0 +1,2 @@
+�Hi�/��P:L�񔢣$�v���ҿ�Z��c�����B�C�݁�n��^���KӤ��&%�s[��oϗ*�(0&��g��⸡�3<
p�X��]����Z�'�&.3f�Ȫ�,�#-�S�YF�Ԛ�_�L�N�6�W	�E�dl��N�biS��f�+�� �[
+eY~��˔��	O�	�y~B��K8v$"O'�:�