ultra-clean-lib 0.0.1

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

@@ -0,0 +1,146 @@
+module FriendlyId
+  # @guide 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
+  #
+  # 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.friendly.find params[:id]
+  #
+  #         # If an old id or a numeric id was used to find the record, then
+  #         # the request slug will not match the current slug, and we should do
+  #         # a 301 redirect to the new path
+  #         if params[:id] != @post.slug
+  #           return redirect_to @post, :status => :moved_permanently
+  #         end
+  #       end
+  #     end
+  #
+  # @guide end
+  module History
+    module Configuration
+      def dependent_value
+        dependent.nil? ? :destroy : dependent
+      end
+    end
+
+    def self.setup(model_class)
+      model_class.instance_eval do
+        friendly_id_config.use :slugged
+        friendly_id_config.class.send :include, History::Configuration
+        friendly_id_config.finder_methods = FriendlyId::History::FinderMethods
+        FriendlyId::Finders.setup(model_class) if friendly_id_config.uses? :finders
+      end
+    end
+
+    # Configures the model instance to use the History add-on.
+    def self.included(model_class)
+      model_class.class_eval do
+        has_many :slugs, -> { order(id: :desc) }, **{
+          as: :sluggable,
+          dependent: @friendly_id_config.dependent_value,
+          class_name: Slug.to_s
+        }
+
+        after_save :create_slug
+      end
+    end
+
+    module FinderMethods
+      include ::FriendlyId::FinderMethods
+
+      def exists_by_friendly_id?(id)
+        super || joins(:slugs).where(slug_history_clause(parse_friendly_id(id))).exists?
+      end
+
+      private
+
+      def first_by_friendly_id(id)
+        super || slug_table_record(parse_friendly_id(id))
+      end
+
+      def slug_table_record(id)
+        select(quoted_table_name + ".*").joins(:slugs).where(slug_history_clause(id)).order(Slug.arel_table[:id].desc).first
+      end
+
+      def slug_history_clause(id)
+        Slug.arel_table[:sluggable_type].eq(base_class.to_s).and(Slug.arel_table[:slug].eq(id))
+      end
+    end
+
+    private
+
+    # If we're updating, don't consider historic slugs for the same record
+    # to be conflicts. This will allow a record to revert to a previously
+    # used slug.
+    def scope_for_slug_generator
+      relation = super.joins(:slugs)
+      unless new_record?
+        relation = relation.merge(Slug.where("sluggable_id <> ?", id))
+      end
+      if friendly_id_config.uses?(:scoped)
+        relation = relation.where(Slug.arel_table[:scope].eq(serialized_scope))
+      end
+      relation
+    end
+
+    def create_slug
+      return unless friendly_id
+      return if history_is_up_to_date?
+      # Allow reversion back to a previously used slug
+      relation = slugs.where(slug: friendly_id)
+      if friendly_id_config.uses?(:scoped)
+        relation = relation.where(scope: serialized_scope)
+      end
+      relation.destroy_all unless relation.empty?
+      slugs.create! do |record|
+        record.slug = friendly_id
+        record.scope = serialized_scope if friendly_id_config.uses?(:scoped)
+      end
+    end
+
+    def history_is_up_to_date?
+      latest_history = slugs.first
+      check = latest_history.try(:slug) == friendly_id
+      if friendly_id_config.uses?(:scoped)
+        check &&= latest_history.scope == serialized_scope
+      end
+      check
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# FriendlyId Global Configuration
+#
+# Use this to set up shared configuration options for your entire application.
+# Any of the configuration options shown here can also be applied to single
+# models by passing arguments to the `friendly_id` class method or defining
+# methods in your model.
+#
+# To learn more, check out the guide:
+#
+# http://norman.github.io/friendly_id/file.Guide.html
+
+FriendlyId.defaults do |config|
+  # ## Reserved Words
+  #
+  # Some words could conflict with Rails's routes when used as slugs, or are
+  # undesirable to allow as slugs. Edit this list as needed for your app.
+  config.use :reserved
+
+  config.reserved_words = %w[new edit index session login logout users admin
+    stylesheets assets javascripts images]
+
+  # This adds an option to treat reserved words as conflicts rather than exceptions.
+  # When there is no good candidate, a UUID will be appended, matching the existing
+  # conflict behavior.
+
+  # config.treat_reserved_as_conflict = true
+
+  #  ## Friendly Finders
+  #
+  # Uncomment this to use friendly finders in all models. By default, if
+  # you wish to find a record by its friendly id, you must do:
+  #
+  #    MyModel.friendly.find('foo')
+  #
+  # If you uncomment this, you can do:
+  #
+  #    MyModel.find('foo')
+  #
+  # This is significantly more convenient but may not be appropriate for
+  # all applications, so you must explicitly opt-in to this behavior. You can
+  # always also configure it on a per-model basis if you prefer.
+  #
+  # Something else to consider is that using the :finders addon boosts
+  # performance because it will avoid Rails-internal code that makes runtime
+  # calls to `Module.extend`.
+  #
+  # config.use :finders
+  #
+  # ## Slugs
+  #
+  # Most applications will use the :slugged module everywhere. If you wish
+  # to do so, uncomment the following line.
+  #
+  # config.use :slugged
+  #
+  # By default, FriendlyId's :slugged addon expects the slug column to be named
+  # 'slug', but you can change it if you wish.
+  #
+  # config.slug_column = 'slug'
+  #
+  # By default, slug has no size limit, but you can change it if you wish.
+  #
+  # config.slug_limit = 255
+  #
+  # When FriendlyId can not generate a unique ID from your base method, it appends
+  # a UUID, separated by a single dash. You can configure the character used as the
+  # separator. If you're upgrading from FriendlyId 4, you may wish to replace this
+  # with two dashes.
+  #
+  # config.sequence_separator = '-'
+  #
+  # Note that you must use the :slugged addon **prior** to the line which
+  # configures the sequence separator, or else FriendlyId will raise an undefined
+  # method error.
+  #
+  #  ## Tips and Tricks
+  #
+  #  ### Controlling when slugs are generated
+  #
+  # As of FriendlyId 5.0, new slugs are generated only when the slug field is
+  # nil, but if you're using a column as your base method can change this
+  # behavior by overriding the `should_generate_new_friendly_id?` method that
+  # FriendlyId adds to your model. The change below makes FriendlyId 5.0 behave
+  # more like 4.0.
+  # Note: Use(include) Slugged module in the config if using the anonymous module.
+  # If you have `friendly_id :name, use: slugged` in the model, Slugged module
+  # is included after the anonymous module defined in the initializer, so it
+  # overrides the `should_generate_new_friendly_id?` method from the anonymous module.
+  #
+  # config.use :slugged
+  # config.use Module.new {
+  #   def should_generate_new_friendly_id?
+  #     slug.blank? || <your_column_name_here>_changed?
+  #   end
+  # }
+  #
+  # FriendlyId uses Rails's `parameterize` method to generate slugs, but for
+  # languages that don't use the Roman alphabet, that's not usually sufficient.
+  # Here we use the Babosa library to transliterate Russian Cyrillic slugs to
+  # ASCII. If you use this, don't forget to add "babosa" to your Gemfile.
+  #
+  # config.use Module.new {
+  #   def normalize_friendly_id(text)
+  #     text.to_slug.normalize! :transliterations => [:russian, :latin]
+  #   end
+  # }
+end

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

