friendly_id 3.3.3.0 → 4.0.0.beta7

data/lib/friendly_id/active_record_adapter/relation.rb

@@ -124,8 +124,8 @@ module FriendlyId
           if result.size == expected_size
             result
           else
-            conditions = arel.where_sql
-            conditions = " [#{conditions}]" if conditions
+            conditions = arel.send(:where_clauses).join(', ')
+            conditions = " [WHERE #{conditions}]" if conditions.present?
             error = "Couldn't find all #{klass.name.pluralize} with IDs "
             error << "(#{ids.join(", ")})#{conditions} (found #{result.size} results, but was looking for #{expected_size})"
             raise ActiveRecord::RecordNotFound, error
@@ -141,6 +141,14 @@ module FriendlyId
         end
       end
 
+      def apply_finder_options(options)
+        if options[:scope]
+          raise "The :scope finder option has been removed from FriendlyId 3.2.0 " +
+            "https://github.com/norman/friendly_id/issues#issue/88"
+        end
+        super
+      end
+
       protected
 
       def find_one(id)

data/lib/friendly_id/active_record_adapter/slugged_model.rb

@@ -4,19 +4,13 @@ module FriendlyId
 
       def self.included(base)
         base.class_eval do
-          has_one :slug, :order => 'id DESC', :as => :sluggable, :dependent => :nullify
           has_many :slugs, :order => 'id DESC', :as => :sluggable, :dependent => :destroy
+          has_one :slug, :order => 'id DESC', :as => :sluggable, :dependent => :nullify
           before_save :build_a_slug
           after_save :set_slug_cache
           after_update :update_scope
           after_update :update_dependent_scopes
           protect_friendly_id_attributes
-
-          def slug_with_rails_3_2_patch
-            slug_without_rails_3_2_patch || slugs.first
-          end
-
-          alias_method_chain :slug, :rails_3_2_patch
         end
       end
 
@@ -80,7 +74,7 @@ module FriendlyId
           slug.scope = send(friendly_id_config.scope).to_param
           similar = Slug.similar_to(slug)
           if !similar.empty?
-            slug.sequence = similar.last.sequence.succ
+            slug.sequence = similar.first.sequence.succ
           end
           slug.save!
         end
@@ -104,7 +98,7 @@ module FriendlyId
       end
 
       # This method was removed in ActiveRecord 3.0.
-      if !::ActiveRecord::Base.private_method_defined? :update_without_callbacks
+      if !ActiveRecord::Base.private_method_defined? :update_without_callbacks
         def update_without_callbacks
           attributes_with_values = arel_attributes_values(false, false, attribute_names)
           return false if attributes_with_values.empty?

data/lib/friendly_id/base.rb

