friendly_id 3.0.6 → 3.1.0.pre

data/lib/friendly_id/active_record_adapter/relation.rb

@@ -0,0 +1,129 @@
+module FriendlyId
+  module ActiveRecordAdapter
+    module Relation
+
+      attr :friendly_id_scope
+
+      # This method overrides Active Record's default in order to allow the :scope option to
+      # be passed to finds.
+      def apply_finder_options(options)
+        @friendly_id_scope = options.delete(:scope)
+        @friendly_id_scope = @friendly_id_scope.to_param if @friendly_id_scope.respond_to?(:to_param)
+        super
+      end
+
+      protected
+
+      def find_one(id)
+        begin
+          return super if !@klass.uses_friendly_id? or id.unfriendly_id?
+          return find_one_using_cached_slug(id) if friendly_id_config.cache_column?
+          return find_one_using_slug(id) if friendly_id_config.use_slugs?
+          record = where(friendly_id_config.column => id).first
+          if record
+            record.friendly_id_status.name = name
+            record
+          else
+            super
+          end
+        rescue ActiveRecord::RecordNotFound => error
+          uses_friendly_id? && friendly_id_config.scope? ? raise_scoped_error(error) : raise(error)
+        end
+      end
+
+      def find_some(ids)
+        return super unless @klass.uses_friendly_id?
+        ids = ids.compact.uniq.map {|id| id.respond_to?(:friendly_id_config) ? id.id.to_i : id}
+        records = friendly_records(*ids.partition {|id| id.friendly_id?}).each do |record|
+          record.friendly_id_status.name = ids
+        end
+        validate_expected_size!(ids, records)
+      end
+
+      private
+
+      def find_one_using_slug(id)
+        name, seq = id.to_s.parse_friendly_id
+        slug = Slug.where(:name => name, :sequence => seq, :scope => friendly_id_scope,
+                          :sluggable_type => @klass.base_class.to_s).first
+        if slug
+          record = find_one(slug.sluggable_id.to_i)
+          record.friendly_id_status.name = name
+          record.friendly_id_status.sequence = seq
+          record.friendly_id_status.slug = slug
+          record
+        else
+          find_one_without_friendly(id)
+        end
+      end
+
+      def find_one_using_cached_slug(id)
+        record = where(friendly_id_config.cache_column => id).first
+        if record
+          name, seq = id.to_s.parse_friendly_id
+          record.friendly_id_status.name = name
+          record.friendly_id_status.sequence = seq
+          record
+        else
+          find_one_using_slug(id)
+        end
+      end
+
+      def raise_scoped_error(error)
+        scope_message = friendly_id_scope || "expected, but none given"
+        message = "%s, scope: %s" % [error.message, scope_message]
+        raise ActiveRecord::RecordNotFound, message
+      end
+
+      def friendly_records(friendly_ids, unfriendly_ids)
+        use_slugs  = friendly_id_config.use_slugs? && !friendly_id_config.cache_column?
+        column     = friendly_id_config.cache_column || friendly_id_config.column
+        friendly   = use_slugs ? slugged_conditions(friendly_ids) : arel_table[column].in(friendly_ids)
+        unfriendly = arel_table[primary_key].in unfriendly_ids
+        if friendly_ids.present? && unfriendly_ids.present?
+          clause = friendly.or(unfriendly)
+        elsif friendly_ids.present?
+          clause = friendly
+        elsif unfriendly_ids.present?
+          clause = unfriendly
+        end
+        use_slugs ? joins(:slugs).where(clause) : where(clause)
+      end
+
+      def slugged_conditions(ids)
+        return if ids.empty?
+        slugs = Slug.arel_table
+        conditions = lambda do |id|
+          name, seq = id.parse_friendly_id
+          slugs[:name].eq(name).and(slugs[:sequence].eq(seq)).and(slugs[:scope].eq(friendly_id_scope))
+        end
+        ids.inject(nil) {|clause, id| clause ? clause.or(conditions.call(id)) : conditions.call(id) }
+      end
+
+      def validate_expected_size!(ids, result)
+        expected_size =
+          if @limit_value && ids.size > @limit_value
+            @limit_value
+          else
+            ids.size
+          end
+
+        # 11 ids with limit 3, offset 9 should give 2 results.
+        if @offset_value && (ids.size - @offset_value < expected_size)
+          expected_size = ids.size - @offset_value
+        end
+
+        if result.size == expected_size
+          result
+        else
+          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
+        end
+      end
+    end
+  end
+end

data/lib/friendly_id/active_record_adapter/simple_model.rb

@@ -3,66 +3,6 @@ module FriendlyId
 
     module SimpleModel
 
