geothird_friendly_id 4.0.9.1

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

data/lib/friendly_id/scoped.rb

@@ -0,0 +1,149 @@
+require "friendly_id/slugged"
+
+module FriendlyId
+
+=begin
+
+== Unique Slugs by Scope
+
+The {FriendlyId::Scoped} module allows FriendlyId to generate unique slugs
+within a scope.
+
+This allows, for example, two restaurants in different cities to have the slug
++joes-diner+:
+
+    class Restaurant < ActiveRecord::Base
+      extend FriendlyId
+      belongs_to :city
+      friendly_id :name, :use => :scoped, :scope => :city
+    end
+
+    class City < ActiveRecord::Base
+      extend FriendlyId
+      has_many :restaurants
+      friendly_id :name, :use => :slugged
+    end
+
+    City.find("seattle").restaurants.find("joes-diner")
+    City.find("chicago").restaurants.find("joes-diner")
+
+Without :scoped in this case, one of the restaurants would have the slug
++joes-diner+ and the other would have +joes-diner--2+.
+
+The value for the +:scope+ option can be the name of a +belongs_to+ relation, or
+a column.
+
+=== Finding Records by Friendly ID
+
+If you are using scopes your friendly ids may not be unique, so a simple find
+like
+
+    Restaurant.find("joes-diner")
+
+may return the wrong record. In these cases it's best to query through the
+relation:
+
+    @city.restaurants.find("joes-diner")
+
+Alternatively, you could pass the scope value as a query parameter:
+
+    Restaurant.find("joes-diner").where(:city_id => @city.id)
+
+
+=== Finding All Records That Match a Scoped ID
+
+Query the slug column directly:
+
+    Restaurant.find_all_by_slug("joes-diner")
+
+=== Routes for Scoped Models
+
+Recall that FriendlyId is a database-centric library, and does not set up any
+routes for scoped models. You must do this yourself in your application. Here's
+an example of one way to set this up:
+
+    # in routes.rb
+    resources :cities do
+      resources :restaurants
+    end
+
+    # in views
+    <%= link_to 'Show', [@city, @restaurant] %>
+
+    # in controllers
+    @city = City.find(params[:city_id])
+    @restaurant = @city.restaurants.find(params[:id])
+
+    # URLs:
+    http://example.org/cities/seattle/restaurants/joes-diner
+    http://example.org/cities/chicago/restaurants/joes-diner
+
+=end
+  module Scoped
+
+
+    # Sets up behavior and configuration options for FriendlyId's scoped slugs
+    # feature.
+    def self.included(model_class)
+      model_class.instance_eval do
+        raise "FriendlyId::Scoped is incompatibe with FriendlyId::History" if self < History
+        include Slugged unless self < Slugged
+        friendly_id_config.class.send :include, Configuration
+        friendly_id_config.slug_generator_class.send :include, SlugGenerator
+      end
+    end
+
+    # This module adds the +:scope+ configuration option to
+    # {FriendlyId::Configuration FriendlyId::Configuration}.
+    module Configuration
+
+      # Gets the scope value.
+      #
+      # When setting this value, the argument should be a symbol referencing a
+      # +belongs_to+ relation, or a column.
+      #
+      # @return Symbol The scope value
+      attr_accessor :scope
+
+      # Gets the scope columns.
+      #
+      # Checks to see if the +:scope+ option passed to
+      # {FriendlyId::Base#friendly_id} refers to a relation, and if so, returns
+      # the realtion's foreign key. Otherwise it assumes the option value was
+      # the name of column and returns it cast to a String.
+      #
+      # @return String The scope column
+      def scope_columns
+        [@scope].flatten.map { |s| (reflection_foreign_key(s) or s).to_s }
+      end
+
+      private
+
+      if ActiveRecord::VERSION::STRING < "3.1"
+        def reflection_foreign_key(scope)
+          model_class.reflections[scope].try(:primary_key_name)
+        end
+      else
+        def reflection_foreign_key(scope)
+          model_class.reflections[scope].try(:foreign_key)
+        end
+      end
+    end
+
+    # This module overrides {FriendlyId::SlugGenerator#conflict} to consider
+    # scope, to avoid adding sequences to slugs under different scopes.
+    module SlugGenerator
+
+      private
+
+      def conflict
+        columns = friendly_id_config.scope_columns
+        matched = columns.inject(conflicts) do |memo, column|
+           memo.where(column => sluggable.send(column))
+        end
+
+        matched.first
+      end
+    end
+  end
+end

data/lib/friendly_id/simple_i18n.rb

