friendly_id 5.2.2 → 5.4.0

data/lib/friendly_id/initializer.rb

@@ -18,6 +18,12 @@ FriendlyId.defaults do |config|
 
   config.reserved_words = %w(new edit index session login logout users admin
     stylesheets assets javascripts images)
+    
+  # This adds an option to treat reserved words as conflicts rather than exceptions.
+  # When there is no good candidate, a UUID will be appended, matching the existing
+  # conflict behavior.
+
+  # config.treat_reserved_as_conflict = true
 
   #  ## Friendly Finders
   #
@@ -76,7 +82,12 @@ FriendlyId.defaults do |config|
   # behavior by overriding the `should_generate_new_friendly_id?` method that
   # FriendlyId adds to your model. The change below makes FriendlyId 5.0 behave
   # more like 4.0.
+  # Note: Use(include) Slugged module in the config if using the anonymous module.
+  # If you have `friendly_id :name, use: slugged` in the model, Slugged module
+  # is included after the anonymous module defined in the initializer, so it
+  # overrides the `should_generate_new_friendly_id?` method from the anonymous module.
   #
+  # config.use :slugged
   # config.use Module.new {
   #   def should_generate_new_friendly_id?
   #     slug.blank? || <your_column_name_here>_changed?

data/lib/friendly_id/migration.rb

@@ -1,4 +1,11 @@
-class CreateFriendlyIdSlugs < ActiveRecord::Migration
+MIGRATION_CLASS =
+  if ActiveRecord::VERSION::MAJOR >= 5
+    ActiveRecord::Migration["#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"]
+  else
+    ActiveRecord::Migration
+  end
+
+class CreateFriendlyIdSlugs < MIGRATION_CLASS
   def change
     create_table :friendly_id_slugs do |t|
       t.string   :slug,           :null => false
@@ -7,9 +14,8 @@ class CreateFriendlyIdSlugs < ActiveRecord::Migration
       t.string   :scope
       t.datetime :created_at
     end
-    add_index :friendly_id_slugs, :sluggable_id
+    add_index :friendly_id_slugs, [:sluggable_type, :sluggable_id]
     add_index :friendly_id_slugs, [:slug, :sluggable_type], length: { slug: 140, sluggable_type: 50 }
     add_index :friendly_id_slugs, [:slug, :sluggable_type, :scope], length: { slug: 70, sluggable_type: 50, scope: 70 }, unique: true
-    add_index :friendly_id_slugs, :sluggable_type
   end
 end

data/lib/friendly_id/object_utils.rb

@@ -2,7 +2,6 @@ module FriendlyId
   # Instances of these classes will never be considered a friendly id.
   # @see FriendlyId::ObjectUtils#friendly_id
   UNFRIENDLY_CLASSES = [
-    ActiveRecord::Base,
     Array,
     FalseClass,
     Hash,
@@ -59,6 +58,10 @@ module FriendlyId
       true
     end
   end
+
+  def self.mark_as_unfriendly(klass)
+    klass.send(:include, FriendlyId::UnfriendlyUtils)
+  end
 end
 
 Object.send :include, FriendlyId::ObjectUtils
@@ -66,4 +69,8 @@ Object.send :include, FriendlyId::ObjectUtils
 # Considered unfriendly if object is an instance of an unfriendly class or
 # one of its descendants.
 
-FriendlyId::UNFRIENDLY_CLASSES.each { |klass| klass.send(:include, FriendlyId::UnfriendlyUtils) }
+FriendlyId::UNFRIENDLY_CLASSES.each { |klass| FriendlyId.mark_as_unfriendly(klass) }
+
+ActiveSupport.on_load(:active_record) do
+  FriendlyId.mark_as_unfriendly(ActiveRecord::Base)
+end

data/lib/friendly_id/reserved.rb

@@ -46,6 +46,7 @@ message to a different field. For example:
     # {FriendlyId::Configuration FriendlyId::Configuration}.
     module Configuration
       attr_accessor :reserved_words
+      attr_accessor :treat_reserved_as_conflict
     end
   end
 end

data/lib/friendly_id/scoped.rb

@@ -122,7 +122,10 @@ an example of one way to set this up:
     end
 
     def scope_for_slug_generator
-      relation = self.class.unscoped.friendly
+      if friendly_id_config.uses?(:History)
+        return super
+      end
+      relation = self.class.base_class.unscoped.friendly
       friendly_id_config.scope_columns.each do |column|
         relation = relation.where(column => send(column))
       end
@@ -132,10 +135,14 @@ an example of one way to set this up:
     private :scope_for_slug_generator
 
     def slug_generator
-      friendly_id_config.slug_generator_class.new(scope_for_slug_generator)
+      friendly_id_config.slug_generator_class.new(scope_for_slug_generator, friendly_id_config)
     end
     private :slug_generator
 
+    def should_generate_new_friendly_id?
+      (changed & friendly_id_config.scope_columns).any? || super
+    end
+
     # This module adds the `:scope` configuration option to
     # {FriendlyId::Configuration FriendlyId::Configuration}.
     module Configuration

data/lib/friendly_id/sequentially_slugged.rb

@@ -11,7 +11,7 @@ module FriendlyId
                                   candidate,
                                   friendly_id_config.slug_column,
                                   friendly_id_config.sequence_separator,
-                                  self.class.base_class).next_slug
+                                  slug_base_class).next_slug
     end
 
     class SequentialSlugCalculator
