friendly_id 5.2.4 → 5.5.0

data/lib/friendly_id/scoped.rb

@@ -1,108 +1,104 @@
 require "friendly_id/slugged"
 
 module FriendlyId
-
-=begin
-
-## Unique Slugs by Scope
-
-The {FriendlyId::Scoped} module allows FriendlyId to generate unique slugs
-within a scope.
-
-This allows, for example, two restaurants in different cities to have the slug
-`joes-diner`:
-
-    class Restaurant < ActiveRecord::Base
-      extend FriendlyId
-      belongs_to :city
-      friendly_id :name, :use => :scoped, :scope => :city
-    end
-
-    class City < ActiveRecord::Base
-      extend FriendlyId
-      has_many :restaurants
-      friendly_id :name, :use => :slugged
-    end
-
-    City.friendly.find("seattle").restaurants.friendly.find("joes-diner")
-    City.friendly.find("chicago").restaurants.friendly.find("joes-diner")
-
-Without :scoped in this case, one of the restaurants would have the slug
-`joes-diner` and the other would have `joes-diner-f9f3789a-daec-4156-af1d-fab81aa16ee5`.
-
-The value for the `:scope` option can be the name of a `belongs_to` relation, or
-a column.
-
-Additionally, the `:scope` option can receive an array of scope values:
-
-    class Cuisine < ActiveRecord::Base
-      extend FriendlyId
-      has_many :restaurants
-      friendly_id :name, :use => :slugged
-    end
-
-    class City < ActiveRecord::Base
-      extend FriendlyId
-      has_many :restaurants
-      friendly_id :name, :use => :slugged
-    end
-
-    class Restaurant < ActiveRecord::Base
-      extend FriendlyId
-      belongs_to :city
-      friendly_id :name, :use => :scoped, :scope => [:city, :cuisine]
-    end
-
-All supplied values will be used to determine scope.
-
-### Finding Records by Friendly ID
-
-If you are using scopes your friendly ids may not be unique, so a simple find
-like:
-
-    Restaurant.friendly.find("joes-diner")
-
-may return the wrong record. In these cases it's best to query through the
-relation:
-
-    @city.restaurants.friendly.find("joes-diner")
-
-Alternatively, you could pass the scope value as a query parameter:
-
-    Restaurant.where(:city_id => @city.id).friendly.find("joes-diner")
-
-
-### Finding All Records That Match a Scoped ID
-
-Query the slug column directly:
-
-    Restaurant.where(:slug => "joes-diner")
-
-### Routes for Scoped Models
-
-Recall that FriendlyId is a database-centric library, and does not set up any
-routes for scoped models. You must do this yourself in your application. Here's
-an example of one way to set this up:
-
-    # in routes.rb
-    resources :cities do
-      resources :restaurants
-    end
-
-    # in views
-    <%= link_to 'Show', [@city, @restaurant] %>
-
-    # in controllers
-    @city = City.friendly.find(params[:city_id])
-    @restaurant = @city.restaurants.friendly.find(params[:id])
-
-    # URLs:
-    http://example.org/cities/seattle/restaurants/joes-diner
-    http://example.org/cities/chicago/restaurants/joes-diner
-
-=end
+  #
+  ## Unique Slugs by Scope
+  #
+  # The {FriendlyId::Scoped} module allows FriendlyId to generate unique slugs
+  # within a scope.
+  #
+  # This allows, for example, two restaurants in different cities to have the slug
+  # `joes-diner`:
+  #
+  #     class Restaurant < ActiveRecord::Base
+  #       extend FriendlyId
+  #       belongs_to :city
+  #       friendly_id :name, :use => :scoped, :scope => :city
+  #     end
+  #
+  #     class City < ActiveRecord::Base
+  #       extend FriendlyId
+  #       has_many :restaurants
+  #       friendly_id :name, :use => :slugged
+  #     end
+  #
+  #     City.friendly.find("seattle").restaurants.friendly.find("joes-diner")
+  #     City.friendly.find("chicago").restaurants.friendly.find("joes-diner")
+  #
+  # Without :scoped in this case, one of the restaurants would have the slug
+  # `joes-diner` and the other would have `joes-diner-f9f3789a-daec-4156-af1d-fab81aa16ee5`.
+  #
+  # The value for the `:scope` option can be the name of a `belongs_to` relation, or
+  # a column.
+  #
+  # Additionally, the `:scope` option can receive an array of scope values:
+  #
+  #     class Cuisine < ActiveRecord::Base
+  #       extend FriendlyId
+  #       has_many :restaurants
+  #       friendly_id :name, :use => :slugged
+  #     end
+  #
+  #     class City < ActiveRecord::Base
+  #       extend FriendlyId
+  #       has_many :restaurants
+  #       friendly_id :name, :use => :slugged
+  #     end
+  #
+  #     class Restaurant < ActiveRecord::Base
+  #       extend FriendlyId
+  #       belongs_to :city
+  #       friendly_id :name, :use => :scoped, :scope => [:city, :cuisine]
+  #     end
+  #
+  # All supplied values will be used to determine scope.
+  #
+  ### Finding Records by Friendly ID
+  #
+  # If you are using scopes your friendly ids may not be unique, so a simple find
+  # like:
+  #
+  #     Restaurant.friendly.find("joes-diner")
+  #
+  # may return the wrong record. In these cases it's best to query through the
+  # relation:
+  #
+  #     @city.restaurants.friendly.find("joes-diner")
+  #
+  # Alternatively, you could pass the scope value as a query parameter:
+  #
+  #     Restaurant.where(:city_id => @city.id).friendly.find("joes-diner")
+  #
+  #
+  ### Finding All Records That Match a Scoped ID
+  #
+  # Query the slug column directly:
+  #
+  #     Restaurant.where(:slug => "joes-diner")
+  #
+  ### Routes for Scoped Models
+  #
+  # Recall that FriendlyId is a database-centric library, and does not set up any
+  # routes for scoped models. You must do this yourself in your application. Here's
+  # an example of one way to set this up:
+  #
+  #     # in routes.rb
+  #     resources :cities do
+  #       resources :restaurants
+  #     end
+  #
+  #     # in views
+  #     <%= link_to 'Show', [@city, @restaurant] %>
+  #
+  #     # in controllers
+  #     @city = City.friendly.find(params[:city_id])
+  #     @restaurant = @city.restaurants.friendly.find(params[:id])
+  #
+  #     # URLs:
+  #     http://example.org/cities/seattle/restaurants/joes-diner
+  #     http://example.org/cities/chicago/restaurants/joes-diner
+  #
   module Scoped
