friendly_id 2.2.7 → 2.3.0

data/lib/friendly_id/non_sluggable_instance_methods.rb

@@ -1,45 +0,0 @@
-module FriendlyId::NonSluggableInstanceMethods
-
-  def self.included(base)
-    base.validate :validate_friendly_id
-  end
-
-  attr :found_using_friendly_id
-
-  # Was the record found using one of its friendly ids?
-  def found_using_friendly_id?
-    @found_using_friendly_id
-  end
-
-  # Was the record found using its numeric id?
-  def found_using_numeric_id?
-    !@found_using_friendly_id
-  end
-  alias has_better_id? found_using_numeric_id?
-
-  # Returns the friendly_id.
-  def friendly_id
-    send friendly_id_options[:method]
-  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
-
-  def validate_friendly_id
-    if self.class.friendly_id_options[:reserved].include? friendly_id
-      self.errors.add(self.class.friendly_id_options[:method],
-        self.class.friendly_id_options[:reserved_message] % friendly_id)
-      return false
-    end
-  end
-
-  def found_using_friendly_id=(value) #:nodoc#
-    @found_using_friendly_id = value
-  end
-
-end

data/lib/friendly_id/slug.rb

@@ -1,98 +0,0 @@
-# A Slug is a unique, human-friendly identifier for an ActiveRecord.
-class Slug < ActiveRecord::Base
-
-  belongs_to :sluggable, :polymorphic => true
-  before_save :check_for_blank_name, :set_sequence
-
-
-  ASCII_APPROXIMATIONS = {
-    198 => "AE",
-    208 => "D",
-    216 => "O",
-    222 => "Th",
-    223 => "ss",
-    230 => "ae",
-    240 => "d",
-    248 => "o",
-    254 => "th"
-  }.freeze
-
-  class << self
-
-    # Sanitizes and dasherizes string to make it safe for URL's.
-    #
-    # Example:
-    #
-    #   slug.normalize('This... is an example!') # => "this-is-an-example"
-    #
-    # Note that the Unicode handling in ActiveSupport may fail to process some
-    # characters from Polish, Icelandic and other languages.
-    def normalize(slug_text)
-      return "" if slug_text.nil? || slug_text == ""
-      ActiveSupport::Multibyte.proxy_class.new(slug_text.to_s).normalize(:kc).
-        gsub(/[\W]/u, ' ').
-        strip.
-        gsub(/\s+/u, '-').
-        gsub(/-\z/u, '').
-        downcase.
-        to_s
-    end
-
-    def parse(friendly_id)
-      name, sequence = friendly_id.split('--')
-      sequence ||= "1"
-      return name, sequence
-    end
-
-    # Remove diacritics (accents, umlauts, etc.) from the string. Borrowed
-    # from "The Ruby Way."
-    def strip_diacritics(string)
-      a = ActiveSupport::Multibyte.proxy_class.new(string || "").normalize(:kd)
-      a.unpack('U*').inject([]) { |a, u|
-        if ASCII_APPROXIMATIONS[u]
-          a += ASCII_APPROXIMATIONS[u].unpack('U*')
-        elsif (u < 0x300 || u > 0x036F)
-          a << u
-        end
-        a
-      }.pack('U*')
-    end
-
-
-
-    # Remove non-ascii characters from the string.
-    def strip_non_ascii(string)
-      strip_diacritics(string).gsub(/[^a-z0-9]+/i, ' ')
-    end
-
-    private
-
-  end
-
-  # Whether or not this slug is the most recent of its owner's slugs.
-  def is_most_recent?
-    sluggable.slug == self
-  end
-
-  def to_friendly_id
-    sequence > 1 ? "#{name}--#{sequence}" : name
-  end
-
-  protected
-
-  # Raise a FriendlyId::SlugGenerationError if the slug name is blank.
-  def check_for_blank_name #:nodoc:#
-    if name.blank?
-      raise FriendlyId::SlugGenerationError.new("The slug text is blank.")
-    end
-  end
-
-  def set_sequence
-    return unless new_record?
-    last = Slug.find(:first, :conditions => { :name => name, :scope => scope,
-      :sluggable_type => sluggable_type}, :order => "sequence DESC",
-      :select => 'sequence')
-    self.sequence = last.sequence + 1 if last
-  end
-
-end

