mil_friendly_id 4.0.9.8

data/gemfiles/Gemfile.rails-3.0.rb

@@ -0,0 +1,21 @@
+source :rubygems
+
+platforms :jruby do
+  gem 'activerecord-jdbcsqlite3-adapter'
+  gem 'activerecord-jdbcmysql-adapter'
+  gem 'activerecord-jdbcpostgresql-adapter'
+  gem 'jruby-openssl'
+end
+
+platforms :ruby do
+  gem 'sqlite3'
+  gem 'mysql2', '~> 0.2.0'
+  gem 'pg'
+end
+
+gem 'activerecord', '~> 3.0.0'
+gem 'railties', '~> 3.0.0'
+gem 'minitest', '3.2.0'
+gem 'mocha'
+gem 'rake'
+gem 'globalize3'

data/gemfiles/Gemfile.rails-3.1.rb

@@ -0,0 +1,22 @@
+source :rubygems
+
+platforms :jruby do
+  gem 'activerecord-jdbcsqlite3-adapter'
+  gem 'activerecord-jdbcmysql-adapter'
+  gem 'activerecord-jdbcpostgresql-adapter'
+  gem 'jruby-openssl'
+end
+
+platforms :ruby do
+  gem 'sqlite3'
+  gem 'mysql2'
+  gem 'pg'
+end
+
+gem 'activerecord', '~> 3.1.0'
+gem 'railties', '~> 3.1.3'
+gem 'ffaker'
+gem 'minitest', '3.2.0'
+gem 'mocha'
+gem 'rake'
+gem 'globalize3'

data/gemfiles/Gemfile.rails-3.2.rb

@@ -0,0 +1,22 @@
+source :rubygems
+
+platforms :jruby do
+  gem 'activerecord-jdbcsqlite3-adapter'
+  gem 'activerecord-jdbcmysql-adapter'
+  gem 'activerecord-jdbcpostgresql-adapter'
+  gem 'jruby-openssl'
+end
+
+platforms :ruby do
+  gem 'sqlite3'
+  gem 'mysql2'
+  gem 'pg'
+end
+
+gem 'ffaker'
+gem 'activerecord', '~> 3.2.0'
+gem 'railties', '~> 3.2.0'
+gem 'minitest', '3.2.0'
+gem 'mocha'
+gem 'rake'
+gem 'globalize3'

data/geothird_friendly_id.gemspec

@@ -0,0 +1,45 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+
+require "friendly_id"
+
+Gem::Specification.new do |s|
+  s.name              = "geothird_friendly_id"
+  s.version           = FriendlyId::VERSION
+  s.authors           = ["Norman Clarke", "Philip Arndt"]
+  s.email             = ["norman@njclarke.com", "parndt@gmail.com"]
+  s.homepage          = "http://github.com/norman/friendly_id"
+  s.summary           = "A comprehensive slugging and pretty-URL plugin."
+  s.rubyforge_project = "friendly_id"
+  s.files             = `git ls-files`.split("\n")
+  s.test_files        = `git ls-files -- {test}/*`.split("\n")
+  s.require_paths     = ["lib"]
+
+  s.add_dependency 'acts_as_paranoid', '0.4.1'
+
+  s.add_development_dependency "railties", "~> 3.2.0"
+  s.add_development_dependency "activerecord", "~> 3.2.0"
+  s.add_development_dependency "minitest", "3.2.0"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "maruku"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "i18n"
+  s.add_development_dependency "ffaker"
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "globalize3"
+
+  s.description = <<-EOM
+FriendlyId is the "Swiss Army bulldozer" of slugging and permalink plugins for
+Ruby on Rails. It allows you to create pretty URLs and work with human-friendly
+strings as if they were numeric ids for Active Record models.
+EOM
+
+  s.post_install_message = <<-EOM
+NOTE: FriendlyId 4.x breaks compatibility with 3.x. If you're upgrading
+from 3.x, please see this document:
+
+http://rubydoc.info/github/norman/friendly_id/master/file/WhatsNew.md
+
+EOM
+
+end

