friendly_id_globalize3 3.2.0

data/lib/friendly_id/version.rb

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

data/lib/generators/friendly_id_generator.rb

@@ -0,0 +1,25 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class FriendlyIdGenerator < Rails::Generators::Base
+
+  include Rails::Generators::Migration
+
+  MIGRATIONS_FILE = File.join(File.dirname(__FILE__), "..", "..", "generators", "friendly_id", "templates", "create_slugs.rb")
+
+  class_option :"skip-migration", :type => :boolean, :desc => "Don't generate a migration for the slugs table"
+
+  def copy_files(*args)
+    migration_template MIGRATIONS_FILE, "db/migrate/create_slugs.rb" unless options["skip-migration"]
+  end
+
+  # Taken from ActiveRecord's migration generator
+  def self.next_migration_number(dirname) #:nodoc:
+    if ActiveRecord::Base.timestamped_migrations
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    else
+      "%.3d" % (current_migration_number(dirname) + 1)
+    end
+  end
+
+end

data/lib/tasks/friendly_id.rake

@@ -0,0 +1,19 @@
+namespace :friendly_id do
+  desc "Make slugs for a model."
+  task :make_slugs => :environment do
+    FriendlyId::TaskRunner.new.make_slugs do |record|
+      puts "#{record.class}(#{record.id}): friendly_id set to '#{record.slug.name}'" if record.slug
+    end
+  end
+
+  desc "Regenereate slugs for a model."
+  task :redo_slugs => :environment do
+    FriendlyId::TaskRunner.new.delete_slugs
+    Rake::Task["friendly_id:make_slugs"].invoke
+  end
+
+  desc "Destroy obsolete slugs older than DAYS=45 days."
+  task :remove_old_slugs => :environment do
+    FriendlyId::TaskRunner.new.delete_old_slugs
+  end
+end

data/rails/init.rb

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

data/test/active_record_adapter/ar_test_helper.rb

@@ -0,0 +1,150 @@
+require File.expand_path('../../test_helper', __FILE__)
+require "logger"
+require "active_record"
+begin
+  require "active_support/log_subscriber"
+rescue LoadError
+end
+
+# If you want to see the ActiveRecord log, invoke the tests using `rake test LOG=true`
+ActiveRecord::Base.logger = Logger.new($stdout) if ENV["LOG"]
+
+require "friendly_id/active_record"
+require File.expand_path("../../../generators/friendly_id/templates/create_slugs", __FILE__)
+require File.expand_path("../support/models", __FILE__)
+require File.expand_path('../core', __FILE__)
+require File.expand_path('../slugged', __FILE__)
+
+driver = (ENV["DB"] or "sqlite3").downcase
+db_yaml = File.expand_path("../support/database.#{driver}.yml", __FILE__)
+ActiveRecord::Base.establish_connection(YAML::load(File.open(db_yaml)))
+
+class ActiveRecord::Base
+  def log_protected_attribute_removal(*args) end
+end
+
+ActiveRecord::Base.connection.tables.each do |table|
+  ActiveRecord::Base.connection.drop_table(table)
+end
+ActiveRecord::Migration.verbose = false
+CreateSlugs.up
+CreateSupportModels.up
+
+# A model that uses the automagically configured "cached_slug" column
+class District < ActiveRecord::Base
+  has_friendly_id :name, :use_slug => true
+  before_save :say_hello
+
+  def say_hello
+    @said_hello = true
+  end
+end
+
+# A model with optimistic locking enabled
+class Region < ActiveRecord::Base
+  has_friendly_id :name, :use_slug => true
+  after_create do |obj|
+    other_instance = Region.find obj.id
+    other_instance.update_attributes :note => name + "!"
+  end
+end
+
+# A model that specifies a custom cached slug column
+class City < ActiveRecord::Base
+  has_friendly_id :name, :use_slug => true, :cache_column => "my_slug"
+end
+
+# A model with a custom slug text normalizer
+class Person < ActiveRecord::Base
+  has_friendly_id :name, :use_slug => true
+
+  def normalize_friendly_id(string)
+    string.upcase
+  end
+
+end
+
+# A model that doesn't use FriendlyId
+class Unfriendly < ActiveRecord::Base
+end
+
+# A slugged model that uses a scope
+class Resident < ActiveRecord::Base
+  belongs_to :country
+  has_friendly_id :name, :use_slug => true, :scope => :country
+end
+
+# Like resident, but has a cached slug
+class Tourist < ActiveRecord::Base
+  belongs_to :country
+  has_friendly_id :name, :use_slug => true, :scope => :country
+end
+
+# A slugged model used as a scope
+class Country < ActiveRecord::Base
+  has_many :people
+  has_many :residents
+  has_friendly_id :name, :use_slug => true
+end
+
+# A model that doesn't use slugs
+class User < ActiveRecord::Base
+  has_friendly_id :name
+  has_many :houses
+end
+
+# Another model that doesn"t use slugs
+class Author < ActiveRecord::Base
+  has_friendly_id :name
+end
+
+
+# A model that uses a non-slugged model for its scope
+class House < ActiveRecord::Base
+  belongs_to :user
+  has_friendly_id :name, :use_slug => true, :scope => :user
+end
+
+# A model that uses default slug settings and has a named scope
+class Post < ActiveRecord::Base
+  has_friendly_id :name, :use_slug => true
+  def self.named_scope(*args) scope(*args) end if FriendlyId.on_ar3?
+  named_scope :published, :conditions => { :published => true }
+end
+
+# Model that uses a custom table name
+class Place < ActiveRecord::Base
+  self.table_name = "legacy_table"
+  has_friendly_id :name, :use_slug => true
+end
+
+# A model that uses a datetime field for its friendly_id
+class Event < ActiveRecord::Base
+  has_friendly_id :event_date, :use_slug => true
+end
+
+# A base model for single table inheritence
+class Book < ActiveRecord::Base ; end
+
+# A model that uses STI
+class Novel < ::Book
+  has_friendly_id :name, :use_slug => true
+end
+
+# A model with no table
+class Question < ActiveRecord::Base
+  has_friendly_id :name, :use_slug => true
+end
+
+# A model to test polymorphic associations
+class Site < ActiveRecord::Base
+  belongs_to :owner, :polymorphic => true
+  has_friendly_id :name, :use_slug => true
+end
+
+# A model used as a polymorphic owner
+class Company < ActiveRecord::Base
+  has_many :sites, :as => :owner
+end
+
+puts "Using: #{RUBY_VERSION}, #{driver}, AR#{ENV["AR"] or 3}"

