friendly_id4 4.0.0.beta4 → 4.0.0.beta5

data/lib/generators/friendly_id_generator.rb

@@ -1,11 +1,14 @@
 require 'rails/generators'
 require 'rails/generators/migration'
 
+# This generator adds a migration for the {FriendlyId::History
+# FriendlyId::History} addon.
 class FriendlyIdGenerator < Rails::Generators::Base
   include Rails::Generators::Migration
 
   source_root File.expand_path('../../friendly_id', __FILE__)
 
+  # Copies the migration template to db/migrate.
   def copy_files(*args)
     migration_template 'migration.rb', 'db/migrate/create_friendly_id_slugs.rb'
   end

data/test/base_test.rb

@@ -28,4 +28,27 @@ class CoreTest < MiniTest::Unit::TestCase
     assert_equal :bar, klass.friendly_id_config.slug_column
   end
 
+  test "the block passed to friendly_id should be evaluated before arguments" do
+    klass = Class.new(ActiveRecord::Base) do
+      extend FriendlyId
+      friendly_id :foo do |config|
+        config.base = :bar
+      end
+    end
+    assert_equal :foo, klass.friendly_id_config.base
+  end
+
+  test "should allow defaults to be set via a block" do
+    begin
+      FriendlyId.defaults do |config|
+        config.base = :foo
+      end
+      klass = Class.new(ActiveRecord::Base) do
+        extend FriendlyId
+      end
+      assert_equal :foo, klass.friendly_id_config.base
+    ensure
+      FriendlyId.instance_variable_set :@defaults, nil
+    end
+  end
 end

data/test/configuration_test.rb

@@ -5,22 +5,22 @@ class ConfigurationTest < MiniTest::Unit::TestCase
   include FriendlyId::Test
 
   def setup
-    @klass = Class.new(ActiveRecord::Base)
+    @model_class = Class.new(ActiveRecord::Base)
   end
 
-  test "should set klass on initialization" do
-    config = FriendlyId::Configuration.new @klass
-    assert_equal @klass, config.klass
+  test "should set model class on initialization" do
+    config = FriendlyId::Configuration.new @model_class
+    assert_equal @model_class, config.model_class
   end
 
   test "should set options on initialization if present" do
-    config = FriendlyId::Configuration.new @klass, :base => "hello"
+    config = FriendlyId::Configuration.new @model_class, :base => "hello"
     assert_equal "hello", config.base
   end
 
   test "should raise error if passed unrecognized option" do
     assert_raises NoMethodError do
-      FriendlyId::Configuration.new @klass, :foo => "bar"
+      FriendlyId::Configuration.new @model_class, :foo => "bar"
     end
   end
 

data/test/core_test.rb

@@ -12,7 +12,7 @@ class CoreTest < MiniTest::Unit::TestCase
   include FriendlyId::Test
   include FriendlyId::Test::Shared
 
-  def klass
+  def model_class
     Author
   end
 
@@ -21,18 +21,10 @@ class CoreTest < MiniTest::Unit::TestCase
   end
 
   test "model classes should have a friendly id config" do
-    assert klass.friendly_id(:name).friendly_id_config
-  end
-
-  test "should reserve 'new' and 'edit' by default" do
-    ["new", "edit"].each do |word|
-      transaction do
-        assert_raises(ActiveRecord::RecordInvalid) {klass.create! :name => word}
-      end
-    end
+    assert model_class.friendly_id(:name).friendly_id_config
   end
 
   test "instances should have a friendly id" do
-    with_instance_of(klass) {|record| assert record.friendly_id}
+    with_instance_of(model_class) {|record| assert record.friendly_id}
   end
 end

data/test/helper.rb

@@ -37,9 +37,9 @@ module FriendlyId
     end
 
     def with_instance_of(*args)
-      klass = args.shift
+      model_class = args.shift
       args[0] ||= {:name => "a"}
-      transaction { yield klass.create!(*args) }
+      transaction { yield model_class.create!(*args) }
     end
 
     module Database

