rdavila_friendly_id 2.2.6

data/History.txt

@@ -0,0 +1,189 @@
+== 2.2.6 2009-12-10
+
+* 2 major fixes
+  * Made cached_slug automagic configuration occur outside of has_friendly_id. This was causing problems
+    in code where the class is loaded before ActiveRecord has established its connection.
+  * Fixes for scope feature with Postgres (Ben Woosley)
+
+* 2 minor enhancements
+  * Migrated away from Hoe/Newgem for gem management.
+  * Made tests database-agnostic (Ben Woosley)
+
+== 2.2.5 2009-11-30
+
+* 1 minor fix
+  * Fixed typo which in config options (Steven Noble).
+
+== 2.2.4 2009-11-12
+
+* 1 minor fix
+  * Fixed typo in post-install message.
+
+== 2.2.3 2009-11-12
+
+* 4 minor enhancements:
+  * Fixed some issues with gem load order under 1.8.x (closes GH Issue #20)
+  * Made sure friendly_id generator makes a lib/tasks directory (Josh Nichols)
+  * Finders now accept instances of ActiveRecord::Base, matching AR's behavior (Josh Nichols)
+  * SlugGenerationError now raise when a blank value is passed to strip_diacritics
+
+== 2.2.2 2009-10-26
+
+* 1 minor enhancement:
+  * Fixed Rake tasks creating duplicate slugs and not properly clearing cached slugs (closes GH issues #14 and #15)
+
+== 2.2.1 2009-10-23
+
+* 2 minor enhancements:
+  * slug cache now properly caches the slug sequence (closes GH issue #10)
+  * attr_protected is now only invoked on the cached_slug column if attr_accessible has not already been invoked. (closes GH issue #11)
+
+== 2.2.0 2009-10-19
+
+* 1 major enhancement:
+  *  Added slug caching, offers huge performance boost (Bruno Michel)
+
+* 2 minor enhancements:
+  * Handle Unicode string length correctly (Mikhail Shirkov)
+  * Remove alias_method_chain in favor of super (Diego Carrion)
+
+== 2.1.4 2009-09-01
+
+* 3 minor enhancements:
+  * Fixed upgrade generator not installing rake tasks (Harry Love)
+  * Fixed handling of very large id's (Nathan Phelps)
+  * Fixed long index name on migration (Rob Ingram)
+
+== 2.1.3 2009-06-03
+
+* 1 minor enhancement:
+  * Always call #to_s on slug_text to allow objects such as DateTimes to be used for the friendly_id text. (reported by Jon Ng)
+
+== 2.1.2 2009-05-21
+
+* 2 minor enhancements:
+  * Non-slugged models now validate the friendly_id on save as well as create (Joe Van Dyk).
+  * Replaced Shoulda with Contest.
+
+== 2.1.1 2009-03-25
+
+* 2 minor enhancements:
+  * Fixed bug with find_some; if a record has old slugs, find_some will no longer return
+multiple copies of that record when finding by numerical ID. (Steve Luscher)
+  * Fixed bug with find_some: you can now find_some with an array of numerical IDs without
+an error being thrown. (Steve Luscher)
+
+== 2.1.0 2009-03-25
+
+* 2 major enhancements:
+  * Ruby 1.9 compatibility.
+  * Removed dependency on ancient Unicode gem.
+
+== 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. (Alistair Holt)
+* 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/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Norman Clarke, Adrian Mugnolo and Emilio Tagua.
+
+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/README.rdoc

@@ -0,0 +1,384 @@
+= 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
+
+You can always read the latest version of this document at the {friendly_id page on
+rdoc.info}[http://rdoc.info/projects/norman/friendly_id].
+
+=== 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.
+
+=== Cached slugs
+
+Checking the slugs table all the time has an impact on performance, so as of
+2.3.0, FriendlyId offers slug caching.
+
+This feature can improve the performance of some views by about 25%, and reduce
+memory consumption by about 40% as compared to the same view without cached
+slugs. The biggest improvement will be for "index" type views with many links
+that depend on slugs to generate the URL.
+
+==== Automagic setup:
+
+To enable slug caching, simply add a column named "cached_slug" to your model.
+FriendlyId will automagically use this column if it detects it:
+
+  class AddCachedSlugToUsers < ActiveRecord::Migration
+    def self.up
+      add_column :users, :cached_slug, :string
+    end
+
+    def self.down
+      remove_column :users, :cached_slug
+    end
+  end
+
+Then, redo the slugs:
+
+  rake friendly_id:redo_slugs MODEL=User
+
+This feature exists largely to improve the performance of URL
+generation, the part of Rails where FriendlyId has the biggest
+performance impact. FriendlyId never queries against this column, so
+it's not necessary to add an index on it unless your application does.
+
+Two warnings when using this feature:
+
+*DO NOT* forget to redo the slugs, or else this feature will not work!
+
+Also, this feature uses +attr_protected+ to protect the cached_slug
+column, unless you have already invoked +attr_accessible+. So if you
+wish to use +attr_accessible+, you must invoke it BEFORE you invoke
++has_friendly_id+ in your class.
+
+==== Using a custom column name:
+
+You can also use a different name for the column if you choose, via the
+:cache_column config option:
+
+  class User < ActiveRecord::Base
+    has_friendly_id :name, :use_slug => true, :cache_column => 'my_cached_slug'
+  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"
+
+=== 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:
+
+  class Post < ActiveRecord::Base
+    has_friendly_id :title, :use_slug => true do |text|
+      MySlugGeneratorClass::my_slug_method(text)
+    end
+  end
+
+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.
+
+== Getting it
+
+FriendlyId is best 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
+
+== Setting it up
+
+The current release works with Rails 2.2 and above, and is compatible with
+Ruby 1.8 and 1.9.
+
+1) Install the Gem:
+
+  sudo gem install friendly_id
+  cd my_app
+  script/generate friendly_id
+  rake db:migrate
+
+2) Add the gem to config/environment.rb:
+
+  config.gem "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:
+
+rake 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
+
+== Installing an older version
+
+You can download older versions of FriendlyId from Github that work with Rails <
+2.2. These versions are, however, no longer maintained or supported.
+
+== Hacking FriendlyId:
+
+FriendlyId is {hosted on Github}[git://github.com/norman/friendly_id.git], and
+we love pull requests. :-)
+
+== Bugs:
+
+Please report them on the {Github issue tracker}[http://github.com/norman/friendly_id/issues]
+for this project.
+
+If you have a bug to report, please include the following information:
+
+* Stack trace and error message.
+* Version information for FriendlyId, Rails and Ruby.
+* Any snippets of relevant model, view or controller code that shows how your are using FriendlyId.
+
+If you are able to, it helps even more if you can fork FriendlyId on Github, and
+add a test that reproduces the error you are experiencing.
+
+== Credits:
+
+FriendlyId was created by {Norman Clarke}[mailto:norman@njclarke.com],
+{Adrian Mugnolo}[mailto:adrian@mugnolo.com], and {Emilio Tagua}[mailto:miloops@gmail.com].
+
+We are grateful for many contributions from the Ruby and Rails community, in
+particular from the following people:
+
+* Adam Cigánek
+* Alistair Holt
+* Andrew Loe III
+* Ben Woosley
+* Bence Nagy
+* Bruno Michel
+* Chris Nolan
+* David Ramalho
+* Diego Carrion
+* Florian Aßmann
+* Harry Love
+* Jesse Crouch
+* Joe Van Dyk
+* Josh Nichols
+* Mikhail Shirkov
+* Nathan Phelps
+* Rob Ingram
+* Sean Abrahams
+* Steve Luscher
+* Steven Noble
+* Tim Kadom
+
+Copyright (c) 2008 Norman Clarke, Adrian Mugnolo and Emilio Tagua, released
+under the MIT license.