data/test/active_record_adapter/basic_slugged_model_test.rb

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

data/test/active_record_adapter/cached_slug_test.rb

@@ -0,0 +1,76 @@
+require File.expand_path("../ar_test_helper", __FILE__)
+
+module FriendlyId
+  module Test
+    module ActiveRecordAdapter
+
+      class CachedSlugTest < ::Test::Unit::TestCase
+
+        include FriendlyId::Test::Generic
+        include FriendlyId::Test::Slugged
+        include FriendlyId::Test::ActiveRecordAdapter::Slugged
+        include FriendlyId::Test::ActiveRecordAdapter::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
+
+        test "#friendly_id should check the cached value by default" do
+          instance.expects(:slug).never
+          instance.friendly_id
+        end
+
+        test "#friendly_id should skip the cache if invoked with true" do
+          instance.expects(:slug)
+          instance.friendly_id(true)
+        end
+
+        test "should not fire callbacks when updating slug cache" do
+          instance.expects(:say_hello).once
+          instance.update_attributes(:name => "new name")
+          assert_equal instance.slug.to_friendly_id, cached_slug
+        end
+      end
+    end
+  end
+end
+

data/test/active_record_adapter/core.rb

@@ -0,0 +1,138 @@
+require File.expand_path("../ar_test_helper", __FILE__)
+
+module FriendlyId
+
+  module Test
+
+    module ActiveRecordAdapter
+
+      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 unfriendly_class
+          Unfriendly
+        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")
+          third = klass.create!(:name => "third_instance")
+          assert_equal 2, klass.find([instance.friendly_id, second.friendly_id]).size
+        end
+
+        test "failing finds with array of unfriendly_id should raise errors normally" do
+          assert_raise ActiveRecord::RecordNotFound do
+            klass.find([0, -1])
+          end
+        end
+
+        test "instances should be findable by an array of numeric ids" do
+          second = klass.create!(:name => "second_instance")
+          third = klass.create!(:name => "third_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")
+          third = klass.create!(:name => "third_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")
+          third = klass.create!(:name => "third_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")
+          third = klass.create!(:name => "third_instance")
+          assert_equal 2, klass.find([instance.friendly_id, second]).size
+        end
+
+        test "should not raise error when finding with empty array" do
+          assert_nothing_raised do
+            klass.find []
+          end
+        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
+
+        test "should not change failure behavior for models not using friendly_id" do
+          assert_raise ActiveRecord::RecordNotFound do
+            unfriendly_class.find(-1)
+          end
+        end
+
+        test "failing finds with unfriendly_id should raise errors normally" do
+          assert_raise ActiveRecord::RecordNotFound do
+            klass.send(find_method, 0)
+          end
+        end
+
+        test "instances found by a single id should not be read-only" do
+          i = klass.find(instance.friendly_id)
+          assert !i.readonly?, "expected instance not to be readonly"
+        end
+
+        test "instances found by an array of ids should not be read-only" do
+          second = klass.create!(:name => "second_instance")
+          third = klass.create!(:name => "third_instance")
+          klass.find([instance.friendly_id, second.friendly_id]).each do |record|
+            assert !record.readonly?, "expected instance not to be readonly"
+          end
+        end
+      end
+    end
+  end
+end

data/test/active_record_adapter/custom_normalizer_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path("../ar_test_helper", __FILE__)
+
+module FriendlyId
+  module Test
+    module ActiveRecordAdapter
+
+      class CustomNormalizerTest < ::Test::Unit::TestCase
+
+        include FriendlyId::Test::ActiveRecordAdapter::Core
+        include FriendlyId::Test::ActiveRecordAdapter::Slugged
+        include FriendlyId::Test::CustomNormalizer
+
+        def klass
+          Person
+        end
+
+      end
+    end
+  end
+end