friendly_id 5.4.0 → 5.5.1

data/lib/generators/friendly_id_generator.rb

@@ -1,4 +1,4 @@
-require 'rails/generators'
+require "rails/generators"
 require "rails/generators/active_record"
 
 # This generator adds a migration for the {FriendlyId::History
@@ -6,21 +6,21 @@ require "rails/generators/active_record"
 class FriendlyIdGenerator < ActiveRecord::Generators::Base
   # ActiveRecord::Generators::Base inherits from Rails::Generators::NamedBase which requires a NAME parameter for the
   # new table name. Our generator always uses 'friendly_id_slugs', so we just set a random name here.
-  argument :name, type: :string, default: 'random_name'
+  argument :name, type: :string, default: "random_name"
 
-  class_option :'skip-migration', :type => :boolean, :desc => "Don't generate a migration for the slugs table"
-  class_option :'skip-initializer', :type => :boolean, :desc => "Don't generate an initializer"
+  class_option :'skip-migration', type: :boolean, desc: "Don't generate a migration for the slugs table"
+  class_option :'skip-initializer', type: :boolean, desc: "Don't generate an initializer"
 
-  source_root File.expand_path('../../friendly_id', __FILE__)
+  source_root File.expand_path("../../friendly_id", __FILE__)
 
   # Copies the migration template to db/migrate.
   def copy_files
-    return if options['skip-migration']
-    migration_template 'migration.rb', 'db/migrate/create_friendly_id_slugs.rb'
+    return if options["skip-migration"]
+    migration_template "migration.rb", "db/migrate/create_friendly_id_slugs.rb"
   end
 
   def create_initializer
-    return if options['skip-initializer']
-    copy_file 'initializer.rb', 'config/initializers/friendly_id.rb'
+    return if options["skip-initializer"]
+    copy_file "initializer.rb", "config/initializers/friendly_id.rb"
   end
 end

data/test/base_test.rb

@@ -21,14 +21,13 @@ class CoreTest < TestCaseClass
     klass = Class.new(ActiveRecord::Base) do
       self.abstract_class = true
       extend FriendlyId
-      friendly_id :foo, :use => :slugged, :slug_column => :bar
+      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
@@ -56,17 +55,15 @@ class CoreTest < TestCaseClass
   end
 
   test "should allow defaults to be set via a block" do
-    begin
-      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
+    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

@@ -14,7 +14,11 @@ require "ffaker"
 N = 50000
 
 def transaction
-  ActiveRecord::Base.transaction { yield ; raise ActiveRecord::Rollback }
+  ActiveRecord::Base.transaction do
+    yield
+
+    raise ActiveRecord::Rollback
+  end
 end
 
 class Array
@@ -27,62 +31,60 @@ Book = Class.new ActiveRecord::Base
 
 class Journalist < ActiveRecord::Base
   extend FriendlyId
-  friendly_id :name, :use => :slugged
+  friendly_id :name, use: :slugged
 end
 
 class Manual < ActiveRecord::Base
   extend FriendlyId
-  friendly_id :name, :use => :history
+  friendly_id :name, use: :history
 end
 
 class Restaurant < ActiveRecord::Base
   extend FriendlyId
-  friendly_id :name, :use => :finders
+  friendly_id :name, use: :finders
 end
 
-
-BOOKS       = []
+BOOKS = []
 JOURNALISTS = []
-MANUALS     = []
+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
+  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}
+  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}
+  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}
+  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)}
+  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)}
+  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}
+  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}
+  x.report "FriendlyId: friendly.find (in-table slug)" do
+    N.times { Restaurant.friendly.find RESTAURANTS.rand }
   end
-
 end

data/test/benchmarks/object_utils.rb

@@ -28,7 +28,7 @@ Book = Class.new ActiveRecord::Base
 
 test_integer = 123
 test_active_record_object = Book.new
-test_hash = {:name=>'joe'}
+test_hash = {name: "joe"}
 test_nil = nil
 test_numeric_string = "123"
 test_string = "abc123"