-      # Some basic methods common to {MultipleFinder} and {SingleFinder}.
-      module SimpleFinder
-
-        # The column used to store the friendly_id.
-        def column
-          "#{table_name}.#{friendly_id_config.column}"
-        end
-
-        # The model's fully-qualified and quoted primary key.
-        def primary_key
-          "#{quoted_table_name}.#{model_class.send :primary_key}"
-        end
-
-      end
-
-      class MultipleFinder
-
-        include FriendlyId::ActiveRecordAdapter::Finders::Multiple
-        include SimpleFinder
-
-        def find
-          @results = model_class.scoped(:conditions => conditions).all(options).uniq
-          raise(::ActiveRecord::RecordNotFound, error_message) if @results.size != expected_size
-          friendly_results.each { |result| result.friendly_id_status.name = result.to_param }
-          @results
-        end
-
-        private
-
-        def conditions
-          ["#{primary_key} IN (?) OR #{column} IN (?)", unfriendly_ids, friendly_ids]
-        end
-
-        def friendly_results
-          results.select { |result| friendly_ids.include? result.to_param }
-        end
-
-      end
-
-      class SingleFinder
-
-        include FriendlyId::Finders::Base
-        include FriendlyId::Finders::Single
-        include SimpleFinder
-
-        def find
-          result = model_class.scoped(find_options).first(options)
-          raise ::ActiveRecord::RecordNotFound.new if friendly? && !result
-          result.friendly_id_status.name = id if result
-          result
-        end
-
-        private
-
-        def find_options
-          @find_options ||= {:conditions => {column => id}}
-        end
-
-      end
-
       def self.included(base)
         base.class_eval do
           column = friendly_id_config.column
@@ -70,7 +10,7 @@ module FriendlyId
           validates_presence_of column, :unless => :skip_friendly_id_validations
           validates_length_of column, :maximum => friendly_id_config.max_length, :unless => :skip_friendly_id_validations
           after_update :update_scopes
-          extend FriendlyId::ActiveRecordAdapter::FinderMethods
+          extend FriendlyId::ActiveRecordAdapter::Finders unless FriendlyId.on_ar3?
         end
       end
 
@@ -120,4 +60,4 @@ module FriendlyId
 
     end
   end
-end
+end

data/lib/friendly_id/active_record_adapter/slug.rb

@@ -1,11 +1,12 @@
 # A Slug is a unique, human-friendly identifier for an ActiveRecord.
 class Slug < ::ActiveRecord::Base
 
+  def self.named_scope(*args, &block) scope(*args, &block) end if FriendlyId.on_ar3?
   table_name = "slugs"
   belongs_to :sluggable, :polymorphic => true
   before_save :enable_name_reversion, :set_sequence
   validate :validate_name
