ultra-clean-lib 0.0.1

data/friendly_id-5.7.0/lib/friendly_id/base.rb

@@ -0,0 +1,275 @@
+module FriendlyId
+  # @guide 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 {FriendlyId::Base#friendly_id} for a list of all
+  # available addons, or skim through the rest of the docs to get a high-level
+  # overview.
+  #
+  # *A note about single table inheritance (STI): you must extend FriendlyId in
+  # all classes that participate in STI, both your parent classes and their
+  # children.*
+  #
+  # ### 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.friendly.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.friendly.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}.
+  #
+  # @guide 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::Reserved :finders}, {FriendlyId::History :history},
+    #   {FriendlyId::Reserved :reserved}, {FriendlyId::Scoped :scoped}, and
+    #   {FriendlyId::SimpleI18n :simple_i18n}.
+    #
+    # @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 [Integer] :slug_limit Available when using `:slugged`.
+    #   Configures the limit of the slug. This option has no default value.
+    #
+    # @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.
+    #
+    # @option options [Symbol,Boolean] :dependent Available when using `:history`.
+    #   Sets the value used for the slugged association's dependent option. Use
+    #   `false` if you do not want to dependently destroy the associated slugged
+    #   record. Defaults to `:destroy`.
+    #
+    # @option options [Symbol] :routes When set to anything other than :friendly,
+    #   ensures that all routes generated by default do *not* use the slug.  This
+    #   allows `form_for` and `polymorphic_path` to continue to generate paths like
+    #   `/team/1` instead of `/team/number-one`.  You can still generate paths
+    #   like the latter using: team_path(team.slug).  When set to :friendly, or
+    #   omitted, the default friendly_id behavior is maintained.
+    #
+    # @yieldparam config The model class's {FriendlyId::Configuration friendly_id_config}.
+    def friendly_id(base = nil, options = {}, &block)
+      yield friendly_id_config if block
+      friendly_id_config.dependent = options.delete :dependent
+      friendly_id_config.use options.delete :use
+      friendly_id_config.send :set, base ? options.merge(base: base) : options
+      include Model
+    end
+
+    # Returns a scope that includes the friendly finders.
+    # @see FriendlyId::FinderMethods
+    def friendly
+      # Guess what? This causes Rails to invoke `extend` on the scope, which has
+      # the well-known effect of blowing away Ruby's method cache. It would be
+      # possible to make this more performant by subclassing the model's
+      # relation class, extending that, and returning an instance of it in this
+      # method. FriendlyId 4.0 did something similar. However in 5.0 I've
+      # decided to only use Rails's public API in order to improve compatibility
+      # and maintainability. If you'd like to improve the performance, your
+      # efforts would be best directed at improving it at the root cause
+      # of the problem - in Rails - because it would benefit more people.
+      all.extending(friendly_id_config.finder_methods)
+    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
+      end
+    end
+
+    def primary_key_type
+      @primary_key_type ||= columns_hash[primary_key].type
+    end
+  end
+
+  # Instance methods that will be added to all classes using FriendlyId.
+  module Model
+    def self.included(model_class)
+      return if model_class.respond_to?(:friendly)
+    end
+
+    # 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 friendly_id_config.routes == :friendly
+        friendly_id.presence.to_param || super
+      else
+        super
+      end
+    end
+
+    # Clears slug on duplicate records when calling `dup`.
+    def dup
+      super.tap { |duplicate| duplicate.slug = nil if duplicate.respond_to?("slug=") }
+    end
+  end
+end

data/friendly_id-5.7.0/lib/friendly_id/candidates.rb

