refinerycms 0.9.6.19 → 0.9.6.21

data/vendor/plugins/friendly_id/lib/friendly_id/active_record2/slugged_model.rb

@@ -0,0 +1,323 @@
+module FriendlyId
+  module ActiveRecord2
+    module SluggedModel
+
+      module SluggedFinder
+        # Whether :include => :slugs has been passed as an option.
+        def slugs_included?
+          [*(options[:include] or [])].flatten.include?(:slugs)
+        end
+      end
+
+      class MultipleFinder
+
+        include FriendlyId::Finders::Base
+        include FriendlyId::ActiveRecord2::Finders::Multiple
+        include SluggedFinder
+
+        attr_reader :slugs
+
+        def find
+          @results = with_scope(:find => 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
+          slugs
+          # [unfriendly_find_conditions, friendly_find_conditions].compact.join(" OR ")
+          ids = (unfriendly_ids + sluggable_ids).join(",")
+          "%s IN (%s)" % ["#{quoted_table_name}.#{primary_key}", ids]
+        end
+
+        def friendly_find_conditions
+          "slugs.id IN (%s)" % slugs.compact.to_s(:db) if slugs?
+        end
+
+        def find_options
+          {:select => "#{quoted_table_name}.*", :conditions => find_conditions,
+            :joins => slugs_included? ? options[:joins] : :slugs}
+        end
+
+        def sluggable_ids
+          if !@sluggable_ids
+            @sluggable_ids ||= []
+            slugs
+          end
+          @sluggable_ids
+        end
+
+        def slugs
+          @sluggable_ids ||= []
+          @slugs ||= friendly_ids.map do |friendly_id|
+            name, sequence = friendly_id.parse_friendly_id(friendly_id_config.sequence_separator)
+            slug = Slug.first :conditions => {
+              :name           => name,
+              :scope          => scope,
+              :sequence       => sequence,
+              :sluggable_type => base_class.name
+            }
+            sluggable_ids << slug.sluggable_id if slug
+            slug
+          end
+        end
+
+        def slugs?
+          !slugs.empty?
+        end
+
+        def slug_for(result)
+          slugs.select {|slug| result.id == slug.sluggable_id}.first
+        end
+
+        def unfriendly_find_conditions
+          "%s IN (%s)" % ["#{quoted_table_name}.#{primary_key}", unfriendly_ids.join(",")] if unfriendly_ids?
+        end
+
+        def unfriendly_ids?
+          ! unfriendly_ids.empty?
+        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 = with_scope({:find => find_options}) { find_initial options }
+          raise ::ActiveRecord::RecordNotFound.new if friendly? and !result
+          result.friendly_id_status.name = name if result
+          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 = options[: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
+
+        def find
+          super
+        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
+
+      # The methods in this module override ActiveRecord's +find_one+ and
+      # +find_some+ to add FriendlyId's features.
+      module FinderMethods
+
+        protected
+
+        def find_one(id_or_name, options)
+          finder = Finders::FinderProxy.new(id_or_name, self, options)
+          finder.unfriendly? ? super : finder.find or super
+        end
+
+        def find_some(ids_and_names, options)
+          Finders::FinderProxy.new(ids_and_names, self, options).find
+        end
+
+        # Since Rails goes out of its way to make these options completely
+        # inaccessible, we have to copy them here.
+        def validate_find_options(options)
+          options.assert_valid_keys([:conditions, :include, :joins, :limit, :offset,
+            :order, :select, :readonly, :group, :from, :lock, :having, :scope])
+        end
+
+      end
+
+      # These methods will be removed in FriendlyId 3.0.
+      module DeprecatedMethods
+
+        # @deprecated Please use #to_param
+        def best_id
+          warn("best_id is deprecated and will be removed in 3.0. Please use #to_param.")
+          to_param
+        end
+
+        # @deprecated Please use #friendly_id_status.slug.
+        def finder_slug
+          warn("finder_slug is deprecated and will be removed in 3.0. Please use #friendly_id_status.slug.")
+          friendly_id_status.slug
+        end
+
+        # Was the record found using one of its friendly ids?
+        # @deprecated Please use #friendly_id_status.friendly?
+        def found_using_friendly_id?
+          warn("found_using_friendly_id? is deprecated and will be removed in 3.0. Please use #friendly_id_status.friendly?")
+          friendly_id_status.friendly?
+        end
+
+        # Was the record found using its numeric id?
+        # @deprecated Please use #friendly_id_status.numeric?
+        def found_using_numeric_id?
+          warn("found_using_numeric_id is deprecated and will be removed in 3.0. Please use #friendly_id_status.numeric?")
+          friendly_id_status.numeric?
+        end
+
+        # Was the record found using an old friendly id?
+        # @deprecated Please use #friendly_id_status.outdated?
+        def found_using_outdated_friendly_id?
+          warn("found_using_outdated_friendly_id is deprecated and will be removed in 3.0. Please use #friendly_id_status.outdated?")
+          friendly_id_status.outdated?
+        end
+
+        # Was the record found using an old friendly id, or its numeric id?
+        # @deprecated Please use !#friendly_id_status.best?
+        def has_better_id?
+          warn("has_better_id? is deprecated and will be removed in 3.0. Please use !#friendly_id_status.best?")
+          ! friendly_id_status.best?
+        end
+
+        # @deprecated Please use #slug?
+        def has_a_slug?
+          warn("has_a_slug? is deprecated and will be removed in 3.0. Please use #slug?")
+          slug?
+        end
+
+      end
+
+      def self.included(base)
+        base.class_eval do
+          has_many :slugs, :order => 'id DESC', :as => :sluggable, :dependent => :destroy
+          before_save :build_slug
+          after_save :set_slug_cache
+          after_update :update_scope
+          after_update :update_dependent_scopes
+          protect_friendly_id_attributes
+          extend FinderMethods
+        end
+      end
+
+      include FriendlyId::Slugged::Model
+      include DeprecatedMethods
+
+      def find_slug(name)
+        separator = friendly_id_config.sequence_separator
+        slugs.find_by_name_and_sequence(*name.to_s.parse_friendly_id(separator))
+      end
+
+      # The model instance's current {FriendlyId::ActiveRecord2::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? && 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 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
+
+      # Does the model use slug caching?
+      def uses_slug_cache?
+        friendly_id_config.cache_column?
+      end
+
+    end
+  end
+end

data/vendor/plugins/friendly_id/lib/friendly_id/active_record2/tasks.rb

@@ -0,0 +1,66 @@
+module FriendlyId
+  class TaskRunner
+
+    attr_accessor :days
+    attr_accessor :klass
+    attr_accessor :task_options
+
+    OLD_SLUG_DAYS = 45
+
+    def initialize(&block)
+      self.klass = ENV["MODEL"]
+      self.days  = ENV["DAYS"]
+    end
+
+    def method_missing(*args)
+      klass.send(*args)
+    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
+      options = {:limit => 100, :include => :slugs, :conditions => "slugs.id IS NULL"}.merge(task_options || {})
+      while records = find(:all, options) do
+        break if records.size == 0
+        records.each do |record|
+          record.save!
+          yield(record) if block_given?
+        end
+      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.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
+      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/vendor/plugins/friendly_id/lib/friendly_id/active_record2/tasks/friendly_id.rake

@@ -0,0 +1,19 @@
+namespace :friendly_id do
+  desc "Make slugs for a model."
+  task :make_slugs => :environment do
+    FriendlyId::TaskRunner.new.make_slugs do |record|
+      puts "%s(%d): friendly_id set to '%s'" % [record.class.to_s, record.id, record.slug.name]
+    end
+  end
+
+  desc "Regenereate slugs for a model."
+  task :redo_slugs => :environment do
+    FriendlyId::TaskRunner.new.delete_slugs
+    Rake::Task["friendly_id:make_slugs"].invoke
+  end
+
+  desc "Kill obsolete slugs older than DAYS=45 days."
+  task :remove_old_slugs => :environment do
+    FriendlyId::TaskRunner.new.delete_old_slugs
+  end
+end

data/vendor/plugins/friendly_id/lib/friendly_id/configuration.rb

@@ -0,0 +1,132 @@
+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 = {
+      :ascii_approximation_options => [],
+      :max_length                  => 255,
+      :reserved_words              => ["index", "new"],
+      :reserved_message            => 'can not be "%s"',
+      :sequence_separator          => "--"
+    }
+
+    # 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
+
+    # A block or proc through which to filter the friendly_id text.
+    # This method will be removed from FriendlyId 3.0.
+    # @deprecated Please override the +normalize_friendly_id+
+    #   method in your model class rather than passing a block to `has_friendly_id`.
+    attr_accessor :normalizer
+
+    # 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 normalizer=(arg)
+      return if arg.nil?
+      warn("passing a block to has_friendly_id is deprecated and will be removed from 3.0. Please override #normalize_friendly_id.")
+      @normalizer = arg
+    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
+
+    # This method will be removed from FriendlyId 3.0.
+    # @deprecated Please use {#reserved_words reserved_words}.
+    def reserved=(*args)
+      warn('The "reserved" option is deprecated and will be removed from FriendlyId 3.0. Please use "reserved_words".')
+      self.reserved_words = *args
+    end
+
+    # This method will be removed from FriendlyId 3.0.
+    # @deprecated Please use {#approximate_ascii approximate_ascii}.
+    def strip_diacritics=(*args)
+      warn('strip_diacritics is deprecated and will be removed from 3.0. Please use #approximate_ascii')
+      self.approximate_ascii = *args
+    end
+
+    %w[approximate_ascii normalizer 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