@@ -0,0 +1,21 @@
+MIGRATION_CLASS =
+  if ActiveRecord::VERSION::MAJOR >= 5
+    ActiveRecord::Migration["#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"]
+  else
+    ActiveRecord::Migration
+  end
+
+class CreateFriendlyIdSlugs < MIGRATION_CLASS
+  def change
+    create_table :friendly_id_slugs do |t|
+      t.string :slug, null: false
+      t.integer :sluggable_id, null: false
+      t.string :sluggable_type, limit: 50
+      t.string :scope
+      t.datetime :created_at
+    end
+    add_index :friendly_id_slugs, [:sluggable_type, :sluggable_id]
+    add_index :friendly_id_slugs, [:slug, :sluggable_type], length: {slug: 140, sluggable_type: 50}
+    add_index :friendly_id_slugs, [:slug, :sluggable_type, :scope], length: {slug: 70, sluggable_type: 50, scope: 70}, unique: true
+  end
+end

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

@@ -0,0 +1,76 @@
+module FriendlyId
+  # Instances of these classes will never be considered a friendly id.
+  # @see FriendlyId::ObjectUtils#friendly_id
+  UNFRIENDLY_CLASSES = [
+    Array,
+    FalseClass,
+    Hash,
+    NilClass,
+    Numeric,
+    Symbol,
+    TrueClass
+  ]
+
+  # 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 if 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?
+      true if respond_to?(:to_i) && to_i.to_s != to_s
+    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
+
+  module UnfriendlyUtils
+    def friendly_id?
+      false
+    end
+
+    def unfriendly_id?
+      true
+    end
+  end
+
+  def self.mark_as_unfriendly(klass)
+    klass.send(:include, FriendlyId::UnfriendlyUtils)
+  end
+end
+
+Object.send :include, FriendlyId::ObjectUtils
+
+# Considered unfriendly if object is an instance of an unfriendly class or
+# one of its descendants.
+
+FriendlyId::UNFRIENDLY_CLASSES.each { |klass| FriendlyId.mark_as_unfriendly(klass) }
+
+ActiveSupport.on_load(:active_record) do
+  FriendlyId.mark_as_unfriendly(ActiveRecord::Base)
+end

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

