friendly_id 2.0.1 → 2.0.2

data/History.txt

@@ -1,3 +1,13 @@
+== 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:

data/Manifest.txt

@@ -14,32 +14,19 @@ 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/models/country.rb
+test/models/person.rb
+test/models/post.rb
+test/models/user.rb
 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/slugged_model_test.rb
 test/test_helper.rb

data/Rakefile

@@ -5,18 +5,15 @@ $hoe = Hoe.new("friendly_id", FriendlyId::Version::STRING) do |p|
   p.rubyforge_name = "friendly-id"
   p.author = ['Norman Clarke', 'Adrian Mugnolo', 'Emilio Tagua']
   p.email = ['norman@randomba.org', 'adrian@randomba.org', 'miloops@gmail.com']
-  p.summary = "A comprehensive slugging and pretty-URL plugin for Ruby on Rails."
-  p.description = 'A comprehensive slugging and pretty-URL plugin for Ruby on Rails.'
-  p.url = 'http://randomba.org'
-  p.need_tar = true
-  p.need_zip = true
+  p.summary = "A comprehensive slugging and pretty-URL plugin for ActiveRecord."
+  p.description = 'A comprehensive slugging and pretty-URL plugin for ActiveRecord.'
+  p.url = 'http://friendly-id.rubyforge.org/'
   p.test_globs = ['test/**/*_test.rb']
   p.extra_deps << ['unicode', '>= 0.1']
-  p.extra_dev_deps = [
-    ['newgem', ">= #{::Newgem::VERSION}"]
-  ]
-  p.rdoc_pattern = /^(lib|bin|ext)|txt|rdoc$/
-  changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.extra_deps << ['activerecord', '>= 2.0.0']
+  p.extra_dev_deps << ['newgem', ">= #{::Newgem::VERSION}"]
+  p.extra_dev_deps << ['Shoulda', ">= 1.2.0"]
+  p.extra_dev_deps << ['sqlite3-ruby']
   p.remote_rdoc_dir = ""
 end
 

data/friendly_id.gemspec

@@ -2,24 +2,24 @@
 
 Gem::Specification.new do |s|
   s.name = %q{friendly_id}
-  s.version = "2.0.1"
+  s.version = "2.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Norman Clarke", "Adrian Mugnolo", "Emilio Tagua"]
-  s.date = %q{2009-01-19}
-  s.description = %q{A comprehensive slugging and pretty-URL plugin for Ruby on Rails.}
+  s.cert_chain = ["/Users/norman/.gem/gem-public_cert.pem"]
+  s.date = %q{2009-02-09}
+  s.description = %q{A comprehensive slugging and pretty-URL plugin for ActiveRecord.}
   s.email = ["norman@randomba.org", "adrian@randomba.org", "miloops@gmail.com"]
   s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"]