@@ -0,0 +1,132 @@
+module FriendlyId
+  # Class methods that will be added to model classes that extend {FriendlyId}.
+  module Base
+
+    # Configure FriendlyId's behavior in a model.
+    #
+    #   class Post < ActiveRecord::Base
+    #     extend FriendlyId
+    #     friendly_id :title, :use => :slugged
+    #   end
+    #
+    # When given the optional block, this method will yield the class's instance
+    # of {FriendlyId::Configuration} to the block before evaluating other
+    # arguments, so configuration values set in the block may be overwritten by
+    # the arguments. This order was chosen to allow passing the same proc to
+    # multiple models, while being able to override the values it sets. Here is
+    # a contrived example:
+    #
+    #   $friendly_id_config_proc = Proc.new do |config|
+    #     config.base = :name
+    #     config.use :slugged
+    #   end
+    #
+    #   class Foo < ActiveRecord::Base
+    #     extend FriendlyId
+    #     friendly_id &$friendly_id_config_proc
+    #   end
+    #
+    #   class Bar < ActiveRecord::Base
+    #     extend FriendlyId
+    #     friendly_id :title, &$friendly_id_config_proc
+    #   end
+    #
+    # However, it's usually better to use {FriendlyId.defaults} for this:
+    #
+    #   FriendlyId.defaults do |config|
+    #     config.base = :name
+    #     config.use :slugged
+    #   end
+    #
+    #   class Foo < ActiveRecord::Base
+    #     extend FriendlyId
+    #   end
+    #
+    #   class Bar < ActiveRecord::Base
+    #     extend FriendlyId
+    #     friendly_id :title
+    #   end
+    #
+    # In general you should use the block syntax either because of your personal
+    # aesthetic preference, or because you need to share some functionality
+    # between multiple models that can't be well encapsulated by
+    # {FriendlyId.defaults}.
+    #
+    # === Order Method Calls in a Block vs Ordering Options
+    #
+    # When calling this method without a block, you may set the hash options in
+    # any order.
+    #
+    # However, when using block-style invocation, be sure to call
+    # FriendlyId::Configuration's {FriendlyId::Configuration#use use} method
+    # *prior* to the associated configuration options, because it will include
+    # modules into your class, and these modules in turn may add required
+    # configuration options to the +@friendly_id_configuraton+'s class:
+    #
+    #   class Person < ActiveRecord::Base
+    #     friendly_id do |config|
+    #       # This will work
+    #       config.use :slugged
+    #       config.sequence_separator = ":"
+    #     end
+    #   end
+    #
+    #   class Person < ActiveRecord::Base
+    #     friendly_id do |config|
+    #       # This will fail
+    #       config.sequence_separator = ":"
+    #       config.use :slugged
+    #     end
+    #   end
+    #
+    # @option options [Symbol] :use The name of an addon to use. By default,
+    #   FriendlyId provides {FriendlyId::Slugged :slugged},
+    #   {FriendlyId::History :history}, {FriendlyId::Reserved :reserved}, and
+    #   {FriendlyId::Scoped :scoped}.
+    #
+    # @option options [Array] :reserved_words Available when using +:reserved+,
+    #   which is loaded by default. Sets an array of words banned for use as
+    #   the basis of a friendly_id. By default this includes "edit" and "new".
+    #
+    # @option options [Symbol] :scope Available when using +:scoped+.
+    #   Sets the relation or column used to scope generated friendly ids. This
+    #   option has no default value.
+    #
+    # @option options [Symbol] :sequence_separator Available when using +:slugged+.
+    #   Configures the sequence of characters used to separate a slug from a
+    #   sequence. Defaults to +--+.
+    #
+    # @option options [Symbol] :slug_column Available when using +:slugged+.
+    #   Configures the name of the column where FriendlyId will store the slug.
+    #   Defaults to +:slug+.
+    #
+    # @option options [Symbol] :slug_sequencer_class Available when using +:slugged+.
+    #   Sets the class used to generate unique slugs. You should not specify this
+    #   unless you're doing some extensive hacking on FriendlyId. Defaults to
+    #   {FriendlyId::SlugSequencer}.
+    #
+    # @yield Provides access to the model class's friendly_id_config, which
+    #   allows an alternate configuration syntax, and conditional configuration
+    #   logic.
+    #
+    # @yieldparam config The model class's {FriendlyId::Configuration friendly_id_config}.
+    def friendly_id(base = nil, options = {}, &block)
+      yield @friendly_id_config if block_given?
+      @friendly_id_config.use options.delete :use
+      @friendly_id_config.send :set, base ? options.merge(:base => base) : options
+      before_save {|rec| rec.instance_eval {@current_friendly_id = friendly_id}}
+      include Model
+    end
+
+    # Returns the model class's {FriendlyId::Configuration friendly_id_config}.
+    # @note In the case of Single Table Inheritance (STI), this method will
+    #   duplicate the parent class's FriendlyId::Configuration instance on first
+    #   access. If you're concerned about thread safety, then be sure to invoke
+    #   {#friendly_id} in your class for each model.
+    def friendly_id_config
+      @friendly_id_config or begin
+       @friendly_id_config = base_class.friendly_id_config.dup
+      end
+    end
+  end
+end

data/lib/friendly_id/configuration.rb

@@ -1,166 +1,79 @@
 module FriendlyId