@@ -0,0 +1,95 @@
+require "i18n"
+
+module FriendlyId
+
+=begin
+
+== Translating Slugs Using Simple I18n
+
+The {FriendlyId::SimpleI18n SimpleI18n} module adds very basic i18n support to
+FriendlyId.
+
+In order to use this module, your model must have a slug column for each locale.
+By default FriendlyId looks for columns named, for example, "slug_en",
+"slug_es", etc. The first part of the name can be configured by passing the
++:slug_column+ option if you choose. Note that the column for the default locale
+must also include the locale in its name.
+
+This module is most suitable to applications that need to support few locales.
+If you need to support two or more locales, you may wish to use the
+{FriendlyId::Globalize Globalize} module instead.
+
+=== Example migration
+
+  def self.up
+    create_table :posts do |t|
+      t.string :title
+      t.string :slug_en
+      t.string :slug_es
+      t.text   :body
+    end
+    add_index :posts, :slug_en
+    add_index :posts, :slug_es
+  end
+
+=== Finds
+
+Finds will take into consideration the current locale:
+
+  I18n.locale = :es
+  Post.find("la-guerra-de-las-galaxas")
+  I18n.locale = :en
+  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(:es) do
+    Post.find("la-guerra-de-las-galaxas")
+  end
+
+=== 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::SimpleI18n::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("La guerra de las galaxas", :es)
+
+If you don't pass in a locale argument, FriendlyId::SimpleI18n will just use the
+current locale:
+
+  I18n.with_locale(:es) do
+    post.set_friendly_id("La guerra de las galaxas")
+  end
+=end
+  module SimpleI18n
+
+    def self.included(model_class)
+      model_class.instance_eval do
+        friendly_id_config.use :slugged
+        friendly_id_config.class.send :include, Configuration
+        include Model
+      end
+    end
+
+    module Model
+      def set_friendly_id(text, locale = nil)
+        I18n.with_locale(locale || I18n.locale) do
+          set_slug(normalize_friendly_id(text))
+        end
+      end
+    end
+
+    module Configuration
+      def slug_column
+        "#{super}_#{I18n.locale}"
+      end
+    end
+  end
+end

data/lib/friendly_id/slug.rb

@@ -0,0 +1,14 @@
+module FriendlyId
+  # A FriendlyId slug stored in an external table.
+  #
+  # @see FriendlyId::History
+  class Slug < ActiveRecord::Base
+    self.table_name = "friendly_id_slugs"
+    belongs_to :sluggable, :polymorphic => true
+
+    def to_param
+      slug
+    end
+
+  end
+end

data/lib/friendly_id/slug_generator.rb

@@ -0,0 +1,80 @@
+module FriendlyId
+  # The default slug generator offers functionality to check slug strings for
+  # uniqueness and, if necessary, appends a sequence to guarantee it.
+  class SlugGenerator
+    attr_reader :sluggable, :normalized
+
+    # Create a new slug generator.
+    def initialize(sluggable, normalized)
+      @sluggable  = sluggable
+      @normalized = normalized
+    end
+
+    # Given a slug, get the next available slug in the sequence.
+    def next
+      "#{normalized}#{separator}#{next_in_sequence}"
+    end
+
+    # Generate a new sequenced slug.
+    def generate
+      conflict? ? self.next : normalized
+    end
+
+    private
+
+    def next_in_sequence
+      last_in_sequence == 0 ? 2 : last_in_sequence.next
+    end
+
+    def last_in_sequence
+      @_last_in_sequence ||= extract_sequence_from_slug(conflict.to_param)
+    end
+
+    def extract_sequence_from_slug(slug)
+      slug.split("#{normalized}#{separator}").last.to_i
+    end
+
+    def column
+      sluggable.connection.quote_column_name friendly_id_config.slug_column
+    end
+
+    def conflict?
+      !! conflict
+    end
+
+    def conflict
+      unless defined? @conflict
+        @conflict = conflicts.first
+      end
+      @conflict
+    end
+
+    def conflicts
+      sluggable_class = friendly_id_config.model_class.base_class
+
+      pkey  = sluggable_class.primary_key
+      value = sluggable.send pkey
+      base = "#{column} = ? OR #{column} LIKE ?"
+      # Awful hack for SQLite3, which does not pick up '\' as the escape character without this.
+      base << "ESCAPE '\\'" if sluggable.connection.adapter_name =~ /sqlite/i
+      scope = sluggable_class.unscoped.where(base, normalized, wildcard)
+      scope = scope.where("#{pkey} <> ?", value) unless sluggable.new_record?
+      scope = scope.order("LENGTH(#{column}) DESC, #{column} DESC")
+    end
+
+    def friendly_id_config
+      sluggable.friendly_id_config
+    end
+
+    def separator
+      friendly_id_config.sequence_separator
+    end
+
+    def wildcard
+      # Underscores (matching a single character) and percent signs (matching
+      # any number of characters) need to be escaped
+      # (While this seems like an excessive number of backslashes, it is correct)
+      "#{normalized}#{separator}".gsub(/[_%]/, '\\\\\&') + '%'
+    end
+  end
+end