friendly_id_globalize3 3.2.0

data/lib/friendly_id/active_record.rb

@@ -0,0 +1,74 @@
+module FriendlyId
+
+  # Are we running on ActiveRecord 3 or higher?
+  def self.on_ar3?
+    ActiveRecord::VERSION::STRING >= "3"
+  end
+
+  module ActiveRecordAdapter
+
+    include FriendlyId::Base
+
+    def has_friendly_id(method, options = {})
+      if FriendlyId.on_ar3?
+        class_attribute :friendly_id_config
+        self.friendly_id_config = Configuration.new(self, method, options)
+      else
+        class_inheritable_accessor :friendly_id_config
+        write_inheritable_attribute :friendly_id_config, Configuration.new(self, method, options)
+      end
+
+      if friendly_id_config.use_slug?
+        include SluggedModel
+      else
+        include SimpleModel
+      end
+    end
+
+    private
+
+    # Prevent the cached_slug column from being accidentally or maliciously
+    # overwritten. Note that +attr_protected+ is used to protect the cached_slug
+    # column, unless you have already invoked +attr_accessible+. So if you
+    # 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 attr_accessible
+      unless accessible_attributes.present?
+        if friendly_id_config.custom_cache_column?
+          attr_protected friendly_id_config.cache_column
+        end
+        attr_protected :cached_slug
+      end
+    end
+
+  end
+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"
+
+module ActiveRecord
+  class Base
+    extend FriendlyId::ActiveRecordAdapter
+    unless FriendlyId.on_ar3?
+      class << self
+        VALID_FIND_OPTIONS << :scope
+        VALID_FIND_OPTIONS << :locale
+      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

@@ -0,0 +1,68 @@
+module FriendlyId
+
+  module ActiveRecordAdapter
+
+    # Extends FriendlyId::Configuration with some implementation details and
+    # features specific to ActiveRecord.
+    class Configuration < FriendlyId::Configuration
+
+      # The column used to cache the friendly_id string. If no column is specified,
+      # FriendlyId will look for a column named +cached_slug+ and use it automatically
+      # if it exists. If for some reason you have a column named +cached_slug+
+      # but don't want FriendlyId to modify it, pass the option
+      # +:cache_column => false+ to {FriendlyId::ActiveRecordAdapter#has_friendly_id has_friendly_id}.
+      attr_accessor :cache_column
+
+      # An array of classes for which the configured class serves as a
+      # FriendlyId scope.
+      attr_reader :child_scopes
+
+      attr_reader :custom_cache_column
+
+      def cache_column
+        return @cache_column if defined?(@cache_column)
+        @cache_column = autodiscover_cache_column
+      end
+
+      def cache_column?
+        !! cache_column
+      end
+
+      def cache_column=(cache_column)
+        @cache_column = cache_column
+        @custom_cache_column = cache_column
+      end
+
+      def child_scopes
+        @child_scopes ||= associated_friendly_classes.select do |klass|
+          klass.friendly_id_config.scopes_over?(configured_class)
+        end
+      end
+
+      def custom_cache_column?
+        !! custom_cache_column
+      end
+
+      def scope_for(record)
+        return nil unless scope?
+        record.send(scope).nil? ? nil : record.send(scope).to_param
+      end
+
+      def scopes_over?(klass)
+        scope? && scope == klass.to_s.underscore.to_sym
+      end
+
+      private
+
+      def autodiscover_cache_column
+        :cached_slug if configured_class.columns.any? { |column| column.name == 'cached_slug' }
+      end
+
+      def associated_friendly_classes
+        configured_class.reflect_on_all_associations.compact.select { |assoc|
+          !assoc.options[:polymorphic] && assoc.klass.respond_to?(:friendly_id_config)
+        }.map(&:klass)
+      end
+    end
+  end
+end

data/lib/friendly_id/active_record_adapter/finders.rb

@@ -0,0 +1,148 @@
+module FriendlyId
+  module ActiveRecordAdapter
+    module Finders
+
+      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 :klass
+        attr :id
+        attr :options
+        attr :result
+        attr :friendly_ids
+        attr :unfriendly_ids
+
+        def initialize(klass, id, options)
+          @klass     = klass
+          @id        = id
+          @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
+        end
+
+        def find_one
+          return find_one_with_cached_slug if !fc.scope? && cache_column?
+          return find_one_with_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 => :slugs)
+          end
+          options[:readonly] = false unless options[:readonly]
+          @result = scope.all(options).uniq
+          validate_expected_size!
+          @result.each { |record| record.friendly_id_status.name = id }
+        end
+
+        private
+
+        def find_one_with_cached_slug
+          @result = scoped(:conditions => ["#{table_name}.#{cache_column} = ?", id]).first(options)
+          assign_status or find_one_with_slug
+        end
+
+        def find_one_with_slug
+          name, seq = id.to_s.parse_friendly_id
+          scope = scoped(:joins => :slugs, :conditions => {:slugs => {:name => name, :sequence => seq}})
+          options[:readonly] = false unless options[:readonly]
+          @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]),
+            result.size,
+            expected
+          ]
+          raise ActiveRecord::RecordNotFound, message
+        end
+
+        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
+
+        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
+
+      def find_one(id, options)
+        return super if id.blank? || id.unfriendly_id?
+        finder = Find.new(self, id, options)
+        finder.find_one or super
+      end
+
+      def find_some(ids, options)
+        return super if ids.empty?
+        finder = Find.new(self, ids, options)
+        finder.find_some
+      end
+    end
+  end
+end