data/lib/friendly_id.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+require "thread"
+require "friendly_id/base"
+require "friendly_id/object_utils"
+require "friendly_id/configuration"
+require "friendly_id/finder_methods"
+
+=begin
+
+== About FriendlyId
+
+FriendlyId is an add-on to Ruby's Active Record that allows you to replace ids
+in your URLs with strings:
+
+    # without FriendlyId
+    http://example.com/states/4323454
+
+    # with FriendlyId
+    http://example.com/states/washington
+
+It requires few changes to your application code and offers flexibility,
+performance and a well-documented codebase.
+
+=== Core Concepts
+
+==== Slugs
+
+The concept of "slugs[http://en.wikipedia.org/wiki/Slug_(web_publishing)]" is at
+the heart of FriendlyId.
+
+A slug is the part of a URL which identifies a page using human-readable
+keywords, rather than an opaque identifier such as a numeric id. This can make
+your application more friendly both for users and search engine.
+
+==== Finders: Slugs Act Like Numeric IDs
+
+To the extent possible, FriendlyId lets you treat text-based identifiers like
+normal IDs. This means that you can perform finds with slugs just like you do
+with numeric ids:
+
+    Person.find(82542335)
+    Person.find("joe")
+
+=end
+module FriendlyId
+
+  # The current version.
+  VERSION = "4.0.9.8"
+
+  @mutex = Mutex.new
+
+  autoload :History,    "friendly_id/history"
+  autoload :Slug,       "friendly_id/slug"
+  autoload :SimpleI18n, "friendly_id/simple_i18n"
+  autoload :Reserved,   "friendly_id/reserved"
+  autoload :Scoped,     "friendly_id/scoped"
+  autoload :Slugged,    "friendly_id/slugged"
+  autoload :Globalize,  "friendly_id/globalize"
+
+  # FriendlyId takes advantage of `extended` to do basic model setup, primarily
+  # extending {FriendlyId::Base} to add {FriendlyId::Base#friendly_id
+  # friendly_id} as a class method.
+  #
+  # Previous versions of FriendlyId simply patched ActiveRecord::Base, but this
+  # version tries to be less invasive.
+  #
+  # In addition to adding {FriendlyId::Base#friendly_id friendly_id}, the class
+  # instance variable +@friendly_id_config+ is added. This variable is an
+  # instance of an anonymous subclass of {FriendlyId::Configuration}. This
+  # allows subsequently loaded modules like {FriendlyId::Slugged} and
+  # {FriendlyId::Scoped} to add functionality to the configuration class only
+  # for the current class, rather than monkey patching
+  # {FriendlyId::Configuration} directly. This isolates other models from large
+  # feature changes an addon to FriendlyId could potentially introduce.
+  #
+  # The upshot of this is, you can have two Active Record models that both have
+  # a @friendly_id_config, but each config object can have different methods
+  # and behaviors depending on what modules have been loaded, without
+  # conflicts.  Keep this in mind if you're hacking on FriendlyId.
+  #
+  # For examples of this, see the source for {Scoped.included}.
+  def self.extended(model_class)
+    return if model_class.respond_to? :friendly_id
+    class << model_class
+      alias relation_without_friendly_id relation
+    end
+    model_class.instance_eval do
+      extend Base
+      @friendly_id_config = Class.new(Configuration).new(self)
+      FriendlyId.defaults.call @friendly_id_config
+    end
+  end
+
+  # Allow developers to `include` FriendlyId or `extend` it.
+  def self.included(model_class)
+    model_class.extend self
+  end
+
+  # Set global defaults for all models using FriendlyId.
+  #
+  # The default defaults are to use the +:reserved+ module and nothing else.
+  #
+  # @example
+  #   FriendlyId.defaults do |config|
+  #     config.base = :name
+  #     config.use :slugged
+  #   end
+  def self.defaults(&block)
+    @mutex.synchronize do
+      @defaults = block if block_given?
+      @defaults ||= lambda {|config| config.use :reserved}
+    end
+  end
+end

data/lib/friendly_id/base.rb

