friendly_id 4.1.0.beta.1 → 5.0.0.alpha.1

data/lib/friendly_id/object_utils.rb

@@ -8,7 +8,7 @@ module FriendlyId
   # be sufficient to avoid conflicts with other libraries.
   module ObjectUtils
 
-    # True is the id is definitely friendly, false if definitely unfriendly,
+    # True if the id is definitely friendly, false if definitely unfriendly,
     # else nil.
     #
     # An object is considired "definitely unfriendly" if its class is or

data/lib/friendly_id/scoped.rb

@@ -28,11 +28,33 @@ This allows, for example, two restaurants in different cities to have the slug
     City.find("chicago").restaurants.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--2+.
++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
@@ -81,14 +103,17 @@ an example of one way to set this up:
 =end
   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)
+      model_class.friendly_id_config.use :slugged
+    end
 
     # Sets up behavior and configuration options for FriendlyId's scoped slugs
     # feature.
     def self.included(model_class)
-      model_class.instance_eval do
-        include Slugged unless self < Slugged
+      model_class.class_eval do
         friendly_id_config.class.send :include, Configuration
-        friendly_id_config.slug_generator_class.send :include, SlugGenerator
       end
     end
 
@@ -96,6 +121,15 @@ an example of one way to set this up:
       friendly_id_config.scope_columns.sort.map { |column| "#{column}:#{send(column)}" }.join(",")
     end
 
+    def slug_generator
+      relation = self.class.unscoped.friendly
+      friendly_id_config.scope_columns.each do |column|
+        relation = relation.where(column => send(column))
+      end
+      friendly_id_config.slug_generator_class.new(relation)
+    end
+    private :slug_generator
+
     # This module adds the +:scope+ configuration option to
     # {FriendlyId::Configuration FriendlyId::Configuration}.
     module Configuration
@@ -122,36 +156,8 @@ an example of one way to set this up:
 
       private
 
-      if ActiveRecord::VERSION::STRING < "3.1"
-        def reflection_foreign_key(scope)
-          model_class.reflections[scope].try(:primary_key_name)
-        end
-      else
-        def reflection_foreign_key(scope)
-          model_class.reflections[scope].try(:foreign_key)
-        end
-      end
-    end
-
-    # This module overrides {FriendlyId::SlugGenerator#conflict} to consider
-    # scope, to avoid adding sequences to slugs under different scopes.
-    module SlugGenerator
-
-      private
-
-      def conflict
-        if friendly_id_config.uses?(:history)
-          # When using the :history module +conflicts+ already returns only real conflicts, so there's no need to check
-          # for the scope columns again
-          conflicts.first
-        else
-          columns = friendly_id_config.scope_columns
-          matched = columns.inject(conflicts) do |memo, column|
-            memo.where(column => sluggable.send(column))
-          end
-
-          matched.first
-        end
+      def reflection_foreign_key(scope)
+        model_class.reflections[scope].try(:foreign_key)
       end
     end
   end

data/lib/friendly_id/scopes.rb

@@ -0,0 +1,28 @@
+module FriendlyId
+  module Scopes
+
+    def self.extended(model_class)
+      model_class.scope :friendly, ->{model_class.all} do
+        def find(*args)
+          id = args.first
+          return super if args.count != 1 || id.unfriendly_id?
+          find_by_friendly_id(id) or super
+        end
+
+        def exists?(conditions = :none)
+          return super if conditions.unfriendly_id? || conditions.unfriendly_id?.nil?
+          exists_by_friendly_id?(conditions)
+        end
+      end
+    end
+
+    def find_by_friendly_id(id)
+      where(friendly_id_config.query_field => id).first
+    end
+
+    def exists_by_friendly_id?(id)
+      where(friendly_id_config.query_field => id).exists?
+    end
+
+  end
+end

data/lib/friendly_id/simple_i18n.rb

@@ -17,7 +17,7 @@ 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
-{FriendlyId::Globalize Globalize} module instead.
+friendly_id_globalize gem instead.
 
 === Example migration
 
@@ -70,9 +70,14 @@ current locale:
 =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)
+      model_class.friendly_id_config.use :slugged
+    end
+
     def self.included(model_class)
