friendly_id4 4.0.0.pre → 4.0.0.pre3

data/lib/friendly_id/finder_methods.rb

@@ -0,0 +1,14 @@
+module FriendlyId
+  # These methods will override the finder methods in ActiveRecord::Relation.
+  module FinderMethods
+
+    protected
+
+    def find_one(id)
+      return super if !@klass.uses_friendly_id? or id.unfriendly_id?
+      where(@klass.friendly_id_config.query_field => id).first or super
+    end
+  end
+end
+
+ActiveRecord::Relation.send :include, FriendlyId::FinderMethods

data/lib/friendly_id/history.rb

@@ -0,0 +1,29 @@
+module FriendlyId
+  module History
+
+    def self.included(base)
+      base.class_eval do
+        include Slugged unless include? Slugged
+        extend  Finder
+        has_many :friendly_id_slugs, :as => :sluggable, :dependent => :destroy
+        before_save :build_friendly_id_slug, :if => lambda {|r| r.slug_sequencer.slug_changed?}
+      end
+    end
+
+    private
+
+    def build_friendly_id_slug
+      self.friendly_id_slugs.build :slug => friendly_id
+    end
+  end
+
+  module Finder
+    def find_by_friendly_id(*args)
+      where("friendly_id_slugs.slug = ?", args.shift).includes(:friendly_id_slugs).first(*args)
+    end
+  end
+end
+
+class FriendlyIdSlug < ActiveRecord::Base
+  belongs_to :sluggable, :polymorphic => true
+end

data/lib/friendly_id/migration.rb

@@ -0,0 +1,17 @@
+class CreateFriendlyIdSlugs < ActiveRecord::Migration
+  def self.up
+    create_table :friendly_id_slugs do |t|
+      t.string   :slug,           :null => false
+      t.integer  :sluggable_id,   :null => false
+      t.string   :sluggable_type, :limit => 40
+      t.datetime :created_at
+    end
+    add_index :friendly_id_slugs, :sluggable_id
+    add_index :friendly_id_slugs, [:slug, :sluggable_type], :unique => true
+    add_index :friendly_id_slugs, :sluggable_type
+  end
+
+  def self.down
+    drop_table :slugs
+  end
+end

data/lib/friendly_id/model.rb

@@ -0,0 +1,22 @@
+module FriendlyId
+  # Instance methods that will be added to all classes using FriendlyId.
+  module Model
+
+    attr_reader :current_friendly_id
+
+    # Convenience method for accessing the class method of the same name.
+    def friendly_id_config
+      self.class.friendly_id_config
+    end
+
+    # Get the instance's friendly_id.
+    def friendly_id
+      send friendly_id_config.query_field
+    end
+
+    # Either the friendly_id, or the numeric id cast to a string.
+    def to_param
+      (friendly_id or id).to_s
+    end
+  end
+end

data/lib/friendly_id/object_utils.rb

@@ -0,0 +1,27 @@
+module FriendlyId
+  # Utility methods that are in Object because it's impossible to predict what
+  # kinds of objects get passed into FinderMethods#find_one and
+  # Model#normalize_friendly_id.
+  module ObjectUtils
+
+    # True is the id is definitely friendly, false if definitely unfriendly,
+    # else nil.
+    def friendly_id?
+      if kind_of?(Integer) or kind_of?(Symbol) or self.class.respond_to? :friendly_id_config
+        false
+      elsif to_i.to_s != to_s
+        true
+      end
+    end
+
+    # True if the id is definitely unfriendly, false if definitely friendly,
+    # else nil.
+    def unfriendly_id?
+      val = friendly_id? ; !val unless val.nil?
+    end
+  end
+end
+
+class Object
+  include FriendlyId::ObjectUtils
+end

data/lib/friendly_id/scoped.rb

@@ -2,7 +2,18 @@ require "friendly_id/slugged"
 
 module FriendlyId
 
-  # This module adds scopes to in-table slugs.
+  # This module adds scopes to in-table slugs. It's not loaded by default,
+  # so in order to active this feature you must include the module in your
+  # class.
+  #
+  # You can scope by an explicit column, or by a `belongs_to` relation.
+  #
+  # @example
+  #   class Restaurant < ActiveRecord::Base
+  #     belongs_to :city
+  #     include FriendlyId::Scoped
+  #     has_friendly_id :name, :scope => :city
+  #   end
   module Scoped
     def self.included(klass)
       klass.send :include, Slugged unless klass.include? Slugged
@@ -10,8 +21,12 @@ module FriendlyId
   end
 
   class SlugSequencer
+    private
+
     alias conflict_without_scope conflict
 
+    # Checks for naming conflicts, taking scopes into account.
+    # @return ActiveRecord::Base
     def conflict_with_scope
       column = friendly_id_config.scope_column
       conflicts.where("#{column} = ?", sluggable.send(column)).first