-
-  # This class is not intended to be used on its own, it is used internally
-  # by `has_friendly_id` to store a model's configuration and
-  # configuration-related methods.
-  #
-  # The arguments accepted by +has_friendly_id+ correspond to the writeable
-  # instance attributes of this class; please see the description of the
-  # attributes below for information on the possible options.
-  #
-  # @example
-  #   has_friendly_id :name,
-  #    :use_slug => true,
-  #    :max_length => 150,
-  #    :approximate_ascii => true,
-  #    :ascii_approximation_options => :german,
-  #    :sequence_separator => ":",
-  #    :reserved_words => ["reserved", "words"],
-  #    :scope => :country,
-  #    :cache_column => :my_cache_column_name
-  #    # etc.
+  # The configuration paramters passed to +friendly_id+ will be stored in
+  # this object.
   class Configuration
 
-    DEFAULTS = {
-      :allow_nil                   => false,
-      :ascii_approximation_options => [],
-      :max_length                  => 255,
-      :reserved_words              => ["index", "new"],
-      :reserved_message            => 'can not be "%s"',
-      :sequence_separator          => "--"
-    }
-
-    # Whether to allow friendly_id and/or slugs to be nil. If this is true then blank
-    # slugs will automatically be converted to nil, allowing for item names that lack
-    # sluggable characters.
-    attr_accessor :allow_nil
-    alias :allow_nil? :allow_nil
-
-    # Strip diacritics from Western characters.
-    attr_accessor :approximate_ascii
-
-    # Locale-type options for ASCII approximations.
-    attr_accessor :ascii_approximation_options
-
-    # The class that's using the configuration.
-    attr_reader :configured_class
-
-    # The maximum allowed byte length for a friendly_id string. This is checked *after* a
-    # string is processed by FriendlyId to remove spaces, special characters, etc.
-    attr_accessor :max_length
-
-    # The method or column that will be used as the basis of the friendly_id string.
-    attr_reader :method
-    alias :column :method
-
-    # The message shown when a reserved word is used.
-    # @see #reserved_words
-    attr_accessor :reserved_message
-
-    # Array of words that are reserved and can't be used as friendly_id strings.
-    # If a listed word is used in a sluggable model, it will raise a
-    # FriendlyId::SlugGenerationError. For Rails applications, you are recommended
-    # to include "index" and "new", which used as the defaults unless overridden.
-    attr_accessor :reserved_words
-
-    # The method or relation to use as the friendly_id's scope.
-    attr_reader :scope
-
-    # The string that separates slug names from slug sequences. Defaults to "--".
-    attr_accessor :sequence_separator
-
-    # Strip non-ASCII characters from the friendly_id string.
-    attr_accessor :strip_non_ascii
-
-    # Use slugs for storing the friendly_id string.
-    attr_accessor :use_slug
-    alias :use_slugs= :use_slug
-
-    def initialize(configured_class, method, options = nil, &block)
-      @configured_class = configured_class
-      @method = method.to_sym
-      DEFAULTS.merge(options || {}).each do |key, value|
-        self.send "#{key}=".to_sym, value
-      end
-      yield self if block_given?
-    end
-
-    def cache_column=(value)
-      @cache_column = value.to_s.strip.to_sym
-      if value =~ /\s/ || [:slug, :slugs].include?(@cache_column)
-        raise ArgumentError, "FriendlyId cache column can not be named '#{value}'"
-      end
-      @cache_column
-    end
-
-    # This should be overridden by adapters that implement caching.
-    def cache_column?
-      false
+    # The base column or method used by FriendlyId as the basis of a friendly id
+    # or slug.
+    #
+    # For models that don't use FriendlyId::Slugged, the base is the column that
+    # is used as the FriendlyId directly. For models using FriendlyId::Slugged,
+    # the base is a column or method whose value is used as the basis of the
+    # slug.
+    #
+    # For example, if you have a model representing blog posts and that uses
+    # slugs, you likely will want to use the "title" attribute as the base, and
+    # FriendlyId will take care of transforming the human-readable title into
+    # something suitable for use in a URL.
+    #
+    # @param [Symbol] A symbol referencing a column or method in the model. This
+    #   value is usually set by passing it as the first argument to
+    #   {FriendlyId::Base#friendly_id friendly_id}:
+    #
+    # @example
+    #   class Book < ActiveRecord::Base
+    #     extend FriendlyId
+    #     friendly_id :name
+    #   end
+    attr_accessor :base
+
+    # The default configuration options.
+    attr_reader :defaults
+
+    # The model class that this configuration belongs to.
+    # @return ActiveRecord::Base
+    attr_reader :model_class
+
+    def initialize(model_class, values = nil)
+      @model_class = model_class
+      @defaults    = {}
+      set values
     end
 