-      model_class.instance_eval do
-        friendly_id_config.use :slugged
+      model_class.class_eval do
         friendly_id_config.class.send :include, Configuration
         include Model
       end
@@ -84,6 +89,11 @@ current locale:
           set_slug(normalize_friendly_id(text))
         end
       end
+
+      def slug=(value)
+        super
+        write_attribute friendly_id_config.slug_column, value
+      end
     end
 
     module Configuration

data/lib/friendly_id/slug.rb

@@ -3,7 +3,6 @@ module FriendlyId
   #
   # @see FriendlyId::History
   class Slug < ActiveRecord::Base
-    self.table_name = "friendly_id_slugs"
     belongs_to :sluggable, :polymorphic => true
 
     def to_param

data/lib/friendly_id/slug_generator.rb

@@ -2,82 +2,23 @@ module FriendlyId
   # The default slug generator offers functionality to check slug strings for
   # uniqueness and, if necessary, appends a sequence to guarantee it.
   class SlugGenerator
-    attr_reader :sluggable, :normalized
 
-    # Create a new slug generator.
-    def initialize(sluggable, normalized)
-      @sluggable  = sluggable
-      @normalized = normalized
+    def initialize(scope)
+      @scope = scope
     end
 
-    # Given a slug, get the next available slug in the sequence.
-    def next
-      "#{normalized}#{separator}#{next_in_sequence}"
+    def available?(slug)
+      !@scope.exists?(slug)
     end
 
-    # Generate a new sequenced slug.
-    def generate
-      conflict? ? self.next : normalized
+    def add(slug)
+      slug
     end
 
-    private
-
-    def next_in_sequence
-      last_in_sequence == 0 ? 2 : last_in_sequence.next
-    end
-
-    def last_in_sequence
-      @_last_in_sequence ||= extract_sequence_from_slug(conflict.to_param)
-    end
-
-    def extract_sequence_from_slug(slug)
-      slug.split("#{normalized}#{separator}").last.to_i
+    def generate(candidates)
+      candidates.each {|c| return add c if available?(c)}
+      nil
     end
 
-    def column
-      sluggable.connection.quote_column_name friendly_id_config.slug_column
-    end
-
-    def conflict?
-      !! conflict
-    end
-
-    def conflict
-      unless defined? @conflict
-        @conflict = conflicts.first
-      end
-      @conflict
-    end
-
-    def conflicts
-      sluggable_class = friendly_id_config.model_class.base_class
-
-      pkey  = sluggable_class.primary_key
-      value = sluggable.send pkey
-      base = "#{column} = ? OR #{column} LIKE ?"
-      # Awful hack for SQLite3, which does not pick up '\' as the escape character without this.
-      base << "ESCAPE '\\'" if sluggable.connection.adapter_name =~ /sqlite/i
-      scope = sluggable_class.unscoped.where(base, normalized, wildcard)
-      scope = scope.where("#{pkey} <> ?", value) unless sluggable.new_record?
-      
-      length_command = "LENGTH"
-      length_command = "LEN" if sluggable.connection.adapter_name =~ /sqlserver/i
-      scope = scope.order("#{length_command}(#{column}) DESC, #{column} DESC")
-    end
-
-    def friendly_id_config
-      sluggable.friendly_id_config
-    end
-
-    def separator
-      friendly_id_config.sequence_separator
-    end
-
-    def wildcard
-      # Underscores (matching a single character) and percent signs (matching
-      # any number of characters) need to be escaped
-      # (While this seems like an excessive number of backslashes, it is correct)
-      "#{normalized}#{separator}".gsub(/[_%]/, '\\\\\&') + '%'
-    end
   end
 end

data/lib/friendly_id/slugged.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 require "friendly_id/slug_generator"
+require "friendly_id/candidates"
 
 module FriendlyId
 =begin
@@ -82,11 +83,11 @@ FriendlyId will append a sequence to the generated slug to ensure uniqueness:
   car2 = Car.create :title => "Peugot 206"
 
   car.friendly_id #=> "peugot-206"
-  car2.friendly_id #=> "peugot-206--2"
+  car2.friendly_id #=> "peugot-206-f9f3789a-daec-4156-af1d-fab81aa16ee5"
 
 ==== Sequence Separator - The Two Dashes
 
