refinerycms 0.9.6.34 → 0.9.7

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

@@ -1,47 +0,0 @@
-require File.join(File.dirname(__FILE__), "active_record2", "configuration")
-require File.join(File.dirname(__FILE__), "active_record2", "finders")
-require File.join(File.dirname(__FILE__), "active_record2", "simple_model")
-require File.join(File.dirname(__FILE__), "active_record2", "slugged_model")
-require File.join(File.dirname(__FILE__), "active_record2", "slug")
-require File.join(File.dirname(__FILE__), "active_record2", "tasks")
-
-module FriendlyId
-
-  module ActiveRecord2
-
-    include FriendlyId::Base
-
-    def has_friendly_id(method, options = {}, &block)
-      class_inheritable_accessor :friendly_id_config
-      write_inheritable_attribute :friendly_id_config, Configuration.new(self,
-        method, options.merge(:normalizer => block))
-      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::ActiveRecord2
-end

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

@@ -1,66 +0,0 @@
-module FriendlyId
-  module ActiveRecord2
-
-    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::ActiveRecord2#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 cache_finders?
-        !! 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.klass.uses_friendly_id? }.map(&:klass)
-      end
-
-    end
-  end
-end

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

@@ -1,140 +0,0 @@
-module FriendlyId
-
-  # The adapter for Ruby on Rails's ActiveRecord. Compatible with AR 2.2.x -
-  # 2.3.x.
-  module ActiveRecord2
-
-    # 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
-
-        attr_reader :finder
-        attr :finder_class
-        attr :ids
-        attr :model_class
-        attr :options
-
-        def initialize(ids, model_class, options={})
-          @ids = ids
-          @model_class = model_class
-          @options = options
-        end
-
-        def method_missing(symbol, *args)
-          finder.send(symbol, *args)
-        end
-
-        # Perform the find query.
-        def finder
-          @finder ||= finder_class.new(ids, model_class, options)
-        end
-
-        private
-
-        def finder_class
-          @finder_class ||= slugged? ? slugged_finder_class : simple_finder_class
-        end
-
-        private
-
-        def cache_available?
-          !! model_class.friendly_id_config.cache_column
-        end
-
-        def multiple?
-          ids.kind_of? Array
-        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
-
-        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
-  end
-end

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

@@ -1,162 +0,0 @@
-module FriendlyId
-  module ActiveRecord2
-
-    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::Finders::Base
-        include FriendlyId::ActiveRecord2::Finders::Multiple
-        include SimpleFinder
-
-        def find
-          @results = with_scope(:find => options) { find_every :conditions => conditions }
-          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 = with_scope(:find => find_options) { find_initial 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
-
-      # 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, options)
-          finder = Finders::FinderProxy.new(id, self, options)
-          !finder.friendly? ? super : finder.find
-        end
-
-        def find_some(ids_and_names, options)
-          Finders::FinderProxy.new(ids_and_names, self, options).find
-        end
-      end
-
-      # These methods will be removed in FriendlyId 3.0.
-      module DeprecatedMethods
-
-        # 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, 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
-
-      end
-
-      def self.included(base)
-        base.class_eval do
-          column = friendly_id_config.column
-          validate :validate_friendly_id
-          validates_presence_of column
-          validates_length_of column, :maximum => friendly_id_config.max_length
-          after_update :update_scopes
-          extend FinderMethods
-          include DeprecatedMethods
-        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 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/vendor/plugins/friendly_id/lib/friendly_id/active_record2/slug.rb

@@ -1,111 +0,0 @@
-module FriendlyId
-  module ActiveRecord2
-
-    module DeprecatedSlugMethods
-      # @deprecated Please use String#parse_friendly_id
-      def parse(string)
-        warn("Slug#parse is deprecated and will be removed in FriendlyId 3.0. Please use String#parse_friendly_id.")
-        string.to_s.parse_friendly_id
-      end
-
-      # @deprecated Please use SlugString#normalize.
-      def normalize(slug_text)
-        warn("Slug#normalize is deprecated and will be removed in FriendlyId 3.0. Please use SlugString#normalize.")
-        raise BlankError if slug_text.blank?
-        SlugString.new(slug_text.to_s).normalize.to_s
-      end
-
-      # @deprecated Please use SlugString#approximate_ascii."
-      def strip_diacritics(string)
-        warn("Slug#strip_diacritics is deprecated and will be removed in FriendlyId 3.0. Please use SlugString#approximate_ascii.")
-        raise BlankError if string.blank?
-        SlugString.new(string).approximate_ascii
-      end
-
-      # @deprecated Please use SlugString#to_ascii.
-      def strip_non_ascii(string)
-        warn("Slug#strip_non_ascii is deprecated and will be removed in FriendlyId 3.0. Please use SlugString#to_ascii.")
-        raise BlankError if string.blank?
-        SlugString.new(string).to_ascii
-      end
-
-    end
-
-  end
-
-end
-
-# A Slug is a unique, human-friendly identifier for an ActiveRecord.
-class Slug < ::ActiveRecord::Base
-
-  extend FriendlyId::ActiveRecord2::DeprecatedSlugMethods
-
-  table_name = "slugs"
-  belongs_to :sluggable, :polymorphic => true
-  before_save :enable_name_reversion, :set_sequence
-  validate :validate_name
-  named_scope :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
-
-  # @deprecated Please used Slug#current?
-  def is_most_recent?
-    warn("Slug#is_most_recent? is deprecated and will be removed in FriendlyId 3.0. Please use Slug#current?")
-    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