mil_friendly_id 4.0.9.8

data/lib/friendly_id/configuration.rb

@@ -0,0 +1,80 @@
+module FriendlyId
+  # The configuration paramters passed to +friendly_id+ will be stored in
+  # this object.
+  class Configuration
+
+    # The base column or method used by FriendlyId as the basis of a friendly id
+    # or slug.
+    #
+    # For models that don't use FriendlyId::Slugged, the base is the column that
+    # is used as the FriendlyId directly. For models using FriendlyId::Slugged,
+    # the base is a column or method whose value is used as the basis of the
+    # slug.
+    #
+    # For example, if you have a model representing blog posts and that uses
+    # slugs, you likely will want to use the "title" attribute as the base, and
+    # FriendlyId will take care of transforming the human-readable title into
+    # something suitable for use in a URL.
+    #
+    # @param [Symbol] A symbol referencing a column or method in the model. This
+    #   value is usually set by passing it as the first argument to
+    #   {FriendlyId::Base#friendly_id friendly_id}:
+    #
+    # @example
+    #   class Book < ActiveRecord::Base
+    #     extend FriendlyId
+    #     friendly_id :name
+    #   end
+    attr_accessor :base
+
+    # The default configuration options.
+    attr_reader :defaults
+
+    # The model class that this configuration belongs to.
+    # @return ActiveRecord::Base
+    attr_accessor :model_class
+
+    def initialize(model_class, values = nil)
+      @model_class = model_class
+      @defaults    = {}
+      set values
+    end
+
+    # Lets you specify the modules to use with FriendlyId.
+    #
+    # This method is invoked by {FriendlyId::Base#friendly_id friendly_id} when
+    # passing the +:use+ option, or when using {FriendlyId::Base#friendly_id
+    # friendly_id} with a block.
+    #
+    # @example
+    #   class Book < ActiveRecord::Base
+    #     extend FriendlyId
+    #     friendly_id :name, :use => :slugged
+    #   end
+    # @param [#to_s,Module] *modules Arguments should be Modules, or symbols or
+    #   strings that correspond with the name of a module inside the FriendlyId
+    #   namespace. By default FriendlyId provides +:slugged+, +:history+,
+    #   +:simple_i18n+, +:globalize+, and +:scoped+.
+    def use(*modules)
+      modules.to_a.flatten.compact.map do |object|
+        mod = object.kind_of?(Module) ? object : FriendlyId.const_get(object.to_s.classify)
+        model_class.send(:include, mod)
+      end
+    end
+
+    # The column that FriendlyId will use to find the record when querying by
+    # friendly id.
+    #
+    # This method is generally only used internally by FriendlyId.
+    # @return String
+    def query_field
+      base.to_s
+    end
+
+    private
+
+    def set(values)
+      values and values.each {|name, value| self.send "#{name}=", value}
+    end
+  end
+end

data/lib/friendly_id/finder_methods.rb

@@ -0,0 +1,35 @@
+module FriendlyId
+  # These methods will be added to the model's {FriendlyId::Base#relation_class relation_class}.
+  module FinderMethods
+
+    protected
+
+    # FriendlyId overrides this method to make it possible to use friendly id's
+    # identically to numeric ids in finders.
+    #
+    # @example
+    #  person = Person.find(123)
+    #  person = Person.find("joe")
+    #
+    # @see FriendlyId::ObjectUtils
+    def find_one(id)
+      return super if id.unfriendly_id?
+      where(@klass.friendly_id_config.query_field => id).first or super
+    end
+
+    # FriendlyId overrides this method to make it possible to use friendly id's
+    # identically to numeric ids in finders.
+    #
+    # @example
+    #  person = Person.exists?(123)
+    #  person = Person.exists?("joe")
+    #  person = Person.exists?({:name => 'joe'})
+    #  person = Person.exists?(['name = ?', 'joe'])
+    #
+    # @see FriendlyId::ObjectUtils
+    def exists?(id = false)
+      return super if id.unfriendly_id?
+      super @klass.friendly_id_config.query_field => id
+    end
+  end
+end

data/lib/friendly_id/globalize.rb

