refinerycms 0.9.6.19 → 0.9.6.21

data/vendor/plugins/friendly_id/lib/friendly_id/status.rb

@@ -0,0 +1,35 @@
+module FriendlyId
+
+  # FriendlyId::Status presents information about the status of the
+  # id that was used to find the model. This class can be useful for figuring
+  # out when to redirect to a new URL.
+  class Status
+
+    # The id or name used as the finder argument
+    attr_accessor :name
+
+    # The found result, if any
+    attr_accessor :record
+
+    def initialize(options={})
+      options.each {|key, value| self.send("#{key}=".to_sym, value)}
+    end
+
+    # Did the find operation use a friendly id?
+    def friendly?
+      !! name
+    end
+
+    # Did the find operation use a numeric id?
+    def numeric?
+      !friendly?
+    end
+
+    # Did the find operation use the best available id?
+    def best?
+      record.friendly_id ? friendly? : true
+    end
+
+  end
+
+end

data/vendor/plugins/friendly_id/lib/friendly_id/test.rb

@@ -0,0 +1,175 @@
+Module.send :include, Module.new {
+  def test(name, &block)
+    define_method("test_#{name.gsub(/[^a-z0-9]/i, "_")}".to_sym, &block)
+  end
+  alias :should :test
+}
+
+module FriendlyId
+  module Test
+
+    # Tests for any model that implements FriendlyId. Any test that tests model
+    # features should include this module.
+    module Generic
+
+      def setup
+        klass.send delete_all_method
+      end
+
+      def teardown
+        klass.send delete_all_method
+        # other_class.delete_all
+      end
+
+      def instance
+        raise NotImplementedError
+      end
+
+      def klass
+        raise NotImplementedError
+      end
+
+      def other_class
+        raise NotImplementedError
+      end
+
+      def find_method
+        raise NotImplementedError
+      end
+
+      def create_method
+        raise NotImplementedError
+      end
+
+      def validation_exceptions
+        return RuntimeError
+      end
+
+      test "models should have a friendly id config" do
+        assert_not_nil klass.friendly_id_config
+      end
+
+      test "instances should have a friendly id" do
+        assert_not_nil instance.friendly_id
+      end
+
+      test "instances should have a friendly id status" do
+        assert_not_nil instance.friendly_id_status
+      end
+
+      test "instances should be findable by their friendly id" do
+        assert_equal instance, klass.send(find_method, instance.friendly_id)
+      end
+
+      test "instances should be findable by their numeric id as an integer" do
+        assert_equal instance, klass.send(find_method, instance.id.to_i)
+      end
+
+      test "instances should be findable by their numeric id as a string" do
+        assert_equal instance, klass.send(find_method, instance.id.to_s)
+      end
+
+      test "creation should raise an error if the friendly_id text is reserved" do
+        assert_raise(*[validation_exceptions].flatten) do
+          klass.send(create_method, :name => "new")
+        end
+      end
+
+      test "creation should raise an error if the friendly_id text is an empty string" do
+        assert_raise(*[validation_exceptions].flatten) do
+          klass.send(create_method, :name => "")
+        end
+      end
+
+      test "creation should raise an error if the friendly_id text is a blank string" do
+        assert_raise(*[validation_exceptions].flatten) do
+          klass.send(create_method, :name => "   ")
+        end
+      end
+
+      test "creation should raise an error if the friendly_id text is nil" do
+        assert_raise(*[validation_exceptions].flatten) do
+          klass.send(create_method, :name => nil)
+        end
+      end
+
+      test "should allow the same friendly_id across models" do
+        other_instance = other_class.send(create_method, :name => instance.name)
+        assert_equal other_instance.friendly_id, instance.friendly_id
+      end
+
+    end
+
+    # Tests for any model that implements slugs.
+    module Slugged
+
+      test "should have a slug" do
+        assert_not_nil instance.slug
+      end
+
+      test "should not make a new slug unless the friendly_id method value has changed" do
+        instance.note = instance.note.to_s << " updated"
+        instance.send save_method
+        assert_equal 1, instance.slugs.size
+      end
+
+      test "should make a new slug if the friendly_id method value has changed" do
+        instance.name = "Changed title"
+        instance.send save_method
+        assert_equal 2, instance.slugs.size
+      end
+
+      test "should be able to reuse an old friendly_id without incrementing the sequence" do
+        old_title = instance.name
+        old_friendly_id = instance.friendly_id
+        instance.name = "A changed title"
+        instance.send save_method
+        instance.name = old_title
+        instance.send save_method
+        assert_equal old_friendly_id, instance.friendly_id
+      end
+
+      test "should increment the slug sequence for duplicate friendly ids" do
+        instance2 = klass.send(create_method, :name => instance.name)
+        assert_match(/2\z/, instance2.friendly_id)
+      end
+
+      test "should find instance with a sequenced friendly_id" do
+        instance2 = klass.send(create_method, :name => instance.name)
+        assert_equal instance2, klass.send(find_method, instance2.friendly_id)
+      end
+
+      test "should remain findable by previous slugs" do
+        old_friendly_id = instance.friendly_id
+        instance.update_attributes :name => "#{old_friendly_id} updated"
+        assert_not_equal old_friendly_id, instance.friendly_id
+        assert_equal instance, klass.find(old_friendly_id)
+      end
+
+    end
+
+    # Tests for models to ensure that they properly implement using the
+    # +normalize_friendly_id+ method to allow developers to hook into the
+    # slug string generation.
+    module CustomNormalizer
+
+      test "should invoke the custom normalizer" do
+        assert_equal "JOE SCHMOE", klass.send(create_method, :name => "Joe Schmoe").friendly_id
+      end
+
+      test "should respect the max_length option" do
+        klass.friendly_id_config.stubs(:max_length).returns(3)
+        assert_equal "JOE", klass.send(create_method, :name => "Joe Schmoe").friendly_id
+      end
+
+      test "should raise an error if the friendly_id text is reserved" do
+        klass.friendly_id_config.stubs(:reserved_words).returns(["JOE"])
+        assert_raise(*[validation_exceptions].flatten) do
+          klass.send(create_method, :name => "Joe")
+        end
+
+      end
+
+    end
+  end
+end