-
     # FriendlyId::Config.use will invoke this method when present, to allow
     # loading dependent modules prior to overriding them when necessary.
     def self.setup(model_class)
@@ -122,7 +118,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
@@ -136,10 +135,13 @@ an example of one way to set this up:
     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
-
       # Gets the scope value.
       #
       # When setting this value, the argument should be a symbol referencing a

data/lib/friendly_id/sequentially_slugged/calculator.rb

@@ -0,0 +1,69 @@
+module FriendlyId
+  module SequentiallySlugged
+    class Calculator
+      attr_accessor :scope, :slug, :slug_column, :sequence_separator
+
+      def initialize(scope, slug, slug_column, sequence_separator, base_class)
+        @scope = scope
+        @slug = slug
+        table_name = scope.connection.quote_table_name(base_class.arel_table.name)
+        @slug_column = "#{table_name}.#{scope.connection.quote_column_name(slug_column)}"
+        @sequence_separator = sequence_separator
+      end
+
+      def next_slug
+        slug + sequence_separator + next_sequence_number.to_s
+      end
+
+      private
+
+      def conflict_query
+        base = "#{slug_column} = ? OR #{slug_column} LIKE ?"
+        # Awful hack for SQLite3, which does not pick up '\' as the escape character
+        # without this.
+        base << " ESCAPE '\\'" if /sqlite/i.match?(scope.connection.adapter_name)
+        base
+      end
+
+      def next_sequence_number
+        last_sequence_number ? last_sequence_number + 1 : 2
+      end
+
+      def last_sequence_number
+        # Reject slug_conflicts that doesn't come from the first_candidate
+        # Map all sequence numbers and take the maximum
+        slug_conflicts
+          .reject { |slug_conflict| !regexp.match(slug_conflict) }
+          .map { |slug_conflict| regexp.match(slug_conflict)[1].to_i }
+          .max
+      end
+
+      # Return the unnumbered (shortest) slug first, followed by the numbered ones
+      # in ascending order.
+      def ordering_query
+        "#{sql_length}(#{slug_column}) ASC, #{slug_column} ASC"
+      end
+
+      def regexp
+        /#{slug}#{sequence_separator}(\d+)\z/
+      end
+
+      def sequential_slug_matcher
+        # Underscores (matching a single character) and percent signs (matching
+        # any number of characters) need to be escaped. While this looks like
+        # an excessive number of backslashes, it is correct.
+        "#{slug}#{sequence_separator}".gsub(/[_%]/, '\\\\\&') + "%"
+      end
+
+      def slug_conflicts
+        scope
+          .where(conflict_query, slug, sequential_slug_matcher)
+          .order(Arel.sql(ordering_query)).pluck(Arel.sql(slug_column))
+      end
+
+      def sql_length
+        /sqlserver/i.match?(scope.connection.adapter_name) ? "LEN" : "LENGTH"
+      end
+    end
+  end
+end

