friendly_id 3.3.3.0 → 4.0.0.beta7

data/bench.rb

@@ -0,0 +1,63 @@
+require File.expand_path("../test/helper", __FILE__)
+require "ffaker"
+
+N = 1000
+
+def transaction
+  ActiveRecord::Base.transaction { yield ; raise ActiveRecord::Rollback }
+end
+
+class Array
+  def rand
+    self[Kernel.rand(length)]
+  end
+end
+
+Book = Class.new ActiveRecord::Base
+
+class Journalist < ActiveRecord::Base
+  extend FriendlyId
+  include FriendlyId::Slugged
+  friendly_id :name
+end
+
+class Manual < ActiveRecord::Base
+  extend FriendlyId
+  include FriendlyId::History
+  friendly_id :name
+end
+
+BOOKS       = []
+JOURNALISTS = []
+MANUALS     = []
+
+100.times do
+  name = Faker::Name.name
+  BOOKS       << (Book.create! :name => name).id
+  JOURNALISTS << (Journalist.create! :name => name).friendly_id
+  MANUALS     << (Manual.create! :name => name).friendly_id
+end
+
+Benchmark.bmbm do |x|
+  x.report 'find (without FriendlyId)' do
+    N.times {Book.find BOOKS.rand}
+  end
+  x.report 'find (in-table slug)' do
+    N.times {Journalist.find JOURNALISTS.rand}
+  end
+  x.report 'find (external slug)' do
+    N.times {Manual.find_by_friendly_id MANUALS.rand}
+  end
+
+  x.report 'insert (without FriendlyId)' do
+    N.times {transaction {Book.create :name => Faker::Name.name}}
+  end
+
+  x.report 'insert (in-table-slug)' do
+    N.times {transaction {Journalist.create :name => Faker::Name.name}}
+  end
+
+  x.report 'insert (external slug)' do
+    N.times {transaction {Manual.create :name => Faker::Name.name}}
+  end
+end

data/friendly_id.gemspec

@@ -0,0 +1,40 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+
+require "friendly_id"
+
+Gem::Specification.new do |s|
+  s.name              = "friendly_id"
+  s.version           = FriendlyId::VERSION
+  s.authors           = ["Norman Clarke"]
+  s.email             = ["norman@njclarke.com"]
+  s.homepage          = "http://norman.github.com/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.add_development_dependency "activerecord", "~> 3.0"
+  s.add_development_dependency "sqlite3", "~> 1.3"
+  s.add_development_dependency "minitest", "~> 2.4.0"
+  s.add_development_dependency "mocha", "~> 0.9.12"
+  s.add_development_dependency "ffaker", "~> 1.8.0"
+  s.add_development_dependency "maruku", "~> 0.6.0"
+  s.add_development_dependency "yard", "~> 0.7.2"
+
+  s.description = <<-EOM
+FriendlyId is the "Swiss Army bulldozer" of slugging and permalink plugins for
+Ruby on Rails. It allows you to create pretty URL's and work with
+human-friendly strings as if they were numeric ids for ActiveRecord 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:
+
+https://github.com/norman/friendly_id/blob/4.0.0/WhatsNew.md
+
+EOM
+
+end

data/gemfiles/Gemfile.rails-3.0.rb

@@ -0,0 +1,18 @@
+source :rubygems
+
+platform :jruby do
+  gem "activerecord-jdbcmysql-adapter"
+  gem "activerecord-jdbcpostgresql-adapter"
+  gem "activerecord-jdbcsqlite3-adapter"
+end
+
+platform :ruby do
+  gem "mysql2", "~> 0.2.0"
+  gem "pg", "~> 0.11.0"
+  gem "sqlite3", "~> 1.3.4"
+end
+
+gem "activerecord", "3.0.9"
+gem "minitest", "~> 2.4.0"
+gem "mocha", "~> 0.9.12"
+gem "rake"

data/gemfiles/Gemfile.rails-3.0.rb.lock