@@ -0,0 +1,71 @@
+require "securerandom"
+
+module FriendlyId
+  # This class provides the slug candidate functionality.
+  # @see FriendlyId::Slugged
+  class Candidates
+    include Enumerable
+
+    def initialize(object, *array)
+      @object = object
+      @raw_candidates = to_candidate_array(object, array.flatten(1))
+    end
+
+    def each(*args, &block)
+      return candidates unless block
+      candidates.each { |candidate| yield candidate }
+    end
+
+    private
+
+    def candidates
+      @candidates ||= begin
+        candidates = normalize(@raw_candidates)
+        filter(candidates)
+      end
+    end
+
+    def normalize(candidates)
+      candidates.map do |candidate|
+        @object.normalize_friendly_id(candidate.map(&:call).join(" "))
+      end.select { |x| wanted?(x) }
+    end
+
+    def filter(candidates)
+      unless candidates.all? { |x| reserved?(x) }
+        candidates.reject! { |x| reserved?(x) }
+      end
+      candidates
+    end
+
+    def to_candidate_array(object, array)
+      array.map do |candidate|
+        case candidate
+        when String
+          [-> { candidate }]
+        when Array
+          to_candidate_array(object, candidate).flatten
+        when Symbol
+          [object.method(candidate)]
+        else
+          if candidate.respond_to?(:call)
+            [candidate]
+          else
+            [-> { candidate.to_s }]
+          end
+        end
+      end
+    end
+
+    def wanted?(slug)
+      slug.present?
+    end
+
+    def reserved?(slug)
+      config = @object.friendly_id_config
+      return false unless config.uses? ::FriendlyId::Reserved
+      return false unless config.reserved_words
+      config.reserved_words.include?(slug)
+    end
+  end
+end

data/friendly_id-5.7.0/lib/friendly_id/configuration.rb

@@ -0,0 +1,111 @@
+module FriendlyId
+  # The configuration parameters passed to {Base#friendly_id} will be stored in
+  # this object.
+  class Configuration
+    attr_writer :base
+
+    # The default configuration options.
+    attr_reader :defaults
+
+    # The modules in use
+    attr_reader :modules
+
+    # The model class that this configuration belongs to.
+    # @return ActiveRecord::Base
+    attr_accessor :model_class
+
+    # The module to use for finders
+    attr_accessor :finder_methods
+
+    # The value used for the slugged association's dependent option
+    attr_accessor :dependent
+
+    # Route generation preferences
+    attr_accessor :routes
+
+    def initialize(model_class, values = nil)
+      @base = nil
+      @model_class = model_class
+      @defaults = {}
+      @modules = []
+      @finder_methods = FriendlyId::FinderMethods
+      self.routes = :friendly
+      set values
+    end
+
+    # Lets you specify the addon 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 an addon to use with FriendlyId.
+    #   By default FriendlyId provides `:slugged`, `:finders`, `:history`,
+    #   `:reserved`, `:simple_i18n`, and `:scoped`.
+    def use(*modules)
+      modules.to_a.flatten.compact.map do |object|
+        mod = get_module(object)
+        mod.setup(@model_class) if mod.respond_to?(:setup)
+        @model_class.send(:include, mod) unless uses? object
+      end
+    end
+
+    # Returns whether the given module is in use.
+    def uses?(mod)
+      @model_class < get_module(mod)
+    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
+
+    # 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}, this is the column that
+    # is used to store the friendly id. 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.
+    #
+    # If you pass an argument, it will be used as the base. Otherwise the current
+    # value is returned.
+    #
+    # @param value 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}.
+    def base(*value)
+      if value.empty?
+        @base
+      else
+        self.base = value.first
+      end
+    end
+
+    private
+
+    def get_module(object)
+      Module === object ? object : FriendlyId.const_get(object.to_s.titleize.camelize.gsub(/\s+/, ""))
+    end
+
+    def set(values)
+      values&.each { |name, value| send "#{name}=", value }
+    end
+  end
+end

data/friendly_id-5.7.0/lib/friendly_id/finder_methods.rb

