friendly_id_globalize3 3.2.0

data/lib/friendly_id/active_record_adapter/simple_model.rb

@@ -0,0 +1,63 @@
+module FriendlyId
+  module ActiveRecordAdapter
+
+    module SimpleModel
+
+      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::Finders unless FriendlyId.on_ar3?
+        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,77 @@
+# A Slug is a unique, human-friendly identifier for an ActiveRecord.
+class Slug < ::ActiveRecord::Base
+  attr_writer :sluggable
+  attr_accessible :name, :scope, :sluggable, :sequence, :locale
+  def self.named_scope(*args, &block) scope(*args, &block) end if FriendlyId.on_ar3?
+  table_name = "slugs"
+  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"
+    }
+  }
+
+  def sluggable
+    sluggable_id && !@sluggable and begin
+      klass = sluggable_type.constantize
+      klass.send(:with_exclusive_scope) do
+        @sluggable = klass.find(sluggable_id.to_i)
+      end
+    end
+    @sluggable
+  end
+
+  # 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

data/lib/friendly_id/active_record_adapter/slugged_model.rb

@@ -0,0 +1,122 @@
+module FriendlyId
+  module ActiveRecordAdapter
+    module SluggedModel
+
+      def self.included(base)
+        base.class_eval do
+          has_many :slugs, :order => 'id DESC', :as => :sluggable, :dependent => :destroy
+          has_one :slug, :order => 'id DESC', :as => :sluggable, :dependent => :destroy,
+                  :conditions => ({:locale => (Thread.current[:globalize_locale] || ::I18n.locale)} if friendly_id_config.class.locales_used?)
+          before_save :build_a_slug
+          after_save :set_slug_cache
+          after_update :update_scope
+          after_update :update_dependent_scopes
+          protect_friendly_id_attributes
+          extend FriendlyId::ActiveRecordAdapter::Finders unless FriendlyId.on_ar3?
+        end
+      end
+
+      include FriendlyId::Slugged::Model
+
+      def find_slug(name, sequence)
+        slugs.find_by_name_and_sequence(name, sequence)
+      end
+
+      # Returns the friendly id, or if none is available, the numeric id. Note that this
+      # method will use the cached_slug value if present, unlike {#friendly_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
+        unless friendly_id_config.class.locales_used?
+          slug? ? slug.to_friendly_id : id.to_s
+        else
+          locale = (Thread.current[:globalize_locale] || ::I18n.locale).to_s
+          if (locale_slug = slugs.detect{|s| s.locale.to_s == locale}).present?
+            locale_slug.to_friendly_id
+          else
+            id.to_s
+          end
+        end
+      end
+
+      # Build the new slug using the generated friendly id.
+      def build_a_slug
+        return unless new_slug_needed?
+        @slug = slugs.build :name => slug_text.to_s, :scope => friendly_id_config.scope_for(self),
+          :sluggable => self
+        @slug.locale = Thread.current[:globalize_locale] || ::I18n.locale if friendly_id_config.class.locales_used?
+        @new_friendly_id = @slug.to_friendly_id
+      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?
+          begin
+            send "#{friendly_id_config.cache_column}=", slug.to_friendly_id
+            update_without_callbacks
+          rescue ActiveRecord::StaleObjectError
+            reload
+            retry
+          end
+        end
+      end
+
+      def update_scope
+        return unless slug && scope_changed?
+        self.class.transaction do
+          slug.scope = send(friendly_id_config.scope).to_param
+          similar = Slug.similar_to(slug)
+          if !similar.empty?
+            slug.sequence = similar.first.sequence.succ
+          end
+          slug.save!
+        end
+      end
+
+      # Update the slugs for any model that is using this model as its
+      # FriendlyId scope.
+      def update_dependent_scopes
+        return unless friendly_id_config.class.scopes_used?
+        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
+
+      # This method was removed in ActiveRecord 3.0.
+      if !ActiveRecord::Base.private_method_defined? :update_without_callbacks
+        def update_without_callbacks
+          attributes_with_values = arel_attributes_values(false, false, attribute_names)
+          return false if attributes_with_values.empty?
+          self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).arel.update(attributes_with_values)
+        end
+      end
+    end
+  end
+end

data/lib/friendly_id/active_record_adapter/tasks.rb

@@ -0,0 +1,72 @@
+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
+      options = {
+        :include => :slug,
+        :limit   => (ENV["LIMIT"] || 100).to_i,
+        :offset  => 0,
+        :order   => ENV["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) unless record.slug?
+          yield(record) if block_given?
+        end
+        options[:offset] += options[:limit]
+      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,178 @@
+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,
+  #    :default_locale => :en
+  #    # 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          => "--",
+      :default_locale              => :en
+    }
+
+    # 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.
+    attr_accessor :ascii_approximation_options
+
+    # The class that's using the configuration.
+    attr_reader :configured_class
+
+    # The maximum allowed byte 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_reader :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
+
+    # Allows setting the default locale when locale column is present.
+    attr_accessor :locale, :default_locale
+
+    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 cache_column=(value)
+      @cache_column = value.to_s.strip.to_sym
+      if value =~ /\s/ || [:slug, :slugs].include?(@cache_column)
+        raise ArgumentError, "FriendlyId cache column can not be named '#{value}'"
+      end
+      @cache_column
+    end
+
+    # This should be overridden by adapters that implement caching.
+    def cache_column?
+      false
+    end
+
+    def reserved_words=(*args)
+      if args.first.kind_of?(Regexp)
+        @reserved_words = args.first
+      else
+        @reserved_words = args.flatten.uniq
+      end
+    end
+
+    def reserved?(word)
+      word = word.to_s
+      if reserved_words.kind_of?(Regexp)
+        reserved_words =~ word
+      else
+        reserved_words.include?(word)
+      end
+    end
+
+    def reserved_error_message(word)
+      [method, reserved_message % word] if reserved? word
+    end
+
+    def scope=(scope)
+      self.class.scopes_used = true
+      @scope = scope
+    end
+
+    def sequence_separator=(string)
+      if string == "-" || string =~ /\s/
+        raise ArgumentError, "FriendlyId sequence_separator can not be '#{string}'"
+      end
+      @sequence_separator = string
+    end
+
+    class << self
+      # This will be set if FriendlyId's scope feature is used in any model. It is here
+      # to provide a way to avoid invoking costly scope lookup methods when the scoped
+      # slug feature is not being used by any models.
+      def scopes_used=(val)
+        @scopes_used = !!val
+      end
+
+      # Are scoped slugs being used by any model?
+      # @see Configuration.scoped_used=
+      def scopes_used?
+        @scopes_used
+      end
+
+      # Are localed used by the slugs model?
+      def locales_used?
+        ::Slug.table_exists? && ::Slug.column_names.include?('locale')
+      end
+    end
+
+    %w[approximate_ascii scope strip_non_ascii use_slug locale].each do |method|
+      class_eval(<<-EOM, __FILE__, __LINE__ + 1)
+        def #{method}?
+          !! #{method}
+        end
+      EOM
+    end
+
+    alias :use_slugs? :use_slug?
+
+    def babosa_options
+      {
+        :to_ascii         => strip_non_ascii?,
+        :transliterate    => approximate_ascii?,
+        :transliterations => ascii_approximation_options,
+        :max_length       => max_length
+      }
+    end
+  end
+end