cmassimo-friendly_id 3.0.4.2

data/lib/friendly_id/active_record.rb

@@ -0,0 +1,52 @@
+module FriendlyId
+
+  module ActiveRecordAdapter
+
+    module Compat
+      def self.scope_method
+        ActiveRecord::VERSION::STRING >= "3" ? :scope : :named_scope
+      end
+    end
+
+    include FriendlyId::Base
+
+    def has_friendly_id(method, options = {})
+      class_inheritable_accessor :friendly_id_config
+      write_inheritable_attribute :friendly_id_config, Configuration.new(self, method, options)
+      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 attributes_accessible
+      if !accessible_attributes
+        if friendly_id_config.custom_cache_column?
+          attr_protected friendly_id_config.cache_column
+        end
+        attr_protected :cached_slug
+      end
+    end
+
+  end
+end
+
+class ActiveRecord::Base
+  extend FriendlyId::ActiveRecordAdapter
+end
+
+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")

data/lib/friendly_id/active_record_adapter/configuration.rb

@@ -0,0 +1,67 @@
+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 { |klass| klass.friendly_id_config.scopes_over?(configured_class) }
+      end
+
+      def custom_cache_column?
+        !! custom_cache_column
+      end
+
+      def scope_for(record)
+        scope? ? record.send(scope).to_param : nil
+      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.select { |assoc|
+          !assoc.options[:polymorphic] &&
+          assoc.klass.uses_friendly_id?
+        }.map(&:klass)
+      end
+
+    end
+  end
+end

data/lib/friendly_id/active_record_adapter/finders.rb

@@ -0,0 +1,156 @@
+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
+
+        extend Forwardable
+
+        attr_reader :finder
+        attr :finder_class
+        attr :ids
+        attr :model_class
+        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
+        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(', '),
+            sanitize_sql(options[:conditions]),
+            results.size,
+            expected_size
+          ]
+        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]
+        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
+        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
+      end
+
+    end
+
+  end
+end

data/lib/friendly_id/active_record_adapter/simple_model.rb

@@ -0,0 +1,123 @@
+module FriendlyId
+  module ActiveRecordAdapter
+
+    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
+          validate :validate_friendly_id, :unless => :skip_friendly_id_validations
+          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
+        end
+      end
+
+      # Get the {FriendlyId::Status} after the find has been performed.
+      def friendly_id_status
+        @friendly_id_status ||= Status.new :record => self
+      end
+
+      # Returns the friendly_id.
+      def friendly_id
+        send friendly_id_config.column
+      end
+      alias best_id friendly_id
+
+      # Returns the friendly id, or if none is available, the numeric id.
+      def to_param
+        (friendly_id || id).to_s
+      end
+
+      private
+
+      # The old and new values for the friendly_id column.
+      def friendly_id_changes
+        changes[friendly_id_config.column.to_s]
+      end
+
+      # Update the slugs for any model that is using this model as its
+      # FriendlyId scope.
+      def update_scopes
+        if changes = friendly_id_changes
+          friendly_id_config.child_scopes.each do |klass|
+            Slug.update_all "scope = '#{changes[1]}'", ["sluggable_type = ? AND scope = ?", klass.to_s, changes[0]]
+          end
+        end
+      end
+
+      def skip_friendly_id_validations
+        friendly_id.nil? && friendly_id_config.allow_nil?
+      end
+
+      def validate_friendly_id
+        if result = friendly_id_config.reserved_error_message(friendly_id)
+          self.errors.add(*result)
+          return false
+        end
+      end
+
+    end
+  end
+end

data/lib/friendly_id/active_record_adapter/slug.rb

@@ -0,0 +1,66 @@
+# A Slug is a unique, human-friendly identifier for an ActiveRecord.
+class Slug < ::ActiveRecord::Base
+
+  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 => {
+        :name           => slug.name,
+        :scope          => slug.scope,
+        :sluggable_type => slug.sluggable_type
+      },
+      :order => "sequence ASC"
+    }
+  }
+
+  # Whether this slug is the most recent of its owner's slugs.
+  def current?
+    sluggable.slug == self
+  end
+
+  def outdated?
+    !current?
+  end
+
+  def to_friendly_id
+    sequence > 1 ? friendly_id_with_sequence : name
+  end
+
+  # Raise a FriendlyId::SlugGenerationError if the slug name is blank.
+  def validate_name
+    if name.blank?
+      raise FriendlyId::BlankError.new("slug.name can not be blank.")
+    end
+  end
+
+  private
+
+  # If we're renaming back to a previously used friendly_id, delete the
+  # slug so that we can recycle the name without having to use a sequence.
+  def enable_name_reversion
+    sluggable.slugs.find_all_by_name_and_scope(name, scope).each { |slug| slug.destroy }
+  end
+
+  def friendly_id_with_sequence
+    "#{name}#{separator}#{sequence}"
+  end
+
+  def similar_to_other_slugs?
+    !similar_slugs.empty?
+  end
+
+  def similar_slugs
+    self.class.similar_to(self)
+  end
+
+  def separator
+    sluggable.friendly_id_config.sequence_separator
+  end
+
+  def set_sequence
+    return unless new_record?
+    self.sequence = similar_slugs.last.sequence.succ if similar_to_other_slugs?
+  end
+
+end