dougcole-friendly_id 2.0.2

data/History.txt

@@ -0,0 +1,88 @@
+== 2.0.1 2009-01-19
+
+* 1 minor enhancements:
+  * Fix infinite redirect bug when using .has_better_id? in your controllers (Sean Abrahams)
+
+
+== 2.0.0 2009-01-03
+
+* 5 major enhancements:
+  * Support for scoped slugs (Norman Clarke)
+  * Support for UTF-8 friendly_ids (Norman Clarke)
+  * Can now be installed via Ruby Gems, or as a Rails plugin (Norman Clarke)
+  * Improved handling of non-unique slugs (Norman Clarke and Adrian Mugnolo)
+* 2 minor enhancements:
+  * Shoulda macro (Josh Nichols)
+  * Various small bugfixes, cleanups and refactorings
+
+== 2008-12-01
+
+* Fixed bug that may return invalid records having similar id/names and using MySQL. (Emilio Tagua)
+* Fixed slug generation to increment only numeric extension without modifying the name on duplicated slugs. (Emilio Tagua)
+
+== 2008-10-31
+
+* Fixed compatibility with Rails 2.0.x. (Norman Clarke)
+* friendly_id::make_slugs update records in chunks of 1000 to avoid running out of memory with large datasets. (Tim Kadom)
+* Fixed logic error with slug name collisions. Thanks to Tim Kadom for reporting this bug.
+
+== 2008-10-22
+
+* Reverted use of UTF8Handler - was causing errors for some people (Bence Nagy)
+* Corrected find in case if a friendly_id begins with number (Bence Nagy)
+* Added ability to reserve words from slugs (Adam Cigánek)
+
+== 2008-10-09
+
+* Moved "require"" for iconv to init.rb (Florian Aßmann)
+* Removed "require" for Unicode, use Rails' handler instead (Florian Aßmann)
+* Replaced some magic numbers with constants (Florian Aßmann)
+* Don't overwrite find, alias_method_chain find_one and find_some instead (Florian Aßmann)
+* Slugs behave more like ids now (Florian Aßmann)
+* Can find by mixture of ids and slugs (Florian Aßmann)
+* Reformatted code and comments (Florian Aßmann)
+* Added support for Edge Rails' Inflector::parameterize (Norman Clarke)
+
+== 2008-08-25
+
+* Moved strip_diacritics into Slug for easier reuse/better organization.
+* Put class methods inside class << self block. (Norman Clarke)
+
+* Small change to allow friendly_id to work better with STI. (David Ramalho)
+
+== 2008-07-14
+
+* Improved slug generation for friendly id's with apostrophes. (alistairholt)
+* Added support for namespaced models in Rakefile. (David Ramalho)
+
+== 2008-06-23
+
+* Cached most recent slug to improve performance (Emilio Tagua).
+
+== 2008-06-10
+
+* Added ability to find friendly_ids by array (Emilio Tagua)
+
+== 2008-05-15
+
+* Made friendly_id raise an error if slug method returns a blank value.
+
+== 2008-05-12
+
+* Added experimental Github gemspec.
+
+== 2008-04-18
+
+* Improved slug name collision avoidance.
+
+== 2008-03-13
+
+* Added :dependent => :destroy to slug relation, as suggested by Emilio Tagua.
+* Fixed error when renaming a slugged item back to a previously used name.
+* Incorporated documentation changes suggested by Jesse Crouch and Chris Nolan.
+
+== 2008-02-07
+
+* Applied patches from blog commenter "suntzu" to fix problem with model values were being overwritten.
+* Applied patch from Dan Blue to make friendly_id no longer ignore options on ActiveRecordBase#find.
+* Added call to options.assert_valid_keys in has_friendly_id. Thanks to W. Andrew Loe III for pointing out that this was missing.

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Norman Clarke and Adrian Mugnolo.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,45 @@
+History.txt
+MIT-LICENSE
+Manifest.txt
+README.rdoc
+Rakefile
+config/website.yml
+friendly_id.gemspec
+generators/friendly_id/friendly_id_generator.rb
+generators/friendly_id/templates/create_slugs.rb
+generators/friendly_id_20_upgrade/friendly_id_20_upgrade_generator.rb
+generators/friendly_id_20_upgrade/templates/upgrade_friendly_id_to_20.rb
+init.rb
+lib/friendly_id.rb
+lib/friendly_id/helpers.rb
+lib/friendly_id/non_sluggable_class_methods.rb
+lib/friendly_id/non_sluggable_instance_methods.rb
+lib/friendly_id/shoulda_macros.rb
+lib/friendly_id/slug.rb
+lib/friendly_id/sluggable_class_methods.rb
+lib/friendly_id/sluggable_instance_methods.rb
+lib/friendly_id/version.rb
+lib/tasks/friendly_id.rake
+lib/tasks/friendly_id.rb
+test/database.yml
+test/fixtures/countries.yml
+test/fixtures/country.rb
+test/fixtures/people.yml
+test/fixtures/person.rb
+test/fixtures/post.rb
+test/fixtures/posts.yml
+test/fixtures/slugs.yml
+test/fixtures/user.rb
+test/fixtures/users.yml
+test/non_slugged_test.rb
+test/rails/2.x/app/controllers/application.rb
+test/rails/2.x/config/boot.rb
+test/rails/2.x/config/database.yml
+test/rails/2.x/config/environment.rb
+test/rails/2.x/config/environments/test.rb
+test/rails/2.x/config/routes.rb
+test/schema.rb
+test/scoped_model_test.rb
+test/slug_test.rb
+test/sluggable_test.rb
+test/test_helper.rb

