friendly_id 3.0.6 → 3.1.0.pre

data/Changelog.md

@@ -6,6 +6,16 @@ suggestions, ideas and improvements to FriendlyId.
 * Table of Contents
 {:toc}
 
+## 3.1.0 (NOT RELEASED)
+
+* Refactored/simplified Active Record 2 and 3 query code.
+* Better support for Active Record 3 finds and scopes.
+* Extract slug handling code into separate gem, [Babosa](http://github.com/norman/babosa).
+* :max-length option now uses bytes rather than characters.
+* Fix quoting issue that prevented using a domain- or database-qualified column. (thanks James Cropcho)
+* Support for Active Record 2.2.x dropped; 2.3 or above is now required.
+* Fixed a few small errors on Postgres.
+
 ## 3.0.6 (2010-06-10)
 
 * Fix bad call to apply_mapping on 2.3.

data/Contributors.md

@@ -18,6 +18,7 @@ community, in particular from the following people:
 * Florian Aßmanqn
 * Harry Love
 * Ian Stewart
+* James Cropcho
 * Jesse Crouch
 * Joe Van Dyk
 * Johan Kok

data/Guide.md

@@ -131,9 +131,9 @@ for {FriendlyId::Configuration}.
 
 ## FriendlyId Strings
 
-FriendlyId comes with {FriendlyId::SlugString excellent support for Unicode
-strings}. When using slugs, FriendlyId will automatically modify the slug text
-to make it more suitable for use in a URL:
+FriendlyId uses the [Babosa](http://github.com/norman/babosa) library for
+generating slug strings. When using slugs, FriendlyId/Babosa will automatically
+modify the slug text to make it more suitable for use in a URL:
 
     class City < ActiveRecord::Base
       has_friendly_id :name, :use_slug => true
@@ -180,15 +180,9 @@ There are special options for some languages:
     @post.create(:title => "¡Feliz año!")
     @post.title  # will be "feliz-anno"
 
-### Approximations for Other Languages
-
-You can add custom approximations for your language by adding Hash of
-approximations to {FriendlyId::SlugString::APPROXIMATIONS}. The approximations
-must be listed as Unicode decimal numbers, and arrays of numbers.
-
 ### Unicode Slugs
 
-By default, any character outside the Unicode Western character sets will be
+By default, any character outside the Unicode Latin character range will be
 passed through untouched, allowing you to have slugs in Arabic, Japanese,
 Greek, etc:
 
@@ -514,15 +508,6 @@ Before removing any public or protected methods, FriendlyId will deprecate
 them through one major release cycle. Private methods may, however, change at
 any time.
 
-## Running the Tests
-
-FriendlyId uses [Bundler](http://github.com/carlhuda/bundler) to manage its gem
-dependencies. To run the tests, first make sure you have bundler installed.
-Then, copy Gemfile.default to Gemfile. If you wish to test against different gem
-versions than the ones specified in the Gemfile (for example, to test with
-Postgres or MySQL rather than SQLite3, or to test against different versions of
-ActiveRecord), then simply modify the Gemfile to suit your dependencies.
-
 ## Some Benchmarks
 
 These benchmarks can give you an idea of FriendlyId's impact on the
@@ -535,27 +520,31 @@ decide not to use FriendlyId for performance reasons, keep in mind that your
 own solution is unlikely to be any faster than FriendlyId with cached slugs
 enabled. But if it is, then your patches would be very welcome!
 
-    ruby 1.9.1p378 (2010-01-10 revision 26273) [i386-darwin10.2.0]
-    activerecord (2.3.5)
-    friendly_id (2.3.2)
-    sqlite3 3.6.19 in-memory database
+
+    activerecord (2.3.8)
+    ruby 1.9.2dev (2010-07-06 revision 28549) [x86_64-darwin10.4.0]
+    friendly_id (3.1.0)
+    sqlite3 3.6.12 in-memory database
+
                                                        | DEFAULT | NO_SLUG |    SLUG | CACHED_SLUG |
     ------------------------------------------------------------------------------------------------
-    find model by id                             x1000 |   0.274 |   0.426 |   0.780 |       0.489 |
-    find model using array of ids                x1000 |   0.517 |   0.525 |   1.692 |       0.623 |
-    find model using id, then to_param           x1000 |   0.279 |   0.431 |   1.253 |       0.498 |
+    find model by id                             x1000 |   0.340 |   0.468 |   0.877 |       0.534 |
+    find model using array of ids                x1000 |   0.551 |   0.592 |   0.989 |       0.893 |
+    find model using id, then to_param           x1000 |   0.340 |   0.487 |   1.310 |       0.551 |
     ================================================================================================
-    Total                                              |   1.071 |   1.382 |   3.725 |       1.610 |
+    Total                                              |   1.231 |   1.547 |   3.176 |       1.979 |
+
+
 
-    ruby 1.9.1p378 (2010-01-10 revision 26273) [i386-darwin10.2.0]
-    activerecord (3.0.0.beta1)
-    friendly_id (2.3.2)
-    sqlite3 3.6.19 in-memory database
+    activerecord (3.0.0.beta4)
+    ruby 1.9.2dev (2010-07-06 revision 28549) [x86_64-darwin10.4.0]
+    friendly_id (3.1.0)
+    sqlite3 3.6.12 in-memory database
 
                                                        | DEFAULT | NO_SLUG |    SLUG | CACHED_SLUG |
     ------------------------------------------------------------------------------------------------
-    find model by id                             x1000 |   0.557 |   1.135 |   6.491 |       1.398 |
-    find model using array of ids                x1000 |   0.862 |   0.882 |   6.152 |       1.919 |
-    find model using id, then to_param           x1000 |   0.658 |   2.200 |   8.398 |       1.539 |
+    find model by id                             x1000 |   0.495 |   0.608 |   1.519 |       0.641 |
+    find model using array of ids                x1000 |   0.708 |   0.722 |   6.483 |       0.782 |
+    find model using id, then to_param           x1000 |   0.506 |   0.645 |   2.644 |       0.637 |
     ================================================================================================
-    Total                                              |   2.077 |   4.217 |  21.041 |       4.856 |
+    Total                                              |   1.709 |   1.976 |  10.645 |       2.061 |

data/README.md

@@ -19,7 +19,7 @@ versioning, scoped slugs, reserved words, custom slug generators, and
 excellent Unicode support. For complete information on using FriendlyId,
 please see the {http://norman.github.com/friendly_id/file.Guide.html FriendlyId Guide}.
 
-FriendlyId is compatible with Rails 2.2.x - 3.0.
+FriendlyId is compatible with Rails 2.3.x and 3.0.
 
 ## Rails Quickstart
 
@@ -30,7 +30,7 @@ FriendlyId is compatible with Rails 2.2.x - 3.0.
     cd my_app
 
     # add to Gemfile
-    gem "friendly_id", "~> 3.0"
+    gem "friendly_id", "~> 3.1"
 
     rails generate friendly_id
     rails generate scaffold user name:string cached_slug:string
@@ -63,8 +63,8 @@ for this project.
 
 If you have a bug to report, please include the following information:
 
+* **Version information for FriendlyId, Rails and Ruby.**
 * Stack trace and error message.
-* Version information for FriendlyId, Rails and Ruby.
 * Any snippets of relevant model, view or controller code that shows how your
   are using FriendlyId.
 

data/Rakefile

@@ -1,17 +1,12 @@
 require "rake"
 require "rake/testtask"
 require "rake/gempackagetask"
-require "rake/rdoctask"
 require "rake/clean"
 
 task :default => :test
 
 CLEAN << "pkg" << "doc" << "coverage" << ".yardoc"
 Rake::GemPackageTask.new(eval(File.read("friendly_id.gemspec"))) { |pkg| }
-Rake::RDocTask.new do |r|
-  r.rdoc_dir = "doc"
-  r.rdoc_files.include "lib/**/*.rb"
-end
 
 begin
   require "yard"

data/extras/bench.rb

@@ -1,4 +1,8 @@
-require File.expand_path('../extras', __FILE__)
+$:.unshift File.expand_path("../lib", File.dirname(__FILE__))
+$:.unshift File.expand_path(File.dirname(__FILE__))
+$:.uniq!
+
+require "extras"
 require 'rbench'
 FACTOR = 10
 

data/extras/prof.rb

@@ -1,5 +1,8 @@
-#!/usr/bin/env ruby -KU
-require File.dirname(__FILE__) + '/extras'
+$:.unshift File.expand_path("../lib", File.dirname(__FILE__))
+$:.unshift File.expand_path(File.dirname(__FILE__))
+$:.uniq!
+
+require "extras"
 require 'ruby-prof'
 
 # RubyProf.measure_mode = RubyProf::MEMORY
@@ -10,5 +13,7 @@ RubyProf.start
 end
 result = RubyProf.stop
 GC.enable
-printer = RubyProf::CallTreePrinter.new(result)
-printer.print(File.new("prof.txt", "w"))
+# printer = RubyProf::CallTreePrinter.new(result)
+printer = RubyProf::GraphPrinter.new(result)
+version = ActiveRecord::VERSION::STRING.gsub(".", "")
+printer.print(File.new("prof#{version}.txt", "w"))

data/lib/friendly_id.rb

@@ -1,3 +1,4 @@
+require "babosa"
 require "forwardable"
 require "active_support/core_ext/class/attribute_accessors"
 begin
@@ -7,11 +8,10 @@ rescue MissingSourceFile
   require "active_support/core_ext/blank"
 end
 
-require File.join(File.dirname(__FILE__), "friendly_id", "slug_string")
-require File.join(File.dirname(__FILE__), "friendly_id", "configuration")
-require File.join(File.dirname(__FILE__), "friendly_id", "status")
-require File.join(File.dirname(__FILE__), "friendly_id", "finders")
-require File.join(File.dirname(__FILE__), "friendly_id", "slugged")
+require "friendly_id/slug_string"
+require "friendly_id/configuration"
+require "friendly_id/status"
+require "friendly_id/slugged"
 
 # FriendlyId is a comprehensive Ruby library for slugging and permalinks with
 # ActiveRecord.
@@ -66,8 +66,36 @@ class String
   def parse_friendly_id(separator = nil)
     separator ||= FriendlyId::Configuration::DEFAULTS[:sequence_separator]
     name, sequence = split(/#{Regexp.escape(separator)}(\d+)?\z/)
-    return name, sequence ||= "1"
+    return name, (sequence ||= 1).to_i
   end
 end
 
-require File.join(File.dirname(__FILE__), "friendly_id", "railtie") if defined?(Rails) && Rails.version >= "3"
+class Object
+
+  # Is the object a friendly id? Note that the return value here is
+  # +false+ if the +id+ is definitely not friendly, and +nil+ if it can
+  # not be determined.
+  # The return value will be:
+  # * +true+ - if the id is definitely friendly (i.e., a string with non-numeric characters)
+  # * +false+ - if the id is definitely unfriendly (i.e., an Integer, a model instance, etc.)
+  # * +nil+ - if it can not be determined (i.e., a numeric string like "206".)
+  # @return [true, false, nil]
+  # @see #unfriendly?
+  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
+
+  # Is the object a numeric id?
+  # @return [true, false, nil] +true+ if definitely unfriendly, +false+ if
+  #   definitely friendly, else +nil+.
+  # @see #friendly?
+  def unfriendly_id?
+    val = friendly_id? ; !val unless val.nil?
+  end
+end
+
+require "friendly_id/railtie" if defined?(Rails) && Rails.version >= "3"

data/lib/friendly_id/active_record.rb

@@ -1,12 +1,11 @@
 module FriendlyId
 
-  module ActiveRecordAdapter
+  # Are we running on ActiveRecord 3 or higher?
+  def self.on_ar3?
+    ActiveRecord::VERSION::STRING >= "3"
+  end
 
-    module Compat
-      def self.scope_method
-        ActiveRecord::VERSION::STRING >= "3" ? :scope : :named_scope
-      end
-    end
+  module ActiveRecordAdapter
 
     include FriendlyId::Base
 
@@ -28,8 +27,8 @@ module FriendlyId
     # wish to use +attr_accessible+, you must invoke it BEFORE you invoke
     # {#has_friendly_id} in your class.
     def protect_friendly_id_attributes
-      # only protect the column if the class is not already using attributes_accessible
-      if !accessible_attributes
+      # only protect the column if the class is not already using attr_accessible
+      unless accessible_attributes.present?
         if friendly_id_config.custom_cache_column?
           attr_protected friendly_id_config.cache_column
         end
@@ -40,13 +39,29 @@ module FriendlyId
   end
 end
 
-class ActiveRecord::Base
-  extend FriendlyId::ActiveRecordAdapter
-end
+require "friendly_id/active_record_adapter/relation"
+require "friendly_id/active_record_adapter/configuration"
+require "friendly_id/active_record_adapter/finders"
+require "friendly_id/active_record_adapter/simple_model"
+require "friendly_id/active_record_adapter/slugged_model"
+require "friendly_id/active_record_adapter/slug"
+require "friendly_id/active_record_adapter/tasks"
 
-require File.join(File.dirname(__FILE__), "active_record_adapter", "configuration")
-require File.join(File.dirname(__FILE__), "active_record_adapter", "finders")
-require File.join(File.dirname(__FILE__), "active_record_adapter", "simple_model")
-require File.join(File.dirname(__FILE__), "active_record_adapter", "slugged_model")
-require File.join(File.dirname(__FILE__), "active_record_adapter", "slug")
-require File.join(File.dirname(__FILE__), "active_record_adapter", "tasks")
+module ActiveRecord
+  class Base
+    extend FriendlyId::ActiveRecordAdapter
+    unless FriendlyId.on_ar3?
+      class << self
+        VALID_FIND_OPTIONS << :scope
+      end
+    end
+  end
+
+  if defined? Relation
+    class Relation
+      alias find_one_without_friendly  find_one
+      alias find_some_without_friendly find_some
+      include FriendlyId::ActiveRecordAdapter::Relation
+    end
+  end
+end

data/lib/friendly_id/active_record_adapter/configuration.rb

@@ -57,6 +57,7 @@ module FriendlyId
 
       def associated_friendly_classes
         configured_class.reflect_on_all_associations.select { |assoc|
+          assoc &&
           !assoc.options[:polymorphic] &&
           assoc.klass.uses_friendly_id?
         }.map(&:klass)

data/lib/friendly_id/active_record_adapter/finders.rb

@@ -1,156 +1,162 @@
 module FriendlyId
-
-  # The adapter for Ruby on Rails's ActiveRecord. Compatible with AR 2.2.x -
-  # 2.3.x.
   module ActiveRecordAdapter
-
-    # The classes in this module are used internally by FriendlyId, and exist
-    # largely to avoid polluting the ActiveRecord models with too many
-    # FriendlyId-specific methods.
     module Finders
 
-      # FinderProxy is used to choose which finder class to instantiate;
-      # depending on the model_class's +friendly_id_config+ and the options
-      # passed into the constructor, it will decide whether to use simple or
-      # slugged finder, a single or multiple finder, and in the case of slugs,
-      # a cached or uncached finder.
-      class FinderProxy
+      class Find
 
         extend Forwardable
+        def_delegators :@klass, :scoped, :friendly_id_config, :quoted_table_name, :table_name, :primary_key,
+          :connection, :name, :sanitize_sql
+        def_delegators :fc, :use_slugs?, :cache_column, :cache_column?
+        alias fc friendly_id_config
 
-        attr_reader :finder
-        attr :finder_class
-        attr :ids
-        attr :model_class
+        attr :klass
+        attr :id
         attr :options
-
-        def_delegators :finder, :find, :unfriendly?
-
-        def initialize(model_class, *args, &block)
-          @model_class = model_class
-          @ids = args.shift
-          @options = args.first.kind_of?(Hash) ? args.first : {}
-        end
-
-        # Perform the find query.
-        def finder
-          @finder ||= finder_class.new(ids, model_class, options)
-        end
-
-        def finder_class
-          @finder_class ||= slugged? ? slugged_finder_class : simple_finder_class
-        end
-
-        def multiple?
-          ids.kind_of? Array
-        end
-
-        private
-
-        def cache_available?
-          !! model_class.friendly_id_config.cache_column
-        end
-
-        def multiple_slugged_finder_class
-          use_cache? ? SluggedModel::CachedMultipleFinder : SluggedModel::MultipleFinder
-        end
-
-        def simple_finder_class
-          multiple? ? SimpleModel::MultipleFinder : SimpleModel::SingleFinder
-        end
-
-        def slugged?
-          !! model_class.friendly_id_config.use_slug?
-        end
-
-        def slugged_finder_class
-          multiple? ? multiple_slugged_finder_class : single_slugged_finder_class
-        end
-
-        def scoped?
-          !! options[:scope]
-        end
-
-        def single_slugged_finder_class
-          use_cache? ? SluggedModel::CachedSingleFinder : SluggedModel::SingleFinder
-        end
-
-        def use_cache?
-          cache_available? and !scoped?
-        end
-
-      end
-
-      # Wraps finds for multiple records using an array of friendly_ids.
-      # @abstract
-      module Multiple
-
-        include FriendlyId::Finders::Base
-
-        attr_reader :friendly_ids, :results, :unfriendly_ids
-
-        def initialize(ids, model_class, options={})
-          @friendly_ids, @unfriendly_ids = ids.partition {|id| FriendlyId::Finders::Base.friendly?(id) }
-          @unfriendly_ids = @unfriendly_ids.map {|id| id.class.respond_to?(:friendly_id_config) ? id.id : id}
-          super
+        attr :scope_val
+        attr :result
+        attr :friendly_ids
+        attr :unfriendly_ids
+
+        def initialize(klass, id, options)
+          @klass     = klass
+          @id        = id
+          @options   = options
+          @scope_val = options.delete(:scope)
+          @scope_val = @scope_val.to_param if @scope_val && @scope_val.respond_to?(:to_param)
+        end
+
+        def find_one
+          return find_one_using_cached_slug if cache_column?
+          return find_one_using_slug if use_slugs?
+          @result = scoped(:conditions => ["#{table_name}.#{fc.column} = ?", id]).first(options)
+          assign_status
+        end
+
+        def find_some
+          parse_ids!
+          scope = some_friendly_scope
+          if use_slugs? && @friendly_ids.present?
+            scope = scope.scoped(:joins => Slug.table_name.to_sym)
+            if fc.scope?
+              scope = scope.scoped(:conditions => {:slugs => {:scope => scope_val}})
+            end
+          end
+          @result = scope.all(options).uniq
+          validate_expected_size!
+          @result.each { |record| record.friendly_id_status.name = id }
+        end
+
+        def raise_error(error)
+          raise(error) unless fc.scope?
+          scope_message = scope_val || "expected, but none given"
+          message = "%s, scope: %s" % [error.message, scope_message]
+          raise ActiveRecord::RecordNotFound, message
         end
 
         private
 
-        # An error message to use when the wrong number of results was returned.
-        def error_message
-          "Couldn't find all %s with IDs (%s) AND %s (found %d results, but was looking for %d)" % [
-            model_class.name.pluralize,
-            ids.join(', '),
+        def find_one_using_cached_slug
+          @result = scoped(:conditions => ["#{table_name}.#{cache_column} = ?", id]).first(options)
+          assign_status or find_one_using_slug
+        end
+
+        def find_one_using_slug
+          name, seq = id.to_s.parse_friendly_id
+          slugs = Slug.table_name.to_sym
+          scope = scoped(:conditions => {slugs => {:name => name, :sequence => seq}}, :joins => slugs)
+          scope = scope.scoped(:conditions => {slugs => {:scope => scope_val}}) if fc.scope?
+          @result = scope.first(options)
+          assign_status
+        end
+
+        def parse_ids!
+          @id = id.uniq.map do |member|
+            if member.respond_to?(:friendly_id_config)
+              member.id.to_i
+            else
+              member
+            end
+          end
+          @friendly_ids, @unfriendly_ids = @id.partition {|member| member.friendly_id?}
+        end
+
+        def validate_expected_size!
+          expected = expected_size
+          return if @result.size == expected
+          message = "Couldn't find all %s with IDs (%s) AND %s (found %d results, but was looking for %d)" % [
+            name.pluralize,
+            id.join(', '),
             sanitize_sql(options[:conditions]),
-            results.size,
-            expected_size
+            result.size,
+            expected
           ]
+          raise ActiveRecord::RecordNotFound, message
         end
 
-        # How many results do we expect?
-        def expected_size
-          limited? ? limit : offset_size
-        end
-
-        # The limit option passed to the find.
-        def limit
-          options[:limit]
+        def assign_status
+          return unless @result
+          name, seq = @id.to_s.parse_friendly_id
+          @result.friendly_id_status.name = name
+          @result.friendly_id_status.sequence = seq if use_slugs?
+          @result
         end
 
-        # Is the find limited?
-        def limited?
-          offset_size > limit if limit
-        end
-
-        # The offset used for the find. If no offset was passed, 0 is returned.
-        def offset
-          options[:offset].to_i
-        end
-
-        # The number of ids, minus the offset.
-        def offset_size
-          ids.size - offset
+        def expected_size
+          if options[:limit] && @id.size > options[:limit]
+            options[:limit]
+          else
+            @id.size
+          end
+        end
+
+        def some_friendly_scope
+          query_slugs = use_slugs? && !cache_column?
+          pkey      = "#{quoted_table_name}.#{primary_key}"
+          column    = "#{table_name}.#{cache_column || fc.column}"
+          if @unfriendly_ids.present?
+            conditions = ["#{pkey} IN (?)", @unfriendly_ids]
+            if @friendly_ids.present?
+              if query_slugs
+                conditions[0] << " OR #{some_slugged_conditions}"
+              else
+                conditions[0] << " OR #{column} IN (?)"
+                conditions << @friendly_ids
+              end
+            end
+          elsif @friendly_ids.present?
+            conditions = query_slugs ? some_slugged_conditions : ["#{column} IN (?)", @friendly_ids]
+          end
+          scoped(:conditions => conditions)
+        end
+
+        def some_slugged_conditions
+          return unless @friendly_ids.present?
+          slug_table = Slug.quoted_table_name
+          fragment = "(#{slug_table}.name = %s AND #{slug_table}.sequence = %d)"
+          @friendly_ids.inject(nil) do |clause, id|
+            name, seq = id.parse_friendly_id
+            string = fragment % [connection.quote(name), seq]
+            clause ? clause + " OR #{string}" : string
+          end
         end
-
       end
 
-    end
-
-    # The methods in this module override ActiveRecord's +find_one+ and
-    # +find_some+ to add FriendlyId's features.
-    module FinderMethods
-
-      def find(*args, &block)
-        finder = Finders::FinderProxy.new(self, *args, &block)
-        if finder.multiple?
-          finder.find
-        else
-          finder.unfriendly? ? super : finder.find or super
-        end
+      def find_one(id, options)
+        return super if id.blank? || id.unfriendly_id?
+        finder = Find.new(self, id, options)
+        finder.find_one or super
+      rescue ActiveRecord::RecordNotFound => error
+        finder.raise_error(error)
       end
 
+      def find_some(ids, options)
+        return super if ids.empty?
+        finder = Find.new(self, ids, options)
+        finder.find_some
+      rescue ActiveRecord::RecordNotFound => error
+        finder.raise_error(error)
+      end
     end
-
   end
 end