friendly_id 5.5.1 → 5.7.0

data/test/scoped_test.rb

@@ -1,95 +0,0 @@
-require "helper"
-
-class Novelist < ActiveRecord::Base
-  extend FriendlyId
-  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]
-
-  def should_generate_new_friendly_id?
-    new_record? || super
-  end
-end
-
-class Publisher < ActiveRecord::Base
-  has_many :novels
-end
-
-class ScopedTest < TestCaseClass
-  include FriendlyId::Test
-  include FriendlyId::Test::Shared::Core
-
-  def model_class
-    Novel
-  end
-
-  test "should detect scope column from belongs_to relation" do
-    assert_equal ["publisher_id", "novelist_id"], Novel.friendly_id_config.scope_columns
-  end
-
-  test "should detect scope column from explicit column name" do
-    model_class = Class.new(ActiveRecord::Base) do
-      self.abstract_class = true
-      extend FriendlyId
-      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")
-      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
-      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
-      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
-    with_instance_of(model_class) do |record|
-      old_id = record.friendly_id
-      record.slug = nil
-      record.save!
-      assert_equal old_id, record.friendly_id
-    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

@@ -1,214 +0,0 @@
-require "helper"
-
-class Article < ActiveRecord::Base
-  extend FriendlyId
-  friendly_id :name, use: :sequentially_slugged
-end
-
-class SequentiallySluggedTest < TestCaseClass
-  include FriendlyId::Test
-  include FriendlyId::Test::Shared::Core
-
-  def model_class
-    Article
-  end
-
-  test "should generate numerically sequential slugs" do
-    transaction do
-      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 }
-    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")
-
-      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")
-
-      assert_equal "a-thing-4", record_4.slug
-    end
-  end
-
-  test "should cope with strange column names" do
-    model_class = Class.new(ActiveRecord::Base) do
-      self.table_name = "journalists"
-      extend FriendlyId
-      friendly_id :name, use: :sequentially_slugged, slug_column: "strange name"
-    end
-
-    transaction do
-      record_1 = model_class.create! name: "Lois Lane"
-      record_2 = model_class.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
-
-  test "should correctly sequence slugs that end in a number" do
-    transaction do
-      record1 = model_class.create! name: "Peugeuot 206"
-      assert_equal "peugeuot-206", record1.slug
-      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"
-      assert_equal "2010-to-2015-records", record1.slug
-      record2 = model_class.create! name: "2010 to 2015 Records"
-      assert_equal "2010-to-2015-records-2", record2.slug
-    end
-  end
-
-  test "should sequence with a custom sequence separator" do
-    model_class = Class.new(ActiveRecord::Base) do
-      self.table_name = "novelists"
-      extend FriendlyId
-      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
-    end
-  end
-
-  test "should not generate a slug when canidates set is empty" do
-    model_class = Class.new(ActiveRecord::Base) do
-      self.table_name = "cities"
-      extend FriendlyId
-      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)
-      assert_nil record.slug
-    end
-  end
-
-  test "should not generate a slug when the sluggable attribute is blank" do
-    record = model_class.create!(name: "")
-    assert_nil record.slug
-  end
-end
-
-class SequentiallySluggedTestWithHistory < TestCaseClass
-  include FriendlyId::Test
-  include FriendlyId::Test::Shared::Core
-
-  class Article < ActiveRecord::Base
-    extend FriendlyId
-    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
-    Article
-  end
-
-  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
-
-      record2.name = "Test name"
-      record2.slug = nil
-      record2.save!
-      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
-
-  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
-
-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!
-      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

