friendly_id 5.6.0 → 5.7.0

data/gemfiles/Gemfile.rails-7.0.rb

@@ -1,22 +0,0 @@
-source "https://rubygems.org"
-
-gemspec path: "../"
-
-gem "activerecord", "~> 7.0.0"
-gem "railties", "~> 7.0.0"
-
-# Database Configuration
-group :development, :test do
-  platforms :jruby do
-    gem "activerecord-jdbcmysql-adapter", "~> 61.0"
-    gem "activerecord-jdbcpostgresql-adapter", "~> 61.0"
-    gem "kramdown"
-  end
-
-  platforms :ruby, :rbx do
-    gem "sqlite3"
-    gem "mysql2"
-    gem "pg"
-    gem "redcarpet"
-  end
-end

data/gemfiles/Gemfile.rails-7.1.rb

@@ -1,22 +0,0 @@
-source "https://rubygems.org"
-
-gemspec path: "../"
-
-gem "activerecord", "~> 7.1.0"
-gem "railties", "~> 7.1.0"
-
-# Database Configuration
-group :development, :test do
-  platforms :jruby do
-    gem "activerecord-jdbcmysql-adapter", "~> 61.0"
-    gem "activerecord-jdbcpostgresql-adapter", "~> 61.0"
-    gem "kramdown"
-  end
-
-  platforms :ruby, :rbx do
-    gem "sqlite3"
-    gem "mysql2"
-    gem "pg"
-    gem "redcarpet"
-  end
-end

data/gemfiles/Gemfile.rails-7.2.rb

@@ -1,22 +0,0 @@
-source "https://rubygems.org"
-
-gemspec path: "../"
-
-gem "activerecord", "~> 7.2.0"
-gem "railties", "~> 7.2.0"
-
-# Database Configuration
-group :development, :test do
-  platforms :jruby do
-    gem "activerecord-jdbcmysql-adapter", "~> 61.0"
-    gem "activerecord-jdbcpostgresql-adapter", "~> 61.0"
-    gem "kramdown"
-  end
-
-  platforms :ruby, :rbx do
-    gem "sqlite3"
-    gem "mysql2"
-    gem "pg"
-    gem "redcarpet"
-  end
-end

data/gemfiles/Gemfile.rails-8.0.rb

@@ -1,22 +0,0 @@
-source "https://rubygems.org"
-
-gemspec path: "../"
-
-gem "activerecord", "~> 8.0.0"
-gem "railties", "~> 8.0.0"
-
-# Database Configuration
-group :development, :test do
-  platforms :jruby do
-    gem "activerecord-jdbcmysql-adapter", "~> 61.0"
-    gem "activerecord-jdbcpostgresql-adapter", "~> 61.0"
-    gem "kramdown"
-  end
-
-  platforms :ruby, :rbx do
-    gem "sqlite3"
-    gem "mysql2"
-    gem "pg"
-    gem "redcarpet"
-  end
-end

data/guide.rb