data/lib/friendly_id/sluggable_class_methods.rb

@@ -1,110 +0,0 @@
-module FriendlyId::SluggableClassMethods
-
-  include FriendlyId::Helpers
-
-  # Finds a single record using the friendly id, or the record's id.
-  def find_one(id_or_name, options) #:nodoc:#
-
-    scope = options.delete(:scope)
-    scope = scope.to_param if scope && scope.respond_to?(:to_param)
-
-    if id_or_name.is_a?(Integer) || id_or_name.kind_of?(ActiveRecord::Base)
-      return super(id_or_name, options)
-    end
-
-    find_options = {:select => "#{self.table_name}.*"}
-    find_options[:joins] = :slugs unless options[:include] && [*options[:include]].flatten.include?(:slugs)
-
-    name, sequence = Slug.parse(id_or_name)
-
-    find_options[:conditions] = {
-      "#{Slug.table_name}.name"     => name,
-      "#{Slug.table_name}.scope"    => scope,
-      "#{Slug.table_name}.sequence" => sequence
-    }
-
-    result = with_scope(:find => find_options) { find_initial(options) }
-    if result
-      result.finder_slug_name = id_or_name
-    elsif id_or_name.to_i.to_s != id_or_name
-      raise ActiveRecord::RecordNotFound
-    else
-      result = super id_or_name, options
-    end
-
-    result
-
-  rescue ActiveRecord::RecordNotFound => e
-
-    if friendly_id_options[:scope]
-      if !scope
-        raise ActiveRecord::RecordNotFound.new("%s; expected scope but got none" % e.message)
-      else
-        raise ActiveRecord::RecordNotFound.new("%s and scope=#{scope}" % e.message)
-      end
-    end
-
-    raise e
-
-  end
-
-  # Finds multiple records using the friendly ids, or the records' ids.
-  def find_some(ids_and_names, options) #:nodoc:#
-
-    slugs, ids = get_slugs_and_ids(ids_and_names, options)
-    results = []
-
-    find_options = {:select => "#{self.table_name}.*"}
-    find_options[:joins] = :slugs unless options[:include] && [*options[:include]].flatten.include?(:slugs)
-    find_options[:conditions] = "#{quoted_table_name}.#{primary_key} IN (#{ids.empty? ? 'NULL' : ids.join(',')}) "
-    find_options[:conditions] << "OR slugs.id IN (#{slugs.to_s(:db)})"
-
-    results = with_scope(:find => find_options) { find_every(options) }.uniq
-
-    expected = expected_size(ids_and_names, options)
-    if results.size != expected
-      raise ActiveRecord::RecordNotFound, "Couldn't find all #{ name.pluralize } with IDs (#{ ids_and_names * ', ' }) AND #{ sanitize_sql options[:conditions] } (found #{ results.size } results, but was looking for #{ expected })"
-    end
-
-    assign_finder_slugs(slugs, results)
-
-    results
-  end
-
-  def validate_find_options(options) #:nodoc:#
-    options.assert_valid_keys([:conditions, :include, :joins, :limit, :offset,
-      :order, :select, :readonly, :group, :from, :lock, :having, :scope])
-  end
-
-  private
-
-  # Assign finder slugs for the results found in find_some_with_friendly
-  def assign_finder_slugs(slugs, results) #:nodoc:#
-    slugs.each do |slug|
-      results.select { |r| r.id == slug.sluggable_id }.each do |result|
-        result.send(:finder_slug=, slug)
-      end
-    end
-  end
-
-  # Build arrays of slugs and ids, for the find_some_with_friendly method.
-  def get_slugs_and_ids(ids_and_names, options) #:nodoc:#
-    scope = options.delete(:scope)
-    slugs = []
-    ids = []
-    ids_and_names.each do |id_or_name|
-      name, sequence = Slug.parse id_or_name.to_s
-      slug = Slug.find(:first, :conditions => {
-        :name           => name,
-        :scope          => scope,
-        :sequence       => sequence,
-        :sluggable_type => base_class.name
-      })
-      # If the slug was found, add it to the array for later use. If not, and
-      # the id_or_name is a number, assume that it is a regular record id.
-      slug ? slugs << slug : (ids << id_or_name if id_or_name.to_s =~ /\A\d*\z/)
-    end
-    return slugs, ids
-  end
-
-end