@@ -25,8 +40,15 @@ module FriendlyId
   class Configuration
     attr_accessor :scope
 
+    # Gets the scope column.
+    #
+    # Checks to see if the +:scope+ option passed to {#has_friendly_id}
+    # refers to a relation, and if so, returns the realtion's foreign key.
+    # Otherwise it assumes the option value was the name of column and returns
+    # it cast to a String.
+    # @return String The scope column
     def scope_column
-      klass.reflections[@scope].try(:association_foreign_key) || @scope.to_s
+      (klass.reflections[@scope].try(:association_foreign_key) || @scope).to_s
     end
   end
 end

data/lib/friendly_id/slug_sequencer.rb

@@ -0,0 +1,79 @@
+module FriendlyId
+  # This class offers functionality to check slug strings for uniqueness and,
+  # if necessary, append a sequence to ensure it.
+  class SlugSequencer
+    attr_reader :sluggable
+
+    def initialize(sluggable)
+      @sluggable = sluggable
+    end
+
+    def next
+      sequence = conflict.slug.split(separator)[1].to_i
+      next_sequence = sequence == 0 ? 2 : sequence.next
+      "#{normalized}#{separator}#{next_sequence}"
+    end
+
+    def generate
+      if slug_changed? or new_record?
+        conflict? ? self.next : normalized
+      else
+        sluggable.friendly_id
+      end
+    end
+
+    def slug_changed?
+      base != sluggable.current_friendly_id.try(:sub, /--[\d]*\z/, '')
+    end
+
+    private
+
+    def base
+      sluggable.send friendly_id_config.base
+    end
+
+    def column
+      friendly_id_config.query_field
+    end
+
+    def conflict?
+      !! conflict
+    end
+
+    def conflict
+      unless defined? @conflict
+        @conflict = conflicts.first
+      end
+      @conflict
+    end
+
+    # @NOTE AR-specific code here
+    def conflicts
+      pkey  = sluggable.class.arel_table.primary_key.name
+      value = sluggable.send pkey
+      scope = sluggable.class.where("#{column} = ? OR #{column} LIKE ?", normalized, wildcard)
+      scope = scope.where("#{pkey} <> ?", value) unless sluggable.new_record?
+      scope = scope.order("#{column} DESC")
+    end
+
+    def friendly_id_config
+      sluggable.friendly_id_config
+    end
+
+    def new_record?
+      sluggable.new_record?
+    end
+
+    def normalized
+      @normalized ||= sluggable.normalize_friendly_id(base)
+    end
+
+    def separator
+      friendly_id_config.sequence_separator
+    end
+
+    def wildcard
+      "#{normalized}#{separator}%"
+    end
+  end
+end

data/lib/friendly_id/slugged.rb

@@ -1,3 +1,5 @@
+require "friendly_id/slug_sequencer"
+
 module FriendlyId
 
   # This module adds in-table slugs to an ActiveRecord model.
@@ -14,10 +16,14 @@ module FriendlyId
       value.to_s.parameterize
     end
 
+    def slug_sequencer
+      SlugSequencer.new(self)
+    end
+
     private
 
     def set_slug
-      send "#{friendly_id_config.slug_column}=", SlugSequencer.new(self).to_s
+      send "#{friendly_id_config.slug_column}=", slug_sequencer.generate
     end
   end
 
@@ -27,101 +33,22 @@ module FriendlyId
     DEFAULTS[:slug_column]        = 'slug'
     DEFAULTS[:sequence_separator] = '--'
 
+    undef query_field
+
     def query_field
       use_slugs? ? slug_column : base
     end
 
     def sequence_separator
-      @sequence_separator || DEFAULTS[:sequence_separator]
+      @sequence_separator ||= DEFAULTS[:sequence_separator]
     end
 
     def slug_column
-      @slug_column || DEFAULTS[:slug_column]
+      @slug_column ||= DEFAULTS[:slug_column]
     end
 
     def use_slugs?
       @use_slugs
     end
   end
