friendly_id 5.6.0 → 5.7.0

data/test/object_utils_test.rb

@@ -1,27 +0,0 @@
-require "helper"
-
-class ObjectUtilsTest < TestCaseClass
-  include FriendlyId::Test
-
-  test "strings with letters are friendly_ids" do
-    assert "a".friendly_id?
-  end
-
-  test "integers should be unfriendly ids" do
-    assert 1.unfriendly_id?
-  end
-
-  test "numeric strings are neither friendly nor unfriendly" do
-    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

data/test/reserved_test.rb

@@ -1,73 +0,0 @@
-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]
-
-    after_validation :move_friendly_id_error_to_name
-
-    def move_friendly_id_error_to_name
-      errors.add :name, *errors.delete(:friendly_id) if errors[:friendly_id].present?
-    end
-
-    def slug_candidates
-      name
-    end
-  end
-
-  def model_class
-    Journalist
-  end
-
-  test "should reserve words" do
-    %w[new edit NEW Edit].each do |word|
-      transaction do
-        assert_raises(ActiveRecord::RecordInvalid) { model_class.create! name: word }
-      end
-    end
-  end
-
-  test "should move friendly_id error to name" do
-    with_instance_of(model_class) do |record|
-      record.errors.add :name, "xxx"
-      record.errors.add :friendly_id, "yyy"
-      record.move_friendly_id_error_to_name
-      assert record.errors[:name].present? && record.errors[:friendly_id].blank?
-      assert_equal 2, record.errors.count
-    end
-  end
-
-  test "should reject reserved candidates" do
-    transaction do
-      record = model_class.new(name: "new")
-      def record.slug_candidates
-        [:name, "foo"]
-      end
-      record.save!
-      assert_equal "foo", record.friendly_id
-    end
-  end
-
-  test "should be invalid if all candidates are reserved" do
-    transaction do
-      record = model_class.new(name: "new")
-      def record.slug_candidates
-        ["edit", "new"]
-      end
-      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
-    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

@@ -1,117 +0,0 @@
-require "friendly_id/migration"
-
-module FriendlyId
-  module Test
-    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
-          tables.each do |name|
-            drop_table name
-          end
-        end
-
-        def up
-          # TODO: use schema version to avoid ugly hacks like this
-          return if @done
-          CreateFriendlyIdSlugs.migrate :up
-
-          tables.each do |table_name|
-            create_table table_name do |t|
-              t.string :name
-              t.boolean :active
-            end
-          end
-
-          tables_with_uuid_primary_key.each do |table_name|
-            create_table table_name, primary_key: :uuid_key, id: false do |t|
-              t.string :name
-              t.string :uuid_key, null: false
-              t.string :slug
-            end
-            add_index table_name, :slug, unique: true
-          end
-
-          slugged_tables.each do |table_name|
-            add_column table_name, :slug, :string
-            add_index table_name, :slug, unique: true if table_name != "novels"
-          end
-
-          scoped_tables.each do |table_name|
-            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
-          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
-
-          # This will be used to test STI
-          add_column :journalists, "type", :string
-
-          # These will be used to test i18n
-          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
-
-          # Used to test :scoped and :history together
-          add_column :restaurants, :city_id, :integer
-
-          # Used to test candidates
-          add_column :cities, :code, :string, limit: 3
-
-          # Used as a non-default slug_column
-          add_column :authors, :subdomain, :string
-
-          @done = true
-        end
-
-        private
-
-        def slugged_tables
-          %w[journalists articles novelists novels manuals cities]
-        end
-
-        def paranoid_tables
-          ["paranoid_records"]
-        end
-
-        def tables_with_uuid_primary_key
-          ["menu_items"]
-        end
-
-        def scoped_tables
-          ["restaurants"]
-        end
-
-        def simple_tables
-          %w[authors books publishers]
-        end
-
-        def tables
-          simple_tables + slugged_tables + scoped_tables + paranoid_tables
-        end
-      end
-    end
-  end
-end

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