dougcole-friendly_id 2.0.5 → 2.0.6

data/lib/friendly_id/shoulda_macros.rb

@@ -1,36 +0,0 @@
-module FriendlyId
-
-  # A Shoulda[http://www.thoughtbot.com/projects/shoulda/] macros for testing
-  # models using FriendlyId.
-  module ShouldaMacros
-
-    # Ensure that a model is using FriendlyId.
-    def self.should_have_friendly_id(column, options = {})
-
-      options.assert_valid_keys(:use_slug)
-      klass = self.model_class
-
-      should "have friendly id for #{method}" do
-        assert_respond_to klass, :friendly_id_options,
-          "#{klass} does not respond to friendly_id_options"
-        assert_equal column, klass.friendly_id_options[:method]
-      end
-
-      if options[:use_slug]
-        should "include/extend friendly_id's sluggable modules" do
-          assert klass.extended_by.include?(FriendlyId::SluggableClassMethods),
-            "#{klass} does not extend FriendlyId::SluggableClassMethods"
-          assert klass.include?(FriendlyId::SluggableInstanceMethods),
-            "#{klass} not include FriendlyId::SluggableInstanceMethods"
-        end
-      else
-        should "include/extend friendly_id's non-sluggable modules" do
-          assert klass.extended_by.include?(FriendlyId::NonSluggableClassMethods),
-            "#{klass} does not extend FriendlyId::NonSluggableClassMethods"
-          assert klass.include?(FriendlyId::NonSluggableInstanceMethods),
-            "#{klass} not include FriendlyId::NonSluggableInstanceMethods"
-        end
-      end
-    end
-  end
-end

data/test/database.yml

@@ -1,3 +0,0 @@
-sqlite3:
-  adapter: sqlite3
-  database: ":memory:"

data/test/fixtures/countries.yml

@@ -1,4 +0,0 @@
-argentina:
-  name: Argentina
-usa:
-  name: USA

data/test/fixtures/people.yml

@@ -1,7 +0,0 @@
-john_smith:
-  name: John Smith
-  country: argentina
-
-john_smith2:
-  name: John Smith
-  country: usa

data/test/fixtures/post.rb

@@ -1,3 +0,0 @@
-class Post < ActiveRecord::Base
-  has_friendly_id :name, :use_slug => true, :reserved => ['new', 'edit']
-end

data/test/fixtures/posts.yml

@@ -1,23 +0,0 @@
-without_slug:
-  name: Without a slug
-  content: Content without a slug
-
-with_one_slug:
-  name: With one slug
-  content: Content with one slug
-
-with_two_slugs:
-  name: With two slugs
-  content: Content with two slugs
-
-common_title:
-  name: Common Title
-  content: A post with a very common title
-
-common_title2:
-  name: Common Title
-  content: A second post with a very common title
-
-john_smith:
-  name: John Smith
-  content: Should allow for identical slug names between sluggable types

data/test/fixtures/slugs.yml

@@ -1,53 +0,0 @@
-post_with_same_friendly_id_as_person:
-  name: john-smith
-  sluggable: john_smith (Post)
-
-person_with_same_friendly_id_as_post:
-  name: john-smith
-  sluggable: john_smith (Person)
-
-one:
-  name: with-one-slug
-  sluggable: with_one_slug
-  sluggable_type: Post
-  sequence: 1
-
-two_old:
-  name: with-two-slugs
-  sluggable: with_two_slugs (Post)
-  sequence: 1
-  
-two_new:
-  name: with-two-slugs-new
-  sluggable: with_two_slugs (Post)
-  sequence: 1
-
-common_title:
-  name: common-title
-  sluggable: common_title (Post)
-  sequence: 1
-
-common_title2:
-  name: common-title
-  sluggable: common_title2 (Post)
-  sequence: 2
-
-john_smith:
-  name: john-smith
-  sluggable: john_smith (Person)
-  sequence: 1
-  scope: argentina
-
-john_smith2:
-  name: john-smith
-  sluggable: john_smith2 (Person)
-  sequence: 1
-  scope: usa
-
-argentina:
-  name: argentina
-  sluggable: argentina (Country)
-    
-usa:
-  name: usa
-  sluggable: usa (Country)

data/test/fixtures/users.yml

@@ -1,7 +0,0 @@
-joe:
-  login: joe
-  email: joe@example.org
-
-jane:
-  login: jane
-  email: jane@example.org

data/test/rails/2.x/config/boot.rb