@@ -0,0 +1,52 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.9)
+      activesupport (= 3.0.9)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activerecord-jdbc-adapter (1.1.3)
+    activerecord-jdbcmysql-adapter (1.1.3)
+      activerecord-jdbc-adapter (= 1.1.3)
+      jdbc-mysql (~> 5.1.0)
+    activerecord-jdbcpostgresql-adapter (1.1.3)
+      activerecord-jdbc-adapter (= 1.1.3)
+      jdbc-postgres (~> 9.0.0)
+    activerecord-jdbcsqlite3-adapter (1.1.3)
+      activerecord-jdbc-adapter (= 1.1.3)
+      jdbc-sqlite3 (~> 3.7.0)
+    activesupport (3.0.9)
+    arel (2.0.10)
+    builder (2.1.2)
+    i18n (0.5.0)
+    jdbc-mysql (5.1.13)
+    jdbc-postgres (9.0.801)
+    jdbc-sqlite3 (3.7.2)
+    minitest (2.4.0)
+    mocha (0.9.12)
+    mysql2 (0.2.11)
+    pg (0.11.0)
+    rake (0.9.2)
+    sqlite3 (1.3.4)
+    tzinfo (0.3.29)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  activerecord (= 3.0.9)
+  activerecord-jdbcmysql-adapter
+  activerecord-jdbcpostgresql-adapter
+  activerecord-jdbcsqlite3-adapter
+  minitest (~> 2.4.0)
+  mocha (~> 0.9.12)
+  mysql2 (~> 0.2.0)
+  pg (~> 0.11.0)
+  rake
+  sqlite3 (~> 1.3.4)

data/gemfiles/Gemfile.rails-3.1.rb

@@ -0,0 +1,18 @@
+source :rubygems
+
+platform :jruby do
+  gem "activerecord-jdbcmysql-adapter"
+  gem "activerecord-jdbcpostgresql-adapter"
+  gem "activerecord-jdbcsqlite3-adapter"
+end
+
+platform :ruby do
+  gem "mysql2", "~> 0.3.6"
+  gem "pg", "~> 0.11.0"
+  gem "sqlite3", "~> 1.3.4"
+end
+
+gem "activerecord", "~> 3.1.0.rc5"
+gem "minitest", "~> 2.4.0"
+gem "mocha", "~> 0.9.12"
+gem "rake"

data/gemfiles/Gemfile.rails-3.1.rb.lock

@@ -0,0 +1,57 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.1.0.rc5)
+      activesupport (= 3.1.0.rc5)
+      bcrypt-ruby (~> 2.1.4)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activerecord (3.1.0.rc5)
+      activemodel (= 3.1.0.rc5)
+      activesupport (= 3.1.0.rc5)
+      arel (~> 2.1.4)
+      tzinfo (~> 0.3.29)
+    activerecord-jdbc-adapter (1.1.3)
+    activerecord-jdbcmysql-adapter (1.1.3)
+      activerecord-jdbc-adapter (= 1.1.3)
+      jdbc-mysql (~> 5.1.0)
+    activerecord-jdbcpostgresql-adapter (1.1.3)
+      activerecord-jdbc-adapter (= 1.1.3)
+      jdbc-postgres (~> 9.0.0)
+    activerecord-jdbcsqlite3-adapter (1.1.3)
+      activerecord-jdbc-adapter (= 1.1.3)
+      jdbc-sqlite3 (~> 3.7.0)
+    activesupport (3.1.0.rc5)
+      multi_json (~> 1.0)
+    arel (2.1.4)
+    bcrypt-ruby (2.1.4)
+    bcrypt-ruby (2.1.4-java)
+    builder (3.0.0)
+    i18n (0.6.0)
+    jdbc-mysql (5.1.13)
+    jdbc-postgres (9.0.801)
+    jdbc-sqlite3 (3.7.2)
+    minitest (2.4.0)
+    mocha (0.9.12)
+    multi_json (1.0.3)
+    mysql2 (0.3.6)
+    pg (0.11.0)
+    rake (0.9.2)
+    sqlite3 (1.3.4)
+    tzinfo (0.3.29)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.1.0.rc5)
+  activerecord-jdbcmysql-adapter
+  activerecord-jdbcpostgresql-adapter
+  activerecord-jdbcsqlite3-adapter
+  minitest (~> 2.4.0)
+  mocha (~> 0.9.12)
+  mysql2 (~> 0.3.6)
+  pg (~> 0.11.0)
+  rake
+  sqlite3 (~> 1.3.4)