data/vendor/plugins/friendly_id/lib/friendly_id/version.rb

@@ -0,0 +1,8 @@
+module FriendlyId
+  module Version
+    MAJOR = 2
+    MINOR = 3
+    TINY = 3
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/vendor/plugins/friendly_id/rails/init.rb

@@ -0,0 +1,2 @@
+require "friendly_id"
+require "friendly_id/active_record2"

data/vendor/plugins/friendly_id/test/active_record2/basic_slugged_model_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module FriendlyId
+  module Test
+    module ActiveRecord2
+      class BasicSluggedModelTest < ::Test::Unit::TestCase
+        include FriendlyId::Test::Generic
+        include FriendlyId::Test::Slugged
+        include FriendlyId::Test::ActiveRecord2::Slugged
+        include FriendlyId::Test::ActiveRecord2::Core
+      end
+    end
+  end
+end

data/vendor/plugins/friendly_id/test/active_record2/cached_slug_test.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module FriendlyId
+  module Test
+    module ActiveRecord2
+
+      class CachedSlugTest < ::Test::Unit::TestCase
+
+        include FriendlyId::Test::Generic
+        include FriendlyId::Test::Slugged
+        include FriendlyId::Test::ActiveRecord2::Slugged
+        include FriendlyId::Test::ActiveRecord2::Core
+
+        def klass
+          District
+        end
+
+        def other_class
+          Post
+        end
+
+        def cached_slug
+          instance.send(cache_column)
+        end
+
+        def cache_column
+          klass.friendly_id_config.cache_column
+        end
+
+        test "should have a cached_slug" do
+          assert_equal cached_slug, instance.slug.to_friendly_id
+        end
+
+        test "should protect the cached slug value" do
+          old_value = cached_slug
+          instance.update_attributes(cache_column => "Madrid")
+          instance.reload
+          assert_equal old_value, cached_slug
+        end
+
+        test "should update the cached slug when updating the slug" do
+          instance.update_attributes(:name => "new name")
+          assert_equal instance.slug.to_friendly_id, cached_slug
+        end
+
+        test "should not update the cached slug column if it has not changed" do
+          instance.note = "a note"
+          instance.expects("#{cache_column}=".to_sym).never
+          instance.save!
+        end
+
+        test "should cache the incremented sequence for duplicate slug names" do
+          instance_2 = klass.create!(:name => instance.name)
+          assert_match(/2\z/, instance_2.send(cache_column))
+        end
+
+      end
+    end
+  end
+end
+