@@ -0,0 +1,50 @@
+module FriendlyId
+  # @guide begin
+  #
+  # ## Reserved Words
+  #
+  # The {FriendlyId::Reserved Reserved} module adds the ability to exclude a list of
+  # words from use as FriendlyId slugs.
+  #
+  # With Ruby on Rails, FriendlyId's generator generates an initializer that
+  # reserves some words such as "new" and "edit" using {FriendlyId.defaults
+  # FriendlyId.defaults}.
+  #
+  # Note that the error messages for fields 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
+  #
+  # @guide 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
+        validates_exclusion_of :friendly_id, in: ->(_) {
+          friendly_id_config.reserved_words || []
+        }
+      end
+    end
+
+    # This module adds the `:reserved_words` configuration option to
+    # {FriendlyId::Configuration FriendlyId::Configuration}.
+    module Configuration
+      attr_accessor :reserved_words
+      attr_accessor :treat_reserved_as_conflict
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+require "friendly_id/slugged"
+
+module FriendlyId
+  # @guide 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.friendly.find("seattle").restaurants.friendly.find("joes-diner")
+  #     City.friendly.find("chicago").restaurants.friendly.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-f9f3789a-daec-4156-af1d-fab81aa16ee5`.
+  #
+  # The value for the `:scope` option can be the name of a `belongs_to` relation, or
+  # a column.
+  #
+  # Additionally, the `:scope` option can receive an array of scope values:
+  #
+  #     class Cuisine < ActiveRecord::Base
+  #       extend FriendlyId
+  #       has_many :restaurants
+  #       friendly_id :name, :use => :slugged
+  #     end
+  #
+  #     class City < ActiveRecord::Base
+  #       extend FriendlyId
+  #       has_many :restaurants
+  #       friendly_id :name, :use => :slugged
+  #     end
+  #
+  #     class Restaurant < ActiveRecord::Base
+  #       extend FriendlyId
+  #       belongs_to :city
+  #       friendly_id :name, :use => :scoped, :scope => [:city, :cuisine]
+  #     end
+  #
+  # All supplied values will be used to determine scope.
+  #
+  # ### Finding Records by Friendly ID
+  #
+  # If you are using scopes your friendly ids may not be unique, so a simple find
+  # like:
+  #
+  #     Restaurant.friendly.find("joes-diner")
+  #
+  # may return the wrong record. In these cases it's best to query through the
+  # relation:
+  #
+  #     @city.restaurants.friendly.find("joes-diner")
+  #
+  # Alternatively, you could pass the scope value as a query parameter:
+  #
+  #     Restaurant.where(:city_id => @city.id).friendly.find("joes-diner")
+  #
+  #
+  # ### Finding All Records That Match a Scoped ID
+  #
+  # Query the slug column directly:
+  #
+  #     Restaurant.where(: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.friendly.find(params[:city_id])
+  #     @restaurant = @city.restaurants.friendly.find(params[:id])
+  #
+  #     # URLs:
+  #     http://example.org/cities/seattle/restaurants/joes-diner
+  #     http://example.org/cities/chicago/restaurants/joes-diner
+  #
+  # @guide end
+  module Scoped
+    # FriendlyId::Config.use will invoke this method when present, to allow
+    # loading dependent modules prior to overriding them when necessary.
+    def self.setup(model_class)
+      model_class.friendly_id_config.use :slugged
+    end
+
+    # Sets up behavior and configuration options for FriendlyId's scoped slugs
+    # feature.
+    def self.included(model_class)
+      model_class.class_eval do
+        friendly_id_config.class.send :include, Configuration
+      end
+    end
+
+    def serialized_scope
+      friendly_id_config.scope_columns.sort.map { |column| "#{column}:#{send(column)}" }.join(",")
+    end
+
+    def scope_for_slug_generator
+      if friendly_id_config.uses?(:History)
+        return super
+      end
+      relation = self.class.base_class.unscoped.friendly
+      friendly_id_config.scope_columns.each do |column|
+        relation = relation.where(column => send(column))
+      end
+      primary_key_name = self.class.primary_key
+      relation.where(self.class.arel_table[primary_key_name].not_eq(send(primary_key_name)))
+    end
+    private :scope_for_slug_generator
+
+    def slug_generator
+      friendly_id_config.slug_generator_class.new(scope_for_slug_generator, friendly_id_config)
+    end
+    private :slug_generator
+
+    def should_generate_new_friendly_id?
+      (changed & friendly_id_config.scope_columns).any? || super
+    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
+
+      def reflection_foreign_key(scope)
+        reflection = model_class.reflections[scope] || model_class.reflections[scope.to_s]
+        reflection.try(:foreign_key)
+      end
+    end
+  end
+end