@@ -0,0 +1,123 @@
+module FriendlyId
+  module FinderMethods
+    # Finds a record using the given id.
+    #
+    # If the id is "unfriendly", it will call the original find method.
+    # If the id is a numeric string like '123' it will first look for a friendly
+    # id matching '123' and then fall back to looking for a record with the
+    # numeric id '123'.
+    #
+    # @param [Boolean] allow_nil (default: false)
+    # Use allow_nil: true if you'd like the finder to return nil instead of
+    # raising ActivRecord::RecordNotFound
+    #
+    # ### Example
+    #
+    #     MyModel.friendly.find("bad-slug")
+    #     #=> raise ActiveRecord::RecordNotFound
+    #
+    #     MyModel.friendly.find("bad-slug", allow_nil: true)
+    #     #=> nil
+    #
+    # Since FriendlyId 5.0, if the id is a nonnumeric string like '123-foo' it
+    # will *only* search by friendly id and not fall back to the regular find
+    # method.
+    #
+    # If you want to search only by the friendly id, use {#find_by_friendly_id}.
+    # @raise ActiveRecord::RecordNotFound
+    def find(*args, allow_nil: false)
+      id = args.first
+      return super(*args) if args.count != 1 || id.unfriendly_id?
+      first_by_friendly_id(id).tap { |result| return result unless result.nil? }
+      return super(*args) if potential_primary_key?(id)
+
+      raise_not_found_exception(id) unless allow_nil
+    rescue ActiveRecord::RecordNotFound => exception
+      raise exception unless allow_nil
+    end
+
+    # Returns true if a record with the given id exists.
+    def exists?(conditions = :none)
+      return super if conditions.unfriendly_id?
+      return true if exists_by_friendly_id?(conditions)
+      super
+    end
+
+    # Finds exclusively by the friendly id, completely bypassing original
+    # `find`.
+    # @raise ActiveRecord::RecordNotFound
+    def find_by_friendly_id(id)
+      first_by_friendly_id(id) or raise_not_found_exception(id)
+    end
+
+    def exists_by_friendly_id?(id)
+      where(friendly_id_config.query_field => parse_friendly_id(id)).exists?
+    end
+
+    private
+
+    def potential_primary_key?(id)
+      key_type = primary_key_type
+      # Hook for "ActiveModel::Type::Integer" instance.
+      key_type = key_type.type if key_type.respond_to?(:type)
+      case key_type
+      when :integer
+        begin
+          Integer(id, 10)
+        rescue
+          false
+        end
+      when :uuid
+        id.match(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/)
+      else
+        true
+      end
+    end
+
+    def first_by_friendly_id(id)
+      find_by(friendly_id_config.query_field => parse_friendly_id(id))
+    end
+
+    # Parse the given value to make it suitable for use as a slug according to
+    # your application's rules.
+    #
+    # This method is not intended to be invoked directly; FriendlyId uses it
+    # internally to process a slug into string to use as a finder.
+    #
+    # However, if FriendlyId's default slug parsing doesn't suit your needs,
+    # you can override this method in your model class to control exactly how
+    # slugs are generated.
+    #
+    # ### Example
+    #
+    #     class Person < ActiveRecord::Base
+    #       extend FriendlyId
+    #       friendly_id :name_and_location
+    #
+    #       def name_and_location
+    #         "#{name} from #{location}"
+    #       end
+    #
+    #       # Use default slug, but lower case
+    #       # If `id` is "Jane-Doe" or "JANE-DOE", this finds data by "jane-doe"
+    #       def parse_friendly_id(slug)
+    #         super.downcase
+    #       end
+    #     end
+    #
+    # @param [#to_s] value The slug to be parsed.
+    # @return The parsed slug, which is not modified by default.
+    def parse_friendly_id(value)
+      value
+    end
+
+    def raise_not_found_exception(id)
+      message = "can't find record with friendly id: #{id.inspect}"
+      if ActiveRecord.version < Gem::Version.create("5.0")
+        raise ActiveRecord::RecordNotFound.new(message)
+      else
+        raise ActiveRecord::RecordNotFound.new(message, name, friendly_id_config.query_field, id)
+      end
+    end
+  end
+end