data/test/history_test.rb

@@ -10,16 +10,16 @@ class HistoryTest < MiniTest::Unit::TestCase
   include FriendlyId::Test
   include FriendlyId::Test::Shared
 
-  def klass
+  def model_class
     Manual
   end
 
   test "should insert record in slugs table on create" do
-    with_instance_of(klass) {|record| assert !record.friendly_id_slugs.empty?}
+    with_instance_of(model_class) {|record| assert !record.friendly_id_slugs.empty?}
   end
 
   test "should not create new slug record if friendly_id is not changed" do
-    with_instance_of(klass) do |record|
+    with_instance_of(model_class) do |record|
       record.active = true
       record.save!
       assert_equal 1, FriendlyIdSlug.count
@@ -27,7 +27,7 @@ class HistoryTest < MiniTest::Unit::TestCase
   end
 
   test "should create new slug record when friendly_id changes" do
-    with_instance_of(klass) do |record|
+    with_instance_of(model_class) do |record|
       record.name = record.name + "b"
       record.save!
       assert_equal 2, FriendlyIdSlug.count
@@ -35,20 +35,20 @@ class HistoryTest < MiniTest::Unit::TestCase
   end
 
   test "should be findable by old slugs" do
-    with_instance_of(klass) do |record|
+    with_instance_of(model_class) do |record|
       old_friendly_id = record.friendly_id
       record.name = record.name + "b"
       record.save!
-      assert found = klass.find_by_friendly_id(old_friendly_id)
+      assert found = model_class.find_by_friendly_id(old_friendly_id)
       assert !found.readonly?
     end
   end
 
   test "should raise error if used with scoped" do
-    klass = Class.new(ActiveRecord::Base)
-    klass.extend FriendlyId
+    model_class = Class.new(ActiveRecord::Base)
+    model_class.extend FriendlyId
     assert_raises RuntimeError do
-      klass.friendly_id :name, :use => [:history, :scoped]
+      model_class.friendly_id :name, :use => [:history, :scoped]
     end
   end
 

data/test/object_utils_test.rb

@@ -19,8 +19,8 @@ class ObjectUtilsTest < MiniTest::Unit::TestCase
   end
 
   test "ActiveRecord::Base instances should be unfriendly_ids" do
-    klass = Class.new(ActiveRecord::Base)
-    klass.table_name = "authors"
-    assert klass.new.unfriendly_id?
+    model_class = Class.new(ActiveRecord::Base)
+    model_class.table_name = "authors"
+    assert model_class.new.unfriendly_id?
   end
 end

data/test/reserved_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path("../helper.rb", __FILE__)
+
+class ReservedTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+
+  class Journalist < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :name
+  end
+
+
+  def model_class
+    Journalist
+  end
+
+  test "should reserve 'new' and 'edit' by default" do
+    ["new", "edit"].each do |word|
+      transaction do
+        assert_raises(ActiveRecord::RecordInvalid) {model_class.create! :name => word}
+      end
+    end
+  end
+end
+
+

data/test/scoped_test.rb

@@ -16,7 +16,7 @@ class ScopedTest < MiniTest::Unit::TestCase
   include FriendlyId::Test
   include FriendlyId::Test::Shared
 
-  def klass
+  def model_class
     Novel
   end
 
@@ -25,10 +25,10 @@ class ScopedTest < MiniTest::Unit::TestCase
   end
 
   test "should detect scope column from explicit column name" do
-    klass = Class.new(ActiveRecord::Base)
-    klass.extend FriendlyId
-    klass.friendly_id :empty, :use => :scoped, :scope => :dummy
-    assert_equal "dummy", klass.friendly_id_config.scope_column
+    model_class = Class.new(ActiveRecord::Base)
+    model_class.extend FriendlyId
+    model_class.friendly_id :empty, :use => :scoped, :scope => :dummy
+    assert_equal "dummy", model_class.friendly_id_config.scope_column
   end
 
   test "should allow duplicate slugs outside scope" do
