friendly_id4 4.0.0.beta1

data/Rakefile

@@ -0,0 +1,111 @@
+require "rubygems"
+require "rake/testtask"
+
+def rubies(&block)
+  ["ruby-1.9.2-p180", "ree-1.8.7-2011.03", "jruby-1.6.2", "rbx-2.0.0pre"].each do |ruby|
+    ENV["RB"] = ruby
+    yield
+    ENV["RB"] = nil
+  end
+end
+
+def versions(&block)
+  ["3.1.0.rc4", "3.0.9"].each do |version|
+    ENV["AR"] = version
+    yield
+    ENV["AR"] = nil
+  end
+end
+
+def adapters(&block)
+  ["mysql", "postgres", "sqlite3"].each do |adapter|
+    ENV["DB"] = adapter
+    yield
+    ENV["DB"] = nil
+  end
+end
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+task :clean do
+  %x{rm -rf *.gem doc pkg}
+  %x{rm -f `find . -name '*.rbc'`}
+end
+
+task :gem do
+  %x{gem build friendly_id.gemspec}
+end
+
+task :yard do
+  %x{bundle exec yard doc --files=*.md}
+end
+
+desc "Bundle for all supported Ruby/AR versions"
+task :bundle do
+  rubies do
+    versions do
+      command = "#{ENV["RB"]} -S bundle"
+      puts "#{command} (with #{ENV['AR']})"
+      `#{command}`
+    end
+  end
+end
+
+namespace :test do
+
+  desc "Test with all configured adapters"
+  task :adapters do
+    adapters {|a| puts %x{rake test}}
+  end
+
+  desc "Test with all configured Rubies"
+  task :rubies do
+    rubies {|r| puts %x{rake-#{ENV["RB"]} test}}
+  end
+
+  desc "Test with all configured versions"
+  task :versions do
+    versions {|v| puts %x{rake test}}
+  end
+
+  desc "Test all rubies, versions and adapters"
+  task :prerelease do
+    rubies do
+      versions do
+        adapters do
+          puts %x{rake test}
+        end
+      end
+    end
+  end
+
+  desc "Run each test class in a separate process"
+  task :isolated do
+    dir = File.expand_path("../test", __FILE__)
+    Dir["#{dir}/*_test.rb"].each do |test|
+      puts "Running #{test}:"
+      puts %x{ruby #{test}}
+    end
+  end
+end
+
+namespace :db do
+  desc "Set up the database schema"
+  task :up do
+    require File.expand_path("../test/helper", __FILE__)
+    FriendlyId::Test::Schema.up
+  end
+
+  desc "Destroy the database schema"
+  task :down do
+    require File.expand_path("../test/helper", __FILE__)
+    FriendlyId::Test::Schema.down
+  end
+end
+
+task :doc => :yard

data/WhatsNew.md

@@ -0,0 +1,142 @@
+# What's new in FriendlyId 4.0?
+
+This is a rewrite/rethink of FriendlyId. It will probably be released some time
+in August or September 2011, once I've had the chance to actually use it in a
+real website for a while.
+
+It's probably not wise to use this on a real site right now unless you're
+comfortable with the source code and willing to fix bugs that will likely occur.
+
+That said, I will soon be deploying this on a high-traffic, production site, so
+I have a personal stake in making this work well. Your feedback is most welcome.
+
+If you want to try it out, grab the source, or [install the
+gem](https://rubygems.org/gems/friendly_id4).
+
+## Back to basics
+
+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. Let's see how small we can make
+this!
+
+Here's what's changed:
+
+## Active Record 3+ only
+
+For 2.3 support, you can use FriendlyId 3, 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
+people seem to want. Keeping slug history in a separate table is an 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
+
+## No more slug history - unless you want it
+
+Since slugs are now stored in-table, when you update them, finds for the
+previous slug will no longer work. This can be a problem for permalinks, since
+renaming a friendly_id will lead to 404's.
+
+This was transparently handled by FriendlyId 3, but there were three problems:
+
+* Not everybody wants or needs this
+* Performance was negatively affected
+* Determining whether a current or old id was used was expensive, clunky, and
+  inconsistent when finding inside relations.
+
+Here's how to do this in FriendlyId 4:
+
+    class PostsController < ApplicationController
+
+      before_filter :find_post
+
+      ...
+
+      def find_post
+        return unless params[:id]
+        @post = begin
+          Post.find params[:id]
+        rescue ActiveRecord::RecordNotFound
+          Post.find_by_friendly_id params[:id]
+        end
+        # If an old id or a numeric id was used to find the record, then
+        # the request path will not match the post_path, and we should do
+        # a 301 redirect that uses the current friendly_id
+        if request.path != post_path(@post)
+          return redirect_to @post, :status => :moved_permanently
+        end
+      end
+
+Under FriendlyId 4 this is a little more verbose, but offers much finer-grained
+control over the finding process, performs better, and has a much simpler
+implementation.
+
+## "Reserved words" are now just a normal validation
+
+Rather than use a custom reserved words validator, use the validations provided
+by Active Record. FriendlyId still reserves "new" and "edit" by default to avoid
+routing problems.
+
+    validates_exclusion_of :name, :in => ["bad", "word"]
+
+You can configure the default words reserved by FriendlyId in
+`FriendlyId::Configuration::DEFAULTS[:reserved_words]`.
+
+## "Allow nil" is now just another validation
+
+Previous versions of FriendlyId offered a special option to allow nil slug
+values, but this is now the default. If you don't want this, then simply add a
+validation to the slug column, and/or declare the column `NOT NULL` in your
+database.
+
+## 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! :transliterate => :russian
+      end
+    end

data/bench.rb

@@ -0,0 +1,71 @@
+require File.expand_path("../test/helper", __FILE__)
+require "ffaker"
+require "friendly_id/migration"
+
+N = 1000
+
+migration do |m|
+  m.add_column :users, :slug, :string
+  m.add_index  :users, :slug, :unique => true
+end
+
+migration do |m|
+  m.create_table :posts do |t|
+    t.string :name
+    t.string :slug
+  end
+  m.add_index  :posts, :slug, :unique => true
+end
+CreateFriendlyIdSlugs.up
+
+
+class Array
+  def rand
+    self[Kernel.rand(length)]
+  end
+end
+
+class User
+  include FriendlyId::Slugged
+  has_friendly_id :name
+end
+
+class Post < ActiveRecord::Base
+  include FriendlyId::History
+  has_friendly_id :name
+end
+
+USERS = []
+BOOKS = []
+POSTS = []
+
+100.times do
+  name = Faker::Name.name
+  USERS << (User.create! :name => name).friendly_id
+  POSTS << (Post.create! :name => name).friendly_id
+  BOOKS << (Book.create! :name => name).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 {User.find USERS.rand}
+  end
+  x.report 'find (external slug)' do
+    N.times {Post.find_by_friendly_id POSTS.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 {User.create :name => Faker::Name.name}}
+  end
+
+  x.report 'insert (external slug)' do
+    N.times {transaction {Post.create :name => Faker::Name.name}}
+  end
+end

data/friendly_id.gemspec

@@ -0,0 +1,31 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+
+require "friendly_id/version"
+
+Gem::Specification.new do |s|
+  s.name              = "friendly_id4"
+  s.version           = FriendlyId::Version::STRING
+  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 "cutest", "~> 1.1.2"
+  s.add_development_dependency "ffaker"
+  s.add_development_dependency "maruku"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "mocha"
+
+  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
+end

data/lib/friendly_id.rb

@@ -0,0 +1,14 @@
+require "friendly_id/base"
+require "friendly_id/model"
+require "friendly_id/object_utils"
+require "friendly_id/configuration"
+require "friendly_id/finder_methods"
+
+# FriendlyId is a comprehensive Ruby library for ActiveRecord permalinks and
+# slugs.
+# @author Norman Clarke
+module FriendlyId
+  autoload :Slugged,  "friendly_id/slugged"
+  autoload :Scoped,   "friendly_id/scoped"
+  autoload :History,  "friendly_id/history"
+end

data/lib/friendly_id/base.rb

@@ -0,0 +1,29 @@
+module FriendlyId
+  # Class methods that will be added to ActiveRecord::Base.
+  module Base
+    extend self
+
+    def has_friendly_id(*args)
+      options = args.extract_options!
+      base = args.shift
+      friendly_id_config.set options.merge(:base => base)
+      include Model
+      # @NOTE: AR-specific code here
+      validates_exclusion_of base, :in => Configuration::DEFAULTS[:reserved_words]
+      before_save do |record|
+        record.instance_eval {@current_friendly_id = friendly_id}
+      end
+      self
+    end
+
+    def friendly_id_config
+      @friendly_id_config ||= Configuration.new(self)
+    end
+
+    def uses_friendly_id?
+      defined? @friendly_id_config
+    end
+  end
+end
+
+ActiveRecord::Base.extend FriendlyId::Base

data/lib/friendly_id/configuration.rb

@@ -0,0 +1,31 @@
+module FriendlyId
+  # The configuration paramters passed to +has_friendly_id+ will be stored
+  # in this object.
+  class Configuration
+    attr_accessor :base
+    attr_reader   :klass
+
+    DEFAULTS = {
+      :config_error_message => 'FriendlyId has no such config option "%s"',
+      :reserved_words       => ["new", "edit"]
+    }
+
+    def initialize(klass, values = nil)
+      @klass = klass
+      set values
+    end
+
+    def method_missing(symbol, *args, &block)
+      option = symbol.to_s.gsub(/=\z/, '')
+      raise ArgumentError, DEFAULTS[:config_error_message] % option
+    end
+
+    def set(values)
+      values and values.each {|name, value| self.send "#{name}=", value}
+    end
+
+    def query_field
+      base
+    end
+  end
+end

data/lib/friendly_id/finder_methods.rb

@@ -0,0 +1,14 @@
+module FriendlyId
+  # These methods will override the finder methods in ActiveRecord::Relation.
+  module FinderMethods
+
+    protected
+
+    def find_one(id)
+      return super if !@klass.uses_friendly_id? or id.unfriendly_id?
+      where(@klass.friendly_id_config.query_field => id).first or super
+    end
+  end
+end
+
+ActiveRecord::Relation.send :include, FriendlyId::FinderMethods