-  send FriendlyId::ActiveRecordAdapter::Compat.scope_method, :similar_to, lambda {|slug| {:conditions => {
+  named_scope :similar_to, lambda {|slug| {:conditions => {
         :name           => slug.name,
         :scope          => slug.scope,
         :sluggable_type => slug.sluggable_type
@@ -63,4 +64,4 @@ class Slug < ::ActiveRecord::Base
     self.sequence = similar_slugs.last.sequence.succ if similar_to_other_slugs?
   end
 
-end
+end

data/lib/friendly_id/active_record_adapter/slugged_model.rb

@@ -2,145 +2,6 @@ module FriendlyId
   module ActiveRecordAdapter
     module SluggedModel
 
-      module SluggedFinder
-        # Whether :include => :slugs has been passed as an option.
-        def slugs_included?
-          [*(options[:include] or [])].flatten.include?(:slugs)
-        end
-
-        def handle_friendly_result
-          raise ::ActiveRecord::RecordNotFound.new unless @result
-          @result.friendly_id_status.friendly_id = id
-        end
-
-      end
-
-      class MultipleFinder
-
-        include FriendlyId::ActiveRecordAdapter::Finders::Multiple
-        include SluggedFinder
-
-        attr_reader :slugs
-
-        def find
-          @results = model_class.scoped(find_options).all(options).uniq
-          raise ::ActiveRecord::RecordNotFound, error_message if @results.size != expected_size
-          @results.each {|result| result.friendly_id_status.name = slug_for(result)}
-        end
-
-        private
-
-        def find_conditions
-          "%s IN (%s)" % [
-            "#{quoted_table_name}.#{primary_key}",
-            (unfriendly_ids + sluggable_ids).join(",")
-          ]
-        end
-
-        def find_options
-          {:select => "#{quoted_table_name}.*", :conditions => find_conditions,
-            :joins => slugs_included? ? options[:joins] : :slugs}
-        end
-
-        def sluggable_ids
-          @sluggable_ids ||= slugs.map(&:sluggable_id)
-        end
-
-        def slugs
-          @slugs ||= friendly_ids.map do |friendly_id|
-            name, sequence = friendly_id.parse_friendly_id(friendly_id_config.sequence_separator)
-            Slug.first :conditions => {
-              :name           => name,
-              :scope          => scope,
-              :sequence       => sequence,
-              :sluggable_type => base_class.name
-            }
-          end.compact
-        end
-
-        def slug_for(result)
-          slugs.detect {|slug| result.id == slug.sluggable_id}
-        end
-
-      end
-
-      # Performs a find a single friendly_id using the cached_slug column,
-      # if available. This is significantly faster, and can be used in all
-      # circumstances unless the +:scope+ argument is present.
-      class CachedMultipleFinder < SimpleModel::MultipleFinder
-        # The column used to store the cached slug.
-        def column
-          "#{table_name}.#{friendly_id_config.cache_column}"
-        end
-      end
-
-      class SingleFinder
-
-        include FriendlyId::Finders::Base
-        include FriendlyId::Finders::Single
-        include SluggedFinder
-
-        def find
-          @result = model_class.scoped(find_options).first(options)
-          handle_friendly_result if @result or friendly_id_config.scope?
-          @result
-        rescue ::ActiveRecord::RecordNotFound => @error
-          friendly_id_config.scope? ? raise_scoped_error : (raise @error)
-        end
-
-        private
-
-        def find_options
-          slug_table = Slug.table_name
-          {
-            :select => "#{model_class.quoted_table_name}.*",
-            :joins => slugs_included? ? options[:joins] : :slugs,
-            :conditions => {
-              "#{slug_table}.name"     => name,
-              "#{slug_table}.scope"    => scope,
-              "#{slug_table}.sequence" => sequence
-            }
-          }
-        end
-
-        def raise_scoped_error
-          scope_message = scope || "expected, but none given"
-          message = "%s, scope: %s" % [@error.message, scope_message]
-          raise ::ActiveRecord::RecordNotFound, message
-        end
-
-      end
-
-      # Performs a find for multiple friendly_ids using the cached_slug column,
-      # if available. This is significantly faster, and can be used in all
-      # circumstances unless the +:scope+ argument is present.
-      class CachedSingleFinder < SimpleModel::SingleFinder
-
-        include SluggedFinder
-
-        def find
-          @result = model_class.scoped(find_options).first(options)
-          if @result
-            handle_friendly_result
-            @result
-          else
-            uncached_find
-          end
-        rescue ActiveRecord::RecordNotFound
-          uncached_find
-        end
-
-        def uncached_find
-          SingleFinder.new(id, model_class, options).find
-        end
-
-        # The column used to store the cached slug.
-        def column
-          "#{table_name}.#{friendly_id_config.cache_column}"
-        end
-
-      end
-
       def self.included(base)
         base.class_eval do
           has_many :slugs, :order => 'id DESC', :as => :sluggable, :dependent => :destroy
@@ -150,7 +11,7 @@ module FriendlyId
           after_update :update_scope
           after_update :update_dependent_scopes
           protect_friendly_id_attributes
-          extend FriendlyId::ActiveRecordAdapter::FinderMethods
+          extend FriendlyId::ActiveRecordAdapter::Finders unless FriendlyId.on_ar3?
         end
       end
 
@@ -160,7 +21,8 @@ module FriendlyId
         slugs.find_by_name_and_sequence(name, sequence)
       end
 
-      # Returns the friendly id, or if none is available, the numeric id.
+      # Returns the friendly id, or if none is available, the numeric id. Note that this
+      # method will use the cached_slug value if present, unlike {#friendly_id}.
       def to_param
         friendly_id_config.cache_column ? to_param_from_cache : to_param_from_slug
       end
@@ -184,7 +46,8 @@ module FriendlyId
       # Build the new slug using the generated friendly id.
       def build_a_slug
         return unless new_slug_needed?
-        @slug = slugs.build :name => slug_text.to_s, :scope => friendly_id_config.scope_for(self)
+        @slug = slugs.build :name => slug_text.to_s, :scope => friendly_id_config.scope_for(self),
+          :sluggable => self
         @new_friendly_id = @slug.to_friendly_id
       end
 
@@ -208,9 +71,14 @@ module FriendlyId
 
       def update_scope
         return unless slug && scope_changed?
-        slug.update_attributes :scope => send(friendly_id_config.scope).to_param
-      rescue ActiveRecord::StatementInvalid
-        slug.update_attributes :sequence => Slug.similar_to(slug).first.sequence.succ
+        self.class.transaction do
+          slug.scope = send(friendly_id_config.scope).to_param
+          similar = Slug.similar_to(slug)
+          if !similar.empty?
+            slug.sequence = similar.first.sequence.succ
+          end
+          slug.save!
+        end
       end
 
       # Update the slugs for any model that is using this model as its

data/lib/friendly_id/configuration.rb

@@ -46,7 +46,7 @@ module FriendlyId
     # The class that's using the configuration.
     attr_reader :configured_class
 
-    # The maximum allowed length for a friendly_id string. This is checked *after* a
+    # 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
 

data/lib/friendly_id/railtie.rb

@@ -1,6 +1,6 @@
 module FriendlyId
   class Railtie < Rails::Railtie
-    
+
     initializer "friendly_id.configure_rails_initialization" do |app|
       # Experimental Sequel support. See: http://github.com/norman/friendly_id_sequel
       if app.config.generators.rails[:orm] == :sequel
@@ -11,7 +11,7 @@ module FriendlyId
         require "friendly_id/active_record"
       end
     end
-    
+
     rake_tasks do
       load "tasks/friendly_id.rake"
     end