@@ -0,0 +1,291 @@
+module FriendlyId
+=begin
+
+== Setting Up FriendlyId in Your Model
+
+To use FriendlyId in your ActiveRecord models, you must first either extend or
+include the FriendlyId module (it makes no difference), then invoke the
+{FriendlyId::Base#friendly_id friendly_id} method to configure your desired
+options:
+
+    class Foo < ActiveRecord::Base
+      include FriendlyId
+      friendly_id :bar, :use => [:slugged, :simple_i18n]
+    end
+
+The most important option is `:use`, which you use to tell FriendlyId which
+addons it should use. See the documentation for this method for a list of all
+available addons, or skim through the rest of the docs to get a high-level
+overview.
+
+=== The Default Setup: Simple Models
+
+The simplest way to use FriendlyId is with a model that has a uniquely indexed
+column with no spaces or special characters, and that is seldom or never
+updated. The most common example of this is a user name:
+
+    class User < ActiveRecord::Base
+      extend FriendlyId
+      friendly_id :login
+      validates_format_of :login, :with => /\A[a-z0-9]+\z/i
+    end
+
+    @user = User.find "joe"   # the old User.find(1) still works, too
+    @user.to_param            # returns "joe"
+    redirect_to @user         # the URL will be /users/joe
+
+In this case, FriendlyId assumes you want to use the column as-is; it will never
+modify the value of the column, and your application should ensure that the
+value is unique and admissible in a URL:
+
+    class City < ActiveRecord::Base
+      extend FriendlyId
+      friendly_id :name
+    end
+
+    @city.find "Viña del Mar"
+    redirect_to @city # the URL will be /cities/Viña%20del%20Mar
+
+Writing the code to process an arbitrary string into a good identifier for use
+in a URL can be repetitive and surprisingly tricky, so for this reason it's
+often better and easier to use {FriendlyId::Slugged slugs}.
+
+=end
+  module Base
+
+    # Configure FriendlyId's behavior in a model.
+    #
+    #   class Post < ActiveRecord::Base
+    #     extend FriendlyId
+    #     friendly_id :title, :use => :slugged
+    #   end
+    #
+    # When given the optional block, this method will yield the class's instance
+    # of {FriendlyId::Configuration} to the block before evaluating other
+    # arguments, so configuration values set in the block may be overwritten by
+    # the arguments. This order was chosen to allow passing the same proc to
+    # multiple models, while being able to override the values it sets. Here is
+    # a contrived example:
+    #
+    #   $friendly_id_config_proc = Proc.new do |config|
+    #     config.base = :name
+    #     config.use :slugged
+    #   end
+    #
+    #   class Foo < ActiveRecord::Base
+    #     extend FriendlyId
+    #     friendly_id &$friendly_id_config_proc
+    #   end
+    #
+    #   class Bar < ActiveRecord::Base
+    #     extend FriendlyId
+    #     friendly_id :title, &$friendly_id_config_proc
+    #   end
+    #
+    # However, it's usually better to use {FriendlyId.defaults} for this:
+    #
+    #   FriendlyId.defaults do |config|
+    #     config.base = :name
+    #     config.use :slugged
+    #   end
+    #
+    #   class Foo < ActiveRecord::Base
+    #     extend FriendlyId
+    #   end
+    #
+    #   class Bar < ActiveRecord::Base
+    #     extend FriendlyId
+    #     friendly_id :title
+    #   end
+    #
+    # In general you should use the block syntax either because of your personal
+    # aesthetic preference, or because you need to share some functionality
+    # between multiple models that can't be well encapsulated by
+    # {FriendlyId.defaults}.
+    #
+    # === Order Method Calls in a Block vs Ordering Options
+    #
+    # When calling this method without a block, you may set the hash options in
+    # any order.
+    #
+    # However, when using block-style invocation, be sure to call
+    # FriendlyId::Configuration's {FriendlyId::Configuration#use use} method
+    # *prior* to the associated configuration options, because it will include
+    # modules into your class, and these modules in turn may add required
+    # configuration options to the +@friendly_id_configuraton+'s class:
+    #
+    #   class Person < ActiveRecord::Base
+    #     friendly_id do |config|
+    #       # This will work
+    #       config.use :slugged
+    #       config.sequence_separator = ":"
+    #     end
+    #   end
+    #
+    #   class Person < ActiveRecord::Base
+    #     friendly_id do |config|
+    #       # This will fail
+    #       config.sequence_separator = ":"
+    #       config.use :slugged
+    #     end
+    #   end
+    #
+    # === Including Your Own Modules
+    #
+    # Because :use can accept a name or a Module, {FriendlyId.defaults defaults}
+    # can be a convenient place to set up behavior common to all classes using
+    # FriendlyId. You can include any module, or more conveniently, define one
+    # on-the-fly. For example, let's say you want to make
+    # Babosa[http://github.com/norman/babosa] the default slugging library in
+    # place of Active Support, and transliterate all slugs from Russian Cyrillic
+    # to ASCII:
+    #
+    #   require "babosa"
+    #
+    #   FriendlyId.defaults do |config|
+    #     config.base = :name
+    #     config.use :slugged
+    #     config.use Module.new {
+    #       def normalize_friendly_id(text)
+    #         text.to_slug.normalize(:transliterations => [:russian, :latin])
+    #       end
+    #     }
+    #   end
+    #
+    #
+    # @option options [Symbol,Module] :use The addon or name of an addon to use.
+    #   By default, FriendlyId provides {FriendlyId::Slugged :slugged},
+    #   {FriendlyId::History :history}, {FriendlyId::Reserved :reserved}, and
+    #   {FriendlyId::Scoped :scoped}, {FriendlyId::SimpleI18n :simple_i18n},
+    #   and {FriendlyId::Globalize :globalize}.
+    #
+    # @option options [Array] :reserved_words Available when using +:reserved+,
+    #   which is loaded by default. Sets an array of words banned for use as
+    #   the basis of a friendly_id. By default this includes "edit" and "new".
+    #
+    # @option options [Symbol] :scope Available when using +:scoped+.
+    #   Sets the relation or column used to scope generated friendly ids. This
+    #   option has no default value.
+    #
+    # @option options [Symbol] :sequence_separator Available when using +:slugged+.
+    #   Configures the sequence of characters used to separate a slug from a
+    #   sequence. Defaults to +--+.
+    #
+    # @option options [Symbol] :slug_column Available when using +:slugged+.
+    #   Configures the name of the column where FriendlyId will store the slug.
+    #   Defaults to +:slug+.
+    #
+    # @option options [Symbol] :slug_generator_class Available when using +:slugged+.
+    #   Sets the class used to generate unique slugs. You should not specify this
+    #   unless you're doing some extensive hacking on FriendlyId. Defaults to
+    #   {FriendlyId::SlugGenerator}.
+    #
+    # @yield Provides access to the model class's friendly_id_config, which
+    #   allows an alternate configuration syntax, and conditional configuration
+    #   logic.
+    #
+    # @yieldparam config The model class's {FriendlyId::Configuration friendly_id_config}.
+    def friendly_id(base = nil, options = {}, &block)
+      yield friendly_id_config if block_given?
+      friendly_id_config.use options.delete :use
+      friendly_id_config.send :set, base ? options.merge(:base => base) : options
+      before_save {|rec| rec.instance_eval {@current_friendly_id = friendly_id}}
+      include Model
+    end
+
+    # Returns the model class's {FriendlyId::Configuration friendly_id_config}.
+    # @note In the case of Single Table Inheritance (STI), this method will
+    #   duplicate the parent class's FriendlyId::Configuration and relation class
+    #   on first access. If you're concerned about thread safety, then be sure
+    #   to invoke {#friendly_id} in your class for each model.
+    def friendly_id_config
+      @friendly_id_config ||= base_class.friendly_id_config.dup.tap do |config|
+        config.model_class = self
+        @relation_class = base_class.send(:relation_class)
+      end
+    end
+
+    private
+
+    # Gets an instance of an the relation class.
+    #
+    # With FriendlyId this will be a subclass of ActiveRecord::Relation, rather than
+    # Relation itself, in order to avoid tainting all Active Record models with
+    # FriendlyId.
+    #
+    # Note that this method is essentially copied and pasted from Rails 3.2.9.rc1,
+    # with the exception of changing the relation class. Obviously this is less than
+    # ideal, but I know of no better way to accomplish this.
+    # @see #relation_class
+    def relation #:nodoc:
+      relation = relation_class.new(self, arel_table)
+
+      if finder_needs_type_condition?
+        relation.with_deleted.where(type_condition).create_with(inheritance_column.to_sym => sti_name)
+      else
+        relation
+      end
+    end
+
+    # Gets (and if necessary, creates) a subclass of the model's relation class.
+    #
+    # Rather than including FriendlyId's overridden finder methods in
+    # ActiveRecord::Relation directly, FriendlyId adds them to a subclass
+    # specific to the AR model, and makes #relation return an instance of this
+    # class. By doing this, we ensure that only models that specifically extend
+    # FriendlyId have their finder methods overridden.
+    #
+    # Note that this method does not directly subclass ActiveRecord::Relation,
+    # but rather whatever class the @relation class instance variable is an
+    # instance of.  In practice, this will almost always end up being
+    # ActiveRecord::Relation, but in case another plugin is using this same
+    # pattern to extend a model's finder functionality, FriendlyId will not
+    # replace it, but rather override it.
+    #
+    # This pattern can be seen as a poor man's "refinement"
+    # (http://timelessrepo.com/refinements-in-ruby), and while I **think** it
+    # will work quite well, I realize that it could cause unexpected issues,
+    # since the authors of Rails are probably not intending this kind of usage
+    # against a private API. If this ends up being problematic I will probably
+    # revert back to the old behavior of simply extending
+    # ActiveRecord::Relation.
+    def relation_class
+      @relation_class or begin
+        @relation_class = Class.new(relation_without_friendly_id.class) do
+          alias_method :find_one_without_friendly_id, :find_one
+          alias_method :exists_without_friendly_id?, :exists?
+          include FriendlyId::FinderMethods
+        end
+        # Set a name so that model instances can be marshalled. Use a
+        # ridiculously long name that will not conflict with anything.
+        # TODO: just use the constant, no need for the @relation_class variable.
+        const_set('FriendlyIdActiveRecordRelation', @relation_class)
+      end
+    end
+  end
+
+  # Instance methods that will be added to all classes using FriendlyId.
+  module Model
+
+    attr_reader :current_friendly_id
+
+    # Convenience method for accessing the class method of the same name.
+    def friendly_id_config
+      self.class.friendly_id_config
+    end
+
+    # Get the instance's friendly_id.
+    def friendly_id
+      send friendly_id_config.query_field
+    end
+
+    # Either the friendly_id, or the numeric id cast to a string.
+    def to_param
+      if diff = changes[friendly_id_config.query_field]
+        diff.first || diff.second
+      else
+        friendly_id.presence || super
+      end
+    end
+  end
+end