-  s.files = ["History.txt", "MIT-LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "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"]
+  s.files = ["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/models/country.rb", "test/models/person.rb", "test/models/post.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/test_helper.rb"]
   s.has_rdoc = true
-  s.homepage = %q{http://randomba.org}
+  s.homepage = %q{http://friendly-id.rubyforge.org/}
   s.rdoc_options = ["--main", "README.rdoc"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{friendly-id}
   s.rubygems_version = %q{1.3.1}
-  s.signing_key = %q{/Users/norman/.gem/gem-private_key.pem}
-  s.summary = %q{A comprehensive slugging and pretty-URL plugin for Ruby on Rails.}
-  s.test_files = ["test/non_slugged_test.rb", "test/scoped_model_test.rb", "test/slug_test.rb", "test/sluggable_test.rb"]
+  s.summary = %q{A comprehensive slugging and pretty-URL plugin for ActiveRecord.}
+  s.test_files = ["test/non_slugged_test.rb", "test/scoped_model_test.rb", "test/slug_test.rb", "test/slugged_model_test.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
@@ -27,16 +27,25 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<unicode>, [">= 0.1"])
+      s.add_runtime_dependency(%q<active_record>, [">= 2.0.0"])
       s.add_development_dependency(%q<newgem>, [">= 1.2.3"])
+      s.add_development_dependency(%q<Shoulda>, [">= 1.2.0"])
+      s.add_development_dependency(%q<sqlite3-ruby>, [">= 0"])
       s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
     else
       s.add_dependency(%q<unicode>, [">= 0.1"])
+      s.add_dependency(%q<active_record>, [">= 2.0.0"])
       s.add_dependency(%q<newgem>, [">= 1.2.3"])
+      s.add_dependency(%q<Shoulda>, [">= 1.2.0"])
+      s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
       s.add_dependency(%q<hoe>, [">= 1.8.0"])
     end
   else
     s.add_dependency(%q<unicode>, [">= 0.1"])
+    s.add_dependency(%q<active_record>, [">= 2.0.0"])
     s.add_dependency(%q<newgem>, [">= 1.2.3"])
+    s.add_dependency(%q<Shoulda>, [">= 1.2.0"])
+    s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
     s.add_dependency(%q<hoe>, [">= 1.8.0"])
   end
 end

data/lib/friendly_id.rb

@@ -1,21 +1,35 @@
-require 'unicode'
 require 'friendly_id/helpers'
 require 'friendly_id/slug'
-require 'friendly_id/shoulda_macros'
-
 
 # FriendlyId is a comprehensize Rails plugin/gem for slugging and permalinks.
 module FriendlyId
 
+  # Default options for has_friendly_id.
+  DEFAULT_FRIENDLY_ID_OPTIONS = {
+    :max_length => 255,
+    :method => nil,
+    :reserved => ["new", "index"],
+    :reserved_message => 'can not be "%s"',
+    :scope => nil,
+    :strip_diacritics => false,
+    :strip_non_ascii => false,
+    :use_slug => false }.freeze
+  
+  # Valid keys for has_friendly_id options.
+  VALID_FRIENDLY_ID_KEYS = [
+    :max_length,
+    :reserved,
+    :reserved_message,
+    :scope,
+    :strip_diacritics,
+    :strip_non_ascii,
+    :use_slug ].freeze
+    
   # This error is raised when it's not possible to generate a unique slug.
   class SlugGenerationError < StandardError ; end
 
   module ClassMethods
 
-    # Default options for friendly_id.
-    DEFAULT_FRIENDLY_ID_OPTIONS = {:method => nil, :use_slug => false, :max_length => 255, :reserved => [], :strip_diacritics => false, :scope => nil}.freeze
-    VALID_FRIENDLY_ID_KEYS = [:use_slug, :max_length, :reserved, :strip_diacritics, :scope].freeze
-
     # Set up an ActiveRecord model to use a friendly_id.
     #
     # The column argument can be one of your model's columns, or a method
@@ -25,15 +39,17 @@ module FriendlyId
     # * <tt>:use_slug</tt> - Defaults to false. Use slugs when you want to use a non-unique text field for friendly ids.
     # * <tt>:max_length</tt> - Defaults to 255. The maximum allowed length for a slug.
     # * <tt>:strip_diacritics</tt> - Defaults to false. If true, it will remove accents, umlauts, etc. from western characters.
-    # * <tt>:reseved</tt> - Array of words that are reserved and can't be used as slugs. If such a word is used, it will be treated the same as if that slug was already taken (numeric extension will be appended). Defaults to [].
+    # * <tt>:strip_non_ascii</tt> - Defaults to false. If true, it will all non-ascii ([^a-z0-9]) characters.
+    # * <tt>:reseved</tt> - Array of words that are reserved and can't be used as friendly_id's. For sluggable models, if such a word is used, it will be treated the same as if that slug was already taken (numeric extension will be appended). Defaults to ["new", "index"].
+    # * <tt>:reseved_message</tt> - The validation message that will be shown when a reserved word is used as a frindly_id. Defaults to '"%s" is reserved'.
     def has_friendly_id(column, options = {})
       options.assert_valid_keys VALID_FRIENDLY_ID_KEYS
       options = DEFAULT_FRIENDLY_ID_OPTIONS.merge(options).merge(:column => column)
       write_inheritable_attribute :friendly_id_options, options
-      class_inheritable_reader :friendly_id_options
+      class_inheritable_accessor :friendly_id_options
 
       if options[:use_slug]
-        has_many :slugs, :order => 'id DESC', :as => :sluggable, :dependent => :destroy, :readonly => true
+        has_many :slugs, :order => 'id DESC', :as => :sluggable, :dependent => :destroy
         require 'friendly_id/sluggable_class_methods'
         require 'friendly_id/sluggable_instance_methods'
         extend SluggableClassMethods
@@ -44,9 +60,10 @@ module FriendlyId
         require 'friendly_id/non_sluggable_instance_methods'
         extend NonSluggableClassMethods
         include NonSluggableInstanceMethods
+        validate_on_create :validate_friendly_id
       end
     end
-
+    
   end
 
   class << self
@@ -55,7 +72,6 @@ module FriendlyId
     def enable
       return if ActiveRecord::Base.methods.include? 'has_friendly_id'
       ActiveRecord::Base.class_eval { extend FriendlyId::ClassMethods }
-      Test::Unit::TestCase.class_eval { include FriendlyId::ShouldaMacros }
     end
 
   end
@@ -64,4 +80,4 @@ end
 
 if defined?(ActiveRecord)
   FriendlyId::enable
-end
+end

data/lib/friendly_id/non_sluggable_class_methods.rb

@@ -21,17 +21,17 @@ module FriendlyId::NonSluggableClassMethods
   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 (?)",
+      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

data/lib/friendly_id/non_sluggable_instance_methods.rb

@@ -25,6 +25,14 @@ module FriendlyId::NonSluggableInstanceMethods
   end
 
   private
+  
+  def validate_friendly_id
+    if self.class.friendly_id_options[:reserved].include? friendly_id
+      self.errors.add(self.class.friendly_id_options[:column],
+        self.class.friendly_id_options[:reserved_message] % friendly_id)
+      return false
+    end
+  end
 
   def found_using_friendly_id=(value) #:nodoc#
     @found_using_friendly_id = value

data/lib/friendly_id/slug.rb

@@ -1,3 +1,4 @@
+require 'unicode'
 # A Slug is a unique, human-friendly identifier for an ActiveRecord.
 class Slug < ActiveRecord::Base
 
@@ -23,12 +24,12 @@ class Slug < ActiveRecord::Base
     # terror in Europe unlike anything ever seen before or after. I'm not
     # taking any chances.
     def normalize(slug_text)
-      return "" if slug_text.blank?
-      slug_text.
+      return "" if slug_text.nil? || slug_text == ""
+      Unicode::normalize_KC(slug_text).
         send(chars_func).
         # For some reason Spanish ¡ and ¿ are not detected as non-word
         # characters. Bug in Ruby?
-        normalize.gsub(/[\W|¡|¿]/u, ' ').
+        gsub(/[\W|¡|¿]/u, ' ').
         strip.
         gsub(/\s+/u, '-').
         gsub(/-\z/u, '').
@@ -42,20 +43,21 @@ class Slug < ActiveRecord::Base
       return name, sequence
     end
 
-    # Remove diacritics (accents, umlauts, etc.) from the string.
+    # Remove diacritics (accents, umlauts, etc.) from the string. Borrowed
+    # from "The Ruby Way."
     def strip_diacritics(string)
-      require 'unicode'
-      Unicode::normalize_KD(string).unpack('U*').select { |cp|
-        cp < 0x300 || cp > 0x036F
-      }.pack('U*')
+      Unicode::normalize_KD(string).unpack('U*').select { |u| u < 0x300 || u > 0x036F }.pack('U*')
+    end
+    
+    # Remove non-ascii characters from the string.
+    def strip_non_ascii(string)
+      strip_diacritics(string).gsub(/[^a-z0-9]+/i, ' ')
     end
 
     private
 
     def chars_func
-      Rails.version =~ /2.2.[\d]*/ ? :mb_chars : :chars
-    rescue NoMethodError
-      :chars
+      "".respond_to?(:mb_chars) ? :mb_chars : :chars
     end
 
   end
@@ -73,7 +75,7 @@ class Slug < ActiveRecord::Base
 
   # Raise a FriendlyId::SlugGenerationError if the slug name is blank.
   def check_for_blank_name #:nodoc:#
-    if name.blank?
+    if name == "" || name.nil?
       raise FriendlyId::SlugGenerationError.new("The slug text is blank.")
     end
   end

data/lib/friendly_id/sluggable_class_methods.rb

@@ -1,5 +1,5 @@
 module FriendlyId::SluggableClassMethods
-  
+
   include FriendlyId::Helpers
 
   def self.extended(base) #:nodoc:#
@@ -38,6 +38,17 @@ module FriendlyId::SluggableClassMethods
     end
 
     result
+  rescue ActiveRecord::RecordNotFound => e
+
+    if friendly_id_options[:scope]
+      if !scope
+        e.message << "; expected scope but got none"
+      else
+        e.message << " and scope=#{scope}"
+      end
+    end
+
+    raise e
 
   end
 
@@ -87,7 +98,7 @@ module FriendlyId::SluggableClassMethods
     ids = []
     ids_and_names.each do |id_or_name|
       name, sequence = Slug.parse id_or_name
-      slug = Slug.find(:first, :readonly => true, :conditions => {
+      slug = Slug.find(:first, :conditions => {
         :name           => name,
         :scope          => scope,
         :sequence       => sequence,

data/lib/friendly_id/sluggable_instance_methods.rb

@@ -6,7 +6,7 @@ module FriendlyId::SluggableInstanceMethods
   attr_accessor :finder_slug_name
 
   def finder_slug
-    @finder_slug ||= init_finder_slug
+    @finder_slug ||= init_finder_slug or nil
   end
 
   # Was the record found using one of its friendly ids?
@@ -57,10 +57,13 @@ module FriendlyId::SluggableInstanceMethods
   def slug_text
     base = send friendly_id_options[:column]
     if self.friendly_id_options[:strip_diacritics]
-      base = Slug::normalize(Slug::strip_diacritics(base))
-    else
-      base = Slug::normalize(base)
+      base = Slug::strip_diacritics(base)
     end
+    if self.friendly_id_options[:strip_non_ascii]
+      base = Slug::strip_non_ascii(base)
+    end
+    base = Slug::normalize(base)
+    
     if base.length > friendly_id_options[:max_length]
       base = base[0...friendly_id_options[:max_length]]
     end
@@ -82,7 +85,7 @@ module FriendlyId::SluggableInstanceMethods
   def init_finder_slug
     return false if !@finder_slug_name
     name, sequence = Slug.parse(@finder_slug_name)
-    slug = Slug.find(:first, :conditions => {:sluggable_id => id, :name => name, :sequence => sequence, :sluggable_type => self.class.name })
+    slug = Slug.find(:first, :conditions => {:sluggable_id => id, :name => name, :sequence => sequence, :sluggable_type => self.class.base_class.name })
     finder_slug = slug
   end
 

data/lib/friendly_id/version.rb

@@ -2,7 +2,7 @@ module FriendlyId #:nodoc:
   module Version #:nodoc:
     MAJOR = 2
     MINOR = 0
-    TINY = 1
+    TINY = 2
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/test/models/post.rb

@@ -0,0 +1,3 @@
+class Post < ActiveRecord::Base
+  has_friendly_id :title, :use_slug => true
+end

data/test/non_slugged_test.rb

@@ -2,84 +2,89 @@ require File.dirname(__FILE__) + '/test_helper'
 
 class NonSluggedTest < Test::Unit::TestCase
 
-  fixtures :users
+  context "A non-slugged model with default FriendlyId options" do
 
-  def setup
-  end
+    setup do
+      User.delete_all
+      @user = User.create!(:login => "joe", :email => "joe@example.org")
+    end
 
-  def test_should_find_user_using_friendly_id
-    assert User.find(users(:joe).friendly_id)
-  end
+    should "have friendly_id options" do
+      assert_not_nil User.friendly_id_options
+    end
 
-  def test_should_find_users_using_friendly_id
-    assert User.find([users(:joe).friendly_id])
-  end
+    should "not have a slug" do
+      assert !@user.respond_to?(:slug)
+    end
 
-  def test_to_param_should_return_a_string
-    assert_equal String, users(:joe).to_param.class
-  end
+    should "be findable by its friendly_id" do
+      assert User.find(@user.friendly_id)
+    end
 
-  def test_should_not_find_users_using_non_existent_friendly_ids
-    assert_raises ActiveRecord::RecordNotFound do
-      User.find(['bad', 'bad2'])
+    should "be findable by its regular id" do
+      assert User.find(@user.id)
     end
-  end
-  
-  def test_finding_by_array_with_friendly_and_non_friendly_id_for_same_record_raises_error
-    assert_raises ActiveRecord::RecordNotFound do
-      User.find([users(:joe).id, "joe"]).size
+
+    should "respect finder conditions" do
+      assert_raises ActiveRecord::RecordNotFound do
+        User.find(@user.friendly_id, :conditions => "1 = 2")
+      end
     end
-  end
 
-  def test_finding_with_mixed_array_should_indicate_whether_found_by_numeric_or_friendly
-    @users = User.find([users(:jane).id, "joe"], :order => "login ASC")
-    assert @users[0].found_using_numeric_id?
-    assert @users[1].found_using_friendly_id?
-  end
+    should "indicate if it was found by its friendly id" do
+      @user = User.find(@user.friendly_id)
+      assert @user.found_using_friendly_id?
+    end
 
-  def test_finder_options_are_not_ignored
-    assert_raises ActiveRecord::RecordNotFound do
-       User.find(users(:joe).friendly_id, :conditions => "1 = 2")
+    should "indicate if it was found by its numeric id" do
+      @user = User.find(@user.id)
+      assert @user.found_using_numeric_id?
     end
-    assert_raises ActiveRecord::RecordNotFound do
-       User.find([users(:joe).friendly_id], :conditions => "1 = 2")
+
+    should "indicate if it has a better id" do
+      @user = User.find(@user.id)
+      assert @user.has_better_id?
     end
-  end
 
-  def test_user_should_have_friendly_id_options
-    assert_not_nil User.friendly_id_options
-  end
+    should "not validate if the friendly_id text is reserved" do
+      @user = User.new(:login => "new", :email => "test@example.org")
+      assert !@user.valid?
+    end
 
-  def test_user_should_not_be_found_using_friendly_id_unless_it_really_was
-    assert !User.find(users(:joe).id).found_using_friendly_id?
-  end
+    should "have always string for a friendly_id" do
+      assert_equal String, @user.to_param.class
+    end
 
-  def test_users_should_not_be_found_using_friendly_id_unless_they_really_were
-    @users = User.find([users(:jane).id])
-    assert @users[0].found_using_numeric_id?
-  end
+    context "when using an array as the find argument" do
 
-  def test_user_should_be_considered_found_by_numeric_id_as_default
-    @user = User.new
-    assert @user.found_using_numeric_id?
-  end
+      setup do
+        @user2 = User.create(:login => "jane", :email => "jane@example.org")
+      end
 
-  def test_user_should_indicate_if_it_was_found_using_numeric_id
-    @user = User.find(users(:joe).id)
-    assert @user.found_using_numeric_id?
-    assert !@user.found_using_friendly_id?
-  end
+      should "return results" do
+        assert_equal 2, User.find([@user.friendly_id, @user2.friendly_id]).size
+      end
 
-  def test_user_should_indicate_if_it_was_found_using_friendly_id
-    @user = User.find(users(:joe).friendly_id)
-    assert !@user.found_using_numeric_id?
-    assert @user.found_using_friendly_id?
-  end
+      should "not allow mixed friendly and non-friendly ids for the same record" do
+        assert_raises ActiveRecord::RecordNotFound do
+          User.find([@user.id, @user.friendly_id]).size
+        end
+      end
+
+      should "raise an error when all records are not found" do
+        assert_raises ActiveRecord::RecordNotFound do
+          User.find(['bad', 'bad2'])
+        end
+      end
+
+      should "indicate if the results were found using a friendly_id" do
+        @users = User.find([@user.id, @user2.friendly_id], :order => "login ASC")
+        assert @users[0].found_using_friendly_id?
+        assert @users[1].found_using_numeric_id?
+      end
+
+    end
 
-  def test_should_indicate_there_is_a_better_id_if_found_by_numeric_id
-    @user = User.find(users(:joe).id)
-    assert @user.found_using_numeric_id?
-    assert @user.has_better_id?
   end
 
 end