data/lib/friendly_id.rb

@@ -1,93 +1,139 @@
-require "babosa"
-require "forwardable"
-require "friendly_id/slug_string"
+# encoding: utf-8
+require "thread"
+require "friendly_id/base"
+require "friendly_id/model"
+require "friendly_id/object_utils"
 require "friendly_id/configuration"
-require "friendly_id/status"
-require "friendly_id/slugged"
-
-# FriendlyId is a comprehensive Ruby library for slugging and permalinks with
-# ActiveRecord.
-# @author Norman Clarke
-# @author Emilio Tagua
-# @author Adrian Mugnolo
-module FriendlyId
+require "friendly_id/finder_methods"
+
+=begin
+
+== About FriendlyId
+
+FriendlyId is an add-on to Ruby's Active Record that allows you to replace ids
+in your URLs with strings:
+
+    # without FriendlyId
+    http://example.com/states/4323454
+
+    # with FriendlyId
+    http://example.com/states/washington
+
+It requires few changes to your application code and offers flexibility,
+performance and a well-documented codebase.
+
+=== Concepts
 
-  # An error based on this class is raised when slug generation fails
-  class SlugGenerationError < StandardError ; end
-
-  # Raised when the slug text is blank.
-  class BlankError < SlugGenerationError ; end
-
-  # Raised when the slug text is reserved.
-  class ReservedError < SlugGenerationError ; end
-
-  module Base
-    # Set up a model to use a friendly_id. This method accepts a hash with
-    # {FriendlyId::Configuration several possible options}.
-    #
-    # @param [#to_sym] method The column or method that should be used as the
-    #   basis of the friendly_id string.
-    #
-    # @param [Hash] options For valid configuration options, see
-    #   {FriendlyId::Configuration}.
-    #
-    # @example
-    #
-    #   class User < ActiveRecord::Base
-    #     has_friendly_id :user_name
-    #   end
-    #
-    #   class Post < ActiveRecord::Base
-    #     has_friendly_id :title, :use_slug => true, :approximate_ascii => true
-    #   end
-    #
-    # @see FriendlyId::Configuration
-    def has_friendly_id(method, options = {})
-      raise NotImplementedError
+Although FriendlyId helps with URLs, it does all of its work inside your models,
+not your routes.
+
+=== Simple Models
+
+The simplest way to use FriendlyId is with a model that has a uniquely indexed
+column with no spaces or special characters, and that is seldom or never
+updated. The most common example of this is a user name:
+
+    class User < ActiveRecord::Base
+      extend FriendlyId
+      friendly_id :login
+      validates_format_of :login, :with => /\A[a-z0-9]+\z/i
     end
 
-    # Does the model class use the FriendlyId plugin?
-    def uses_friendly_id?
-      respond_to? :friendly_id_config
+    @user = User.find "joe"   # the old User.find(1) still works, too
+    @user.to_param            # returns "joe"
+    redirect_to @user         # the URL will be /users/joe
+
+In this case, FriendlyId assumes you want to use the column as-is; it will never
+modify the value of the column, and your application should ensure that the
+value is admissible in a URL:
+
+    class City < ActiveRecord::Base
+      extend FriendlyId
+      friendly_id :name
     end
-  end
 
-end
+    @city.find "Viña del Mar"
+    redirect_to @city # the URL will be /cities/Viña%20del%20Mar
 