@@ -47,7 +47,7 @@ module FriendlyId
       def slug_conflicts
         scope.
           where(conflict_query, slug, sequential_slug_matcher).
-          order(ordering_query).pluck(slug_column)
+          order(Arel.sql(ordering_query)).pluck(Arel.sql(slug_column))
       end
 
       def conflict_query
@@ -73,5 +73,15 @@ module FriendlyId
         "#{length_command}(#{slug_column}) ASC, #{slug_column} ASC"
       end
     end
+
+    private
+
+    def slug_base_class
+      if friendly_id_config.uses?(:history)
+        Slug
+      else
+        self.class.base_class
+      end
+    end
   end
 end

data/lib/friendly_id/slug.rb

@@ -5,6 +5,10 @@ module FriendlyId
   class Slug < ActiveRecord::Base
     belongs_to :sluggable, :polymorphic => true
 
+    def sluggable
+      sluggable_type.constantize.unscoped { super }
+    end
+
     def to_param
       slug
     end

data/lib/friendly_id/slug_generator.rb

@@ -3,11 +3,16 @@ module FriendlyId
   # availability.
   class SlugGenerator
 
-    def initialize(scope)
+    def initialize(scope, config)
       @scope = scope
+      @config = config
     end
 
     def available?(slug)
+      if @config.uses?(::FriendlyId::Reserved) && @config.reserved_words.present? && @config.treat_reserved_as_conflict
+        return false if @config.reserved_words.include?(slug)
+      end
+
       !@scope.exists_by_friendly_id?(slug)
     end
 

data/lib/friendly_id/slugged.rb

@@ -67,7 +67,7 @@ app's behavior and requirements.
 #### Formatting
 
 By default, FriendlyId uses Active Support's
-[paramaterize](http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-parameterize)
+[parameterize](http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-parameterize)
 method to create slugs. This method will intelligently replace spaces with
 dashes, and Unicode Latin characters with ASCII approximations:
 