-
-  # This class offers functionality to check slug strings for uniqueness and,
-  # if necessary, append a sequence to ensure it.
-  class SlugSequencer
-    attr_reader :sluggable
-
-    def initialize(sluggable)
-      @sluggable = sluggable
-    end
-
-    def base
-      sluggable.send friendly_id_config.base
-    end
-
-    def changed?
-      base != current_friendly_id.try(:sub, /--[\d]*\z/, '')
-    end
-
-    def column
-      friendly_id_config.query_field
-    end
-
-    def conflict?
-      !! conflict
-    end
-
-    def conflict
-      unless defined? @conflict
-        @conflict = conflicts.first
-      end
-      @conflict
-    end
-
-    # @NOTE AR-specific code here
-    def conflicts
-      pkey  = sluggable.class.arel_table.primary_key.name
-      value = sluggable.send pkey
-      scope = sluggable.class.where("#{column} = ? OR #{column} LIKE ?", normalized, wildcard)
-      scope = scope.where("#{pkey} <> ?", value) unless sluggable.new_record?
-      scope = scope.order("#{column} DESC")
-    end
-
-    def current_friendly_id
-      sluggable.instance_variable_get(:@_current_friendly_id)
-    end
-
-    def friendly_id_config
-      sluggable.friendly_id_config
-    end
-
-    def new_record?
-      sluggable.new_record?
-    end
-
-    def normalized
-      @normalized ||= sluggable.normalize_friendly_id(base)
-    end
-
-    def separator
-      friendly_id_config.sequence_separator
-    end
-
-    def next
-      sequence = conflict.slug.split(separator)[1].to_i
-      next_sequence = sequence == 0 ? 2 : sequence.next
-      "#{normalized}#{separator}#{next_sequence}"
-    end
-
-    def to_s
-      if changed? or new_record?
-        conflict? ? self.next : normalized
-      else
-        sluggable.friendly_id
-      end
-    end
-
-    def wildcard
-      "#{normalized}#{separator}%"
-    end
-  end
-
 end

data/lib/friendly_id/version.rb

@@ -3,7 +3,7 @@ module FriendlyId
     MAJOR = 4
     MINOR = 0
     TINY  = 0
-    BUILD = 'pre'
+    BUILD = 'pre3'
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end
 end

data/lib/generators/friendly_id_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class FriendlyIdGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+
+  source_root File.expand_path('../../friendly_id', __FILE__)
+
+  def copy_files(*args)
+    migration_template 'migration.rb', 'db/migrate/create_friendly_id_slugs.rb'
+  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/test/core_test.rb

@@ -1,68 +1,35 @@
-require File.expand_path("../test_helper", __FILE__)
+require File.expand_path("../helper.rb", __FILE__)
 
-class ModelTest < Test::Unit::TestCase
+setup { Class.new ActiveRecord::Base }
 
-  include FriendlyId::Test::Generic
-
-  def instance(name = "user")
-    @instance ||= klass.create!(:name => name)
-  end
-
-  # @TODO - this kind of setup is repeated in a few places and should probably
-  # be abstracted.
-  def klass
-    @@klass ||= make_model("core", :name) do |t|
-      t.string  :name,   :unique  => true
-      t.boolean :active, :default => true
-    end
-    @@klass
-  end
-
-  def other_class
-    @@other_class ||= make_model("core_two", :name) do |t|
-      t.string  :name,   :unique  => true
-      t.boolean :active, :default => true
-    end
-  end
-
-  def setup
-    klass.stubs(:name).returns("Cores")
-    other_class.stubs(:name).returns("CoreTwos")
-  end
-
-  test "models don't use friendly_id by default" do
-    assert !Class.new(ActiveRecord::Base).uses_friendly_id?
-  end
+test "models don't use friendly_id by default" do |klass|
+  assert !klass.uses_friendly_id?
+end
 
-  test "integers should be unfriendly ids" do
-    assert 1.unfriendly_id?
-  end
+test "model classes should have a friendly id config" do |klass|
+  assert klass.has_friendly_id(:name).friendly_id_config
+end
 
-  test "ActiveRecord::Base instances should be unfriendly_ids" do
-    assert klass.new.unfriendly_id?
+test "should raise error when bad config options are set" do |klass|
+  assert_raise ArgumentError do
+    klass.has_friendly_id :name, :garbage => :in
   end
+end
 
-  test "numeric strings are neither friendly nor unfriendly" do
-    assert_equal nil, "1".friendly_id?
-    assert_equal nil, "1".unfriendly_id?
-  end
+[User, Book].map {|klass| klass.has_friendly_id :name}
 
-  test "strings with letters are friendly_ids" do
-    assert "a".friendly_id?
-  end
+setup {User}
 
-  test "should raise error when bad config options are set" do
-    assert_raises ArgumentError do
-      klass.has_friendly_id :smeg, :garbage => :in
-    end
-  end
-
-  test "reserves 'new' and 'edit' by default" do
-    FriendlyId::Configuration::DEFAULTS[:reserved_words].each do |word|
-      assert_raises ActiveRecord::RecordInvalid do
-        klass.create! :name => word
-      end
+test "should reserve 'new' and 'edit' by default" do |klass|
+  ["new", "edit"].each do |word|
+    transaction do
+      assert_raise(ActiveRecord::RecordInvalid) {klass.create! :name => word}
     end
   end
+end
 
+test "instances should have a friendly id" do |klass|
+  with_instance_of(klass) {|record| assert record.friendly_id}
 end
+
+require File.expand_path("../shared.rb", __FILE__)