-    def reserved_words=(*args)
-      if args.first.kind_of?(Regexp)
-        @reserved_words = args.first
-      else
-        @reserved_words = args.flatten.uniq
+    # Lets you specify the modules to use with FriendlyId.
+    #
+    # This method is invoked by {FriendlyId::Base#friendly_id friendly_id} when
+    # passing the +:use+ option, or when using {FriendlyId::Base#friendly_id
+    # friendly_id} with a block.
+    #
+    # @example
+    #   class Book < ActiveRecord::Base
+    #     extend FriendlyId
+    #     friendly_id :name, :use => :slugged
+    #   end
+    # @param [#to_s] *modules Arguments should be a symbols or strings that
+    #   correspond with the name of a module inside the FriendlyId namespace. By
+    #   default FriendlyId provides +:slugged+, +:history+ and +:scoped+.
+    def use(*modules)
+      modules.to_a.flatten.compact.map do |name|
+        mod = FriendlyId.const_get(name.to_s.classify)
+        model_class.send(:include, mod) unless model_class < mod
       end
     end
 
-    def reserved?(word)
-      word = word.to_s
-      if reserved_words.kind_of?(Regexp)
-        reserved_words =~ word
-      else
-        reserved_words.include?(word)
-      end
-    end
-
-    def reserved_error_message(word)
-      [method, reserved_message % word] if reserved? word
-    end
-
-    def scope=(scope)
-      self.class.scopes_used = true
-      @scope = scope
-    end
-
-    def sequence_separator=(string)
-      if string == "-" || string =~ /\s/
-        raise ArgumentError, "FriendlyId sequence_separator can not be '#{string}'"
-      end
-      @sequence_separator = string
-    end
-
-    # This will be set if FriendlyId's scope feature is used in any model. It is here
-    # to provide a way to avoid invoking costly scope lookup methods when the scoped
-    # slug feature is not being used by any models.
-    def self.scopes_used=(val)
-      @scopes_used = !!val
-    end
-
-    # Are scoped slugs being used by any model?
-    # @see Configuration.scoped_used=
-    def self.scopes_used?
-      @scopes_used
-    end
-
-    %w[approximate_ascii scope strip_non_ascii use_slug].each do |method|
-      class_eval(<<-EOM, __FILE__, __LINE__ + 1)
-        def #{method}?
-          !! #{method}
-        end
-      EOM
+    # The column that FriendlyId will use to find the record when querying by
+    # friendly id.
+    #
+    # This method is generally only used internally by FriendlyId.
+    # @return String
+    def query_field
+      base.to_s
     end
 
-    alias :use_slugs? :use_slug?
+    private
 
-    def babosa_options
-      {
-        :to_ascii         => strip_non_ascii?,
-        :transliterate    => approximate_ascii?,
-        :transliterations => ascii_approximation_options,
-        :max_length       => max_length
-      }
+    def set(values)
+      values and values.each {|name, value| self.send "#{name}=", value}
     end
   end
 end

data/lib/friendly_id/finder_methods.rb

@@ -0,0 +1,20 @@
+module FriendlyId
+  # These methods will override the finder methods in ActiveRecord::Relation.
+  module FinderMethods
+
+    protected
+
+    # FriendlyId overrides this method to make it possible to use friendly id's
+    # identically to numeric ids in finders.
+    #
+    # @example
+    #  person = Person.find(123)
+    #  person = Person.find("joe")
+    #
+    # @see FriendlyId::ObjectUtils
+    def find_one(id)
+      return super if !@klass.respond_to?(:friendly_id) || id.unfriendly_id?
+      where(@klass.friendly_id_config.query_field => id).first or super
+    end
+  end
+end