@@ -370,12 +370,12 @@ Github issue](https://github.com/norman/friendly_id/issues/185) for discussion.
     private :scope_for_slug_generator
 
     def slug_generator
-      friendly_id_config.slug_generator_class.new(scope_for_slug_generator)
+      friendly_id_config.slug_generator_class.new(scope_for_slug_generator, friendly_id_config)
     end
     private :slug_generator
 
     def unset_slug_if_invalid
-      if errors.present? && attribute_changed?(friendly_id_config.query_field.to_s)
+      if errors[friendly_id_config.query_field].present? && attribute_changed?(friendly_id_config.query_field.to_s)
         diff = changes[friendly_id_config.query_field]
         send "#{friendly_id_config.slug_column}=", diff.first
       end

data/lib/friendly_id/version.rb

@@ -1,3 +1,3 @@
 module FriendlyId
-  VERSION = '5.2.2'.freeze
+  VERSION = '5.4.0'.freeze
 end

data/test/databases.yml

@@ -2,14 +2,16 @@ mysql:
   adapter: mysql2
   database: friendly_id_test
   username: root
-  hostname: localhost
+  password: <%= ENV['MYSQL_PASSWORD'] %>
+  host: 127.0.0.1
+  port: 3306
   encoding: utf8
 
 postgres:
   adapter: postgresql
-  host: localhost
-  port: 5432
-  username: postgres
+  host: <%= ENV.fetch('PGHOST') { 'localhost' } %>
+  port: <%= ENV.fetch('PGPORT') { '5432' } %>
+  username: <%= ENV.fetch('PGUSER') { 'postgres' } %>
   database: friendly_id_test
   encoding: utf8
 

data/test/finders_test.rb

@@ -26,4 +26,28 @@ class Finders < TestCaseClass
       assert model_class.existing.find(record.friendly_id)
     end
   end
+
+  test 'should find capitalized records with finders as class methods' do
+    with_instance_of(model_class) do |record|
+      assert model_class.find(record.friendly_id.capitalize)
+    end
+  end
+
+  test 'should find capitalized records with finders on relations' do
+    with_instance_of(model_class) do |record|
+      assert model_class.existing.find(record.friendly_id.capitalize)
+    end
+  end
+
+  test 'should find upcased records with finders as class methods' do
+    with_instance_of(model_class) do |record|
+      assert model_class.find(record.friendly_id.upcase)
+    end
+  end
+
+  test 'should find upcased records with finders on relations' do
+    with_instance_of(model_class) do |record|
+      assert model_class.existing.find(record.friendly_id.upcase)
+    end
+  end
 end

data/test/helper.rb

@@ -27,6 +27,7 @@ end
 require "mocha/setup"
 require "active_record"
 require 'active_support/core_ext/time/conversions'
+require 'erb'
 
 I18n.enforce_available_locales = false
 
@@ -38,6 +39,10 @@ if ENV["LOG"]
   ActiveRecord::Base.logger = Logger.new($stdout)
 end
 
+if ActiveSupport::VERSION::STRING >= '4.2'
+  ActiveSupport.test_order = :random
+end
+
 module FriendlyId
   module Test
 
@@ -65,7 +70,6 @@ module FriendlyId
 
       def connect
         version = ActiveRecord::VERSION::STRING
-        driver  = FriendlyId::Test::Database.driver
         engine  = RUBY_ENGINE rescue "ruby"
 
         ActiveRecord::Base.establish_connection config[driver]
@@ -82,11 +86,17 @@ module FriendlyId
       end
 
       def config
-        @config ||= YAML::load(File.open(File.expand_path("../databases.yml", __FILE__)))
+        @config ||= YAML::load(
+          ERB.new(
+            File.read(File.expand_path("../databases.yml", __FILE__))
+          ).result
+        )
       end
 
       def driver
-        (ENV["DB"] or "sqlite3").downcase
+        _driver = ENV.fetch('DB', 'sqlite3').downcase
+        _driver = "postgres" if %w(postgresql pg).include?(_driver)
+        _driver
       end
 
       def in_memory?

data/test/history_test.rb

@@ -65,8 +65,7 @@ class HistoryTest < TestCaseClass
   test "should not be read only when found by slug" do
     with_instance_of(model_class) do |record|
       refute model_class.friendly.find(record.friendly_id).readonly?
-      assert record.update_attribute :name, 'foo'
-      assert record.update_attributes name: 'foo'
+      assert record.update name: 'foo'
     end
   end
 
@@ -93,6 +92,28 @@ class HistoryTest < TestCaseClass
     end
   end
 
+  test 'should maintain history even if current slug is not the most recent one' do
+    with_instance_of(model_class) do |record|
+      record.name = 'current'
+      assert record.save
+
+      # this feels like a hack. only thing i can get to work with the HistoryTestWithSti
+      # test cases. (Editorialist vs Journalist.)
+      sluggable_type = FriendlyId::Slug.first.sluggable_type
+      # create several slugs for record
+      # current slug does not have max id
+      FriendlyId::Slug.delete_all
+      FriendlyId::Slug.create(sluggable_type: sluggable_type, sluggable_id: record.id, slug: 'current')
+      FriendlyId::Slug.create(sluggable_type: sluggable_type, sluggable_id: record.id, slug: 'outdated')
+
+      record.reload
+      record.slug = nil
+      assert record.save
+
+      assert_equal 2, FriendlyId::Slug.count
+    end
+  end
+
   test "should not create new slugs that match old slugs" do
     transaction do
       first_record = model_class.create! :name => "foo"
@@ -109,10 +130,10 @@ class HistoryTest < TestCaseClass
       first_record = model_class.create! :name => "foo"
       second_record = model_class.create! :name => 'another'
 
-      second_record.update_attributes :name => 'foo', :slug => nil
+      second_record.update :name => 'foo', :slug => nil
       assert_match(/foo-.*/, second_record.slug)
 
-      first_record.update_attributes :name => 'another', :slug => nil
+      first_record.update :name => 'another', :slug => nil
       assert_match(/another-.*/, first_record.slug)
     end
   end
@@ -172,7 +193,7 @@ class HistoryTestWithAutomaticSlugRegeneration < HistoryTest
   end
 end
 
-class DependentDestroyTest < HistoryTest
+class DependentDestroyTest < TestCaseClass
 
   include FriendlyId::Test
 
@@ -211,6 +232,37 @@ class DependentDestroyTest < HistoryTest
   end
 end
 
+if ActiveRecord::VERSION::STRING >= '5.0'
+  class HistoryTestWithParanoidDeletes < HistoryTest
+    class ParanoidRecord < ActiveRecord::Base
+      extend FriendlyId
+      friendly_id :name, :use => :history, :dependent => false
+
+      default_scope { where(deleted_at: nil) }
+    end
+
+    def model_class
+      ParanoidRecord
+    end
+
+    test 'slug should have a sluggable even when soft deleted by a library' do
+      transaction do
+        assert FriendlyId::Slug.find_by_slug('paranoid').nil?
+        record = model_class.create(name: 'paranoid')
+        assert FriendlyId::Slug.find_by_slug('paranoid').present?
+
+        record.update deleted_at: Time.now
+
+        orphan_slug = FriendlyId::Slug.find_by_slug('paranoid')
+        assert orphan_slug.present?, 'Orphaned slug should exist'
+
+        assert orphan_slug.valid?, "Errors: #{orphan_slug.errors.full_messages}"
+        assert orphan_slug.sluggable.present?, 'Orphaned slug should still find corresponding paranoid sluggable'
+      end
+    end
+  end
+end
+
 class HistoryTestWithSti < HistoryTest
   class Journalist < ActiveRecord::Base
     extend FriendlyId
@@ -248,7 +300,7 @@ class HistoryTestWithFriendlyFinders < HistoryTest
         begin
           assert model_class.find(old_friendly_id)
           assert model_class.exists?(old_friendly_id), "should exist? by old id for #{model_class.name}"
-        rescue ActiveRecord::RecordNotFound => e
+        rescue ActiveRecord::RecordNotFound
           flunk "Could not find record by old id for #{model_class.name}"
         end
       end
@@ -346,6 +398,33 @@ class ScopedHistoryTest < TestCaseClass
     end
   end
 
+  test "should record history when scope changes" do
+    transaction do
+      city1 = City.create!
+      city2 = City.create!
+      with_instance_of(Restaurant) do |record|
+        record.name = "x"
+        record.slug = nil
+
+        record.city = city1
+        record.save!
+        assert_equal("city_id:#{city1.id}", record.slugs.reload.first.scope)
+        assert_equal("x", record.slugs.reload.first.slug)
+
+        record.city = city2
+        record.save!
+        assert_equal("city_id:#{city2.id}", record.slugs.reload.first.scope)
+
+        record.name = "y"
+        record.slug = nil
+        record.city = city1
+        record.save!
+        assert_equal("city_id:#{city1.id}", record.slugs.reload.first.scope)
+        assert_equal("y", record.slugs.reload.first.slug)
+      end
+    end
+  end
+
   test "should allow equal slugs in different scopes" do
     transaction do
       city = City.create!
@@ -356,4 +435,4 @@ class ScopedHistoryTest < TestCaseClass
       assert_equal record.slug, second_record.slug
     end
   end
-end
+end