data/lib/friendly_id/sluggable_instance_methods.rb

@@ -1,161 +0,0 @@
-module FriendlyId::SluggableInstanceMethods
-
-  def self.included(base)
-    base.class_eval do
-      has_many :slugs, :order => 'id DESC', :as => :sluggable, :dependent => :destroy
-      before_save :set_slug
-      after_save :set_slug_cache
-      # only protect the column if the class is not already using attributes_accessible
-      if !accessible_attributes
-        if friendly_id_options[:cache_column]
-          attr_protected friendly_id_options[:cache_column].to_sym
-        end
-        attr_protected :cached_slug
-      end
-    end
-
-    def base.cache_column
-      if defined?(@cache_column)
-        return @cache_column
-      elsif friendly_id_options[:cache_column]
-        @cache_column = friendly_id_options[:cache_column].to_sym
-      elsif columns.any? { |c| c.name == 'cached_slug' }
-        @cache_column = :cached_slug
-      else
-        @cache_column = nil
-      end
-    end
-
-  end
-
-  NUM_CHARS_RESERVED_FOR_FRIENDLY_ID_EXTENSION = 2
-
-  attr :finder_slug
-  attr_accessor :finder_slug_name
-
-  def finder_slug
-    @finder_slug ||= init_finder_slug or nil
-  end
-
-  # Was the record found using one of its friendly ids?
-  def found_using_friendly_id?
-    !!@finder_slug_name
-  end
-
-  # Was the record found using its numeric id?
-  def found_using_numeric_id?
-    !found_using_friendly_id?
-  end
-
-  # Was the record found using an old friendly id?
-  def found_using_outdated_friendly_id?
-    return false if cache_column && send(cache_column) == @finder_slug_name
-    finder_slug.id != slug.id
-  end
-
-  # Was the record found using an old friendly id, or its numeric id?
-  def has_better_id?
-    has_a_slug? and found_using_numeric_id? || found_using_outdated_friendly_id?
-  end
-
-  # Does the record have (at least) one slug?
-  def has_a_slug?
-    @finder_slug_name || slug
-  end
-
-  # Returns the friendly id.
-  def friendly_id
-    slug(true).to_friendly_id
-  end
-  alias best_id friendly_id
-
-  # Has the basis of our friendly id changed, requiring the generation of a
-  # new slug?
-  def new_slug_needed?
-    !slug || slug_text != slug.name
-  end
-
-  # Returns the most recent slug, which is used to determine the friendly
-  # id.
-  def slug(reload = false)
-    @most_recent_slug = nil if reload
-    @most_recent_slug ||= slugs.first(:order => "id DESC")
-  end
-
-  # Returns the friendly id, or if none is available, the numeric id.
-  def to_param
-    if cache_column
-      read_attribute(cache_column) || id.to_s
-    else
-      slug ? slug.to_friendly_id : id.to_s
-    end
-  end
-
-  # Get the processed string used as the basis of the friendly id.
-  def slug_text
-    base = send friendly_id_options[:method]
-    if self.slug_normalizer_block
-      base = self.slug_normalizer_block.call(base)
-    else
-      if self.friendly_id_options[:strip_diacritics]
-        base = Slug::strip_diacritics(base)
-      end
-      if self.friendly_id_options[:strip_non_ascii]
-        base = Slug::strip_non_ascii(base)
-      end
-      base = Slug::normalize(base)
-    end
-
-    if base.mb_chars.length > friendly_id_options[:max_length]
-      base = base.mb_chars[0...friendly_id_options[:max_length]]
-    end
-    if friendly_id_options[:reserved].include?(base)
-      raise FriendlyId::SlugGenerationError.new("The slug text is a reserved value")
-    end
-    return base
-  end
-
-private
-
-  def cache_column
-    self.class.cache_column
-  end
-
-  def finder_slug=(finder_slug)
-    @finder_slug_name = finder_slug.name
-    slug = finder_slug
-    slug.sluggable = self
-    slug
-  end
-
-  def init_finder_slug
-    return false if !@finder_slug_name
-    name, sequence = Slug.parse(@finder_slug_name)
-    slug = Slug.find(:first, :conditions => {:sluggable_id => id, :name => name, :sequence => sequence, :sluggable_type => self.class.base_class.name })
-    finder_slug = slug
-  end
-
-  # Set the slug using the generated friendly id.
-  def set_slug
-    if self.class.friendly_id_options[:use_slug] && new_slug_needed?
-      @most_recent_slug = nil
-      slug_attributes = {:name => slug_text}
-      if friendly_id_options[:scope]
-        scope = send(friendly_id_options[:scope])
-        slug_attributes[:scope] = scope.respond_to?(:to_param) ? scope.to_param : scope.to_s
-      end
-      # 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.
-      slugs.find(:all, :conditions => {:name => slug_text, :scope => slug_attributes[:scope]}).each { |s| s.destroy }
-      slugs.build slug_attributes
-    end
-  end
-
-  def set_slug_cache
-    if cache_column && send(cache_column) != slug.to_friendly_id
-      send "#{cache_column}=", slug.to_friendly_id
-      send :update_without_callbacks
-    end
-  end
-
-end

