rakutenusa-friendly_id 2.0.6

data/History.txt

@@ -0,0 +1,108 @@
+== 2.0.4 2009-02-12
+
+* 1 major enhancment:
+  * You can now pass in your own custom slug generation blocks while setting up friendly_id.
+
+== 2.0.3 2009-02-11
+
+* 1 minor enhancment:
+  * Fixed to_param returning an empty string for non-slugged models with a null friendly_id.
+
+== 2.0.2 2009-02-09
+
+* 2 major enhancements:
+  * Made FriendlyId depend only on ActiveRecord. It should now be possible to
+    use FriendlyId with Camping or any other codebase that uses AR.
+  * Overhauled creaky testing setup and switched to Shoulda.
+
+* 1 minor enhancment:
+  * Made reserved words work for non-slugged models.
+
+== 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/Manifest.txt

@@ -0,0 +1,37 @@
+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/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/custom_slug_normalizer_test.rb
+test/models/book.rb
+test/models/country.rb
+test/models/novel.rb
+test/models/person.rb
+test/models/post.rb
+test/models/thing.rb
+test/models/user.rb
+test/non_slugged_test.rb
+test/schema.rb
+test/scoped_model_test.rb
+test/slug_test.rb
+test/slugged_model_test.rb
+test/sti_test.rb
+test/test_helper.rb

data/README.rdoc

@@ -0,0 +1,347 @@
+= 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 => ["my", "values"]
+  end
+
+As of FriendlyId version 2.0.2, "new" and "index" are reseved by default. When
+you attempt to store a reserved value, FriendlyId raises a
+FriendlyId::SlugGenerationError.
+
+
+=== 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"
+  
+=== Custom Slug Generation
+
+While FriendlyId's slug generation options work for most people, you may need
+something else. As of version 2.0.4 you can pass in your own custom slug
+generation block:
+
+  require 'stringex'
+  class Post < ActiveRecord::Base
+    has_friendly_id :title, :use_slug => true do |text|
+      # User stringex to generate the friendly_id rather than the baked-in methods
+      text.to_url
+    end
+  end
+  
+  ...
+  
+  @post = Post.create(:title => "tell your readers 你好")
+  @post.friendly_id # "tell-your-readers-ni-hao"
+
+FriendlyId will still respect your settings for max length and reserved words,
+but will use your block rather than the baked-in methods to normalize the
+friendly_id text.
+
+(As an aside, the stringex[http://github.com/rsl/stringex/tree/master] library
+provides some very cool slugging functionality and is a great option for
+apps using FriendlyId in either English or Chinese. Definitely check it out.)
+
+== 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 - 2.3.0. 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.x,
+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
+
+== 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,47 @@
+require 'lib/friendly_id/version'
+
+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
+
+desc 'Publish RDoc to RubyForge.'
+task :publish_docs => [:clean, :docs] do
+  host = "compay@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/friendly-id"
+  local_dir = 'doc'
+  sh %{rsync -av --delete #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "friendly_id"
+    gemspec.summary = "TODO"
+    gemspec.email = "dev@rakutenusa.com"
+    gemspec.homepage = "http://github.com/rakutenusa/friendly_id"
+    gemspec.description = "TODO"
+    gemspec.authors = ["RakutenUSA"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 0
+:patch: 6
+:major: 2

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/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, 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, ids_and_names]
+    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