data/lib/friendly_id/sequentially_slugged.rb

@@ -1,3 +1,5 @@
+require_relative "sequentially_slugged/calculator"
+
 module FriendlyId
   module SequentiallySlugged
     def self.setup(model_class)
@@ -7,70 +9,31 @@ module FriendlyId
     def resolve_friendly_id_conflict(candidate_slugs)
       candidate = candidate_slugs.first
       return if candidate.nil?
-      SequentialSlugCalculator.new(scope_for_slug_generator,
-                                  candidate,
-                                  friendly_id_config.slug_column,
-                                  friendly_id_config.sequence_separator,
-                                  self.class.base_class).next_slug
-    end
-
-    class SequentialSlugCalculator
-      attr_accessor :scope, :slug, :slug_column, :sequence_separator
-
-      def initialize(scope, slug, slug_column, sequence_separator, base_class)
-        @scope = scope
-        @slug = slug
-        table_name = scope.connection.quote_table_name(base_class.arel_table.name)
-        @slug_column = "#{table_name}.#{scope.connection.quote_column_name(slug_column)}"
-        @sequence_separator = sequence_separator
-      end
 
-      def next_slug
-        slug + sequence_separator + next_sequence_number.to_s
-      end
+      Calculator.new(
+        scope_for_slug_generator,
+        candidate,
+        slug_column,
+        friendly_id_config.sequence_separator,
+        slug_base_class
+      ).next_slug
+    end
 
     private
 
-      def next_sequence_number
-        last_sequence_number ? last_sequence_number + 1 : 2
-      end
-
-      def last_sequence_number
-        regexp = /#{slug}#{sequence_separator}(\d+)\z/
-        # Reject slug_conflicts that doesn't come from the first_candidate
-        # Map all sequence numbers and take the maximum
-        slug_conflicts.reject{ |slug_conflict| !regexp.match(slug_conflict) }.map do |slug_conflict|
-          regexp.match(slug_conflict)[1].to_i
-        end.max
-      end
-
-      def slug_conflicts
-        scope.
-          where(conflict_query, slug, sequential_slug_matcher).
-          order(Arel.sql(ordering_query)).pluck(Arel.sql(slug_column))
-      end
-
-      def conflict_query
-        base = "#{slug_column} = ? OR #{slug_column} LIKE ?"
-        # Awful hack for SQLite3, which does not pick up '\' as the escape character
-        # without this.
-        base << " ESCAPE '\\'" if scope.connection.adapter_name =~ /sqlite/i
-        base
-      end
-
-      def sequential_slug_matcher
-        # Underscores (matching a single character) and percent signs (matching
-        # any number of characters) need to be escaped. While this looks like
-        # an excessive number of backslashes, it is correct.
-        "#{slug}#{sequence_separator}".gsub(/[_%]/, '\\\\\&') + '%'
+    def slug_base_class
+      if friendly_id_config.uses?(:history)
+        Slug
+      else
+        self.class.base_class
       end
+    end
 
-      # Return the unnumbered (shortest) slug first, followed by the numbered ones
-      # in ascending order.
-      def ordering_query
-        length_command = "LENGTH"
-        length_command = "LEN" if scope.connection.adapter_name =~ /sqlserver/i
-        "#{length_command}(#{slug_column}) ASC, #{slug_column} ASC"
+    def slug_column
+      if friendly_id_config.uses?(:history)
+        :slug
+      else
+        friendly_id_config.slug_column
       end
     end
   end

data/lib/friendly_id/simple_i18n.rb

@@ -1,75 +1,75 @@
 require "i18n"
 
 module FriendlyId