@@ -1,109 +0,0 @@
-# Don't change this file!
-# Configure your app in config/environment.rb and config/environments/*.rb
-
-RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
-
-module Rails
-  class << self
-    def boot!
-      unless booted?
-        preinitialize
-        pick_boot.run
-      end
-    end
-
-    def booted?
-      defined? Rails::Initializer
-    end
-
-    def pick_boot
-      (vendor_rails? ? VendorBoot : GemBoot).new
-    end
-
-    def vendor_rails?
-      File.exist?("#{RAILS_ROOT}/vendor/rails")
-    end
-
-    def preinitialize
-      load(preinitializer_path) if File.exist?(preinitializer_path)
-    end
-
-    def preinitializer_path
-      "#{RAILS_ROOT}/config/preinitializer.rb"
-    end
-  end
-
-  class Boot
-    def run
-      load_initializer
-      Rails::Initializer.run(:set_load_path)
-    end
-  end
-
-  class VendorBoot < Boot
-    def load_initializer
-      require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
-      Rails::Initializer.run(:install_gem_spec_stubs)
-    end
-  end
-
-  class GemBoot < Boot
-    def load_initializer
-      self.class.load_rubygems
-      load_rails_gem
-      require 'initializer'
-    end
-
-    def load_rails_gem
-      if version = self.class.gem_version
-        gem 'rails', version
-      else
-        gem 'rails'
-      end
-    rescue Gem::LoadError => load_error
-      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
-      exit 1
-    end
-
-    class << self
-      def rubygems_version
-        Gem::RubyGemsVersion rescue nil
-      end
-
-      def gem_version
-        if defined? RAILS_GEM_VERSION
-          RAILS_GEM_VERSION
-        elsif ENV.include?('RAILS_GEM_VERSION')
-          ENV['RAILS_GEM_VERSION']
-        else
-          parse_gem_version(read_environment_rb)
-        end
-      end
-
-      def load_rubygems
-        require 'rubygems'
-        min_version = '1.3.1'
-        unless rubygems_version >= min_version
-          $stderr.puts %Q(Rails requires RubyGems >= #{min_version} (you have #{rubygems_version}). Please `gem update --system` and try again.)
-          exit 1
-        end
-
-      rescue LoadError
-        $stderr.puts %Q(Rails requires RubyGems >= #{min_version}. Please install RubyGems and try again: http://rubygems.rubyforge.org)
-        exit 1
-      end
-
-      def parse_gem_version(text)
-        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
-      end
-
-      private
-        def read_environment_rb
-          File.read("#{RAILS_ROOT}/config/environment.rb")
-        end
-    end
-  end
-end
-
-# All that for this:
-Rails.boot!

data/test/rails/2.x/config/database.yml

@@ -1,3 +0,0 @@
-test:
-  adapter: sqlite3
-  database: ":memory:"

data/test/rails/2.x/config/environment.rb

@@ -1,7 +0,0 @@
-if ENV['RAILS_VERSION']
-  RAILS_GEM_VERSION = ENV['RAILS_VERSION']
-end
-require File.join(File.dirname(__FILE__), 'boot')
-Rails::Initializer.run
-ActiveRecord::Base.colorize_logging = false
-require File.dirname(__FILE__) + '/../../../../init.rb'

data/test/rails/2.x/config/environments/test.rb

@@ -1,6 +0,0 @@
-config.cache_classes = true
-config.whiny_nils = true
-config.action_controller.consider_all_requests_local = true
-config.action_controller.perform_caching             = false
-config.action_controller.allow_forgery_protection    = false
-config.action_mailer.delivery_method = :test

data/test/sluggable_test.rb

@@ -1,185 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class SluggableTest < Test::Unit::TestCase
-
-  fixtures :posts, :slugs
-
-  def setup
-    Post.friendly_id_options[:max_length] = FriendlyId::ClassMethods::DEFAULT_FRIENDLY_ID_OPTIONS[:max_length]
-  end
-
-  def test_should_allow_for_identical_slug_names_between_sluggable_types
-    assert !Post.find(slugs(:post_with_same_friendly_id_as_person).name).has_better_id?
-  end
-
-  def test_class_should_have_friendly_id_options
-    assert_not_nil Post.friendly_id_options
-  end
-
-  def test_should_generate_slug_text
-   @post = Post.new(:name => "Test post", :content => "Test content")
-   assert_equal "test-post", @post.slug_text
-  end
-
-  def test_should_save_slug_when_creating
-    @post = Post.create(:name => "Test post", :content => "Test content")
-    assert @post.slug
-  end
-
-  def test_to_param_should_always_return_a_string
-    assert_equal String, posts(:without_slug).to_param.class
-    assert_equal String, posts(:with_one_slug).to_param.class
-  end
-
-  def test_finder_options_are_not_ignored
-    assert_raises ActiveRecord::RecordNotFound do
-      Post.find(slugs(:one).name, :conditions => "1 = 2")
-    end
-  end
-
-  def test_should_still_be_able_to_find_record_by_id
-    post = Post.create!(:name => "New post")
-    Post.create!(:name => "#{post.id.to_s} and some text")
-    assert_equal post, Post.find(post.id)
-  end
-
-
-  def test_should_not_be_found_using_friendly_id_by_default
-    @post = Post.new
-    assert !@post.found_using_friendly_id?
-    assert @post.found_using_numeric_id?
-  end
-
-  def test_should_be_using_friendly_id_when_find_arg_is_an_array
-    @posts = Post.find([posts(:with_one_slug).friendly_id, posts(:with_two_slugs).friendly_id])
-    assert @posts.all? { |post| post.found_using_friendly_id? }
-  end
-
-  def test_raises_active_record_not_found_when_not_all_records_found
-    assert_raises(ActiveRecord::RecordNotFound) do
-      Post.find([posts(:with_one_slug).slug.name, 'non-existant-slug-record'])
-    end
-  end
-
-  def test_should_indicate_if_it_was_found_using_numeric_id
-    @post = Post.find(posts(:with_two_slugs).id)
-    assert @post.found_using_numeric_id?
-  end
-
-  def test_post_should_indicate_if_it_was_found_using_friendly_id
-    @post = Post.find(posts(:with_two_slugs).slug.name)
-    assert @post.found_using_friendly_id?
-  end
-
-  def test_post_should_indicate_if_it_was_found_using_outdated_friendly_id
-    @post = Post.find(posts(:with_two_slugs).slugs.last.name)
-    assert @post.found_using_outdated_friendly_id?
-  end
-
-  def test_should_indicate_there_is_a_better_id_if_found_by_numeric_id
-    @post = Post.find(posts(:with_one_slug).id)
-    assert @post.has_better_id?
-  end
-
-  def test_should_indicate_there_is_a_better_id_if_found_by_outdated_friendly_id
-    @post = Post.find(posts(:with_two_slugs).slugs.last.name)
-    assert @post.has_better_id?
-  end
-
-  def test_slug_should_always_be_the_most_recent
-    @post = Post.find(posts(:with_two_slugs).slug.name)
-    assert !@post.has_better_id?
-    assert slugs(:two_new).name, @post.slug.name
-  end
-
-  def test_should_strip_diactics_from_slug_if_configured_to_do_so
-    Post.friendly_id_options[:strip_diacritics] = true
-    @post = Post.new(:name => "¡FELIZ AÑO!")
-    # Happy anus to you too
-    assert_equal "feliz-ano", @post.slug_text
-  end
-
-  def test_should_not_strip_diactics_from_slug_unless_configured_to_do_so
-    Post.friendly_id_options[:strip_diacritics] = false
-    @post = Post.new(:name => "¡FELIZ AÑO!")
-    assert_equal "feliz-año", @post.slug_text
-  end
-
-  def test_should_not_make_new_slug_unless_friendly_id_method_has_changed
-    posts(:with_one_slug).content = "Edited content"
-    posts(:with_one_slug).save!
-    assert_equal 1, posts(:with_one_slug).slugs.size
-  end
-
-  def test_post_should_make_new_slug_if_friendly_id_method_is_changed
-    posts(:with_one_slug).name = "Edited name"
-    posts(:with_one_slug).save!
-    assert_equal 2, posts(:with_one_slug).slugs.size
-  end
-
-  def test_should_increment_sequence_for_duplicate_slugs
-    @post = Post.create!(:name => slugs(:one).name, :content => "stuff")
-    assert_equal 2, @post.slug.sequence
-  end
-
-  def test_friendly_id_should_contain_sequence_unless_its_1
-    @post = Post.create!(:name => slugs(:one).name, :content => "stuff")
-    assert_equal "#{slugs(:one).name}--2", @post.friendly_id
-  end
-
-  def test_should_truncate_slugs_longer_than_maxlength
-    Post.friendly_id_options[:max_length] = 10
-    @post = Post.new(:name => "x" * 11, :content => "Test content")
-    assert @post.slug_text.length <= Post.friendly_id_options[:max_length]
-  end
-
-  def test_should_ensure_truncated_slugs_that_collide_have_different_sequences
-    Post.friendly_id_options[:max_length] = 2
-    p = Post.create!(:name => "aaa")
-    q = Post.create!(:name => "aaab")
-    assert_not_equal p.friendly_id, q.friendly_id
-    assert_equal p.slug.name, q.slug.name
-    assert_not_equal p.slug.sequence, q.slug.sequence
-  end
-
-  def test_should_be_able_to_rename_back_to_old_friendly_id
-    p = Post.create!(:name => "value")
-    assert_equal "value", p.friendly_id
-    p.name = "different value"
-    p.save!
-    p.reload
-    assert_equal "different-value", p.friendly_id
-    p.name = "value"
-    assert p.save!
-    p.reload
-    assert_equal "value", p.friendly_id
-  end
-
-  def test_should_raise_error_if_friendly_id_is_blank
-    assert_raises(FriendlyId::SlugGenerationError) do
-      Post.create(:name => nil)
-    end
-  end
-
-  def test_should_raise_error_if_normalized_friendly_id_becomes_blank
-    assert_raises(FriendlyId::SlugGenerationError) do
-      post = Post.create!(:name => "-.-")
-    end
-  end
-
-  def test_should_raise_error_if_slug_text_is_reserved
-    assert_raises(FriendlyId::SlugGenerationError) do
-      Post.create(:name => "new")
-    end
-  end
-
-  def test_should_allow_eager_loading_of_slugs
-    assert_nothing_raised do
-      Post.find(slugs(:one).name, :include => :slugs)
-    end
-    assert_nothing_raised do
-      Post.find([slugs(:one).name, slugs(:two_new).name], :include => :slugs)
-    end
-  end
-
-end