friendly_id 5.2.3 → 5.4.1

data/Rakefile

@@ -71,7 +71,7 @@ namespace :db do
     driver = FriendlyId::Test::Database.driver
     config = FriendlyId::Test::Database.config[driver]
     commands = {
-      "mysql"    => "mysql -u #{config['username']} -e 'create database #{config["database"]};' >/dev/null",
+      "mysql"    => "mysql -h #{config['host']} -P #{config['port']} -u #{config['username']} --password=#{config['password']} -e 'create database #{config["database"]};' >/dev/null",
       "postgres" => "psql -c 'create database #{config['database']};' -U #{config['username']} >/dev/null"
     }
     %x{#{commands[driver] || true}}
@@ -83,7 +83,7 @@ namespace :db do
     driver = FriendlyId::Test::Database.driver
     config = FriendlyId::Test::Database.config[driver]
     commands = {
-      "mysql"    => "mysql -u #{config['username']} -e 'drop database #{config["database"]};' >/dev/null",
+      "mysql"    => "mysql -h #{config['host']} -P #{config['port']} -u #{config['username']} --password=#{config['password']} -e 'drop database #{config["database"]};' >/dev/null",
       "postgres" => "psql -c 'drop database #{config['database']};' -U #{config['username']} >/dev/null"
     }
     %x{#{commands[driver] || true}}

data/UPGRADING.md

@@ -0,0 +1,115 @@
+## Articles
+
+* [Migrating an ad-hoc URL slug system to FriendlyId](http://olivierlacan.com/posts/migrating-an-ad-hoc-url-slug-system-to-friendly-id/)
+* [Pretty URLs with FriendlyId](http://railscasts.com/episodes/314-pretty-urls-with-friendlyid)
+
+## Docs
+
+The most current docs from the master branch can always be found
+[here](http://norman.github.io/friendly_id).
+
+Docs for older versions are also available:
+
+* [5.0](http://norman.github.io/friendly_id/5.0/)
+* [4.0](http://norman.github.io/friendly_id/4.0/)
+* [3.3](http://norman.github.io/friendly_id/3.3/)
+* [2.3](http://norman.github.io/friendly_id/2.3/)
+
+## What Changed in Version 5.1
+
+5.1 is a bugfix release, but bumps the minor version because some applications may be dependent
+on the previously buggy behavior. The changes include:
+
+* Blank strings can no longer be used as slugs.
+* When the first slug candidate is rejected because it is reserved, additional candidates will
+  now be considered before marking the record as invalid.
+* The `:finders` module is now compatible with Rails 4.2.
+
+## What Changed in Version 5.0
+
+As of version 5.0, FriendlyId uses [semantic versioning](http://semver.org/). Therefore, as you might
+infer from the version number, 5.0 introduces changes incompatible with 4.0.
+
+The most important changes are:
+
+* Finders are no longer overridden by default. If you want to do friendly finds,
+  you must do `Model.friendly.find` rather than `Model.find`. You can however
+  restore FriendlyId 4-style finders by using the `:finders` addon:
+
+  ```ruby
+  friendly_id :foo, use: :slugged # you must do MyClass.friendly.find('bar')
+  # or...
+  friendly_id :foo, use: [:slugged, :finders] # you can now do MyClass.find('bar')
+  ```
+* A new "candidates" functionality which makes it easy to set up a list of
+  alternate slugs that can be used to uniquely distinguish records, rather than
+  appending a sequence. For example:
+
+  ```ruby
+  class Restaurant < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :slug_candidates, use: :slugged
+
+    # Try building a slug based on the following fields in
+    # increasing order of specificity.
+    def slug_candidates
+      [
+        :name,
+        [:name, :city],
+        [:name, :street, :city],
+        [:name, :street_number, :street, :city]
+      ]
+    end
+  end
+  ```
+* Now that candidates have been added, FriendlyId no longer uses a numeric
+  sequence to differentiate conflicting slug, but rather a UUID (e.g. something
+  like `2bc08962-b3dd-4f29-b2e6-244710c86106`). This makes the
+  codebase simpler and more reliable when running concurrently, at the expense
+  of uglier ids being generated when there are conflicts.
+* The default sequence separator has been changed from two dashes to one dash.
+* Slugs are no longer regenerated when a record is saved. If you want to regenerate
+  a slug, you must explicitly set the slug column to nil:
+
+  ```ruby
+  restaurant.friendly_id # joes-diner
+  restaurant.name = "The Plaza Diner"
+  restaurant.save!
+  restaurant.friendly_id # joes-diner
+  restaurant.slug = nil
+  restaurant.save!
+  restaurant.friendly_id # the-plaza-diner
+  ```
+
+  You can restore some of the old behavior by overriding the
+  `should_generate_new_friendly_id?` method.
+* The `friendly_id` Rails generator now generates an initializer showing you
+  how to do some common global configuration.
+* The Globalize plugin has moved to a [separate gem](https://github.com/norman/friendly_id-globalize) (currently in alpha).
+* The `:reserved` module no longer includes any default reserved words.
+  Previously it blocked "edit" and "new" everywhere. The default word list has
+  been moved to `config/initializers/friendly_id.rb` and now includes many more
+  words.
+* The `:history` and `:scoped` addons can now be used together.
+* Since it now requires Rails 4, FriendlyId also now requires Ruby 1.9.3 or
+  higher.
+
+## Upgrading from FriendlyId 4.0
+
+Run `rails generate friendly_id --skip-migration` and edit the initializer
+generated in `config/initializers/friendly_id.rb`. This file contains notes
+describing how to restore (or not) some of the defaults from FriendlyId 4.0.
+
+If you want to use the `:history` and `:scoped` addons together, you must add a
+`:scope` column to your friendly_id_slugs table and replace the unique index on
+`:slug` and `:sluggable_type` with a unique index on those two columns, plus
+the new `:scope` column.
+
+A migration like this should be sufficient:
+
+```ruby
+add_column   :friendly_id_slugs, :scope, :string
+remove_index :friendly_id_slugs, [:slug, :sluggable_type]
+add_index    :friendly_id_slugs, [:slug, :sluggable_type]
+add_index    :friendly_id_slugs, [:slug, :sluggable_type, :scope], unique: true
+```

data/certs/parndt.pem

@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIEMjCCApqgAwIBAgIBATANBgkqhkiG9w0BAQsFADAjMSEwHwYDVQQDDBhnZW1z
+L0RDPXAvREM9YXJuZHQvREM9aW8wHhcNMjAwNTEwMjIxOTQ2WhcNMjEwNTEwMjIx
+OTQ2WjAjMSEwHwYDVQQDDBhnZW1zL0RDPXAvREM9YXJuZHQvREM9aW8wggGiMA0G
+CSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDT+JzHYPGMYJt9ct2DCsbIymn1uJJp
+HnDkQESfsGe40jTC90oF2iVbVOkaacNc1N3CSWUZvZjuygUuS86P6/kpBILGdO2+
+bkXXKtfGC2YGGx9TdNLpCb4925vQHvdFeKXGpQDZdDw1SNC6zraZou47CvOE1cl2
+Bp+1QMZuGRZ4+5CzOEWDWurjqce3O1jUEbyBB7z5H0h/YEaxfXipxhL1Dhi0sgkH
+qP/e6SxzifdifdZCksJFQ06a1ji9hJY6eM23qbv/aaluVHAZSVBAQBS7rYniLo+N
+G4vpFhoubQO5u8UluUtCaPUpI/qOvVcSaZn3ZkzlMwC8b1RwAeXBQmtFE2wnrv2i
+ovTwoN7rHchwhgaHbkuFh4Wr92wGbrWL7J+X8rWKk1f8RF4kvtNE/NA6YrkxTpVh
+QMyDmekt7rTxvcq2NneLGroWIUVCx/JID+Jw492LKQ6Sl1/P2TRzdEDtqZAZL0gt
+xlWeMUfGG2D/gLnhs5qnaFaWQwGTmBnTgHcCAwEAAaNxMG8wCQYDVR0TBAIwADAL
+BgNVHQ8EBAMCBLAwHQYDVR0OBBYEFEqtAyQVxPgKsrgoTQ1YmaIu/fmvMBoGA1Ud
+EQQTMBGBD2dlbXNAcC5hcm5kdC5pbzAaBgNVHRIEEzARgQ9nZW1zQHAuYXJuZHQu
+aW8wDQYJKoZIhvcNAQELBQADggGBALu2HM50B8xqlAXkCwavJDvWWtV9pG1igFUg
+friZRWprUQ5nTaNmAd8p8qbJQwaIK2gt+DfYWfB9LtKnQTfbhLRBbmJ7zYw8LjKY
+PwCs4RWjDAiuyCO3ppfsz+1bsMUXPLgWlaUkXsUy3nr2NruEFTO9zu3wGYQQ93Tt
+vYSHOnP35UB4QjsjNrOO7FBaQfy6O909PP+GnVcJ62s9c26voJz63RSolwY7Jydw
+XUlG68jjJKSoDHRzVTmNB7sX8rs8P2kvYkpIUXPHyls3mWBWjBWbdEYWESZrxI2x
+dS7jY3AnfqhvsWra2pSREb2IDqPnJrHVOejnEI/zuuufUxLwDx3AC6SMdsyWkZ7V
+9OmLt2rg75Sct6h2220lO5ySqYtqAXuOMBDGv5L0zLalx1g8LACA7uILTKVWh8B8
+Hsej0MQ3drCB1eA4c9OXdCUQJnY2aLTq3uNvTbZvoTgWK55eq3KLBJ4zzoKZ4tBX
+/HIFI/fEwYlI1Ji3oikUrHkc4rWgaQ==
+-----END CERTIFICATE-----

data/friendly_id.gemspec

@@ -8,18 +8,17 @@ Gem::Specification.new do |s|
   s.email             = ["norman@njclarke.com", "p@arndt.io"]
   s.homepage          = "https://github.com/norman/friendly_id"
   s.summary           = "A comprehensive slugging and pretty-URL plugin."
-  s.rubyforge_project = "friendly_id"
   s.files             = `git ls-files`.split("\n")
   s.test_files        = `git ls-files -- {test}/*`.split("\n")
   s.require_paths     = ["lib"]
   s.license           = 'MIT'
 
-  s.required_ruby_version = '>= 1.9.3'
+  s.required_ruby_version = '>= 2.1.0'
 
   s.add_dependency 'activerecord', '>= 4.0.0'
 
   s.add_development_dependency 'coveralls'
-  s.add_development_dependency 'railties', '~> 4.0'
+  s.add_development_dependency 'railties', '>= 4.0'
   s.add_development_dependency 'minitest', '~> 5.3'
   s.add_development_dependency 'mocha', '~> 1.1'
   s.add_development_dependency 'yard'
@@ -32,4 +31,9 @@ FriendlyId is the "Swiss Army bulldozer" of slugging and permalink plugins for
 Active Record. It lets you create pretty URLs and work with human-friendly
 strings as if they were numeric ids.
 EOM
+
+  s.cert_chain = [File.expand_path('certs/parndt.pem', __dir__)]
+  if $PROGRAM_NAME =~ /gem\z/ && ARGV.include?('build') && ARGV.include?(__FILE__)
+    s.signing_key = File.expand_path('~/.ssh/gem-private_key.pem')
+  end
 end

data/gemfiles/{Gemfile.rails-4.2.rb → Gemfile.rails-5.2.rb}

@@ -2,15 +2,14 @@ source 'https://rubygems.org'
 
 gemspec path: '../'
 
-gem 'activerecord', '~> 4.2.1'
-gem 'railties', '~> 4.2.1'
-gem 'i18n', '~> 0.7.0'
+gem 'activerecord', '~> 5.2.0'
+gem 'railties', '~> 5.2.0'
 
 # Database Configuration
 group :development, :test do
   platforms :jruby do
-    gem 'activerecord-jdbcmysql-adapter', '~> 1.3.14'
-    gem 'activerecord-jdbcpostgresql-adapter', '~> 1.3.14'
+    gem 'activerecord-jdbcmysql-adapter', '~> 51.1'
+    gem 'activerecord-jdbcpostgresql-adapter', '~> 51.1'
     gem 'kramdown'
   end
 

data/gemfiles/{Gemfile.rails-4.1.rb → Gemfile.rails-6.0.rb}

@@ -2,21 +2,20 @@ source 'https://rubygems.org'
 
 gemspec path: '../'
 
-gem 'activerecord', '~> 4.1.9'
-gem 'railties', '~> 4.1.9'
+gem 'activerecord', '~> 6.0.0'
+gem 'railties', '~> 6.0.0'
 
 # Database Configuration
 group :development, :test do
   platforms :jruby do
-    gem 'activerecord-jdbcsqlite3-adapter', '~> 1.3.14'
-    gem 'activerecord-jdbcmysql-adapter', '~> 1.3.14'
-    gem 'activerecord-jdbcpostgresql-adapter', '~> 1.3.14'
+    gem 'activerecord-jdbcmysql-adapter', '~> 51.1'
+    gem 'activerecord-jdbcpostgresql-adapter', '~> 51.1'
     gem 'kramdown'
   end
 
   platforms :ruby, :rbx do
     gem 'sqlite3'
-    gem 'mysql2', '~> 0.3.13'
+    gem 'mysql2'
     gem 'pg'
     gem 'redcarpet'
   end
@@ -24,6 +23,5 @@ group :development, :test do
   platforms :rbx do
     gem 'rubysl', '~> 2.0'
     gem 'rubinius-developer_tools'
-    gem 'json'
   end
 end

data/lib/friendly_id/base.rb

@@ -159,8 +159,9 @@ often better and easier to use {FriendlyId::Slugged slugs}.
     #
     # @option options [Symbol,Module] :use The addon or name of an addon to use.
     #   By default, FriendlyId provides {FriendlyId::Slugged :slugged},
-    #   {FriendlyId::History :history}, {FriendlyId::Reserved :reserved}, and
-    #   {FriendlyId::Scoped :scoped}, and {FriendlyId::SimpleI18n :simple_i18n}.
+    #   {FriendlyId::Reserved :finders}, {FriendlyId::History :history},
+    #   {FriendlyId::Reserved :reserved}, {FriendlyId::Scoped :scoped}, and
+    #   {FriendlyId::SimpleI18n :simple_i18n}.
     #
     # @option options [Array] :reserved_words Available when using `:reserved`,
     #   which is loaded by default. Sets an array of words banned for use as
@@ -261,12 +262,7 @@ often better and easier to use {FriendlyId::Slugged slugs}.
     # Either the friendly_id, or the numeric id cast to a string.
     def to_param
       if friendly_id_config.routes == :friendly
-        if attribute_changed?(friendly_id_config.query_field)
-          diff = changes[friendly_id_config.query_field]
-          diff.first || diff.second
-        else
-          friendly_id.presence.to_param || super
-        end
+        friendly_id.presence.to_param || super
       else
         super
       end

data/lib/friendly_id/candidates.rb

@@ -63,8 +63,6 @@ module FriendlyId
       slug.present?
     end
 
-    private
-
     def reserved?(slug)
       config = @object.friendly_id_config
       return false unless config.uses? ::FriendlyId::Reserved

data/lib/friendly_id/configuration.rb

@@ -25,6 +25,7 @@ module FriendlyId
     attr_accessor :routes
 
     def initialize(model_class, values = nil)
+      @base           = nil
       @model_class    = model_class
       @defaults       = {}
       @modules        = []
@@ -47,8 +48,8 @@ module FriendlyId
     #
     # @param [#to_s,Module] modules Arguments should be Modules, or symbols or
     #   strings that correspond with the name of an addon to use with FriendlyId.
-    #   By default FriendlyId provides `:slugged`, `:history`, `:simple_i18n`,
-    #   and `:scoped`.
+    #   By default FriendlyId provides `:slugged`, `:finders`, `:history`,
+    #   `:reserved`, `:simple_i18n`, and `:scoped`.
     def use(*modules)
       modules.to_a.flatten.compact.map do |object|
         mod = get_module(object)

data/lib/friendly_id/finder_methods.rb

@@ -9,7 +9,7 @@ module FriendlyId
     # id matching '123' and then fall back to looking for a record with the
     # numeric id '123'.
     #
-    # Since FriendlyId 5.0, if the id is a numeric string like '123-foo' it
+    # Since FriendlyId 5.0, if the id is a nonnumeric string like '123-foo' it
     # will *only* search by friendly id and not fall back to the regular find
     # method.
     #
@@ -20,20 +20,22 @@ module FriendlyId
       return super if args.count != 1 || id.unfriendly_id?
       first_by_friendly_id(id).tap {|result| return result unless result.nil?}
       return super if potential_primary_key?(id)
-      raise ActiveRecord::RecordNotFound, "can't find record with friendly id: #{id.inspect}"
+      raise_not_found_exception id
+      
     end
 
     # Returns true if a record with the given id exists.
     def exists?(conditions = :none)
-      return super unless conditions.friendly_id?
-      exists_by_friendly_id?(conditions)
+      return super if conditions.unfriendly_id?
+      return true if exists_by_friendly_id?(conditions)
+      super
     end
 
     # Finds exclusively by the friendly id, completely bypassing original
     # `find`.
     # @raise ActiveRecord::RecordNotFound
     def find_by_friendly_id(id)
-      first_by_friendly_id(id) or raise ActiveRecord::RecordNotFound, "can't find record with friendly id: #{id.inspect}"
+      first_by_friendly_id(id) or raise raise_not_found_exception(id)
     end
 
     def exists_by_friendly_id?(id)
@@ -50,14 +52,23 @@ module FriendlyId
       when :integer
         Integer(id, 10) rescue false
       when :uuid
-        id.match /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/
+        id.match(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/)
       else
         true
       end
     end
 
     def first_by_friendly_id(id)
-      find_by(friendly_id_config.query_field => id)
+      find_by(friendly_id_config.query_field => id.downcase)
+    end
+
+    def raise_not_found_exception(id)
+      message = "can't find record with friendly id: #{id.inspect}"
+      if ActiveRecord.version < Gem::Version.create('5.0') then 
+        raise ActiveRecord::RecordNotFound.new(message)
+      else 
+        raise ActiveRecord::RecordNotFound.new(message, name, friendly_id_config.query_field, id)
+      end
     end
 
   end

data/lib/friendly_id/finders.rb

@@ -76,7 +76,7 @@ for models that use FriendlyId with something similar to the following:
     def self.setup(model_class)
       model_class.instance_eval do
         relation.class.send(:include, friendly_id_config.finder_methods)
-        if (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR == 2) || ActiveRecord::VERSION::MAJOR == 5
+        if (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR == 2) || ActiveRecord::VERSION::MAJOR >= 5
           model_class.send(:extend, friendly_id_config.finder_methods)
         end
       end

data/lib/friendly_id/history.rb

@@ -44,9 +44,9 @@ method.
         @post = Post.friendly.find params[:id]
 
         # If an old id or a numeric id was used to find the record, then
-        # the request path will not match the post_path, and we should do
-        # a 301 redirect that uses the current friendly id.
-        if request.path != post_path(@post)
+        # the request slug will not match the current slug, and we should do
+        # a 301 redirect to the new path
+        if params[:id] != @post.slug
           return redirect_to @post, :status => :moved_permanently
         end
       end
@@ -72,7 +72,7 @@ method.
     # Configures the model instance to use the History add-on.
     def self.included(model_class)
       model_class.class_eval do
-        has_many :slugs, -> {order("#{Slug.quoted_table_name}.id DESC")}, {
+        has_many :slugs, -> {order(id: :desc)}, **{
           :as         => :sluggable,
           :dependent  => @friendly_id_config.dependent_value,
           :class_name => Slug.to_s
@@ -86,14 +86,13 @@ method.
       include ::FriendlyId::FinderMethods
 
       def exists_by_friendly_id?(id)
-        where(arel_table[friendly_id_config.query_field].eq(id)).exists? || joins(:slugs).where(slug_history_clause(id)).exists?
+        super || joins(:slugs).where(slug_history_clause(id)).exists?
       end
 
       private
 
       def first_by_friendly_id(id)
-        matching_record = where(friendly_id_config.query_field => id).first
-        matching_record || slug_table_record(id)
+        super || slug_table_record(id)
       end
 
       def slug_table_record(id)
@@ -111,9 +110,10 @@ method.
     # to be conflicts. This will allow a record to revert to a previously
     # used slug.
     def scope_for_slug_generator
-      relation = super
-      return relation if new_record?
-      relation = relation.joins(:slugs).merge(Slug.where('sluggable_id <> ?', id))
+      relation = super.joins(:slugs)
+      unless new_record?
+        relation = relation.merge(Slug.where('sluggable_id <> ?', id))
+      end
       if friendly_id_config.uses?(:scoped)
         relation = relation.where(Slug.arel_table[:scope].eq(serialized_scope))
       end
@@ -122,17 +122,26 @@ method.
 
     def create_slug
       return unless friendly_id
-      return if slugs.first.try(:slug) == friendly_id
+      return if history_is_up_to_date?
       # Allow reversion back to a previously used slug
       relation = slugs.where(:slug => friendly_id)
       if friendly_id_config.uses?(:scoped)
         relation = relation.where(:scope => serialized_scope)
       end
-      relation.delete_all
+      relation.destroy_all unless relation.empty?
       slugs.create! do |record|
         record.slug = friendly_id
         record.scope = serialized_scope if friendly_id_config.uses?(:scoped)
       end
     end
+
+    def history_is_up_to_date?
+      latest_history = slugs.first
+      check = latest_history.try(:slug) == friendly_id
+      if friendly_id_config.uses?(:scoped)
+        check = check && latest_history.scope == serialized_scope
+      end
+      check
+    end
   end
 end