@@ -48,10 +48,10 @@ class ScopedTest < MiniTest::Unit::TestCase
   end
 
   test "should raise error if used with history" do
-    klass = Class.new(ActiveRecord::Base)
-    klass.extend FriendlyId
+    model_class = Class.new(ActiveRecord::Base)
+    model_class.extend FriendlyId
     assert_raises RuntimeError do
-      klass.friendly_id :name, :use => [:scoped, :history]
+      model_class.friendly_id :name, :use => [:scoped, :history]
     end
   end
 end

data/test/shared.rb

@@ -3,69 +3,69 @@ module FriendlyId
     module Shared
 
       test "finds should respect conditions" do
-        with_instance_of(klass) do |record|
+        with_instance_of(model_class) do |record|
           assert_raises(ActiveRecord::RecordNotFound) do
-            klass.where("1 = 2").find record.friendly_id
+            model_class.where("1 = 2").find record.friendly_id
           end
         end
       end
 
       test "should be findable by friendly id" do
-        with_instance_of(klass) {|record| assert klass.find record.friendly_id}
+        with_instance_of(model_class) {|record| assert model_class.find record.friendly_id}
       end
 
       test "should be findable by id as integer" do
-        with_instance_of(klass) {|record| assert klass.find record.id.to_i}
+        with_instance_of(model_class) {|record| assert model_class.find record.id.to_i}
       end
 
       test "should be findable by id as string" do
-        with_instance_of(klass) {|record| assert klass.find record.id.to_s}
+        with_instance_of(model_class) {|record| assert model_class.find record.id.to_s}
       end
 
       test "should be findable by numeric friendly_id" do
-        with_instance_of(klass, :name => "206") {|record| assert klass.find record.friendly_id}
+        with_instance_of(model_class, :name => "206") {|record| assert model_class.find record.friendly_id}
       end
 
       test "to_param should return the friendly_id" do
-        with_instance_of(klass) {|record| assert_equal record.friendly_id, record.to_param}
+        with_instance_of(model_class) {|record| assert_equal record.friendly_id, record.to_param}
       end
 
       test "should be findable by themselves" do
-        with_instance_of(klass) {|record| assert_equal record, klass.find(record)}
+        with_instance_of(model_class) {|record| assert_equal record, model_class.find(record)}
       end
 
       test "updating record's other values should not change the friendly_id" do
-        with_instance_of klass do |record|
+        with_instance_of model_class do |record|
           old = record.friendly_id
           record.update_attributes! :active => false
-          assert klass.find old
+          assert model_class.find old
         end
       end
 
       test "instances found by a single id should not be read-only" do
-        with_instance_of(klass) {|record| assert !klass.find(record.friendly_id).readonly?}
+        with_instance_of(model_class) {|record| assert !model_class.find(record.friendly_id).readonly?}
       end
 
       test "failing finds with unfriendly_id should raise errors normally" do
-        assert_raises(ActiveRecord::RecordNotFound) {klass.find 0}
+        assert_raises(ActiveRecord::RecordNotFound) {model_class.find 0}
       end
 
       test "should return numeric id if the friendly_id is nil" do
-        with_instance_of(klass) do |record|
+        with_instance_of(model_class) do |record|
           record.expects(:friendly_id).returns(nil)
           assert_equal record.id.to_s, record.to_param
         end
       end
 
       test "should return numeric id if the friendly_id is an empty string" do
-        with_instance_of(klass) do |record|
+        with_instance_of(model_class) do |record|
           record.expects(:friendly_id).returns("")
           assert_equal record.id.to_s, record.to_param
         end
       end
 
       test "should return numeric id if the friendly_id is blank" do
-        with_instance_of(klass) do |record|
+        with_instance_of(model_class) do |record|
           record.expects(:friendly_id).returns("  ")
           assert_equal record.id.to_s, record.to_param
         end

data/test/slugged_test.rb

@@ -12,16 +12,16 @@ class SluggedTest < MiniTest::Unit::TestCase
   include FriendlyId::Test
   include FriendlyId::Test::Shared
 