data/friendly_id-5.7.0/lib/friendly_id/finders.rb

@@ -0,0 +1,92 @@
+module FriendlyId
+  # @guide begin
+  #
+  # ## Performing Finds with FriendlyId
+  #
+  # FriendlyId offers enhanced finders which will search for your record by
+  # friendly id, and fall back to the numeric id if necessary. This makes it easy
+  # to add FriendlyId to an existing application with minimal code modification.
+  #
+  # By default, these methods are available only on the `friendly` scope:
+  #
+  #     Restaurant.friendly.find('plaza-diner') #=> works
+  #     Restaurant.friendly.find(23)            #=> also works
+  #     Restaurant.find(23)                     #=> still works
+  #     Restaurant.find('plaza-diner')          #=> will not work
+  #
+  # ### Restoring FriendlyId 4.0-style finders
+  #
+  # Prior to version 5.0, FriendlyId overrode the default finder methods to perform
+  # friendly finds all the time. This required modifying parts of Rails that did
+  # not have a public API, which was harder to maintain and at times caused
+  # compatiblity problems. In 5.0 we decided to change the library's defaults and add
+  # the friendly finder methods only to the `friendly` scope in order to boost
+  # compatiblity. However, you can still opt-in to original functionality very
+  # easily by using the `:finders` addon:
+  #
+  #     class Restaurant < ActiveRecord::Base
+  #       extend FriendlyId
+  #
+  #       scope :active, -> {where(:active => true)}
+  #
+  #       friendly_id :name, :use => [:slugged, :finders]
+  #     end
+  #
+  #     Restaurant.friendly.find('plaza-diner') #=> works
+  #     Restaurant.find('plaza-diner')          #=> now also works
+  #     Restaurant.active.find('plaza-diner')   #=> now also works
+  #
+  # ### Updating your application to use FriendlyId's finders
+  #
+  # Unless you've chosen to use the `:finders` addon, be sure to modify the finders
+  # in your controllers to use the `friendly` scope. For example:
+  #
+  #     # before
+  #     def set_restaurant
+  #       @restaurant = Restaurant.find(params[:id])
+  #     end
+  #
+  #     # after
+  #     def set_restaurant
+  #       @restaurant = Restaurant.friendly.find(params[:id])
+  #     end
+  #
+  # #### Active Admin
+  #
+  # Unless you use the `:finders` addon, you should modify your admin controllers
+  # for models that use FriendlyId with something similar to the following:
+  #
+  #     controller do
+  #       def find_resource
+  #         scoped_collection.friendly.find(params[:id])
+  #       end
+  #     end
+  #
+  # @guide end
+  module Finders
+    module ClassMethods
+      if (ActiveRecord::VERSION::MAJOR == 4) && (ActiveRecord::VERSION::MINOR == 0)
+        def relation_delegate_class(klass)
+          relation_class_name = :"#{klass.to_s.gsub("::", "_")}_#{to_s.gsub("::", "_")}"
+          klass.const_get(relation_class_name)
+        end
+      end
+    end
+
+    def self.setup(model_class)
+      model_class.instance_eval do
+        relation.class.send(:include, friendly_id_config.finder_methods)
+        if (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR == 2) || ActiveRecord::VERSION::MAJOR >= 5
+          model_class.send(:extend, friendly_id_config.finder_methods)
+        end
+      end
+
+      # Support for friendly finds on associations for Rails 4.0.1 and above.
+      if ::ActiveRecord.const_defined?("AssociationRelation")
+        model_class.extend(ClassMethods)
+        association_relation_delegate_class = model_class.relation_delegate_class(::ActiveRecord::AssociationRelation)
+        association_relation_delegate_class.send(:include, model_class.friendly_id_config.finder_methods)
+      end
+    end
+  end
+end