data/vendor/plugins/friendly_id/test/active_record2/core.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module FriendlyId
+
+  module Test
+
+    module ActiveRecord2
+
+      module Core
+
+        def teardown
+          klass.delete_all
+          other_class.delete_all
+          Slug.delete_all
+        end
+
+        def find_method
+          :find
+        end
+
+        def create_method
+          :create!
+        end
+
+        def delete_all_method
+          :delete_all
+        end
+
+        def save_method
+          :save!
+        end
+
+        def validation_exceptions
+          [ActiveRecord::RecordInvalid, FriendlyId::ReservedError, FriendlyId::BlankError]
+        end
+
+        test "should return their friendly_id for #to_param" do
+          assert_match(instance.friendly_id, instance.to_param)
+        end
+
+        test "instances should be findable by their own instance" do
+          assert_equal instance, klass.find(instance)
+        end
+
+        test "instances should be findable by an array of friendly_ids" do
+          second = klass.create!(:name => "second_instance")
+          assert_equal 2, klass.find([instance.friendly_id, second.friendly_id]).size
+        end
+
+        test "instances should be findable by an array of numeric ids" do
+          second = klass.create!(:name => "second_instance")
+          assert_equal 2, klass.find([instance.id.to_i, second.id.to_i]).size
+        end
+
+        test "instances should be findable by an array of numeric ids as strings" do
+          second = klass.create!(:name => "second_instance")
+          assert_equal 2, klass.find([instance.id.to_s, second.id.to_s]).size
+        end
+
+        test "instances should be findable by an array of instances" do
+          second = klass.create!(:name => "second_instance")
+          assert_equal 2, klass.find([instance, second]).size
+        end
+
+        test "instances should be findable by an array of mixed types" do
+          second = klass.create!(:name => "second_instance")
+          assert_equal 2, klass.find([instance.friendly_id, second]).size
+        end
+
+        test "models should raise an error when not all records are found" do
+          assert_raises(ActiveRecord::RecordNotFound) do
+            klass.find([instance.friendly_id, 'bad-friendly-id'])
+          end
+        end
+
+        test "models should respect finder conditions" do
+          assert_raise ActiveRecord::RecordNotFound do
+            klass.find(instance.friendly_id, :conditions => "1 = 2")
+          end
+        end
+
+        # This emulates a fairly common issue where id's generated by fixtures are very high.
+        test "should continue to admit very large ids" do
+          klass.connection.execute("INSERT INTO #{klass.table_name} (id, name) VALUES (2047483647, 'An instance')")
+          assert_nothing_raised do
+            klass.base_class.find(2047483647)
+          end
+        end
+
+      end
+    end
+  end
+end

data/vendor/plugins/friendly_id/test/active_record2/custom_normalizer_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module FriendlyId
+  module Test
+    module ActiveRecord2
+
+      class CustomNormalizerTest < ::Test::Unit::TestCase
+
+        include FriendlyId::Test::ActiveRecord2::Core
+        include FriendlyId::Test::ActiveRecord2::Slugged
+        include FriendlyId::Test::CustomNormalizer
+
+        def klass
+          Person
+        end
+
+      end
+    end
+  end
+end

data/vendor/plugins/friendly_id/test/active_record2/custom_table_name_test.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module FriendlyId
+  module Test
+    module ActiveRecord2
+
+      class CustomTableNameTest < ::Test::Unit::TestCase
+
+        include FriendlyId::Test::Generic
+        include FriendlyId::Test::Slugged
+        include FriendlyId::Test::ActiveRecord2::Slugged
+        include FriendlyId::Test::ActiveRecord2::Core
+
+        def klass
+          Place
+        end
+
+      end
+
+    end
+  end
+end

data/vendor/plugins/friendly_id/test/active_record2/deprecated_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module FriendlyId
+  module Test
+    module ActiveRecord2
+
+      class DeprecatedTest < ::Test::Unit::TestCase
+
+        include FriendlyId::Test::Generic
+        include FriendlyId::Test::Slugged
+        include FriendlyId::Test::ActiveRecord2::Slugged
+        include FriendlyId::Test::ActiveRecord2::Core
+
+        def klass
+          Block
+        end
+
+      end
+
+    end
+  end
+end
+