-  def klass
+  def model_class
     Journalist
   end
 
   test "configuration should have a sequence_separator" do
-    assert !klass.friendly_id_config.sequence_separator.empty?
+    assert !model_class.friendly_id_config.sequence_separator.empty?
   end
 
   test "should make a new slug if the friendly_id method value has changed" do
-    with_instance_of klass do |record|
+    with_instance_of model_class do |record|
       record.name = "Changed Value"
       record.save!
       assert_equal "changed-value", record.slug
@@ -29,21 +29,31 @@ class SluggedTest < MiniTest::Unit::TestCase
   end
 
   test "should increment the slug sequence for duplicate friendly ids" do
-    with_instance_of klass do |record|
-      record2 = klass.create! :name => record.name
+    with_instance_of model_class do |record|
+      record2 = model_class.create! :name => record.name
       assert record2.friendly_id.match(/2\z/)
     end
   end
 
   test "should not add slug sequence on update after other conflicting slugs were added" do
-    with_instance_of klass do |record|
+    with_instance_of model_class do |record|
       old = record.friendly_id
-      record2 = klass.create! :name => record.name
+      record2 = model_class.create! :name => record.name
       record.save!
       record.reload
       assert_equal old, record.to_param
     end
   end
+
+  test "should not increment sequence on save" do
+    with_instance_of model_class do |record|
+      record2 = model_class.create! :name => record.name
+      record2.active = !record2.active
+      record2.save!
+      assert record2.friendly_id.match(/2\z/)
+    end
+  end
+
 end
 
 class SlugSequencerTest < MiniTest::Unit::TestCase
@@ -51,12 +61,12 @@ class SlugSequencerTest < MiniTest::Unit::TestCase
   include FriendlyId::Test
 
   test "should quote column names" do
-    klass            = Class.new(ActiveRecord::Base)
-    klass.table_name = "journalists"
-    klass.extend FriendlyId
-    klass.friendly_id :name, :use => :slugged, :slug_column => "strange name"
+    model_class            = Class.new(ActiveRecord::Base)
+    model_class.table_name = "journalists"
+    model_class.extend FriendlyId
+    model_class.friendly_id :name, :use => :slugged, :slug_column => "strange name"
     begin
-      with_instance_of(klass) {|record| assert klass.find(record.friendly_id)}
+      with_instance_of(model_class) {|record| assert model_class.find(record.friendly_id)}
     rescue ActiveRecord::StatementInvalid
       flunk "column name was not quoted"
     end
@@ -72,20 +82,20 @@ class SlugSeparatorTest < MiniTest::Unit::TestCase
     friendly_id :name, :use => :slugged, :sequence_separator => ":"
   end
 
-  def klass
+  def model_class
     Journalist
   end
 
   test "should increment sequence with configured sequence separator" do
-    with_instance_of klass do |record|
-      record2 = klass.create! :name => record.name
+    with_instance_of model_class do |record|
+      record2 = model_class.create! :name => record.name
       assert record2.friendly_id.match(/:2\z/)
     end
   end
 
   test "should detect when a sequenced slug has changed" do
-    with_instance_of klass do |record|
-      record2 = klass.create! :name => record.name
+    with_instance_of model_class do |record|
+      record2 = model_class.create! :name => record.name
       assert !record2.slug_sequencer.slug_changed?
       record2.name = "hello world"
       assert record2.slug_sequencer.slug_changed?
@@ -96,14 +106,14 @@ end
 class SluggedRegressionsTest < MiniTest::Unit::TestCase
   include FriendlyId::Test
 
-  def klass
+  def model_class
     Journalist
   end
 
   test "should increment the slug sequence for duplicate friendly ids beyond 10" do
-    with_instance_of klass do |record|
+    with_instance_of model_class do |record|
       (2..12).each do |i|
-        r = klass.create! :name => record.name
+        r = model_class.create! :name => record.name
         assert r.friendly_id.match(/#{i}\z/)
       end
     end