@@ -36,21 +36,21 @@ 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("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("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("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("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("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?} }
+  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,9 +1,16 @@
 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
@@ -16,8 +23,8 @@ class CandidatesTest < TestCaseClass
 
   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"
+      city1 = klass.create! name: "New York", code: "JFK"
+      city2 = klass.create! name: "New York", code: "EWR"
       yield city1, city2
     end
   end
@@ -26,7 +33,7 @@ class CandidatesTest < TestCaseClass
   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)
+      assert_match(/\Anew-york-([a-z0-9]+-){4}[a-z0-9]+\z/, city2.slug)
     end
   end
 
@@ -37,7 +44,7 @@ class CandidatesTest < TestCaseClass
       end
     end
     with_instances_of klass do |_, city|
-      assert_match(/\Anew-york-([a-z0-9]+\-){4}[a-z0-9]+\z/, city.slug)
+      assert_match(/\Anew-york-([a-z0-9]+-){4}[a-z0-9]+\z/, city.slug)
     end
   end
 
@@ -59,7 +66,7 @@ class CandidatesTest < TestCaseClass
       end
     end
     with_instances_of klass do |_, city|
-      assert_match(/\Anew-york-([a-z0-9]+\-){4}[a-z0-9]+\z/, city.slug)
+      assert_match(/\Anew-york-([a-z0-9]+-){4}[a-z0-9]+\z/, city.slug)
     end
   end
 
@@ -70,7 +77,7 @@ class CandidatesTest < TestCaseClass
       end
     end
     with_instances_of klass do |_, city|
-      assert_match(/\Anew-york-([a-z0-9]+\-){4}[a-z0-9]+\z/, city.slug)
+      assert_match(/\Anew-york-([a-z0-9]+-){4}[a-z0-9]+\z/, city.slug)
     end
   end
 
@@ -88,7 +95,7 @@ class CandidatesTest < TestCaseClass
   test "accepts candidate with lambda" do
     klass = Class.new City do
       def slug_candidates
-        [name, [name, ->{ rand 1000 }]]
+        [name, [name, -> { rand 1000 }]]
       end
     end
     with_instances_of klass do |_, city|
@@ -98,13 +105,6 @@ class CandidatesTest < TestCaseClass
 
   test "accepts candidate with object" do
     klass = Class.new City do
-      class Airport
-        def initialize(code)
-          @code = code
-        end
-        attr_reader :code
-        alias_method :to_s, :code
-      end
       def slug_candidates
         [name, [name, Airport.new(code)]]
       end
@@ -122,7 +122,7 @@ class CandidatesTest < TestCaseClass
     end
     with_instances_of klass do |_, city|
       candidates = FriendlyId::Candidates.new(city, city.slug_candidates)
-      assert_equal candidates.each, ['new-york']
+      assert_equal candidates.each, ["new-york"]
     end
   end
 
@@ -136,8 +136,7 @@ class CandidatesTest < TestCaseClass
       collected_candidates = []
       candidates = FriendlyId::Candidates.new(city, city.slug_candidates)
       candidates.each { |candidate| collected_candidates << candidate }
-      assert_equal collected_candidates, ['new-york']
+      assert_equal collected_candidates, ["new-york"]
     end
   end
-
 end

data/test/configuration_test.rb

@@ -1,7 +1,6 @@
 require "helper"
 
 class ConfigurationTest < TestCaseClass
-
   include FriendlyId::Test
 
   def setup
@@ -16,13 +15,13 @@ class ConfigurationTest < TestCaseClass
   end
 
   test "should set options on initialization if present" do
-    config = FriendlyId::Configuration.new @model_class, :base => "hello"
+    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"
+      FriendlyId::Configuration.new @model_class, foo: "bar"
     end
   end
 
@@ -30,7 +29,7 @@ class ConfigurationTest < TestCaseClass
     refute @model_class < FriendlyId::Slugged
     @model_class.class_eval do
       extend FriendlyId
-      friendly_id :hello, :use => :slugged
+      friendly_id :hello, use: :slugged
     end
     assert @model_class < FriendlyId::Slugged
   end
@@ -40,7 +39,7 @@ class ConfigurationTest < TestCaseClass
     refute @model_class < my_module
     @model_class.class_eval do
       extend FriendlyId
-      friendly_id :hello, :use => my_module
+      friendly_id :hello, use: my_module
     end
     assert @model_class < my_module
   end
@@ -48,17 +47,14 @@ class ConfigurationTest < TestCaseClass
   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
+    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 "foo"
     config.base nil
     assert_nil config.base
-
   end
-
-
 end

data/test/core_test.rb

@@ -12,7 +12,6 @@ class Author < ActiveRecord::Base
 end
 
 class CoreTest < TestCaseClass
-
   include FriendlyId::Test
   include FriendlyId::Test::Shared::Core
 
@@ -31,6 +30,6 @@ class CoreTest < TestCaseClass
   end
 
   test "instances should have a friendly id" do
-    with_instance_of(model_class) {|record| assert record.friendly_id}
+    with_instance_of(model_class) { |record| assert record.friendly_id }
   end
 end

data/test/databases.yml

@@ -9,9 +9,10 @@ mysql:
 
 postgres:
   adapter: postgresql
-  host: <%= ENV.fetch('PGHOST') { 'localhost' } %>
-  port: <%= ENV.fetch('PGPORT') { '5432' } %>
-  username: <%= ENV.fetch('PGUSER') { 'postgres' } %>
+  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
 

data/test/finders_test.rb

@@ -1,53 +1,76 @@
 require "helper"
 
 class JournalistWithFriendlyFinders < ActiveRecord::Base
-  self.table_name = 'journalists'
+  self.table_name = "journalists"
   extend FriendlyId
-  scope :existing, -> {where('1 = 1')}
+  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
+  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
+  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 'should find capitalized records with finders as class methods' do
+  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 model_class.find(record.friendly_id.capitalize)
+      assert_nil model_class.find("0", allow_nil: true)
     end
   end
 
-  test 'should find capitalized records with finders on relations' do
+  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 model_class.existing.find(record.friendly_id.capitalize)
+      assert_nil model_class.existing.find("0", allow_nil: true)
     end
   end
 
-  test 'should find upcased records with finders as class methods' do
+  test "allows nil with nil ID and allow_nil: true" do
     with_instance_of(model_class) do |record|
-      assert model_class.find(record.friendly_id.upcase)
+      assert_nil model_class.find(nil, allow_nil: true)
     end
   end
 
-  test 'should find upcased records with finders on relations' do
+  test "allows nil on relations with nil ID and allow_nil: true" do
     with_instance_of(model_class) do |record|
-      assert model_class.existing.find(record.friendly_id.upcase)
+      assert_nil model_class.existing.find(nil, allow_nil: true)
     end
   end
 end

data/test/generator_test.rb

@@ -3,46 +3,36 @@ require "rails/generators"
 require "generators/friendly_id_generator"
 
 class FriendlyIdGeneratorTest < Rails::Generators::TestCase
-
   tests FriendlyIdGenerator
   destination File.expand_path("../../tmp", __FILE__)
 
   setup :prepare_destination
 
   test "should generate a migration" do
-    begin
-      run_generator
-      assert_migration "db/migrate/create_friendly_id_slugs"
-    ensure
-      FileUtils.rm_rf self.destination_root
-    end
+    run_generator
+    assert_migration "db/migrate/create_friendly_id_slugs"
+  ensure
+    FileUtils.rm_rf destination_root
   end
 
   test "should skip the migration when told to do so" do
-    begin
-      run_generator ['--skip-migration']
-      assert_no_migration "db/migrate/create_friendly_id_slugs"
-    ensure
-      FileUtils.rm_rf self.destination_root
-    end
+    run_generator ["--skip-migration"]
+    assert_no_migration "db/migrate/create_friendly_id_slugs"
+  ensure
+    FileUtils.rm_rf destination_root
   end
 
   test "should generate an initializer" do
-    begin
-      run_generator
-      assert_file "config/initializers/friendly_id.rb"
-    ensure
-      FileUtils.rm_rf self.destination_root
-    end
+    run_generator
+    assert_file "config/initializers/friendly_id.rb"
+  ensure
+    FileUtils.rm_rf destination_root
   end
 
   test "should skip the initializer when told to do so" do
-    begin
-      run_generator ['--skip-initializer']
-      assert_no_file "config/initializers/friendly_id.rb"
-    ensure
-      FileUtils.rm_rf self.destination_root
-    end
+    run_generator ["--skip-initializer"]
+    assert_no_file "config/initializers/friendly_id.rb"
+  ensure
+    FileUtils.rm_rf destination_root
   end
-
 end