test/models/country.rb test/models/person.rb test/models/post.rb test/models/user.rb test/slugged_model_test.rb @@ -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: History.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 Manifest.txt @@ -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 Rakefile @@ -6,19 +6,20 @@ Gem::Specification.new do |s| 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-02-07} - 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", "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"] + 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.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 @@ -26,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 friendly_id.gemspec @@ -1,20 +1,35 @@ 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, :strip_non_ascii => false, :scope => nil}.freeze - VALID_FRIENDLY_ID_KEYS = [:use_slug, :max_length, :reserved, :strip_diacritics, :strip_non_ascii, :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,12 +40,13 @@ module FriendlyId # * <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>: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 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>: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 @@ -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,15 +72,6 @@ module FriendlyId def enable return if ActiveRecord::Base.methods.include? 'has_friendly_id' ActiveRecord::Base.class_eval { extend FriendlyId::ClassMethods } - begin - if Rails.version >= "2.3" - ActiveSupport::TestCase.class_eval { include FriendlyId::ShouldaMacros } - else - Test::Unit::TestCase.class_eval { include FriendlyId::ShouldaMacros } - end - rescue NoMethodError - Test::Unit::TestCase.class_eval { include FriendlyId::ShouldaMacros } - end end end lib/friendly_id.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 lib/friendly_id/non_sluggable_class_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 lib/friendly_id/non_sluggable_instance_methods.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,12 +43,10 @@ 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. @@ -58,9 +57,7 @@ class Slug < ActiveRecord::Base private def chars_func - Rails.version >= "2.2" ? :mb_chars : :chars - rescue NoMethodError - :chars + "".respond_to?(:mb_chars) ? :mb_chars : :chars end end @@ -78,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 lib/friendly_id/slug.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 lib/friendly_id/sluggable_class_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? lib/friendly_id/sluggable_instance_methods.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 \ No newline at end of file test/non_slugged_test.rb @@ -1,35 +1,35 @@ -ActiveRecord::Schema.define(:version => 3) do +ActiveRecord::Schema.define(:version => 1) do create_table "posts", :force => true do |t| - t.string "name" - t.text "content" - t.datetime "created_at" - t.datetime "updated_at" + t.column "title", "string" + t.column "content", "text" + t.column "created_at", "datetime" + t.column "updated_at", "datetime" end create_table "users", :force => true do |t| - t.string "login" - t.string "email" - t.datetime "created_at" - t.datetime "updated_at" + t.column "login", "string" + t.column "email", "string" + t.column "created_at", "datetime" + t.column "updated_at", "datetime" end create_table "people", :force => true do |t| - t.string "name" - t.integer "country_id" + t.column "name", "string" + t.column "country_id", "integer" end create_table "countries", :force => true do |t| - t.string "name" + t.column "name", "string" end create_table "slugs", :force => true 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" + t.column "name", "string" + t.column "sluggable_id", "integer" + t.column "sequence", "integer", :null => false, :default => 1 + t.column "sluggable_type", "string", :limit => 40 + t.column "scope", "string", :limit => 40 + t.column "created_at", "datetime" end add_index "slugs", ["sluggable_id"], :name => "index_slugs_on_sluggable_id" test/schema.rb @@ -2,20 +2,50 @@ require File.dirname(__FILE__) + '/test_helper' class ScopedModelTest < Test::Unit::TestCase - fixtures :people, :countries, :slugs - - def test_should_find_scoped_records_without_scope - assert_equal 2, Person.find(:all, "john-smith").size - end + context "A slugged model that uses a scope" do + + setup do + Person.delete_all + Country.delete_all + Slug.delete_all + @usa = Country.create!(:name => "USA") + @canada = Country.create!(:name => "Canada") + @person = Person.create!(:name => "John Smith", :country => @usa) + @person2 = Person.create!(:name => "John Smith", :country => @canada) + end + + should "find all scoped records without scope" do + assert_equal 2, Person.find(:all, @person.friendly_id).size + end + + should "find a single scoped records with a scope" do + assert Person.find(@person.friendly_id, :scope => @person.country.to_param) + end + + should "raise an error when finding a single scoped record with no scope" do + assert_raises ActiveRecord::RecordNotFound do + Person.find(@person.friendly_id) + end + end + + should "append scope error info when missing scope causes a find to fail" do + begin + Person.find(@person.friendly_id) + fail "The find should not have succeeded" + rescue ActiveRecord::RecordNotFound => e + assert_match /expected scope/, e.message + end + end + + should "append scope error info when the scope value causes a find to fail" do + begin + Person.find(@person.friendly_id, :scope => "badscope") + fail "The find should not have succeeded" + rescue ActiveRecord::RecordNotFound => e + assert_match /scope=badscope/, e.message + end + end - def test_should_find_scoped_records_with_scope - assert_equal people(:john_smith), Person.find("john-smith", :scope => "argentina") - assert_equal people(:john_smith2), Person.find("john-smith", :scope => "usa") - end - - def test_should_create_scoped_records_with_scope - person = Person.create!(:name => "Joe Schmoe", :country => countries(:usa)) - assert_equal "usa", person.slug.scope end end \ No newline at end of file test/scoped_model_test.rb @@ -1,87 +1,106 @@ +# encoding: utf-8 + require File.dirname(__FILE__) + '/test_helper' class SlugTest < Test::Unit::TestCase - fixtures :posts, :slugs - - def test_should_indicate_if_it_is_the_most_recent - assert slugs(:two_new).is_most_recent? - assert !slugs(:two_old).is_most_recent? - end - - def test_parse_should_return_slug_name_and_sequence - assert_equal ["test", "2"], Slug::parse("test--2") - end - - def test_parse_should_return_a_default_sequnce_of_1 - assert_equal ["test", "1"], Slug::parse("test") - end - - def test_strip_diacritics_should_strip_diacritics - assert_equal "acai", Slug::strip_diacritics("açaí") - end - - def test_to_friendly_id_should_include_sequence_if_its_greater_than_1 - slug = Slug.new(:name => "test", :sequence => 2) - assert_equal "test--2", slug.to_friendly_id - end - - def test_to_friendly_id_should_include_sequence_if_its_than_1 - slug = Slug.new(:name => "test", :sequence => 1) - assert_equal "test", slug.to_friendly_id - end - - def test_normalize_should_lowercase_strings - assert_match /abc/, Slug::normalize("ABC") - end - - def test_normalize_should_replace_whitespace_with_dashes - assert_match /a-b/, Slug::normalize("a b") - end - - def test_normalize_should_replace_2spaces_with_1dash - assert_match /a-b/, Slug::normalize("a b") - end - - def test_normalize_should_remove_punctuation - assert_match /abc/, Slug::normalize('abc!@#$%^&*•¶§∞¢££¡¿()><?"":;][]\.,/') - end - - def test_normalize_should_strip_trailing_space - assert_match /ab/, Slug::normalize("ab ") - end - - def test_normalize_should_strip_leading_space - assert_match /ab/, Slug::normalize(" ab") - end - - def test_normalize_should_strip_trailing_slashes - assert_match /ab/, Slug::normalize("ab-") - end + context "a slug" do + + setup do + Slug.delete_all + Post.delete_all + end - def test_normalize_should_strip_leading_slashes - assert_match /ab/, Slug::normalize("-ab") - end + should "indicate if it is the most recent slug" do + @post = Post.create!(:title => "test title", :content => "test content") + @post.title = "a new title" + @post.save! + assert @post.slugs.last.is_most_recent? + assert !@post.slugs.first.is_most_recent? + end - def test_normalize_should_not_modify_valid_name_strings - assert_match /a-b-c-d/, Slug::normalize("a-b-c-d") end + + context "the Slug class" do + + should "parse the slug name and sequence" do + assert_equal ["test", "2"], Slug::parse("test--2") + end + + should "parse with a default sequence of 1" do + assert_equal ["test", "1"], Slug::parse("test") + end - # These strings are taken from various international Google homepages. I - # would be most grateful if a fluent speaker of any language that uses a - # writing system other than the Roman alphabet could help me make some - # better tests to ensure this is working correctly. - def test_normalize_works_with_non_roman_chars - assert_equal "検-索", Slug::normalize("検 索") + should "should strip diacritics" do + assert_equal "acai", Slug::strip_diacritics("açaí") + end + + should "strip diacritics correctly " do + input = "ÀÁÂÃÄÅÆÇÈÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ" + output = Slug::strip_diacritics(input).split(//) + expected = "AAAAAAAECEEEIIIIDNOOOOOOUUUUYThssaaaaaaaeceeeeiiiidnoooooouuuuythy".split(//) + output.split.each_index do |i| + assert_equal output[i], expected[i] + end + end + end - - def test_strip_diactics_correctly_strips_diacritics - input = "ÀÁÂÃÄÅÆÇÈÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ" - output = Slug::strip_diacritics(input).split(//) - expected = "AAAAAAAECEEEIIIIDNOOOOOOUUUUYThssaaaaaaaeceeeeiiiidnoooooouuuuythy".split(//) - output.split.each_index do |i| - assert_equal output[i], expected[i] + + context "the Slug class's to_friendly_id method" do + + should "include the sequence if the sequence is greater than 1" do + slug = Slug.new(:name => "test", :sequence => 2) + assert_equal "test--2", slug.to_friendly_id end + + should "not include the sequence if the sequence is 1" do + slug = Slug.new(:name => "test", :sequence => 1) + assert_equal "test", slug.to_friendly_id + end + end + context "the Slug class's normalize method" do + + should "should lowercase strings" do + assert_match /abc/, Slug::normalize("ABC") + end + + should "should replace whitespace with dashes" do + assert_match /a-b/, Slug::normalize("a b") + end + + should "should replace 2spaces with 1dash" do + assert_match /a-b/, Slug::normalize("a b") + end + + should "should remove punctuation" do + assert_match /abc/, Slug::normalize('abc!@#$%^&*•¶§∞¢££¡¿()><?"":;][]\.,/') + end + + should "should strip trailing space" do + assert_match /ab/, Slug::normalize("ab ") + end + + should "should strip leading space" do + assert_match /ab/, Slug::normalize(" ab") + end + + should "should strip trailing slashes" do + assert_match /ab/, Slug::normalize("ab-") + end + + should "should strip leading slashes" do + assert_match /ab/, Slug::normalize("-ab") + end + + should "should not modify valid name strings" do + assert_match /a-b-c-d/, Slug::normalize("a-b-c-d") + end + + should "work with non roman chars" do + assert_equal "検-索", Slug::normalize("検 索") + end + + end end \ No newline at end of file test/slug_test.rb @@ -1,35 +1,33 @@ $:.unshift(File.dirname(__FILE__) + '/../lib') -$VERBOSE = false - -ENV['RAILS_ENV'] = 'test' -require File.dirname(__FILE__) + '/rails/2.x/config/environment.rb' -ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log") - +$:.unshift(File.dirname(__FILE__)) +$VERBOSE=false +require 'rubygems' require 'test/unit' -require 'active_record/fixtures' -require 'action_controller/test_process' -require 'sqlite3' -require 'friendly_id/slug' - -config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml')) -ActiveRecord::Base.establish_connection - -silence_stream(STDOUT) do - load(File.dirname(__FILE__) + "/schema.rb") +require 'shoulda' +# You can use "rake test AR_VERSION=2.0.5" to test against 2.0.5, for example. +# The default is to use the latest installed ActiveRecord. +if ENV["AR_VERSION"] + gem 'activerecord', "#{ENV["AR_VERSION"]}" end +require 'active_record' -Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures" -$LOAD_PATH.unshift(Test::Unit::TestCase.fixture_path) +require 'friendly_id' +require 'models/post' +require 'models/person' +require 'models/user' +require 'models/country' -class Test::Unit::TestCase #:nodoc: - include ActionController::TestProcess - def create_fixtures(*table_names) - if block_given? - Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield } - else - Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) - end - end - self.use_transactional_fixtures = true - self.use_instantiated_fixtures = false +# Borrowed from ActiveSupport +def silence_stream(stream) + old_stream = stream.dup + stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null') + stream.sync = true + yield +ensure + stream.reopen(old_stream) end + +ActiveRecord::Base.establish_connection :adapter => "sqlite3", :database => ":memory:" +silence_stream(STDOUT) do + load(File.dirname(__FILE__) + "/schema.rb") +end \ No newline at end of file test/test_helper.rb lib/friendly_id/shoulda_macros.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/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/sluggable_test.rb 88f6fad0c0535ad6584537ffbd5e9720f4eb2ac8 Norman Clarke norman@randomba.org http://github.com/norman/friendly_id/commit/10e757ad3fcedb0c798b2532b823678e8ef2314e 10e757ad3fcedb0c798b2532b823678e8ef2314e 2009-02-09T11:56:42-08:00 2009-02-09T07:13:53-08:00 Made reserved words work for non-slugged models. Remove dependencies on Rails in favor of ActiveRecord. Overhauled creaky testing setup and switched it over to Shoulda. 21682b4c94095abb9b2a4e0ad7635fb28afe3536 Norman Clarke norman@randomba.org