@@ -1,24 +0,0 @@
-#!/usr/bin/env ruby
-
-# This script generates the Guide.md file included in the Yard docs.
-
-def comments_from path
-  path = File.expand_path("../lib/friendly_id/#{path}", __FILE__)
-  matches = File.read(path).match(/\n\s*# @guide begin\n(.*)\s*# @guide end/m)
-
-  return if matches.nil?
-
-  match = matches[1].to_s
-  match.split("\n")
-    .map { |x| x.sub(/^\s*#\s?/, "") } # Strip off the comment, leading whitespace, and the space after the comment
-    .reject { |x| x =~ /^@/ }         # Ignore yarddoc tags for the guide
-    .join("\n").strip
-end
-
-File.open(File.expand_path("../Guide.md", __FILE__), "w:utf-8") do |guide|
-  ["../friendly_id.rb", "base.rb", "finders.rb", "slugged.rb", "history.rb",
-    "scoped.rb", "simple_i18n.rb", "reserved.rb"].each do |file|
-    guide.write comments_from file
-    guide.write "\n"
-  end
-end

data/test/base_test.rb

@@ -1,69 +0,0 @@
-require "helper"
-
-class CoreTest < TestCaseClass
-  include FriendlyId::Test
-
-  test "friendly_id can be added using 'extend'" do
-    klass = Class.new(ActiveRecord::Base) do
-      extend FriendlyId
-    end
-    assert klass.respond_to? :friendly_id
-  end
-
-  test "friendly_id can be added using 'include'" do
-    klass = Class.new(ActiveRecord::Base) do
-      include FriendlyId
-    end
-    assert klass.respond_to? :friendly_id
-  end
-
-  test "friendly_id should accept a base and a hash" do
-    klass = Class.new(ActiveRecord::Base) do
-      self.abstract_class = true
-      extend FriendlyId
-      friendly_id :foo, use: :slugged, slug_column: :bar
-    end
-    assert klass < FriendlyId::Slugged
-    assert_equal :foo, klass.friendly_id_config.base
-    assert_equal :bar, klass.friendly_id_config.slug_column
-  end
-
-  test "friendly_id should accept a block" do
-    klass = Class.new(ActiveRecord::Base) do
-      self.abstract_class = true
-      extend FriendlyId
-      friendly_id :foo do |config|
-        config.use :slugged
-        config.base = :foo
-        config.slug_column = :bar
-      end
-    end
-    assert klass < FriendlyId::Slugged
-    assert_equal :foo, klass.friendly_id_config.base
-    assert_equal :bar, klass.friendly_id_config.slug_column
-  end
-
-  test "the block passed to friendly_id should be evaluated before arguments" do
-    klass = Class.new(ActiveRecord::Base) do
-      self.abstract_class = true
-      extend FriendlyId
-      friendly_id :foo do |config|
-        config.base = :bar
-      end
-    end
-    assert_equal :foo, klass.friendly_id_config.base
-  end
-
-  test "should allow defaults to be set via a block" do
-    FriendlyId.defaults do |config|
-      config.base = :foo
-    end
-    klass = Class.new(ActiveRecord::Base) do
-      self.abstract_class = true
-      extend FriendlyId
-    end
-    assert_equal :foo, klass.friendly_id_config.base
-  ensure
-    FriendlyId.instance_variable_set :@defaults, nil
-  end
-end

data/test/benchmarks/finders.rb

@@ -1,90 +0,0 @@
-require File.expand_path("../../helper", __FILE__)
-require "ffaker"
-
-# This benchmark tests ActiveRecord and FriendlyId methods for performing a find
-#
-# ActiveRecord: where.first                     8.970000   0.040000   9.010000 (  9.029544)
-# ActiveRecord: where.take                      8.100000   0.030000   8.130000 (  8.157024)
-# ActiveRecord: find                            2.720000   0.010000   2.730000 (  2.733527)
-# ActiveRecord: find_by(:id)                    2.920000   0.000000   2.920000 (  2.926318)
-# ActiveRecord: find_by(:slug)                  2.650000   0.020000   2.670000 (  2.662677)
-# FriendlyId: find (in-table slug w/ finders)   9.820000   0.030000   9.850000 (  9.873358)
-# FriendlyId: friendly.find (in-table slug)    12.890000   0.050000  12.940000 ( 12.951156)
-
-N = 50000
-
-def transaction
-  ActiveRecord::Base.transaction do
-    yield
-
-    raise ActiveRecord::Rollback
-  end
-end
-
-class Array
-  def rand
-    self[Kernel.rand(length)]
-  end
-end
-
-Book = Class.new ActiveRecord::Base
-
-class Journalist < ActiveRecord::Base
-  extend FriendlyId
-  friendly_id :name, use: :slugged
-end
-
-class Manual < ActiveRecord::Base
-  extend FriendlyId
-  friendly_id :name, use: :history
-end
-
-class Restaurant < ActiveRecord::Base
-  extend FriendlyId
-  friendly_id :name, use: :finders
-end
-
-BOOKS = []
-JOURNALISTS = []
-MANUALS = []
-RESTAURANTS = []
-
-100.times do
-  name = FFaker::Name.name
-  BOOKS << (Book.create! name: name).id
-  JOURNALISTS << (Journalist.create! name: name).friendly_id
-  MANUALS << (Manual.create! name: name).friendly_id
-  RESTAURANTS << (Restaurant.create! name: name).friendly_id
-end
-
-ActiveRecord::Base.connection.execute "UPDATE manuals SET slug = NULL"
-
-Benchmark.bmbm do |x|
-  x.report "ActiveRecord: where.first" do
-    N.times { Book.where(id: BOOKS.rand).first }
-  end
-
-  x.report "ActiveRecord: where.take" do
-    N.times { Book.where(id: BOOKS.rand).take }
-  end
-
-  x.report "ActiveRecord: find" do
-    N.times { Book.find BOOKS.rand }
-  end
-
-  x.report "ActiveRecord: find_by(:id)" do
-    N.times { Book.find_by(id: BOOKS.rand) }
-  end
-
-  x.report "ActiveRecord: find_by(:slug)" do
-    N.times { Restaurant.find_by(slug: RESTAURANTS.rand) }
-  end
-
-  x.report "FriendlyId: find (in-table slug w/ finders)" do
-    N.times { Restaurant.find RESTAURANTS.rand }
-  end
-
-  x.report "FriendlyId: friendly.find (in-table slug)" do
-    N.times { Restaurant.friendly.find RESTAURANTS.rand }
-  end
-end

data/test/benchmarks/object_utils.rb

@@ -1,56 +0,0 @@
-require File.expand_path("../../helper", __FILE__)
-
-# This benchmark compares the timings of the friendly_id? and unfriendly_id? on various objects
-#
-# integer friendly_id?            6.370000   0.000000   6.370000 (  6.380925)
-# integer unfriendly_id?          6.640000   0.010000   6.650000 (  6.646057)
-# AR::Base friendly_id?           2.340000   0.000000   2.340000 (  2.340743)
-# AR::Base unfriendly_id?         2.560000   0.000000   2.560000 (  2.560039)
-# hash friendly_id?               5.090000   0.010000   5.100000 (  5.097662)
-# hash unfriendly_id?             5.430000   0.000000   5.430000 (  5.437160)
-# nil friendly_id?                5.610000   0.010000   5.620000 (  5.611487)
-# nil unfriendly_id?              5.870000   0.000000   5.870000 (  5.880484)
-# numeric string friendly_id?     9.270000   0.030000   9.300000 (  9.308452)
-# numeric string unfriendly_id?   9.190000   0.040000   9.230000 (  9.252890)
-# test_string friendly_id?        8.380000   0.010000   8.390000 (  8.411762)
-# test_string unfriendly_id?      8.450000   0.010000   8.460000 (  8.463662)
-
-# From the ObjectUtils docs...
-#     123.friendly_id?                  #=> false
-#     :id.friendly_id?                  #=> false
-#     {:name => 'joe'}.friendly_id?     #=> false
-#     ['name = ?', 'joe'].friendly_id?  #=> false
-#     nil.friendly_id?                  #=> false
-#     "123".friendly_id?                #=> nil
-#     "abc123".friendly_id?             #=> true
-
-Book = Class.new ActiveRecord::Base
-
-test_integer = 123
-test_active_record_object = Book.new
-test_hash = {name: "joe"}
-test_nil = nil
-test_numeric_string = "123"
-test_string = "abc123"
-
-N = 5_000_000
-
-Benchmark.bmbm do |x|
-  x.report("integer friendly_id?") { N.times { test_integer.friendly_id? } }
-  x.report("integer unfriendly_id?") { N.times { test_integer.unfriendly_id? } }
-
-  x.report("AR::Base friendly_id?") { N.times { test_active_record_object.friendly_id? } }
-  x.report("AR::Base unfriendly_id?") { N.times { test_active_record_object.unfriendly_id? } }
-
-  x.report("hash friendly_id?") { N.times { test_hash.friendly_id? } }
-  x.report("hash unfriendly_id?") { N.times { test_hash.unfriendly_id? } }
-
-  x.report("nil friendly_id?") { N.times { test_nil.friendly_id? } }
-  x.report("nil unfriendly_id?") { N.times { test_nil.unfriendly_id? } }
-
-  x.report("numeric string friendly_id?") { N.times { test_numeric_string.friendly_id? } }
-  x.report("numeric string unfriendly_id?") { N.times { test_numeric_string.unfriendly_id? } }
-
-  x.report("test_string friendly_id?") { N.times { test_string.friendly_id? } }
-  x.report("test_string unfriendly_id?") { N.times { test_string.unfriendly_id? } }
-end

data/test/candidates_test.rb

@@ -1,142 +0,0 @@
-require "helper"
-
-class CandidatesTest < TestCaseClass
-  include FriendlyId::Test
-
-  class Airport
-    def initialize(code)
-      @code = code
-    end
-    attr_reader :code
-    alias_method :to_s, :code
-  end
-
-  class City < ActiveRecord::Base
-    extend FriendlyId
-    friendly_id :slug_candidates, use: :slugged
-    alias_attribute :slug_candidates, :name
-  end
-
-  def model_class
-    City
-  end
-
-  def with_instances_of(klass = model_class, &block)
-    transaction do
-      city1 = klass.create! name: "New York", code: "JFK"
-      city2 = klass.create! name: "New York", code: "EWR"
-      yield city1, city2
-    end
-  end
-  alias_method :with_instances, :with_instances_of
-
-  test "resolves conflict with candidate" do
-    with_instances do |city1, city2|
-      assert_equal "new-york", city1.slug
-      assert_match(/\Anew-york-([a-z0-9]+-){4}[a-z0-9]+\z/, city2.slug)
-    end
-  end
-
-  test "accepts candidate as symbol" do
-    klass = Class.new model_class do
-      def slug_candidates
-        :name
-      end
-    end
-    with_instances_of klass do |_, city|
-      assert_match(/\Anew-york-([a-z0-9]+-){4}[a-z0-9]+\z/, city.slug)
-    end
-  end
-
-  test "accepts multiple candidates" do
-    klass = Class.new model_class do
-      def slug_candidates
-        [name, code]
-      end
-    end
-    with_instances_of klass do |_, city|
-      assert_equal "ewr", city.slug
-    end
-  end
-
-  test "ignores blank candidate" do
-    klass = Class.new model_class do
-      def slug_candidates
-        [name, ""]
-      end
-    end
-    with_instances_of klass do |_, city|
-      assert_match(/\Anew-york-([a-z0-9]+-){4}[a-z0-9]+\z/, city.slug)
-    end
-  end
-
-  test "ignores nil candidate" do
-    klass = Class.new model_class do
-      def slug_candidates
-        [name, nil]
-      end
-    end
-    with_instances_of klass do |_, city|
-      assert_match(/\Anew-york-([a-z0-9]+-){4}[a-z0-9]+\z/, city.slug)
-    end
-  end
-
-  test "accepts candidate with nested array" do
-    klass = Class.new model_class do
-      def slug_candidates
-        [name, [name, code]]
-      end
-    end
-    with_instances_of klass do |_, city|
-      assert_equal "new-york-ewr", city.slug
-    end
-  end
-
-  test "accepts candidate with lambda" do
-    klass = Class.new City do
-      def slug_candidates
-        [name, [name, -> { rand 1000 }]]
-      end
-    end
-    with_instances_of klass do |_, city|
-      assert_match(/\Anew-york-\d{,3}\z/, city.friendly_id)
-    end
-  end
-
-  test "accepts candidate with object" do
-    klass = Class.new City do
-      def slug_candidates
-        [name, [name, Airport.new(code)]]
-      end
-    end
-    with_instances_of klass do |_, city|
-      assert_equal "new-york-ewr", city.friendly_id
-    end
-  end
-
-  test "allows to iterate through candidates without passing block" do
-    klass = Class.new model_class do
-      def slug_candidates
-        :name
-      end
-    end
-    with_instances_of klass do |_, city|
-      candidates = FriendlyId::Candidates.new(city, city.slug_candidates)
-      assert_equal candidates.each, ["new-york"]
-    end
-  end
-
-  test "iterates through candidates with passed block" do
-    klass = Class.new model_class do
-      def slug_candidates
-        :name
-      end
-    end
-    with_instances_of klass do |_, city|
-      collected_candidates = []
-      candidates = FriendlyId::Candidates.new(city, city.slug_candidates)
-      candidates.each { |candidate| collected_candidates << candidate }
-      assert_equal collected_candidates, ["new-york"]
-    end
-  end
-end

data/test/configuration_test.rb

@@ -1,60 +0,0 @@
-require "helper"
-
-class ConfigurationTest < TestCaseClass
-  include FriendlyId::Test
-
-  def setup
-    @model_class = Class.new(ActiveRecord::Base) do
-      self.abstract_class = true
-    end
-  end
-
-  test "should set model class on initialization" do
-    config = FriendlyId::Configuration.new @model_class
-    assert_equal @model_class, config.model_class
-  end
-
-  test "should set options on initialization if present" do
-    config = FriendlyId::Configuration.new @model_class, base: "hello"
-    assert_equal "hello", config.base
-  end
-
-  test "should raise error if passed unrecognized option" do
-    assert_raises NoMethodError do
-      FriendlyId::Configuration.new @model_class, foo: "bar"
-    end
-  end
-
-  test "#use should accept a name that resolves to a module" do
-    refute @model_class < FriendlyId::Slugged
-    @model_class.class_eval do
-      extend FriendlyId
-      friendly_id :hello, use: :slugged
-    end
-    assert @model_class < FriendlyId::Slugged
-  end
-
-  test "#use should accept a module" do
-    my_module = Module.new
-    refute @model_class < my_module
-    @model_class.class_eval do
-      extend FriendlyId
-      friendly_id :hello, use: my_module
-    end
-    assert @model_class < my_module
-  end
-
-  test "#base should optionally set a value" do
-    config = FriendlyId::Configuration.new @model_class
-    assert_nil config.base
-    config.base = "foo"
-    assert_equal "foo", config.base
-  end
-
-  test "#base can set the value to nil" do
-    config = FriendlyId::Configuration.new @model_class
-    config.base "foo"
-    config.base nil
-    assert_nil config.base
-  end
-end

data/test/core_test.rb

@@ -1,35 +0,0 @@
-require "helper"
-
-class Book < ActiveRecord::Base
-  extend FriendlyId
-  friendly_id :name
-end
-
-class Author < ActiveRecord::Base
-  extend FriendlyId
-  friendly_id :name
-  has_many :books
-end
-
-class CoreTest < TestCaseClass
-  include FriendlyId::Test
-  include FriendlyId::Test::Shared::Core
-
-  def model_class
-    Author
-  end
-
-  test "models don't use friendly_id by default" do
-    assert !Class.new(ActiveRecord::Base) {
-      self.abstract_class = true
-    }.respond_to?(:friendly_id)
-  end
-
-  test "model classes should have a friendly id config" do
-    assert model_class.friendly_id(:name).friendly_id_config
-  end
-
-  test "instances should have a friendly id" do
-    with_instance_of(model_class) { |record| assert record.friendly_id }
-  end
-end

data/test/databases.yml

@@ -1,22 +0,0 @@
-mysql:
-  adapter: mysql2
-  database: friendly_id_test
-  username: root
-  password: <%= ENV['MYSQL_PASSWORD'] %>
-  host: 127.0.0.1
-  port: 3306
-  encoding: utf8
-
-postgres:
-  adapter: postgresql
-  host: <%= ENV.fetch('PGHOST', 'localhost') %>
-  port: <%= ENV.fetch('PGPORT', '5432') %>
-  username: <%= ENV.fetch('PGUSER', 'postgres') %>
-  password: <%= ENV.fetch('PGPASSWORD', 'postgres') %>
-  database: friendly_id_test
-  encoding: utf8
-
-sqlite3:
-  adapter: sqlite3
-  database: ":memory:"
-  encoding: utf8

data/test/finders_test.rb

@@ -1,76 +0,0 @@
-require "helper"
-
-class JournalistWithFriendlyFinders < ActiveRecord::Base
-  self.table_name = "journalists"
-  extend FriendlyId
-  scope :existing, -> { where("1 = 1") }
-  friendly_id :name, use: [:slugged, :finders]
-end
-
-class Finders < TestCaseClass
-  include FriendlyId::Test
-
-  def model_class
-    JournalistWithFriendlyFinders
-  end
-
-  test "should find records with finders as class methods" do
-    with_instance_of(model_class) do |record|
-      assert model_class.find(record.friendly_id)
-    end
-  end
-
-  test "should find records with finders on relations" do
-    with_instance_of(model_class) do |record|
-      assert model_class.existing.find(record.friendly_id)
-    end
-  end
-
-  test "allows nil with allow_nil: true" do
-    with_instance_of(model_class) do |record|
-      assert_nil model_class.find("foo", allow_nil: true)
-    end
-  end
-
-  test "allows nil on relations with allow_nil: true" do
-    with_instance_of(model_class) do |record|
-      assert_nil model_class.existing.find("foo", allow_nil: true)
-    end
-  end
-
-  test "allows nil with a bad primary key ID and allow_nil: true" do
-    with_instance_of(model_class) do |record|
-      assert_nil model_class.find(0, allow_nil: true)
-    end
-  end
-
-  test "allows nil on relations with a bad primary key ID and allow_nil: true" do
-    with_instance_of(model_class) do |record|
-      assert_nil model_class.existing.find(0, allow_nil: true)
-    end
-  end
-
-  test "allows nil with a bad potential primary key ID and allow_nil: true" do
-    with_instance_of(model_class) do |record|
-      assert_nil model_class.find("0", allow_nil: true)
-    end
-  end
-
-  test "allows nil on relations with a bad potential primary key ID and allow_nil: true" do
-    with_instance_of(model_class) do |record|
-      assert_nil model_class.existing.find("0", allow_nil: true)
-    end
-  end
-
-  test "allows nil with nil ID and allow_nil: true" do
-    with_instance_of(model_class) do |record|
-      assert_nil model_class.find(nil, allow_nil: true)
-    end
-  end
-
-  test "allows nil on relations with nil ID and allow_nil: true" do
-    with_instance_of(model_class) do |record|
-      assert_nil model_class.existing.find(nil, allow_nil: true)
-    end
-  end
-end