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

data/WhatsNew.md

@@ -1,95 +1,3 @@
-# What's New in FriendlyId 4?
+# What's New in FriendlyId 5?
 
-## Back to basics
-
-FriendlyId is mostly a different codebase from FriendlyId 3. However, this isn't
-the "big rewrite," it's the "small rewrite:"
-
-Adding new features with each release is not sustainable. This release *removes*
-features, but makes it possible to add them back as addons. We can also remove
-some complexity by relying on the better default functionality provided by newer
-versions of Active Support and Active Record.
-
-Here's what's changed:
-
-## New configuration and setup
-
-FriendlyId is no longer added to Active Record by default, you must explicitly
-add it to each model you want to use it in. The method and options have also
-changed:
-
-    # FriendlyId 3
-    class Post < ActiveRecord::Base
-      has_friendly_id :title, :use_slugs => true
-    end
-
-    # FriendlyId 4
-    class Post < ActiveRecord::Base
-      extend FriendlyId
-      friendly_id :title, :use => :slugged
-    end
-
-It also adds a new "defaults" method for configuring all models:
-
-    FriendlyId.defaults do |config|
-      config.use :slugged, :reserved
-      config.base = :name
-    end
-
-## Active Record 3+ only
-
-For 2.3 support, you can use FriendlyId 3.x, which will continue to be
-maintained until people don't want it any more.
-
-## In-table slugs
-
-FriendlyId no longer creates a separate slugs table - it just stores the
-generated slug value in the model table, which is simpler, faster and what most
-want by default. Keeping slug history in a separate table is an
-{FriendlyId::History optional add-on} for FriendlyId 4.
-
-## No more multiple finds
-
-    Person.find "joe-schmoe"               # Supported
-    Person.find ["joe-schmoe", "john-doe"] # No longer supported
-
-If you want find by more than one friendly id, build your own query:
-
-    Person.where(:slug => ["joe-schmoe", "john-doe"])
-
-This lets us do *far* less monkeypatching in Active Record. How much less?
-FriendlyId overrides the base find with a mere 2 lines of code, and otherwise
-changes nothing else. This means more stability and less breakage between Rails
-updates.
-
-## No more finder status
-
-FriendlyId 3 offered finder statuses to help you determine when an outdated
-or non-friendly id was used to find the record, so that you could decide whether
-to permanently redirect to the canonical URL. However, there's a simpler way to
-do that, so this feature has been removed:
-
-    if request.path != person_path(@person)
-      return redirect_to @person, :status => :moved_permanently
-    end
-
-## Bye-bye Babosa
-
-[Babosa](http://github.com/norman/babosa) is FriendlyId 3's slugging library.
-
-FriendlyId 4 doesn't use it by default because the most important pieces of it
-were already accepted into Active Support 3.
-
-However, Babosa is still useful, for example, for idiomatically transliterating
-Cyrillic ([or other
-language](https://github.com/norman/babosa/tree/master/lib/babosa/transliterator))
-strings to ASCII. It's very easy to include - just override
-`#normalize_friendly_id` in your model:
-
-    class MyModel < ActiveRecord::Base
-      ...
-
-      def normalize_friendly_id(text)
-        text.to_slug.normalize! :transliterations => :russian
-      end
-    end
+## Write me

data/friendly_id.gemspec

@@ -1,43 +1,33 @@
 # encoding: utf-8
-$:.push File.expand_path("../lib", __FILE__)
-
-require "friendly_id"
+require File.expand_path("../lib/friendly_id/version", __FILE__)
 
 Gem::Specification.new do |s|
   s.name              = "friendly_id"
   s.version           = FriendlyId::VERSION
   s.authors           = ["Norman Clarke", "Philip Arndt"]
-  s.email             = ["norman@njclarke.com", "parndt@gmail.com"]
-  s.homepage          = "http://github.com/norman/friendly_id"
+  s.email             = ["norman@njclarke.com", "p@arndt.io"]
+  s.homepage          = "http://github.com/FriendlyId/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.add_development_dependency "railties", "~> 3.2.0"
-  s.add_development_dependency "activerecord", "~> 3.2.0"
-  s.add_development_dependency "minitest", "3.2.0"
-  s.add_development_dependency "mocha"
-  s.add_development_dependency "maruku"
+  s.add_development_dependency "railties", "~> 4.0.0"
+  s.add_development_dependency "activerecord", "~> 4.0.0"
+  s.add_development_dependency "minitest", ">= 4.4.0"
+  s.add_development_dependency "mocha", "~> 0.13.3"
   s.add_development_dependency "yard"
   s.add_development_dependency "i18n"
   s.add_development_dependency "ffaker"
   s.add_development_dependency "simplecov"
-  s.add_development_dependency "globalize3"
 
   s.description = <<-EOM
 FriendlyId is the "Swiss Army bulldozer" of slugging and permalink plugins for
 Ruby on Rails. It allows you to create pretty URLs and work with human-friendly
 strings as if they were numeric ids for Active Record models.
 EOM
-
-  s.post_install_message = <<-EOM
-NOTE: FriendlyId 4.x breaks compatibility with 3.x. If you're upgrading
-from 3.x, please see this document:
-
-http://rubydoc.info/github/norman/friendly_id/master/file/WhatsNew.md
-
-EOM
-
 end

data/gemfiles/Gemfile.rails-4.0.rb

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+gemspec path: '../'
+
+# Database Configuration
+group :development, :test do
+  platforms :jruby do
+    gem 'activerecord-jdbcsqlite3-adapter', '>= 1.3.0.beta2'
+    gem 'activerecord-jdbcmysql-adapter', '>= 1.3.0.beta2'
+    gem 'activerecord-jdbcpostgresql-adapter', '>= 1.3.0.beta2'
+    gem 'jruby-openssl'
+  end
+
+  platforms :ruby do
+    gem 'sqlite3'
+    gem 'mysql2'
+    gem 'pg'
+  end
+end

data/lib/friendly_id.rb

@@ -3,7 +3,7 @@ require "thread"
 require "friendly_id/base"
 require "friendly_id/object_utils"
 require "friendly_id/configuration"
-require "friendly_id/finder_methods"
+require "friendly_id/scopes"
 
 =begin
 
@@ -44,9 +44,6 @@ with numeric ids:
 =end
 module FriendlyId
 
-  # The current version.
-  VERSION = "4.1.0.beta.1"
-
   @mutex = Mutex.new
 
   autoload :History,    "friendly_id/history"
@@ -55,7 +52,6 @@ module FriendlyId
   autoload :Reserved,   "friendly_id/reserved"
   autoload :Scoped,     "friendly_id/scoped"
   autoload :Slugged,    "friendly_id/slugged"
-  autoload :Globalize,  "friendly_id/globalize"
 
   # FriendlyId takes advantage of `extended` to do basic model setup, primarily
   # extending {FriendlyId::Base} to add {FriendlyId::Base#friendly_id
@@ -84,10 +80,11 @@ module FriendlyId
     class << model_class
       alias relation_without_friendly_id relation
     end
-    model_class.instance_eval do
+    model_class.class_eval do
       extend Base
       @friendly_id_config = Class.new(Configuration).new(self)
       FriendlyId.defaults.call @friendly_id_config
+      include Model
     end
   end
 
@@ -111,4 +108,12 @@ module FriendlyId
       @defaults ||= lambda {|config| config.use :reserved}
     end
   end
+
+  # Set the ActiveRecord table name prefix to friendly_id_
+  #
+  # This makes 'slugs' into 'friendly_id_slugs' and also respects any
+  # 'global' table_name_prefix set on ActiveRecord::Base.
+  def self.table_name_prefix
+    "#{ActiveRecord::Base.table_name_prefix}friendly_id_"
+  end
 end

data/lib/friendly_id/.gitattributes

@@ -0,0 +1 @@
+version.rb merge=ours

data/lib/friendly_id/base.rb

@@ -156,8 +156,7 @@ 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}, {FriendlyId::SimpleI18n :simple_i18n},
-    #   and {FriendlyId::Globalize :globalize}.
+    #   {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
@@ -169,7 +168,7 @@ often better and easier to use {FriendlyId::Slugged slugs}.
     #
     # @option options [Symbol] :sequence_separator Available when using +:slugged+.
     #   Configures the sequence of characters used to separate a slug from a
-    #   sequence. Defaults to +--+.
+    #   sequence. Defaults to +-+.
     #
     # @option options [Symbol] :slug_column Available when using +:slugged+.
     #   Configures the name of the column where FriendlyId will store the slug.
@@ -189,8 +188,8 @@ often better and easier to use {FriendlyId::Slugged slugs}.
       yield friendly_id_config if block_given?
       friendly_id_config.use options.delete :use
       friendly_id_config.send :set, base ? options.merge(:base => base) : options
-      before_save {|rec| rec.instance_eval {@current_friendly_id = friendly_id}}
       include Model
+      extend Scopes
     end
 
     # Returns the model class's {FriendlyId::Configuration friendly_id_config}.
@@ -201,73 +200,15 @@ often better and easier to use {FriendlyId::Slugged slugs}.
     def friendly_id_config
       @friendly_id_config ||= base_class.friendly_id_config.dup.tap do |config|
         config.model_class = self
-        @relation_class = base_class.send(:relation_class)
-      end
-    end
-
-    private
-
-    # Gets an instance of an the relation class.
-    #
-    # With FriendlyId this will be a subclass of ActiveRecord::Relation, rather than
-    # Relation itself, in order to avoid tainting all Active Record models with
-    # FriendlyId.
-    #
-    # Note that this method is essentially copied and pasted from Rails 3.2.9.rc1,
-    # with the exception of changing the relation class. Obviously this is less than
-    # ideal, but I know of no better way to accomplish this.
-    # @see #relation_class
-    def relation #:nodoc:
-      relation = relation_class.new(self, arel_table)
-
-      if finder_needs_type_condition?
-        relation.where(type_condition).create_with(inheritance_column.to_sym => sti_name)
-      else
-        relation
-      end
-    end
-
-    # Gets (and if necessary, creates) a subclass of the model's relation class.
-    #
-    # Rather than including FriendlyId's overridden finder methods in
-    # ActiveRecord::Relation directly, FriendlyId adds them to a subclass
-    # specific to the AR model, and makes #relation return an instance of this
-    # class. By doing this, we ensure that only models that specifically extend
-    # FriendlyId have their finder methods overridden.
-    #
-    # Note that this method does not directly subclass ActiveRecord::Relation,
-    # but rather whatever class the @relation class instance variable is an
-    # instance of.  In practice, this will almost always end up being
-    # ActiveRecord::Relation, but in case another plugin is using this same
-    # pattern to extend a model's finder functionality, FriendlyId will not
-    # replace it, but rather override it.
-    #
-    # This pattern can be seen as a poor man's "refinement"
-    # (http://timelessrepo.com/refinements-in-ruby), and while I **think** it
-    # will work quite well, I realize that it could cause unexpected issues,
-    # since the authors of Rails are probably not intending this kind of usage
-    # against a private API. If this ends up being problematic I will probably
-    # revert back to the old behavior of simply extending
-    # ActiveRecord::Relation.
-    def relation_class
-      @relation_class or begin
-        @relation_class = Class.new(relation_without_friendly_id.class) do
-          alias_method :find_one_without_friendly_id, :find_one
-          alias_method :exists_without_friendly_id?, :exists?
-          include FriendlyId::FinderMethods
-        end
-        # Set a name so that model instances can be marshalled. Use a
-        # ridiculously long name that will not conflict with anything.
-        # TODO: just use the constant, no need for the @relation_class variable.
-        const_set('FriendlyIdActiveRecordRelation', @relation_class)
       end
     end
   end
 
   # Instance methods that will be added to all classes using FriendlyId.
   module Model
-
-    attr_reader :current_friendly_id
+    def self.included(model_class)
+      return if model_class.respond_to?(:friendly)
+    end
 
     # Convenience method for accessing the class method of the same name.
     def friendly_id_config

data/lib/friendly_id/candidates.rb

@@ -0,0 +1,41 @@
+require 'securerandom'
+
+module FriendlyId
+
+  class Candidates
+
+    include Enumerable
+
+    def initialize(object, *array)
+      @object = object
+      @candidates = to_candidate_array(object, array.flatten(1))
+    end
+
+    def each(*args, &block)
+      @candidates.each(*args) do |candidate|
+        yield @object.normalize_friendly_id(candidate.map(&:call).join(' '))
+      end
+    end
+
+    private
+
+    def to_candidate_array(object, array)
+      array.map do |candidate|
+        case candidate
+        when String
+          [->{candidate}]
+        when Array
+          to_candidate_array(object, candidate).flatten
+        when Symbol
+          [object.method(candidate)]
+        else
+          if candidate.respond_to?(:call)
+            [candidate]
+          else
+            [->{candidate.to_s}]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_id/configuration.rb

@@ -58,18 +58,18 @@ module FriendlyId
     # @param [#to_s,Module] *modules Arguments should be Modules, or symbols or
     #   strings that correspond with the name of a module inside the FriendlyId
     #   namespace. By default FriendlyId provides +:slugged+, +:history+,
-    #   +:simple_i18n+, +:globalize+, and +:scoped+.
+    #   +:simple_i18n+, and +:scoped+.
     def use(*modules)
       modules.to_a.flatten.compact.map do |object|
-        mod = object.kind_of?(Module) ? object : FriendlyId.const_get(object.to_s.classify)
-        model_class.send(:include, mod)
-        @modules << mod.name.split("::").last.downcase.to_sym if mod.name.present?
+        mod = get_module(object)
+        mod.setup(@model_class) if mod.respond_to?(:setup)
+        @model_class.send(:include, mod) unless uses? object
       end
     end
 
     # Returns whether the given module is in use
-    def uses?(modul)
-      @modules.include?(modul)
+    def uses?(mod)
+      @model_class < get_module(mod)
     end
 
     # The column that FriendlyId will use to find the record when querying by
@@ -83,6 +83,10 @@ module FriendlyId
 
     private
 
+    def get_module(object)
+      Module === object ? object : FriendlyId.const_get(object.to_s.classify)
+    end
+
     def set(values)
       values and values.each {|name, value| self.send "#{name}=", value}
     end

data/lib/friendly_id/history.rb

@@ -58,13 +58,26 @@ method.
 
     # Configures the model instance to use the History add-on.
     def self.included(model_class)
-      model_class.instance_eval do
+      model_class.class_eval do
         @friendly_id_config.use :slugged
-        has_many :slugs, :as => :sluggable, :dependent => :destroy,
-          :class_name => Slug.to_s, :order => "#{Slug.quoted_table_name}.id DESC"
+
+        has_many :slugs, -> {order("#{Slug.quoted_table_name}.id DESC")}, {
+          :as         => :sluggable,
+          :dependent  => :destroy,
+          :class_name => Slug.to_s
+        }
         after_save :create_slug
-        relation_class.send :include, FinderMethods
-        friendly_id_config.slug_generator_class.send :include, SlugGenerator
+        def self.find_by_friendly_id(id)
+          includes(:slugs).where(slug_history_clause(id)).references(:slugs).first
+        end
+
+        def self.exists_by_friendly_id?(id)
+          includes(:slugs).where(arel_table[friendly_id_config.query_field].eq(id).or(slug_history_clause(id))).exists?
+        end
+
+        def self.slug_history_clause(id)
+          Slug.arel_table[:sluggable_type].eq(base_class.to_s).and(Slug.arel_table[:slug].eq(id))
+        end
       end
     end
 
@@ -75,65 +88,14 @@ method.
       return if slugs.first.try(:slug) == friendly_id
       # Allow reversion back to a previously used slug
       relation = slugs.where(:slug => friendly_id)
-      result = relation.select("id").lock(true).all
-      relation.delete_all unless result.empty?
+      if friendly_id_config.uses?(:scoped)
+        relation = relation.where(:scope => serialized_scope)
+      end
+      relation.delete_all
       slugs.create! do |record|
         record.slug = friendly_id
         record.scope = serialized_scope if friendly_id_config.uses?(:scoped)
       end
     end
-
-    # Adds a finder that explictly uses slugs from the slug table.
-    module FinderMethods
-
-      # Search for a record in the slugs table using the specified slug.
-      def find_one(id)
-        return super(id) if id.unfriendly_id?
-        where(@klass.friendly_id_config.query_field => id).first or
-        with_old_friendly_id(id) {|x| where(:id => x).first} or
-        find_one_without_friendly_id(id)
-      end
-
-      # Search for a record in the slugs table using the specified slug.
-      def exists?(id = false)
-        return super if id.unfriendly_id?
-        exists_without_friendly_id?(@klass.friendly_id_config.query_field => id) or
-        with_old_friendly_id(id) {|x| exists_without_friendly_id?(:id => x)} or
-        exists_without_friendly_id?(id)
-      end
-
-      private
-
-      # Accepts a slug, and yields a corresponding sluggable_id into the block.
-      def with_old_friendly_id(slug, &block)
-        sql = "SELECT sluggable_id FROM #{Slug.quoted_table_name} WHERE sluggable_type = %s AND slug = %s"
-        sql = sql % [@klass.base_class.to_s, slug].map {|x| connection.quote(x)}
-        sluggable_ids = connection.select_values(sql)
-        yield sluggable_ids if sluggable_ids
-      end
-    end
-
-    # This module overrides {FriendlyId::SlugGenerator#conflicts} to consider
-    # all historic slugs for that model.
-    module SlugGenerator
-
-      private
-
-      def conflicts
-        sluggable_class = friendly_id_config.model_class.base_class
-        pkey            = sluggable_class.primary_key
-        value           = sluggable.send pkey
-
-        scope = Slug.where("slug = ? OR slug LIKE ?", normalized, wildcard)
-        scope = scope.where(:sluggable_type => sluggable_class.to_s)
-        scope = scope.where("sluggable_id <> ?", value) unless sluggable.new_record?
-        if sluggable.friendly_id_config.uses?(:scoped)
-          scope = scope.where("scope = ?", sluggable.serialized_scope)
-        end
-        length_command = "LENGTH"
-        length_command = "LEN" if sluggable.connection.adapter_name =~ /sqlserver/i
-        scope.order("#{length_command}(slug) DESC, slug DESC")
-      end
-    end
   end
 end