-
-=begin
-
-## Translating Slugs Using Simple I18n
-
-The {FriendlyId::SimpleI18n SimpleI18n} module adds very basic i18n support to
-FriendlyId.
-
-In order to use this module, your model must have a slug column for each locale.
-By default FriendlyId looks for columns named, for example, "slug_en",
-"slug_es", etc. The first part of the name can be configured by passing the
-`:slug_column` option if you choose. Note that the column for the default locale
-must also include the locale in its name.
-
-This module is most suitable to applications that need to support few locales.
-If you need to support two or more locales, you may wish to use the
-friendly_id_globalize gem instead.
-
-### Example migration
-
-    def self.up
-      create_table :posts do |t|
-        t.string :title
-        t.string :slug_en
-        t.string :slug_es
-        t.text   :body
-      end
-      add_index :posts, :slug_en
-      add_index :posts, :slug_es
-    end
-
-### Finds
-
-Finds will take into consideration the current locale:
-
-    I18n.locale = :es
-    Post.friendly.find("la-guerra-de-las-galaxias")
-    I18n.locale = :en
-    Post.friendly.find("star-wars")
-
-To find a slug by an explicit locale, perform the find inside a block
-passed to I18n's `with_locale` method:
-
-    I18n.with_locale(:es) do
-      Post.friendly.find("la-guerra-de-las-galaxias")
-    end
-
-### Creating Records
-
-When new records are created, the slug is generated for the current locale only.
-
-### Translating Slugs
-
-To translate an existing record's friendly_id, use
-{FriendlyId::SimpleI18n::Model#set_friendly_id}. This will ensure that the slug
-you add is properly escaped, transliterated and sequenced:
-
-    post = Post.create :name => "Star Wars"
-    post.set_friendly_id("La guerra de las galaxias", :es)
-
-If you don't pass in a locale argument, FriendlyId::SimpleI18n will just use the
-current locale:
-
-    I18n.with_locale(:es) do
-      post.set_friendly_id("La guerra de las galaxias")
-    end
-=end
+  #
+  ## Translating Slugs Using Simple I18n
+  #
+  # The {FriendlyId::SimpleI18n SimpleI18n} module adds very basic i18n support to
+  # FriendlyId.
+  #
+  # In order to use this module, your model must have a slug column for each locale.
+  # By default FriendlyId looks for columns named, for example, "slug_en",
+  # "slug_es", "slug_pt_br", etc. The first part of the name can be configured by
+  # passing the `:slug_column` option if you choose. Note that the column for the
+  # default locale must also include the locale in its name.
+  #
+  # This module is most suitable to applications that need to support few locales.
+  # If you need to support two or more locales, you may wish to use the
+  # friendly_id_globalize gem instead.
+  #
+  ### Example migration
+  #
+  #     def self.up
+  #       create_table :posts do |t|
+  #         t.string :title
+  #         t.string :slug_en
+  #         t.string :slug_es
+  #         t.string :slug_pt_br
+  #         t.text   :body
+  #       end
+  #       add_index :posts, :slug_en
+  #       add_index :posts, :slug_es
+  #       add_index :posts, :slug_pt_br
+  #     end
+  #
+  ### Finds
+  #
+  # Finds will take into consideration the current locale:
+  #
+  #     I18n.locale = :es
+  #     Post.friendly.find("la-guerra-de-las-galaxias")
+  #     I18n.locale = :en
+  #     Post.friendly.find("star-wars")
+  #     I18n.locale = :"pt-BR"
+  #     Post.friendly.find("guerra-das-estrelas")
+  #
+  # To find a slug by an explicit locale, perform the find inside a block
+  # passed to I18n's `with_locale` method:
+  #
+  #     I18n.with_locale(:es) do
+  #       Post.friendly.find("la-guerra-de-las-galaxias")
+  #     end
+  #
+  ### Creating Records
+  #
+  # When new records are created, the slug is generated for the current locale only.
+  #
+  ### Translating Slugs
+  #
+  # To translate an existing record's friendly_id, use
+  # {FriendlyId::SimpleI18n::Model#set_friendly_id}. This will ensure that the slug
+  # you add is properly escaped, transliterated and sequenced:
+  #
+  #     post = Post.create :name => "Star Wars"
+  #     post.set_friendly_id("La guerra de las galaxias", :es)
+  #
+  # If you don't pass in a locale argument, FriendlyId::SimpleI18n will just use the
+  # current locale:
+  #
+  #     I18n.with_locale(:es) do
+  #       post.set_friendly_id("La guerra de las galaxias")
+  #     end
   module SimpleI18n
-
     # FriendlyId::Config.use will invoke this method when present, to allow
     # loading dependent modules prior to overriding them when necessary.
     def self.setup(model_class)
@@ -98,7 +98,13 @@ current locale:
 
     module Configuration
       def slug_column
-        "#{super}_#{I18n.locale}"
+        "#{super}_#{locale_suffix}"
+      end
+
+      private
+
+      def locale_suffix
+        I18n.locale.to_s.underscore
       end
     end
   end

data/lib/friendly_id/slug.rb

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

data/lib/friendly_id/slug_generator.rb

@@ -2,7 +2,6 @@ module FriendlyId
   # The default slug generator offers functionality to check slug candidates for
   # availability.
   class SlugGenerator
-
     def initialize(scope, config)
       @scope = scope
       @config = config
@@ -17,9 +16,8 @@ module FriendlyId
     end
 
     def generate(candidates)
-      candidates.each {|c| return c if available?(c)}
+      candidates.each { |c| return c if available?(c) }
       nil
     end
-
   end
 end