@@ -1,181 +0,0 @@
-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?
-        end
-
-        test "should make a new slug if the slug has been set to nil changed" do
-          with_instance_of model_class do |record|
-            record.name = "Changed Value"
-            record.slug = nil
-            record.save!
-            assert_equal "changed-value", record.slug
-          end
-        end
-
-        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/)
-          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
-            record.save!
-            record.reload
-            assert_equal old, record.to_param
-          end
-        end
-
-        test "should not change the sequence on save" do
-          with_instance_of model_class do |record|
-            record2 = model_class.create! name: record.name
-            friendly_id = record2.friendly_id
-            record2.active = !record2.active
-            record2.save!
-            assert_equal friendly_id, record2.reload.friendly_id
-          end
-        end
-
-        test "should create slug on save if the slug is nil" do
-          with_instance_of model_class do |record|
-            record.slug = nil
-            record.save!
-            refute_nil record.slug
-          end
-        end
-
-        test "should set the slug to nil on dup" do
-          with_instance_of model_class do |record|
-            record2 = record.dup
-            assert_nil record2.slug
-          end
-        end
-
-        test "when validations block save, to_param should return friendly_id rather than nil" do
-          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 my_model_class.friendly_id_config.slug_column => nil
-            record = my_model_class.friendly.find(record.id)
-            record.class.validate proc { errors.add(:name, "FAIL") }
-            record.save
-            assert_equal record.to_param, record.friendly_id
-          end
-        end
-      end
-
-      module Core
-        test "finds should respect conditions" do
-          with_instance_of(model_class) do |record|
-            assert_raises(ActiveRecord::RecordNotFound) do
-              model_class.where("1 = 2").friendly.find record.friendly_id
-            end
-            assert_raises(ActiveRecord::RecordNotFound) do
-              model_class.where("1 = 2").friendly.find record.id
-            end
-          end
-        end
-
-        test "should be findable by friendly id" do
-          with_instance_of(model_class) { |record| assert model_class.friendly.find record.friendly_id }
-        end
-
-        test "should exist? by friendly id" do
-          with_instance_of(model_class) do |record|
-            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?(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 }
-        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 }
-        end
-
-        test "should treat numeric part of string as an integer id" do
-          with_instance_of(model_class) do |record|
-            assert_raises(ActiveRecord::RecordNotFound) do
-              model_class.friendly.find "#{record.id}-foo"
-            end
-          end
-        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 }
-        end
-
-        test "to_param should return the friendly_id" do
-          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) }
-          end
-        end
-
-        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! active: false
-            assert model_class.friendly.find old
-          end
-        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? }
-        end
-
-        test "failing finds with unfriendly_id should raise errors normally" do
-          assert_raises(ActiveRecord::RecordNotFound) { model_class.friendly.find 0 }
-        end
-
-        test "should return numeric id if the friendly_id is nil" do
-          with_instance_of(model_class) do |record|
-            record.expects(:friendly_id).returns(nil)
-            assert_equal record.id.to_s, record.to_param
-          end
-        end
-
-        test "should return numeric id if the friendly_id is an empty string" do
-          with_instance_of(model_class) do |record|
-            record.expects(:friendly_id).returns("")
-            assert_equal record.id.to_s, record.to_param
-          end
-        end
-
-        test "should return the friendly_id as a string" do
-          with_instance_of(model_class) do |record|
-            record.expects(:friendly_id).returns(5)
-            assert_equal "5", record.to_param
-          end
-        end
-
-        test "should return numeric id if the friendly_id is blank" do
-          with_instance_of(model_class) do |record|
-            record.expects(:friendly_id).returns("  ")
-            assert_equal record.id.to_s, record.to_param
-          end
-        end
-
-        test "should return nil for to_param with a new record" do
-          assert_nil model_class.new.to_param
-        end
-      end
-    end
-  end
-end

data/test/simple_i18n_test.rb

@@ -1,144 +0,0 @@
-require "helper"
-
-class SimpleI18nTest < TestCaseClass
-  include FriendlyId::Test
-
-  class Journalist < ActiveRecord::Base
-    extend FriendlyId
-    friendly_id :name, use: :simple_i18n
-  end
-
-  def setup
-    I18n.locale = :en
-  end
-
-  test "friendly_id should return the current locale's slug" do
-    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
-    end
-    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.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.valid?
-      assert_equal "john-doe", journalist.slug_es
-      assert_nil journalist.slug_en
-    end
-  end
-
-  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")
-      I18n.with_locale(:es) do
-        journalist.save!
-        assert_equal "juan-fulano", journalist.to_param
-      end
-      assert_equal journalist.id.to_s, journalist.to_param
-    end
-  end
-
-  test "should set friendly id for locale" do
-    transaction do
-      journalist = Journalist.create!(name: "John Smith")
-      journalist.set_friendly_id("Juan Fulano", :es)
-      journalist.save!
-      assert_equal "juan-fulano", journalist.slug_es
-      I18n.with_locale(:es) do
-        assert_equal "juan-fulano", journalist.to_param
-      end
-    end
-  end
-
-  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")
-      end
-      journalist.set_friendly_id("John Doe")
-      journalist.save!
-      assert_equal "john-doe", journalist.slug_en
-    end
-  end
-
-  test "should sequence localized slugs" do
-    transaction do
-      journalist = Journalist.create!(name: "John Smith")
-      I18n.with_locale(:es) do
-        Journalist.create!(name: "Juan Fulano")
-      end
-      journalist.set_friendly_id("Juan Fulano", :es)
-      journalist.save!
-      assert_equal "john-smith", journalist.to_param
-      I18n.with_locale(:es) do
-        assert_match(/juan-fulano-.+/, journalist.to_param)
-      end
-    end
-  end
-
-  class RegressionTest < TestCaseClass
-    include FriendlyId::Test
-
-    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 name: "Johnny Smith"
-        assert_equal "johnny-smith", journalist.to_param
-        I18n.with_locale(:es) do
-          assert_equal "juan-fulano", journalist.to_param
-        end
-      end
-    end
-  end
-
-  class ConfigurationTest < TestCaseClass
-    test "should add locale to slug column for a non-default locale" do
-      I18n.with_locale :es do
-        assert_equal "slug_es", Journalist.friendly_id_config.slug_column
-      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
-      end
-      I18n.with_locale :es do
-        assert_equal "foo_es", model_class.friendly_id_config.slug_column
-      end
-    end
-
-    test "should add locale to slug column for default locale" do
-      I18n.with_locale(I18n.default_locale) do
-        assert_equal "slug_en", Journalist.friendly_id_config.slug_column
-      end
-    end
-  end
-end