cmassimo-friendly_id 3.0.4.2

data/lib/friendly_id/active_record_adapter/slugged_model.rb

@@ -0,0 +1,238 @@
+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 friendly?
+          @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)
+          handle_friendly_result if friendly?
+          @result
+        rescue ActiveRecord::RecordNotFound
+          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
+          before_create :build_slug
+          after_create :set_slug_cache
+          after_update :update_scope
+          after_update :update_dependent_scopes
+					after_update :update_slug_from_cache
+          protect_friendly_id_attributes
+          extend FriendlyId::ActiveRecordAdapter::FinderMethods
+        end
+      end
+
+      include FriendlyId::Slugged::Model
+
+      def find_slug(name, sequence)
+        slugs.find_by_name_and_sequence(name, sequence)
+      end
+
+      # The model instance's current {FriendlyId::ActiveRecordAdapter::Slug slug}.
+      def slug
+        return @slug if new_record?
+        @slug ||= slugs.first(:order => "id DESC")
+      end
+
+      # Set the slug.
+      def slug=(slug)
+        @new_friendly_id = slug.to_friendly_id unless slug.nil?
+        super
+      end
+
+      # Returns the friendly id, or if none is available, the numeric id.
+      def to_param
+        friendly_id_config.cache_column ? to_param_from_cache : to_param_from_slug
+      end
+
+      private
+
+      def scope_changed?
+        friendly_id_config.scope? && send(friendly_id_config.scope).to_param != slug.scope
+      end
+
+      # Respond with the cached value if available.
+      def to_param_from_cache
+        read_attribute(friendly_id_config.cache_column) || id.to_s
+      end
+
+      # Respond with the slugged value if available.
+      def to_param_from_slug
+        slug? ? slug.to_friendly_id : id.to_s
+      end
+
+      # Build the new slug using the generated friendly id.
+      def build_slug
+        return unless new_slug_needed?
+        self.slug = slugs.build :name => slug_text.to_s, :scope => friendly_id_config.scope_for(self)
+      end
+
+      # Reset the cached friendly_id?
+      def new_cache_needed?
+        uses_slug_cache? && slug? && send(friendly_id_config.cache_column) != slug.to_friendly_id
+      end
+
+      # Reset the cached friendly_id.
+      def set_slug_cache
+        if new_cache_needed?
+          send "#{friendly_id_config.cache_column}=", slug.to_friendly_id
+          send :update_without_callbacks
+        end
+      end
+
+      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
+      end
+			
+      # Update the slugs for any model that is using this model as its
+      # FriendlyId scope.
+      def update_dependent_scopes
+        if slugs(true).size > 1 && @new_friendly_id
+          friendly_id_config.child_scopes.each do |klass|
+            Slug.update_all "scope = '#{@new_friendly_id}'", ["sluggable_type = ? AND scope = ?",
+              klass.to_s, slugs.second.to_friendly_id]
+          end
+        end
+      end
+
+			# Creates a new slug when the cached friendly_id is modified
+			def update_slug_from_cache
+				if uses_slug_cache? && send("#{friendly_id_config.cache_column}_changed?")
+					self.slug = slugs.create :name => send(friendly_id_config.cache_column).to_s, :scope => friendly_id_config.scope_for(self)
+				end
+			end
+      # Does the model use slug caching?
+      def uses_slug_cache?
+        friendly_id_config.cache_column?
+      end
+
+    end
+  end
+end

data/lib/friendly_id/active_record_adapter/tasks.rb

@@ -0,0 +1,69 @@
+module FriendlyId
+  class TaskRunner
+
+    extend Forwardable
+
+    attr_accessor :days
+    attr_accessor :klass
+    attr_accessor :task_options
+
+    def_delegators :klass, :find, :friendly_id_config, :update_all
+
+    OLD_SLUG_DAYS = 45
+
+    def initialize(&block)
+      self.klass = ENV["MODEL"]
+      self.days  = ENV["DAYS"]
+    end
+
+    def days=(days)
+      @days ||= days.blank? ? OLD_SLUG_DAYS : days.to_i
+    end
+
+    def klass=(klass)
+      @klass ||= klass.to_s.classify.constantize unless klass.blank?
+    end
+
+    def make_slugs
+      validate_uses_slugs
+      cond = "slugs.id IS NULL"
+      options = {:limit => 100, :include => :slugs, :conditions => cond, :order => "#{klass.table_name}.id ASC"}.merge(task_options || {})
+      while records = find(:all, options) do
+        break if records.size == 0
+        records.each do |record|
+          record.save(:validate => false)
+          yield(record) if block_given?
+        end
+        options[:conditions] = cond + " and #{klass.table_name}.id > #{records.last.id}"
+      end
+    end
+
+    def delete_slugs
+      validate_uses_slugs
+      Slug.destroy_all(["sluggable_type = ?", klass.to_s])
+      if column = friendly_id_config.cache_column
+        update_all("#{column} = NULL")
+      end
+    end
+
+    def delete_old_slugs
+      conditions = ["created_at < ?", DateTime.now - days]
+      if klass
+        conditions[0] << " AND sluggable_type = ?"
+        conditions << klass.to_s
+      end
+      Slug.all(:conditions => conditions).select(&:outdated?).map(&:destroy)
+    end
+
+    def validate_uses_slugs
+      (raise "You need to pass a MODEL=<model name> argument to rake") if klass.blank?
+      unless friendly_id_config.use_slug?
+        raise "Class '%s' doesn't use slugs" % klass.to_s
+      end
+    rescue NoMethodError
+      raise "Class '%s' doesn't use FriendlyId" % klass.to_s
+    end
+
+  end
+
+end