data/friendly_id-5.7.0/lib/friendly_id/sequentially_slugged/calculator.rb

@@ -0,0 +1,69 @@
+module FriendlyId
+  module SequentiallySlugged
+    class Calculator
+      attr_accessor :scope, :slug, :slug_column, :sequence_separator
+
+      def initialize(scope, slug, slug_column, sequence_separator, base_class)
+        @scope = scope
+        @slug = slug
+        table_name = scope.connection.quote_table_name(base_class.arel_table.name)
+        @slug_column = "#{table_name}.#{scope.connection.quote_column_name(slug_column)}"
+        @sequence_separator = sequence_separator
+      end
+
+      def next_slug
+        slug + sequence_separator + next_sequence_number.to_s
+      end
+
+      private
+
+      def conflict_query
+        base = "#{slug_column} = ? OR #{slug_column} LIKE ?"
+        # Awful hack for SQLite3, which does not pick up '\' as the escape character
+        # without this.
+        base << " ESCAPE '\\'" if /sqlite/i.match?(scope.connection.adapter_name)
+        base
+      end
+
+      def next_sequence_number
+        last_sequence_number ? last_sequence_number + 1 : 2
+      end
+
+      def last_sequence_number
+        # Reject slug_conflicts that doesn't come from the first_candidate
+        # Map all sequence numbers and take the maximum
+        slug_conflicts
+          .reject { |slug_conflict| !regexp.match(slug_conflict) }
+          .map { |slug_conflict| regexp.match(slug_conflict)[1].to_i }
+          .max
+      end
+
+      # Return the unnumbered (shortest) slug first, followed by the numbered ones
+      # in ascending order.
+      def ordering_query
+        "#{sql_length}(#{slug_column}) ASC, #{slug_column} ASC"
+      end
+
+      def regexp
+        /#{slug}#{sequence_separator}(\d+)\z/
+      end
+
+      def sequential_slug_matcher
+        # Underscores (matching a single character) and percent signs (matching
+        # any number of characters) need to be escaped. While this looks like
+        # an excessive number of backslashes, it is correct.
+        "#{slug}#{sequence_separator}".gsub(/[_%]/, '\\\\\&') + "%"
+      end
+
+      def slug_conflicts
+        scope
+          .where(conflict_query, slug, sequential_slug_matcher)
+          .order(Arel.sql(ordering_query)).pluck(Arel.sql(slug_column))
+      end
+
+      def sql_length
+        /sqlserver/i.match?(scope.connection.adapter_name) ? "LEN" : "LENGTH"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require_relative "sequentially_slugged/calculator"
+
+module FriendlyId
+  module SequentiallySlugged
+    def self.setup(model_class)
+      model_class.friendly_id_config.use :slugged
+    end
+
+    def resolve_friendly_id_conflict(candidate_slugs)
+      candidate = candidate_slugs.first
+      return if candidate.nil?
+
+      Calculator.new(
+        scope_for_slug_generator,
+        candidate,
+        slug_column,
+        friendly_id_config.sequence_separator,
+        slug_base_class
+      ).next_slug
+    end
+
+    private
+
+    def slug_base_class
+      if friendly_id_config.uses?(:history)
+        Slug
+      else
+        self.class.base_class
+      end
+    end
+
+    def slug_column
+      if friendly_id_config.uses?(:history)
+        :slug
+      else
+        friendly_id_config.slug_column
+      end
+    end
+  end
+end