data/lib/friendly_id/tasks.rb

@@ -1,56 +0,0 @@
-module FriendlyId
-  class Tasks
-    class << self
-
-      def make_slugs(klass, options = {})
-        klass = parse_class_name(klass)
-        validate_uses_slugs(klass)
-        options = {:limit => 100, :include => :slugs, :conditions => "slugs.id IS NULL"}.merge(options)
-        while records = klass.find(:all, options) do
-          break if records.size == 0
-          records.each do |r|
-            r.save!
-            yield(r) if block_given?
-          end
-        end
-      end
-
-      def delete_slugs_for(klass)
-        klass = parse_class_name(klass)
-        validate_uses_slugs(klass)
-        Slug.destroy_all(["sluggable_type = ?", klass.to_s])
-        if klass.cache_column
-          klass.update_all("#{klass.cache_column} = NULL")
-        end
-      end
-
-      def delete_old_slugs(days = nil, class_name = nil)
-        days = days.blank? ? 45 : days.to_i
-        klass = class_name.blank? ? nil : parse_class_name(class_name.to_s)
-        conditions = ["created_at < ?", DateTime.now - days.days]
-        if klass
-          conditions[0] << " AND sluggable_type = ?"
-          conditions << klass.to_s
-        end
-        slugs = Slug.find :all, :conditions => conditions
-        slugs.each { |s| s.destroy unless s.is_most_recent? }
-      end
-
-      def parse_class_name(class_name)
-        return class_name if class_name.class == Class
-        if (class_name.split('::').size > 1)
-          class_name.split('::').inject(Kernel) {|scope, const_name| scope.const_get(const_name)}
-        else
-          Object.const_get(class_name)
-        end
-      end
-
-      private
-
-      def validate_uses_slugs(klass)
-        raise "Class '%s' doesn't use slugs" % klass.to_s unless klass.friendly_id_options[:use_slug]
-      end
-
-    end
-  end
-end