data/README.rdoc

@@ -0,0 +1,318 @@
+= FriendlyId
+
+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.
+
+Using FriendlyId, it's easy to make your application use URL's like:
+
+  http://example.com/states/washington
+
+instead of:
+
+  http://example.com/states/4323454
+
+Want to find out more? Read on. The {most recent version of the FriendlyId
+RDocs}[http://friendly-id.rubyforge.org] can always be found on
+Rubyforge[http://www.rubyforge.org].
+
+=== Why?
+
+* Text-based id's look better
+* They make URL's easier to remember.
+* They give no hint about the number of records in your database.
+* They are better for search engine optimization.
+
+=== But...
+
+* They can change, breaking your URL's and your SEO.
+* It can be tricky to ensure they're always unique.
+* They can become a pain to manage in large Rails applications.
+* They can conflict with your application's namespace.
+
+FriendlyId tries to offer you the all the advantages, and avoid or soften the
+potential impact of the disadvantages.
+
+== Typical Uses
+
+=== User names ("non-slugged" models)
+
+Usually users have unique user names stored in a column with a unique
+constraint or index. In this case, all you need to do is add this to your
+model:
+
+  has_friendly_id :login
+
+and you can then write code like this:
+
+  @member = Member.find("joe")   # the old Member.find(1) still works, too.
+  @member.to_param               # returns "joe"
+  redirect_to @member            # The URL would be /members/joe
+
+=== Blog posts ("slugged" models)
+
+Blog posts generally have titles which are distinctive but not necessarily
+unique. In this and similar cases, FriendlyId provides a Slug model separate
+from your Post model. The Slug model handles duplicate friendly_ids, as well
+as versioning.
+
+Your model code would look something like this:
+
+  has_friendly_id :title, :use_slug => true
+
+and you can then write code like this:
+
+  @post = Post.find("new-version-released")  # Post.find(1) still works, too
+  @post.to_param                             # returns "new-version-released"
+  redirect_to @post                          # The URL would be /posts/new-version-released
+
+Now in your controllers, if you want to prevent people from accessing your
+models by numeric id, you can detect whether they were found by the
+friendly_id:
+
+  @post = Post.find(params[:id])
+  raise "some error" if !@post.found_using_friendly_id?
+
+or, you can 301 redirect if the model was found by the numeric id if you don't
+care about numeric access, but want the SEO value of the friendly_id:
+
+  @post = Post.find(params[:id])
+  redirect_to @post, :status => 301 if @post.has_better_id?
+
+The "has_better_id?" method returns true if the model was found with the
+numeric id, or with an outdated slug.
+
+== Extra Features
+
+=== Slug Versioning
+
+FriendlyId will record changes to slugs so that you can tell when the model is
+found with an older slug, or by the numeric id. This can be useful if you want
+to do a 301 redirect to your updated URL.
+
+  class PostsController < ApplicationController
+
+    before_filter ensure_current_post_url, :only => :show
+
+    ...
+
+    def ensure_current_post_url
+      redirect_to @post, :status => :moved_permanently if @post.has_better_id?
+    end
+
+  end
+
+This is particularly useful when implementing FrindlyId on an existing
+website that already has many URL's with the old numeric id listed on search
+engines. When the search engine spiders crawl your site, they will
+eventually pick up the new, more SEO-friendly URL's.
+
+=== Non-unique Slug Names
+
+FriendlyId will append a arbitrary number to the end of the id to keep it
+unique if necessary:
+
+  /posts/new-version-released
+  /posts/new-version-released--2
+  /posts/new-version-released--3
+  ...
+  etc.
+
+Note that the number is preceeded by two dashes to distinguish it from the
+rest of the slug. This is important to enable having slugs like:
+
+  /cars/peugeot-206
+  /cars/peugeot-206--2
+
+=== Reserved Names
+
+You can mark off some strings as reserved so that, for example, you don't end
+up with this problem:
+
+  /users/joe-schmoe # A user chose "joe schmoe" as his user name - no worries.
+  /users/new # A user chose "new" as his user name, and now no one can sign up.
+
+Here's how to do it:
+
+  class Restaurant < ActiveRecord::Base
+    belongs_to :city
+    has_friendly_id :name, :use_slug => true, :reserved => ["new", "index"]
+  end
+
+
+=== Scoped Slugs
+
+FriendlyId can generate unique slugs within a given scope. For example:
+
+  class Restaurant < ActiveRecord::Base
+    belongs_to :city
+    has_friendly_id :name, :use_slug => true, :scope => :city
+  end
+
+  class City < ActiveRecord::Base
+    has_many :restaurants
+    has_friendly_id :name, :use_slug => true
+  end
+
+  http://example.org/cities/seattle/restaurants/joes-diner
+  http://example.org/cities/chicago/restaurants/joes-diner
+
+  Restaurant.find("joes-diner", :scope => "seattle") # returns 1 record
+  Restaurant.find("joes-diner", :scope => "chicago") # returns 1 record
+  Restaurant.find("joes-diner") # returns both records
+
+
+The value for the :scope key in your model can be a custom method you define,
+or the name of a relation. If it's the name of a relation, then the scope's
+text value will be the result of calling <code>to_param</code> on the related
+model record. In the example above, the city model also uses FriendlyId and so
+its <code>to_param</code> method returns its friendly_id: chicago or seattle.
+
+This feature is new in FriendlyId 2 and should be considered of experimental
+quality. Please don't use this for code that needs to run on the Space
+Shuttle.
+
+=== Text Normalization
+
+FriendlyId's slugging can strip diacritics from Western European characters,
+so that you can have ASCII-only URL's; for example, conveting "ñøîéçü" to
+"noiecu."
+
+  has_friendly_id :title, :use_slug => true, :strip_diacritics => true
+
+If you are not using slugs, you'll have to do this manually for whatever value
+you're using as the friendly_id.
+
+=== Diacritic-sensitive normalization
+
+FriendlyId can also normalize slug text while preserving accented characters, if
+you prefer to leave them in your URL's:
+
+  has_friendly_id :title, :use_slug => true
+  ...
+  @post = Post.create(:title => "¡Feliz Año!")
+  @post.friendly_id # "feliz-año"
+
+=== Unicode URL's
+
+FriendlyId can generate slugs in any language that can be written with
+Unicode. It does its best to strip away punctuation regardless of the language
+being used. Since the authors only speak English, Spanish, Portuguese and
+German, this has not been extensively tested with anything like Chinese,
+Russian, Greek, etc, but it "should work." If you're a speaker of a language
+that uses a non-Roman writing system, your feedback would be most welcome.
+
+  has_friendly_id :title, :use_slug => true
+  ...
+  @post = Post.create(:title => "友好编号在中国")
+  @post.friendly_id # "友好编号在中国"
+  @post2 = Post.create(:title => "友好编号在中国")
+  @post2.friendly_id # "友好编号在中国--2"
+
+== Getting it
+
+FriendlyId is installed as a Ruby Gem:
+
+  gem install friendly_id
+
+Alternatively, you can install it as a Rails plugin, though this is
+discouraged:
+
+  ./script/plugin install git://github.com/norman/friendly_id.git
+
+If you are installing as a plugin, make sure you have installed the unicode gem,
+which FriendlyId depends on:
+
+  gem install unicode
+
+
+== Setting it up
+
+FriendlyId currently works with Rails 2.0.0 and higher. Here's how to set it up.
+
+1) Install the Gem:
+
+  sudo gem install friendly_id
+  cd my_app
+  script/generate friendly_id
+  rake db:migrate
+
+2) Load FriendlyId in your app:
+
+  # Rails 2.1 and higher; add this to the gem section of environment.rb:
+  config.gem "friendly_id"
+
+  # Rails 2.0; this goes at the bottom of environment.rb
+  require 'friendly_id'
+
+3) Add some code to your models:
+
+  class Post < ActiveRecord::Base
+    has_friendly_id :title, :use_slug => true
+  end
+
+4) If you are using slugs, you can use a Rake task to generate slugs for your
+existing records:
+
+friendly_id:make_slugs MODEL=MyModelName
+
+If you eventually want to expire old slugs every so often, or perhaps every
+day via cron, you can do:
+
+rake:friendly_id:remove_old_slugs
+
+The default is to remove dead slugs older than 45 days, but is configurable:
+
+rake:friendly_id:remove_old_slugs MODEL=MyModelName DAYS=60
+
+== Upgrading from an older version
+
+If you installed an older version of FriendlyId and want to upgrade to 2.0,
+follow these steps:
+
+==== Install the friendly_id Gem:
+
+  sudo gem install friendly_id
+
+==== Add FriendlyId to environment.rb:
+
+===== For Rails 2.1 and higher:
+
+  config.gem "friendly_id"
+
+===== For Rails 2.0:
+
+Add this to the bottom of environment.rb:
+
+  require 'friendly_id'
+
+==== Remove the older version of FriendlyId:
+
+  git rm -rf vendor/plugins/friendly_id
+  svn delete vendor/plugins/friendly_id
+  # or whatever
+
+====  Generate the upgrade migration and run it
+
+  ./script generate friendly_id_20_upgrade
+  rake db:migrate
+
+That's it!
+
+== Hacking FriendlyId:
+
+FriendlyId is {hosted on Github}[git://github.com/norman/friendly_id.git], and
+we love pull requests. :-)
+
+== Bugs:
+
+Please report them on Lighthouse[http://randomba.lighthouseapp.com/projects/14675-friendly_id].
+
+
+== Credits:
+
+FriendlyId was created by {Norman Clarke}[mailto:norman@randomba.org],
+{Adrian Mugnolo}[mailto:adrian@randomba.org], and {Emilio Tagua}[mailto:miloops@gmail.com].
+
+Copyright (c) 2008 Norman Clarke, Adrian Mugnolo and Emilio Tagua, released
+under the MIT license.

data/Rakefile

@@ -0,0 +1,67 @@
+require 'rubygems'
+require 'lib/friendly_id/version'
+require 'rake/gempackagetask'
+
+begin 
+  require 'jeweler' 
+  Jeweler::Tasks.new do |s| 
+    s.name = "friendly_id" 
+    s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+    s.authors = ["Norman Clarke", "Adrian Mugnolo", "Emilio Tagua"]
+    s.summary = %q{A comprehensive slugging and pretty-URL plugin for Ruby on Rails.}
+    s.email = ["norman@randomba.org", "adrian@randomba.org", "miloops@gmail.com"]
+    s.homepage = %q{http://randomba.org}
+    s.description = %q{A comprehensive slugging and pretty-URL plugin for Ruby on Rails.}
+    s.add_dependency 'schacon-git' 
+    s.has_rdoc = true
+    s.rdoc_options = ["--main", "README.rdoc"]
+    s.require_paths = ["lib"]
+    s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"]
+    s.files = FileList["[A-Z]*", "{bin,generators,lib,test}/**/*","init.rb"]
+    if s.respond_to? :specification_version then
+      current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+      s.specification_version = 2
+
+      if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+        s.add_runtime_dependency(%q<unicode>, [">= 0.1"])
+        s.add_development_dependency(%q<newgem>, [">= 1.2.3"])
+        s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+      else
+        s.add_dependency(%q<unicode>, [">= 0.1"])
+        s.add_dependency(%q<newgem>, [">= 1.2.3"])
+        s.add_dependency(%q<hoe>, [">= 1.8.0"])
+      end
+    else
+      s.add_dependency(%q<unicode>, [">= 0.1"])
+      s.add_dependency(%q<newgem>, [">= 1.2.3"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    end
+  end 
+rescue LoadError 
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com" 
+end
+
+
+desc "Run RCov"
+task :rcov do
+  run_coverage Dir["test/**/*_test.rb"]
+end
+
+def run_coverage(files)
+  rm_f "coverage"
+  rm_f "coverage.data"
+  if files.length == 0
+    puts "No files were specified for testing"
+    return
+  end
+  files = files.join(" ")
+  if PLATFORM =~ /darwin/
+    exclude = '--exclude "gems/"'
+  else
+    exclude = '--exclude "rubygems"'
+  end
+  rcov = "rcov -Ilib:test --sort coverage --text-report #{exclude} --no-validator-links"
+  cmd = "#{rcov} #{files}"
+  puts cmd
+  sh cmd
+end

data/generators/friendly_id/friendly_id_generator.rb

@@ -0,0 +1,12 @@
+class FriendlyIdGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      unless options[:skip_migration]
+        m.migration_template(
+          'create_slugs.rb', 'db/migrate', :migration_file_name => 'create_slugs'
+        )
+        m.file "/../../../lib/tasks/friendly_id.rake", "lib/tasks/friendly_id.rake"
+      end
+    end
+  end
+end

data/generators/friendly_id/templates/create_slugs.rb

@@ -0,0 +1,18 @@
+class CreateSlugs < ActiveRecord::Migration
+  def self.up
+    create_table :slugs do |t|
+      t.string :name
+      t.integer :sluggable_id
+      t.integer :sequence, :null => false, :default => 1
+      t.string :sluggable_type, :limit => 40
+      t.string :scope, :limit => 40
+      t.datetime :created_at
+    end
+    add_index :slugs, [:name, :sluggable_type, :scope, :sequence], :unique => true
+    add_index :slugs, :sluggable_id
+  end
+
+  def self.down
+    drop_table :slugs
+  end
+end

data/generators/friendly_id_20_upgrade/friendly_id_20_upgrade_generator.rb

@@ -0,0 +1,11 @@
+class FriendlyId20UpgradeGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      unless options[:skip_migration]
+        m.migration_template(
+          'upgrade_friendly_id_to_20.rb', 'db/migrate', :migration_file_name => 'upgrade_friendly_id_to_20'
+        )
+      end
+    end
+  end
+end

data/generators/friendly_id_20_upgrade/templates/upgrade_friendly_id_to_20.rb

@@ -0,0 +1,19 @@
+class UpgradeFriendlyIdTo20 < ActiveRecord::Migration
+
+  def self.up
+    remove_column :slugs, :updated_at
+    remove_index :slugs, :column => [:name, :sluggable_type]
+    add_column :slugs, :sequence, :integer, :null => false, :default => 1
+    add_column :slugs, :scope, :string, :limit => 40
+    add_index :slugs, [:name, :sluggable_type, :scope, :sequence], :unique => true, :name => "index_slugs_on_n_s_s_and_s"
+  end
+
+  def self.down
+    remove_index :slugs, :name => "index_slugs_on_n_s_s_and_s"
+    remove_column :slugs, :scope
+    remove_column :slugs, :sequence
+    add_column :slugs, :updated_at, :datetime
+    add_index :slugs, [:name, :sluggable_type], :unique => true
+  end
+
+end

data/init.rb

@@ -0,0 +1 @@
+require 'friendly_id'

data/lib/friendly_id/helpers.rb

@@ -0,0 +1,13 @@
+module FriendlyId
+  
+  module Helpers
+    # Calculate expected result size for find_some_with_friendly (taken from
+    # active_record/base.rb)
+    def expected_size(ids_and_names, options) #:nodoc:#
+      size = options[:offset] ? ids_and_names.size - options[:offset] : ids_and_names.size
+      size = options[:limit] if options[:limit] && size > options[:limit]
+      size
+    end
+  end
+  
+end

data/lib/friendly_id/non_sluggable_class_methods.rb

@@ -0,0 +1,40 @@
+module FriendlyId::NonSluggableClassMethods
+
+  include FriendlyId::Helpers
+
+  def self.extended(base) #:nodoc:#
+    class << base
+      alias_method_chain :find_one, :friendly
+      alias_method_chain :find_some, :friendly
+    end
+  end
+
+  protected
+
+  def find_one_with_friendly(id, options) #:nodoc:#
+    if id.is_a?(String) && result = send("find_by_#{ friendly_id_options[:column] }", id, options)
+      result.send(:found_using_friendly_id=, true)
+    else
+      result = find_one_without_friendly id.to_i, options
+    end
+    result
+  end
+
+  def find_some_with_friendly(ids_and_names, options) #:nodoc:#
+    
+    results = with_scope :find => options do
+      find :all, :conditions => ["#{ quoted_table_name }.#{ primary_key } IN (?) OR #{friendly_id_options[:column].to_s} IN (?)",
+        ids_and_names.map {|id| id.to_i}, ids_and_names.map {|id| id.to_s}]
+    end
+    
+    expected = expected_size(ids_and_names, options)
+    if results.size != expected
+      raise ActiveRecord::RecordNotFound, "Couldn't find all #{ name.pluralize } with IDs (#{ ids_and_names * ', ' }) AND #{ sanitize_sql options[:conditions] } (found #{ results.size } results, but was looking for #{ expected })"
+    end
+    
+    results.each {|r| r.send(:found_using_friendly_id=, true) if ids_and_names.include?(r.friendly_id)}
+
+    results
+
+  end
+end