-class String
-  def parse_friendly_id(separator = nil)
-    separator ||= FriendlyId::Configuration::DEFAULTS[:sequence_separator]
-    name, sequence = split(/#{Regexp.escape(separator)}(\d+)?\z/)
-    return name, (sequence ||= 1).to_i
-  end
-end
+For this reason, it is often more convenient to use "slugs" rather than a single
+column.
+
+=== Slugged Models
+
+FriendlyId can uses a separate column to store slugs for models which require
+some processing of the friendly_id text. The most common example is a blog
+post's title, which may have spaces, uppercase characters, or other attributes
+you wish to modify to make them more suitable for use in URL's.
 
-class Object
-
-  # Is the object a friendly id? Note that the return value here is
-  # +false+ if the +id+ is definitely not friendly, and +nil+ if it can
-  # not be determined.
-  # The return value will be:
-  # * +true+ - if the id is definitely friendly (i.e., a string with non-numeric characters)
-  # * +false+ - if the id is definitely unfriendly (i.e., an Integer, a model instance, etc.)
-  # * +nil+ - if it can not be determined (i.e., a numeric string like "206".)
-  # @return [true, false, nil]
-  # @see #unfriendly?
-  def friendly_id?
-    if kind_of?(Integer) or kind_of?(Symbol) or self.class.respond_to? :friendly_id_config
-      false
-    elsif to_i.to_s != to_s
-      true
+    class Post < ActiveRecord::Base
+      extend FriendlyId
+      friendly_id :title, :use => :slugged
     end
+
+    @post = Post.create(:title => "This is the first post!")
+    @post.friendly_id   # returns "this-is-the-first-post"
+    redirect_to @post   # the URL will be /posts/this-is-the-first-post
+
+In general, use slugs by default unless you know for sure you don't need them.
+
+@author Norman Clarke
+=end
+module FriendlyId
+
+  # The current version.
+  VERSION = "4.0.0.beta7"
+
+  @mutex = Mutex.new
+
+  autoload :History,  "friendly_id/history"
+  autoload :Reserved, "friendly_id/reserved"
+  autoload :Scoped,   "friendly_id/scoped"
+  autoload :Slugged,  "friendly_id/slugged"
+
+  # FriendlyId takes advantage of `extended` to do basic model setup, primarily
+  # extending {FriendlyId::Base} to add {FriendlyId::Base#friendly_id
+  # friendly_id} as a class method.
+  #
+  # Previous versions of FriendlyId simply patched ActiveRecord::Base, but this
+  # version tries to be less invasive.
+  #
+  # In addition to adding {FriendlyId::Base#friendly_id friendly_id}, the class
+  # instance variable +@friendly_id_config+ is added. This variable is an
+  # instance of an anonymous subclass of {FriendlyId::Configuration}. This
+  # allows subsequently loaded modules like {FriendlyId::Slugged} and
+  # {FriendlyId::Scoped} to add functionality to the configuration class only
+  # for the current class, rather than monkey patching
+  # {FriendlyId::Configuration} directly. This isolates other models from large
+  # feature changes an addon to FriendlyId could potentially introduce.
+  #
+  # The upshot of this is, you can htwo Active Record models that both have a
+  # @friendly_id_config, but each config object can have different methods and
+  # behaviors depending on what modules have been loaded, without conflicts.
+  # Keep this in mind if you're hacking on FriendlyId.
+  #
+  # For examples of this, see the source for {Scoped.included}.
+  def self.extended(model_class)
+    model_class.instance_eval do
+      extend Base
+      @friendly_id_config = Class.new(Configuration).new(self)
+      FriendlyId.defaults.call @friendly_id_config
+    end
+    ActiveRecord::Relation.send :include, FinderMethods
   end
 
-  # Is the object a numeric id?
-  # @return [true, false, nil] +true+ if definitely unfriendly, +false+ if
-  #   definitely friendly, else +nil+.
-  # @see #friendly?
-  def unfriendly_id?
-    val = friendly_id? ; !val unless val.nil?
+  # Set global defaults for all models using FriendlyId.
+  #
+  # The default defaults are to use the +:reserved+ module and nothing else.
+  #
+  # @example
+  #   FriendlyId.defaults do |config|
+  #     config.base = :name
+  #     config.use :slugged
+  #   end
+  def self.defaults(&block)
+    @mutex.synchronize do
+      @defaults = block if block_given?
+      @defaults ||= lambda {|config| config.use :reserved}
+    end
   end
 end
-
-require "friendly_id/railtie" if defined?(Rails) && Rails.version >= "3"