-By default, FriendlyId uses two dashes to separate the slug from a sequence.
+By default, FriendlyId uses a dash to separate the slug from a sequence.
 
 You can change this with the {FriendlyId::Slugged::Configuration#sequence_separator
 sequence_separator} configuration option.
@@ -185,11 +186,11 @@ second, in concurrent code, either in threads or multiple processes.
 
 To solve the nested attributes issue, I recommend simply avoiding them when
 creating more than one nested record for a model that uses FriendlyId. See {this
-Github issue}[https://github.com/norman/friendly_id/issues/185] for discussion.
+Github issue}[https://github.com/FriendlyId/friendly_id/issues/185] for discussion.
 
 To solve the concurrency issue, I recommend locking the model's table against
 inserts while when saving the record. See {this Github
-issue}[https://github.com/norman/friendly_id/issues/180] for discussion.
+issue}[https://github.com/FriendlyId/friendly_id/issues/180] for discussion.
 
 =end
   module Slugged
@@ -199,9 +200,9 @@ issue}[https://github.com/norman/friendly_id/issues/180] for discussion.
     def self.included(model_class)
       model_class.friendly_id_config.instance_eval do
         self.class.send :include, Configuration
-        self.slug_generator_class     ||= Class.new(SlugGenerator)
+        self.slug_generator_class     ||= SlugGenerator
         defaults[:slug_column]        ||= 'slug'
-        defaults[:sequence_separator] ||= '--'
+        defaults[:sequence_separator] ||= '-'
       end
       model_class.before_validation :set_slug
     end
@@ -250,34 +251,28 @@ issue}[https://github.com/norman/friendly_id/issues/180] for discussion.
     # You can override this method in your model if, for example, you only want
     # slugs to be generated once, and then never updated.
     def should_generate_new_friendly_id?
-      base       = send(friendly_id_config.base)
-      slug_value = send(friendly_id_config.slug_column)
-
-      # If the slug base is nil, and the slug field is nil, then we're going to
-      # leave the slug column NULL.
-      return false if base.nil? && slug_value.nil?
-      # Otherwise, if this is a new record, we're definitely going to try to
-      # create a new slug.
-      return true if new_record?
-      slug_base = normalize_friendly_id(base)
-      separator = Regexp.escape friendly_id_config.sequence_separator
-      # If the slug base (with and without sequence) is different from either the current
-      # friendly id or the slug value, then we'll generate a new friendly_id.
-      compare = (current_friendly_id || slug_value)
-      slug_base != compare && slug_base != compare.try(:sub, /#{separator}[\d]*\z/, '')
+      send(friendly_id_config.slug_column).nil? && !send(friendly_id_config.base).nil?
+    end
+
+    def resolve_friendly_id_conflict(candidates)
+      candidates.first + friendly_id_config.sequence_separator + SecureRandom.uuid
     end
 
     # Sets the slug.
-    # FIXME: This method sucks and the logic is pretty dubious.
     def set_slug(normalized_slug = nil)
-      if normalized_slug || should_generate_new_friendly_id?
-        normalized_slug ||= normalize_friendly_id send(friendly_id_config.base)
-        generator = friendly_id_config.slug_generator_class.new self, normalized_slug
-        send "#{friendly_id_config.slug_column}=", generator.generate
+      if should_generate_new_friendly_id?
+        candidates = FriendlyId::Candidates.new(self, normalized_slug || send(friendly_id_config.base))
+        slug = slug_generator.generate(candidates) || resolve_friendly_id_conflict(candidates)
+        send "#{friendly_id_config.slug_column}=", slug
       end
     end
     private :set_slug
 
+    def slug_generator
+      friendly_id_config.slug_generator_class.new(self.class.base_class.unscoped.friendly)
+    end
+    private :slug_generator
+
     # This module adds the +:slug_column+, and +:sequence_separator+, and
     # +:slug_generator_class+ configuration options to
     # {FriendlyId::Configuration FriendlyId::Configuration}.
@@ -293,17 +288,10 @@ issue}[https://github.com/norman/friendly_id/issues/180] for discussion.
 
       # The string used to separate a slug base from a numeric sequence.
       #
-      # By default, +--+ is used to separate the slug from the sequence.
-      # FriendlyId uses two dashes to distinguish sequences from slugs with
-      # numbers in their name.
-      #
       # You can change the default separator by setting the
       # {FriendlyId::Slugged::Configuration#sequence_separator
       # sequence_separator} configuration option.
-      #
-      # For obvious reasons, you should avoid setting it to "+-+" unless you're
-      # sure you will never want to have a friendly id with a number in it.
-      # @return String The sequence separator string. Defaults to "+--+".
+      # @return String The sequence separator string. Defaults to "+-+".
       def sequence_separator
         @sequence_separator or defaults[:sequence_separator]
       end

data/lib/friendly_id/version.rb

@@ -0,0 +1,3 @@
+module FriendlyId
+  VERSION = "5.0.0.alpha.1"
+end

data/lib/generators/friendly_id_generator.rb

@@ -3,14 +3,15 @@ require "rails/generators/active_record"
 
 # This generator adds a migration for the {FriendlyId::History
 # FriendlyId::History} addon.
-class FriendlyIdGenerator < Rails::Generators::Base
-  include Rails::Generators::Migration
-  extend ActiveRecord::Generators::Migration
+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'
 
   source_root File.expand_path('../../friendly_id', __FILE__)
 
   # Copies the migration template to db/migrate.
-  def copy_files(*args)
+  def copy_files
     migration_template 'migration.rb', 'db/migrate/create_friendly_id_slugs.rb'
   end
 

data/test/helper.rb

@@ -1,7 +1,7 @@
 require "rubygems"
 require "bundler/setup"
 require "minitest/unit"
-require "mocha"
+require "mocha/setup"
 require "active_record"
 require 'active_support/core_ext/time/conversions'
 

data/test/history_test.rb

@@ -2,7 +2,7 @@ require "helper"
 
 class Manual < ActiveRecord::Base
   extend FriendlyId
-  friendly_id :name, :use => :history
+  friendly_id :name, :use => [:slugged, :history]
 end
 
 class HistoryTest < MiniTest::Unit::TestCase
@@ -29,6 +29,7 @@ class HistoryTest < MiniTest::Unit::TestCase
   test "should create new slug record when friendly_id changes" do
     with_instance_of(model_class) do |record|
       record.name = record.name + "b"
+      record.slug = nil
       record.save!
       assert_equal 2, FriendlyId::Slug.count
     end
@@ -38,10 +39,11 @@ class HistoryTest < MiniTest::Unit::TestCase
     with_instance_of(model_class) do |record|
       old_friendly_id = record.friendly_id
       record.name = record.name + "b"
+      record.slug = nil
       record.save!
       begin
-        assert model_class.find(old_friendly_id)
-        assert model_class.exists?(old_friendly_id), "should exist? by old id"
+        assert model_class.friendly.find(old_friendly_id)
+        assert model_class.friendly.exists?(old_friendly_id), "should exist? by old id"
       rescue ActiveRecord::RecordNotFound
         flunk "Could not find record by old id"
       end
@@ -52,8 +54,9 @@ class HistoryTest < MiniTest::Unit::TestCase
     transaction do
       record = model_class.create! :name => "hello"
       assert_equal 1, FriendlyId::Slug.count
-      record = model_class.find("hello")
+      record = model_class.friendly.find("hello")
       record.name = "hello again"
+      record.slug = nil
       record.save!
       assert_equal 2, FriendlyId::Slug.count
     end
@@ -64,17 +67,7 @@ class HistoryTest < MiniTest::Unit::TestCase
       old_friendly_id = record.friendly_id
       record.name = record.name + "b"
       record.save!
-      assert !model_class.find(old_friendly_id).readonly?
-    end
-  end
-
-  test "should create correct sequence numbers even when some conflicted slugs have changed" do
-    transaction do
-      record1 = model_class.create! :name => 'hello'
-      record2 = model_class.create! :name => 'hello!'
-      record2.update_attributes :name => 'goodbye'
-      record3 = model_class.create! :name => 'hello!'
-      assert_equal 'hello--3', record3.slug
+      assert !model_class.friendly.find(old_friendly_id).readonly?
     end
   end
 
@@ -96,16 +89,7 @@ class HistoryTest < MiniTest::Unit::TestCase
       first_record.save!
       second_record = model_class.create! :name => "foo"
       assert second_record.slug != "foo"
-      assert second_record.slug == "foo--2"
-    end
-  end
-
-  test 'should increment the sequence by one for each historic slug' do
-    transaction do
-      previous_record = model_class.create! :name => "foo"
-      first_record = model_class.create! :name => 'another'
-      second_record = model_class.create! :name => 'another'
-      assert second_record.slug == "another--2"
+      assert_match(/foo-.+/, second_record.slug)
     end
   end
 
@@ -114,13 +98,28 @@ class HistoryTest < MiniTest::Unit::TestCase
       first_record = model_class.create! :name => "foo"
       second_record = model_class.create! :name => 'another'
 
-      second_record.update_attributes :name => 'foo'
-      assert second_record.slug == "foo--2"
-      first_record.update_attributes :name => 'another'
-      assert first_record.slug == "another--2"
+      second_record.update_attributes :name => 'foo', :slug => nil
+      assert_match(/foo-.*/, second_record.slug)
+
+      first_record.update_attributes :name => 'another', :slug => nil
+      assert_match(/another-.*/, first_record.slug)
     end
   end
 
+  test 'should name table according to prefix and suffix' do
+    transaction do
+      begin
+        prefix = "prefix_"
+        without_prefix = FriendlyId::Slug.table_name
+        ActiveRecord::Base.table_name_prefix = prefix
+        FriendlyId::Slug.reset_table_name
+        assert_equal prefix + without_prefix, FriendlyId::Slug.table_name
+      ensure
+        ActiveRecord::Base.table_name_prefix = ""
+        FriendlyId::Slug.table_name = without_prefix
+      end
+    end
+  end
 end
 
 class HistoryTestWithSti < HistoryTest
@@ -137,8 +136,6 @@ class HistoryTestWithSti < HistoryTest
   end
 end
 
-
-
 class City < ActiveRecord::Base
   has_many :restaurants
 end
@@ -158,45 +155,55 @@ class ScopedHistoryTest < MiniTest::Unit::TestCase
   end
 
   test "should find old scoped slugs" do
-    city = City.create!
-    with_instance_of(Restaurant) do |record|
-      record.city = city
+    transaction do
+      city = City.create!
+      with_instance_of(Restaurant) do |record|
+        record.city = city
 
-      record.name = "x"
-      record.save!
+        record.name = "x"
+        record.slug = nil
+        record.save!
 
-      record.name = "y"
-      record.save!
+        record.name = "y"
+        record.slug = nil
+        record.save!
 
-      assert_equal city.restaurants.find("x"), city.restaurants.find("y")
+        assert_equal city.restaurants.friendly.find("x"), city.restaurants.friendly.find("y")
+      end
     end
   end
 
   test "should consider old scoped slugs when creating slugs" do
-    city = City.create!
-    with_instance_of(Restaurant) do |record|
-      record.city = city
+    transaction do
+      city = City.create!
+      with_instance_of(Restaurant) do |record|
+        record.city = city
 
-      record.name = "x"
-      record.save!
+        record.name = "x"
+        record.slug = nil
+        record.save!
 
-      record.name = "y"
-      record.save!
+        record.name = "y"
+        record.slug = nil
+        record.save!
 
-      second_record = model_class.create! :city => city, :name => 'x'
-      assert_equal "x--2", second_record.friendly_id
+        second_record = model_class.create! :city => city, :name => 'x'
+        assert_match(/x-.+/, second_record.friendly_id)
 
-      third_record = model_class.create! :city => city, :name => 'y'
-      assert_equal "y--2", third_record.friendly_id
+        third_record = model_class.create! :city => city, :name => 'y'
+        assert_match(/y-.+/, third_record.friendly_id)
+      end
     end
   end
 
   test "should allow equal slugs in different scopes" do
-    city = City.create!
-    second_city = City.create!
-    record = model_class.create! :city => city, :name => 'x'
-    second_record = model_class.create! :city => second_city, :name => 'x'
+    transaction do
+      city = City.create!
+      second_city = City.create!
+      record = model_class.create! :city => city, :name => 'x'
+      second_record = model_class.create! :city => second_city, :name => 'x'
 
-    assert_equal record.slug, second_record.slug
+      assert_equal record.slug, second_record.slug
+    end
   end
-end
+end