@@ -0,0 +1,115 @@
+require 'i18n'
+
+module FriendlyId
+
+=begin
+
+== Translating Slugs Using Globalize
+
+The {FriendlyId::Globalize Globalize} module lets you use
+Globalize[https://github.com/svenfuchs/globalize3] to translate slugs. This
+module is most suitable for applications that need to be localized to many
+languages. If your application only needs to be localized to one or two
+languages, you may wish to consider the {FriendlyId::SimpleI18n SimpleI18n}
+module.
+
+In order to use this module, your model's table and translation table must both
+have a slug column, and your model must set the +slug+ field as translatable
+with Globalize:
+
+    class Post < ActiveRecord::Base
+      translates :title, :slug
+      extend FriendlyId
+      friendly_id :title, :use => :globalize
+    end
+
+=== Finds
+
+Finds will take the current locale into consideration:
+
+  I18n.locale = :it
+  Post.find("guerre-stellari")
+  I18n.locale = :en
+  Post.find("star-wars")
+
+Additionally, finds will fall back to the default locale:
+
+  I18n.locale = :it
+  Post.find("star-wars")
+
+To find a slug by an explicit locale, perform the find inside a block
+passed to I18n's +with_locale+ method:
+
+  I18n.with_locale(:it) { Post.find("guerre-stellari") }
+
+=== Creating Records
+
+When new records are created, the slug is generated for the current locale only.
+
+=== Translating Slugs
+
+To translate an existing record's friendly_id, use
+{FriendlyId::Globalize::Model#set_friendly_id}. This will ensure that the slug
+you add is properly escaped, transliterated and sequenced:
+
+  post = Post.create :name => "Star Wars"
+  post.set_friendly_id("Guerre stellari", :it)
+
+If you don't pass in a locale argument, FriendlyId::Globalize will just use the
+current locale:
+
+  I18n.with_locale(:it) { post.set_friendly_id("Guerre stellari") }
+
+=end
+  module Globalize
+
+    def self.included(model_class)
+      model_class.instance_eval do
+        friendly_id_config.use :slugged
+        relation_class.send :include, FinderMethods
+        include Model
+        # Check if slug field is enabled to be translated with Globalize
+        unless respond_to?('translated_attribute_names') || translated_attribute_names.exclude?(friendly_id_config.query_field.to_sym)
+          puts "\n[FriendlyId] You need to translate '#{friendly_id_config.query_field}' field with Globalize (add 'translates :#{friendly_id_config.query_field}' in your model '#{self.class.name}')\n\n"
+        end
+      end
+    end
+
+    module Model
+      def set_friendly_id(text, locale)
+        I18n.with_locale(locale || I18n.locale) do
+          set_slug(normalize_friendly_id(text))
+        end
+      end
+    end
+
+    module FinderMethods
+      # FriendlyId overrides this method to make it possible to use friendly id's
+      # identically to numeric ids in finders.
+      #
+      # @example
+      #  person = Person.find(123)
+      #  person = Person.find("joe")
+      #
+      # @see FriendlyId::ObjectUtils
+      def find_one(id)
+        return super if id.unfriendly_id?
+        found = where(@klass.friendly_id_config.query_field => id).first
+        found = includes(:translations).
+                where(translation_class.arel_table[:locale].in([I18n.locale, I18n.default_locale])).
+                where(translation_class.arel_table[@klass.friendly_id_config.query_field].eq(id)).first if found.nil?
+
+        if found
+          # Reload the translations for the found records.
+          found.tap { |f| f.translations.reload }
+        else
+          # if locale is not translated fallback to default locale
+          super
+        end
+      end
+
+      protected :find_one
+
+    end
+  end
+end

data/lib/friendly_id/history.rb

@@ -0,0 +1,134 @@
+module FriendlyId
+
+=begin
+
+== History: Avoiding 404's When Slugs Change
+
+FriendlyId's {FriendlyId::History History} module adds the ability to store a
+log of a model's slugs, so that when its friendly id changes, it's still
+possible to perform finds by the old id.
+
+The primary use case for this is avoiding broken URLs.
+
+=== Setup
+
+In order to use this module, you must add a table to your database schema to
+store the slug records. FriendlyId provides a generator for this purpose:
+
+  rails generate friendly_id
+  rake db:migrate
+
+This will add a table named +friendly_id_slugs+, used by the {FriendlyId::Slug}
+model.
+
+=== Considerations
+
+This module is incompatible with the +:scoped+ module.
+
+Because recording slug history requires creating additional database records,
+this module has an impact on the performance of the associated model's +create+
+method.
+
+=== Example
+
+    class Post < ActiveRecord::Base
+      extend FriendlyId
+      friendly_id :title, :use => :history
+    end
+
+    class PostsController < ApplicationController
+
+      before_filter :find_post
+
+      ...
+
+      def find_post
+        @post = Post.find params[:id]
+
+        # If an old id or a numeric id was used to find the record, then
+        # the request path will not match the post_path, and we should do
+        # a 301 redirect that uses the current friendly id.
+        if request.path != post_path(@post)
+          return redirect_to @post, :status => :moved_permanently
+        end
+      end
+    end
+=end
+  module History
+
+    # Configures the model instance to use the History add-on.
+    def self.included(model_class)
+      model_class.instance_eval do
+        raise "FriendlyId::History is incompatible with FriendlyId::Scoped" if self < Scoped
+        @friendly_id_config.use :slugged
+        has_many :slugs, :as => :sluggable, :dependent => :destroy,
+          :class_name => Slug.to_s, :order => "#{Slug.quoted_table_name}.id DESC"
+        after_save :create_slug
+        relation_class.send :include, FinderMethods
+        friendly_id_config.slug_generator_class.send :include, SlugGenerator
+      end
+    end
+
+    private
+
+    def create_slug
+      return unless friendly_id
+      return if slugs.first.try(:slug) == friendly_id
+      # Allow reversion back to a previously used slug
+      relation = slugs.where(:slug => friendly_id)
+      result = relation.select("id").lock(true).all
+      relation.delete_all unless result.empty?
+      slugs.create! do |record|
+        record.slug = friendly_id
+      end
+    end
+
+    # Adds a finder that explictly uses slugs from the slug table.
+    module FinderMethods
+
+      # Search for a record in the slugs table using the specified slug.
+      def find_one(id)
+        return super(id) if id.unfriendly_id?
+        where(@klass.friendly_id_config.query_field => id).first or
+        with_old_friendly_id(id) {|x| find_one_without_friendly_id(x)} or
+        find_one_without_friendly_id(id)
+      end
+
+      # Search for a record in the slugs table using the specified slug.
+      def exists?(id = false)
+        return super if id.unfriendly_id?
+        exists_without_friendly_id?(@klass.friendly_id_config.query_field => id) or
+        with_old_friendly_id(id) {|x| exists_without_friendly_id?(x)} or
+        exists_without_friendly_id?(id)
+      end
+
+      private
+
+      # Accepts a slug, and yields a corresponding sluggable_id into the block.
+      def with_old_friendly_id(slug, &block)
+        sql = "SELECT sluggable_id FROM #{Slug.quoted_table_name} WHERE sluggable_type = %s AND slug = %s"
+        sql = sql % [@klass.base_class.to_s, slug].map {|x| connection.quote(x)}
+        sluggable_id = connection.select_values(sql).first
+        yield sluggable_id if sluggable_id
+      end
+    end
+
+    # This module overrides {FriendlyId::SlugGenerator#conflicts} to consider
+    # all historic slugs for that model.
+    module SlugGenerator
+
+      private
+
+      def conflicts
+        sluggable_class = friendly_id_config.model_class.base_class
+        pkey            = sluggable_class.primary_key
+        value           = sluggable.send pkey
+
+        scope = Slug.with_deleted.where("slug = ? OR slug LIKE ?", normalized, wildcard)
+        scope = scope.where(:sluggable_type => sluggable_class.to_s)
+        scope = scope.where("sluggable_id <> ?", value) unless sluggable.new_record?
+        scope.order("LENGTH(slug) DESC, slug DESC")
+      end
+    end
+  end
+end

data/lib/friendly_id/migration.rb

@@ -0,0 +1,19 @@
+class CreateSlugs < ActiveRecord::Migration
+
+  def self.up
+    create_table :slugs do |t|
+      t.string     :slug,           :null => false
+      t.integer    :sluggable_id,   :null => false
+      t.string     :sluggable_type, :limit => 40
+      t.datetime   :created_at
+      t.deleted_at :boolean
+    end
+    add_index :slugs, :sluggable_id
+    add_index :slugs, [:slug, :sluggable_type], :unique => true
+    add_index :slugs, :sluggable_type
+  end
+
+  def self.down
+    drop_table :slugs
+  end
+end

data/lib/friendly_id/object_utils.rb

@@ -0,0 +1,50 @@
+module FriendlyId
+  # Utility methods for determining whether any object is a friendly id.
+  #
+  # Monkey-patching Object is a somewhat extreme measure not to be taken lightly
+  # by libraries, but in this case I decided to do it because to me, it feels
+  # cleaner than adding a module method to {FriendlyId}. I've given the methods
+  # names that unambigously refer to the library of their origin, which should
+  # be sufficient to avoid conflicts with other libraries.
+  module ObjectUtils
+
+    # True is the id is definitely friendly, false if definitely unfriendly,
+    # else nil.
+    #
+    # An object is considired "definitely unfriendly" if its class is or
+    # inherits from ActiveRecord::Base, Array, Hash, NilClass, Numeric, or
+    # Symbol.
+    #
+    # An object is considered "definitely friendly" if it responds to +to_i+,
+    # and its value when cast to an integer and then back to a string is
+    # different from its value when merely cast to a string:
+    #
+    #   123.friendly_id?                  #=> false
+    #   :id.friendly_id?                  #=> false
+    #   {:name => 'joe'}.friendly_id?     #=> false
+    #   ['name = ?', 'joe'].friendly_id?  #=> false
+    #   nil.friendly_id?                  #=> false
+    #   "123".friendly_id?                #=> nil
+    #   "abc123".friendly_id?             #=> true
+    def friendly_id?
+      # Considered unfriendly if this is an instance of an unfriendly class or
+      # one of its descendants.
+      unfriendly_classes = [ActiveRecord::Base, Array, Hash, NilClass, Numeric,
+                            Symbol, TrueClass, FalseClass]
+
+      if unfriendly_classes.detect {|klass| self.class <= klass}
+        false
+      elsif respond_to?(:to_i) && to_i.to_s != to_s
+        true
+      end
+    end
+
+    # True if the id is definitely unfriendly, false if definitely friendly,
+    # else nil.
+    def unfriendly_id?
+      val = friendly_id? ; !val unless val.nil?
+    end
+  end
+end
+
+Object.send :include, FriendlyId::ObjectUtils

data/lib/friendly_id/reserved.rb

@@ -0,0 +1,68 @@
+module FriendlyId
+
+=begin
+
+== Reserved Words
+
+The {FriendlyId::Reserved Reserved} module adds the ability to exlude a list of
+words from use as FriendlyId slugs.
+
+By default, FriendlyId reserves the words "new" and "edit" when this module is
+included. You can configure this globally by using {FriendlyId.defaults
+FriendlyId.defaults}:
+
+  FriendlyId.defaults do |config|
+    config.use :reserved
+    # Reserve words for English and Spanish URLs
+    config.reserved_words = %w(new edit nueva nuevo editar)
+  end
+
+Note that the error message will appear on the field +:friendly_id+. If you are
+using Rails's scaffolded form errors display, then it will have no field to
+highlight. If you'd like to change this so that scaffolding works as expected,
+one way to accomplish this is to move the error message to a different field.
+For example:
+
+  class Person < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :name, use: :slugged
+
+    after_validation :move_friendly_id_error_to_name
+
+    def move_friendly_id_error_to_name
+      errors.add :name, *errors.delete(:friendly_id) if errors[:friendly_id].present?
+    end
+  end
+
+=end
+  module Reserved
+
+    # When included, this module adds configuration options to the model class's
+    # friendly_id_config.
+    def self.included(model_class)
+      model_class.class_eval do
+        friendly_id_config.class.send :include, Reserved::Configuration
+        friendly_id_config.defaults[:reserved_words] ||= ["new", "edit"]
+      end
+    end
+
+    # This module adds the +:reserved_words+ configuration option to
+    # {FriendlyId::Configuration FriendlyId::Configuration}.
+    module Configuration
+      attr_writer :reserved_words
+
+      # Overrides {FriendlyId::Configuration#base} to add a validation to the
+      # model class.
+      def base=(base)
+        super
+        reserved_words = model_class.friendly_id_config.reserved_words
+        model_class.validates_exclusion_of :friendly_id, :in => reserved_words
+      end
+
+      # An array of words forbidden as slugs.
+      def reserved_words
+        @reserved_words ||= @defaults[:reserved_words]
+      end
+    end
+  end
+end