data/lib/friendly_id/configuration.rb

@@ -0,0 +1,113 @@
+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.
+  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. This is not
+    # generally useful on its own, but may allow you greater flexibility to
+    # customize your application.
+    attr_accessor :allow_nil
+    alias :allow_nil? :allow_nil
+
+    # Strip diacritics from Western characters.
+    attr_accessor :approximate_ascii
+
+    # Locale-type options for ASCII approximations. These can be any of the
+    # values supported by {SlugString#approximate_ascii!}.
+    attr_accessor :ascii_approximation_options
+
+    # 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
+    # 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_accessor :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 reserved_words=(*words)
+      @reserved_words = words.flatten.uniq
+    end
+
+    def reserved?(word)
+      reserved_words.include? word.to_s
+    end
+
+    def reserved_error_message(word)
+      [method, reserved_message % word] if reserved? word
+    end
+
+    %w[approximate_ascii scope strip_non_ascii use_slug].each do |method|
+      class_eval(<<-EOM)
+        def #{method}?
+          !! #{method}
+        end
+      EOM
+    end
+
+    alias :use_slugs? :use_slug?
+
+  end
+
+end

data/lib/friendly_id/finders.rb

@@ -0,0 +1,109 @@
+module FriendlyId
+
+  module Finders
+
+    module Base
+
+      extend Forwardable
+
+      def_delegators :model_class, :base_class, :friendly_id_config,
+        :primary_key, :quoted_table_name, :sanitize_sql, :table_name
+
+      # Is the id friendly or numeric? Not 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., any 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 self.friendly?(id)
+        if id.is_a?(Integer) or id.is_a?(Symbol) or id.class.respond_to? :friendly_id_config
+          return false
+        elsif id.to_i.to_s != id.to_s
+          return true
+        else
+          return nil
+        end
+      end
+
+      # Is the id numeric?
+      # @return [true, false, nil] +true+ if definitely unfriendly, +false+ if
+      #   definitely friendly, else +nil+.
+      # @see #friendly?
+      def self.unfriendly?(id)
+        !friendly?(id) unless friendly?(id) == nil
+      end
+
+      def initialize(ids, model_class, options={})
+        self.ids = ids
+        self.options = options
+        self.model_class = model_class
+        self.scope = options.delete :scope
+      end
+
+      # An array of ids; can be both friendly and unfriendly.
+      attr_accessor :ids
+
+      # The ActiveRecord query options
+      attr_accessor :options
+
+      # The FriendlyId scope
+      attr_accessor :scope
+
+      # The model class being used to perform the query.
+      attr_accessor :model_class
+
+      # Perform the find.
+      def find
+        raise NotImplementedError
+      end
+
+      private
+
+      def ids=(ids)
+        @ids = [ids].flatten
+      end
+      alias :id= :ids=
+
+      def scope=(scope)
+        unless scope.nil?
+          @scope = scope.respond_to?(:to_param) ? scope.to_param : scope.to_s
+        end
+      end
+    end
+
+    module Single
+      # Is the id definitely friendly?
+      # @see Finder::friendly?
+      def friendly?
+        Base.friendly?(id)
+      end
+
+      # Is the id definitely unfriendly?
+      # @see Finder::unfriendly?
+      def unfriendly?
+        Base.unfriendly?(id)
+      end
+
+      private
+
+      # The id (numeric or friendly).
+      def id
+        ids[0]
+      end
+
+      # The slug name; i.e. if "my-title--2", then "my-title".
+      def name
+        id.to_s.parse_friendly_id(friendly_id_config.sequence_separator)[0]
+      end
+
+      # The slug sequence; i.e. if "my-title--2", then "2".
+      def sequence
+        id.to_s.parse_friendly_id(friendly_id_config.sequence_separator)[1]
+      end
+    end
+
+  end
+end