data/lib/friendly_id/active_record_adapter/relation.rb

@@ -0,0 +1,165 @@
+module FriendlyId
+  module ActiveRecordAdapter
+    module Relation
+
+      class Find
+        extend Forwardable
+
+        attr :relation
+        attr :ids
+        alias id ids
+
+        def_delegators :relation, :arel, :arel_table, :klass, :limit_value, :offset_value, :where
+        def_delegators :klass, :connection, :friendly_id_config
+        alias fc friendly_id_config
+
+        def initialize(relation, ids)
+          @relation = relation
+          @ids = ids
+        end
+
+        def find_one
+          if fc.cache_column?
+            find_one_with_cached_slug
+          elsif fc.use_slugs?
+            find_one_with_slug
+          else
+            find_one_without_slug
+          end
+        end
+
+        def find_some
+          ids = @ids.compact.uniq.map {|id| id.respond_to?(:friendly_id_config) ? id.id.to_i : id}
+          friendly_ids, unfriendly_ids = ids.partition {|id| id.friendly_id?}
+          return if friendly_ids.empty?
+          records = friendly_records(friendly_ids, unfriendly_ids).each do |record|
+            record.friendly_id_status.name = ids
+          end
+          validate_expected_size!(ids, records)
+        end
+
+        private
+
+        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 fc.use_slugs?
+          @result
+        end
+
+        def find_one_without_slug
+          @result = where(fc.column => id).first
+          assign_status
+        end
+
+        def find_one_with_cached_slug
+          @result = where(fc.cache_column => id).first
+          assign_status or find_one_with_slug
+        end
+
+        def find_one_with_slug
+          sluggable_ids = sluggable_ids_for([id])
+
+          if sluggable_ids.size > 1 && fc.scope?
+            return relation.where(relation.primary_key.in(sluggable_ids)).first
+          end
+
+          sluggable_id = sluggable_ids.first
+
+          if sluggable_id
+            name, seq = id.to_s.parse_friendly_id
+            record = relation.send(:find_one_without_friendly, sluggable_id)
+            record.friendly_id_status.name     = name
+            record.friendly_id_status.sequence = seq
+            record
+          else
+            relation.send(:find_one_without_friendly, id)
+          end
+        end
+
+        def friendly_records(friendly_ids, unfriendly_ids)
+          use_slugs_table =  fc.use_slugs? && (!fc.cache_column?)
+          return find_some_using_slug(friendly_ids, unfriendly_ids) if use_slugs_table
+          column     = fc.cache_column || fc.column
+          friendly   = arel_table[column].in(friendly_ids)
+          unfriendly = arel_table[relation.primary_key.name].in unfriendly_ids
+          if friendly_ids.present? && unfriendly_ids.present?
+            where(friendly.or(unfriendly))
+          else
+            where(friendly)
+          end
+        end
+
+        def find_some_using_slug(friendly_ids, unfriendly_ids)
+          ids = [unfriendly_ids + sluggable_ids_for(friendly_ids)].flatten.uniq
+          where(arel_table[relation.primary_key.name].in(ids))
+        end
+
+        def sluggable_ids_for(ids)
+          return [] if ids.empty?
+          fragment = "(slugs.sluggable_type = %s AND slugs.name = %s AND slugs.sequence = %d)"
+          conditions = ids.inject(nil) do |clause, id|
+            name, seq = id.parse_friendly_id
+            string = fragment % [connection.quote(klass.base_class), connection.quote(name), seq]
+            clause ? clause + " OR #{string}" : string
+          end
+          sql = "SELECT sluggable_id FROM slugs WHERE (%s)" % conditions
+          connection.select_values sql
+        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
+
+      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)
+        begin
+          return super if !klass.uses_friendly_id? or id.unfriendly_id?
+          find = Find.new(self, id)
+          find.find_one or super
+        end
+      end
+
+      def find_some(ids)
+        return super unless klass.uses_friendly_id?
+        Find.new(self, ids).find_some or begin
+          # A change in Arel 2.0.x causes find_some to fail with arrays of instances; not sure why.
+          # This is an emergency, temporary fix.
+          ids = ids.map {|id| (id.respond_to?(:friendly_id_config) ? id.id : id).to_i}
+          super
+        end
+      end
+    end
+  end
+end