ultra-clean-lib 0.0.1

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

@@ -0,0 +1,114 @@
+require "i18n"
+
+module FriendlyId
+  # @guide 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", "slug_pt_br", 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
+  # friendly_id_globalize gem instead.
+  #
+  # ### Example migration
+  #
+  #     def self.up
+  #       create_table :posts do |t|
+  #         t.string :title
+  #         t.string :slug_en
+  #         t.string :slug_es
+  #         t.string :slug_pt_br
+  #         t.text   :body
+  #       end
+  #       add_index :posts, :slug_en
+  #       add_index :posts, :slug_es
+  #       add_index :posts, :slug_pt_br
+  #     end
+  #
+  # ### Finds
+  #
+  # Finds will take into consideration the current locale:
+  #
+  #     I18n.locale = :es
+  #     Post.friendly.find("la-guerra-de-las-galaxias")
+  #     I18n.locale = :en
+  #     Post.friendly.find("star-wars")
+  #     I18n.locale = :"pt-BR"
+  #     Post.friendly.find("guerra-das-estrelas")
+  #
+  # 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.friendly.find("la-guerra-de-las-galaxias")
+  #     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 galaxias", :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 galaxias")
+  #     end
+  #
+  # @guide end
+  module SimpleI18n
+    # 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
+
+    def self.included(model_class)
+      model_class.class_eval do
+        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
+
+      def slug=(value)
+        super
+        write_attribute friendly_id_config.slug_column, value
+      end
+    end
+
+    module Configuration
+      def slug_column
+        "#{super}_#{locale_suffix}"
+      end
+
+      private
+
+      def locale_suffix
+        I18n.locale.to_s.underscore
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module FriendlyId
+  # A FriendlyId slug stored in an external table.
+  #
+  # @see FriendlyId::History
+  class Slug < ActiveRecord::Base
+    belongs_to :sluggable, polymorphic: true
+
+    def sluggable
+      sluggable_type.constantize.unscoped { super }
+    end
+
+    def to_param
+      slug
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module FriendlyId
+  # The default slug generator offers functionality to check slug candidates for
+  # availability.
+  class SlugGenerator
+    def initialize(scope, config)
+      @scope = scope
+      @config = config
+    end
+
+    def available?(slug)
+      if @config.uses?(::FriendlyId::Reserved) && @config.reserved_words.present? && @config.treat_reserved_as_conflict
+        return false if @config.reserved_words.include?(slug)
+      end
+
+      if @config.treat_numeric_as_conflict && purely_numeric_slug?(slug)
+        return false
+      end
+
+      !@scope.exists_by_friendly_id?(slug)
+    end
+
+    def generate(candidates)
+      candidates.each { |c| return c if available?(c) }
+      nil
+    end
+
+    private
+
+    def purely_numeric_slug?(slug)
+      return false unless slug
+      begin
+        Integer(slug, 10).to_s == slug.to_s
+      rescue ArgumentError, TypeError
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,436 @@
+require "friendly_id/slug_generator"
+require "friendly_id/candidates"
+
+module FriendlyId
+  # @guide begin
+  #
+  # ## Slugged Models
+  #
+  # FriendlyId can use a separate column to store slugs for models which require
+  # some text processing.
+  #
+  # For example, blog applications typically use a post title to provide the basis
+  # of a search engine friendly URL. Such identifiers typically lack uppercase
+  # characters, use ASCII to approximate UTF-8 characters, and strip out other
+  # characters which may make them aesthetically unappealing or error-prone when
+  # used in a URL.
+  #
+  #     class Post < ActiveRecord::Base
+  #       extend FriendlyId
+  #       friendly_id :title, :use => :slugged
+  #     end
+  #
+  #     @post = Post.create(:title => "This is the first post!")
+  #     @post.friendly_id   # returns "this-is-the-first-post"
+  #     redirect_to @post   # the URL will be /posts/this-is-the-first-post
+  #
+  # In general, use slugs by default unless you know for sure you don't need them.
+  # To activate the slugging functionality, use the {FriendlyId::Slugged} module.
+  #
+  # FriendlyId will generate slugs from a method or column that you specify, and
+  # store them in a field in your model. By default, this field must be named
+  # `:slug`, though you may change this using the
+  # {FriendlyId::Slugged::Configuration#slug_column slug_column} configuration
+  # option. You should add an index to this column, and in most cases, make it
+  # unique. You may also wish to constrain it to NOT NULL, but this depends on your
+  # app's behavior and requirements.
+  #
+  # ### Example Setup
+  #
+  #     # your model
+  #     class Post < ActiveRecord::Base
+  #       extend FriendlyId
+  #       friendly_id :title, :use => :slugged
+  #       validates_presence_of :title, :slug, :body
+  #     end
+  #
+  #     # a migration
+  #     class CreatePosts < ActiveRecord::Migration
+  #       def self.up
+  #         create_table :posts do |t|
+  #           t.string :title, :null => false
+  #           t.string :slug, :null => false
+  #           t.text :body
+  #         end
+  #
+  #         add_index :posts, :slug, :unique => true
+  #       end
+  #
+  #       def self.down
+  #         drop_table :posts
+  #       end
+  #     end
+  #
+  # ### Working With Slugs
+  #
+  # #### Formatting
+  #
+  # By default, FriendlyId uses Active Support's
+  # [parameterize](http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-parameterize)
+  # method to create slugs. This method will intelligently replace spaces with
+  # dashes, and Unicode Latin characters with ASCII approximations:
+  #
+  #     movie = Movie.create! :title => "Der Preis fürs Überleben"
+  #     movie.slug #=> "der-preis-furs-uberleben"
+  #
+  # #### Column or Method?
+  #
+  # FriendlyId always uses a method as the basis of the slug text - not a column. At
+  # first glance, this may sound confusing, but remember that Active Record provides
+  # methods for each column in a model's associated table, and that's what
+  # FriendlyId uses.
+  #
+  # Here's an example of a class that uses a custom method to generate the slug:
+  #
+  #     class Person < ActiveRecord::Base
+  #       extend FriendlyId
+  #       friendly_id :name_and_location, use: :slugged
+  #
+  #       def name_and_location
+  #         "#{name} from #{location}"
+  #       end
+  #     end
+  #
+  #     bob = Person.create! :name => "Bob Smith", :location => "New York City"
+  #     bob.friendly_id #=> "bob-smith-from-new-york-city"
+  #
+  # FriendlyId refers to this internally as the "base" method.
+  #
+  # #### Uniqueness
+  #
+  # When you try to insert a record that would generate a duplicate friendly id,
+  # FriendlyId will append a UUID to the generated slug to ensure uniqueness:
+  #
+  #     car = Car.create :title => "Peugeot 206"
+  #     car2 = Car.create :title => "Peugeot 206"
+  #
+  #     car.friendly_id #=> "peugeot-206"
+  #     car2.friendly_id #=> "peugeot-206-f9f3789a-daec-4156-af1d-fab81aa16ee5"
+  #
+  # Previous versions of FriendlyId appended a numeric sequence to make slugs
+  # unique, but this was removed to simplify using FriendlyId in concurrent code.
+  #
+  # #### Candidates
+  #
+  # Since UUIDs are ugly, FriendlyId provides a "slug candidates" functionality to
+  # let you specify alternate slugs to use in the event the one you want to use is
+  # already taken. For example:
+  #
+  #     class Restaurant < ActiveRecord::Base
+  #       extend FriendlyId
+  #       friendly_id :slug_candidates, use: :slugged
+  #
+  #       # Try building a slug based on the following fields in
+  #       # increasing order of specificity.
+  #       def slug_candidates
+  #         [
+  #           :name,
+  #           [:name, :city],
+  #           [:name, :street, :city],
+  #           [:name, :street_number, :street, :city]
+  #         ]
+  #       end
+  #     end
+  #
+  #     r1 = Restaurant.create! name: 'Plaza Diner', city: 'New Paltz'
+  #     r2 = Restaurant.create! name: 'Plaza Diner', city: 'Kingston'
+  #
+  #     r1.friendly_id  #=> 'plaza-diner'
+  #     r2.friendly_id  #=> 'plaza-diner-kingston'
+  #
+  # To use candidates, make your FriendlyId base method return an array. The
+  # method need not be named `slug_candidates`; it can be anything you want. The
+  # array may contain any combination of symbols, strings, procs or lambdas and
+  # will be evaluated lazily and in order. If you include symbols, FriendlyId will
+  # invoke a method on your model class with the same name. Strings will be
+  # interpreted literally. Procs and lambdas will be called and their return values
+  # used as the basis of the friendly id. If none of the candidates can generate a
+  # unique slug, then FriendlyId will append a UUID to the first candidate as a
+  # last resort.
+  #
+  # #### Sequence Separator
+  #
+  # By default, FriendlyId uses a dash to separate the slug from a sequence.
+  #
+  # You can change this with the {FriendlyId::Slugged::Configuration#sequence_separator
+  # sequence_separator} configuration option.
+  #
+  # #### Avoiding Numeric Slugs
+  #
+  # Purely numeric slugs like "123" can create ambiguity in Rails routing - they could
+  # be interpreted as either a friendly slug or a database ID. To prevent this, you can
+  # configure FriendlyId to treat numeric slugs as conflicts and add a UUID suffix:
+  #
+  #     class Product < ActiveRecord::Base
+  #       extend FriendlyId
+  #       friendly_id :sku, use: :slugged
+  #       friendly_id_config.treat_numeric_as_conflict = true
+  #     end
+  #
+  #     product = Product.create! sku: "123"
+  #     product.slug #=> "123-f9f3789a-daec-4156-af1d-fab81aa16ee5"
+  #
+  # This only affects purely numeric slugs. Alphanumeric slugs like "product-123"
+  # or "abc123" will work normally.
+  #
+  # #### Providing Your Own Slug Processing Method
+  #
+  # You can override {FriendlyId::Slugged#normalize_friendly_id} in your model for
+  # total control over the slug format. It will be invoked for any generated slug,
+  # whether for a single slug or for slug candidates.
+  #
+  # #### Deciding When to Generate New Slugs
+  #
+  # As of FriendlyId 5.0, slugs are only generated when the `slug` field is nil. If
+  # you want a slug to be regenerated,set the slug field to nil:
+  #
+  #     restaurant.friendly_id # joes-diner
+  #     restaurant.name = "The Plaza Diner"
+  #     restaurant.save!
+  #     restaurant.friendly_id # joes-diner
+  #     restaurant.slug = nil
+  #     restaurant.save!
+  #     restaurant.friendly_id # the-plaza-diner
+  #
+  # You can also override the
+  # {FriendlyId::Slugged#should_generate_new_friendly_id?} method, which lets you
+  # control exactly when new friendly ids are set:
+  #
+  #     class Post < ActiveRecord::Base
+  #       extend FriendlyId
+  #       friendly_id :title, :use => :slugged
+  #
+  #       def should_generate_new_friendly_id?
+  #         title_changed?
+  #       end
+  #     end
+  #
+  # If you want to extend the default behavior but add your own conditions,
+  # don't forget to invoke `super` from your implementation:
+  #
+  #     class Category < ActiveRecord::Base
+  #       extend FriendlyId
+  #       friendly_id :name, :use => :slugged
+  #
+  #       def should_generate_new_friendly_id?
+  #         name_changed? || super
+  #       end
+  #     end
+  #
+  # #### Locale-specific Transliterations
+  #
+  # Active Support's `parameterize` uses
+  # [transliterate](http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-transliterate),
+  # which in turn can use I18n's transliteration rules to consider the current
+  # locale when replacing Latin characters:
+  #
+  #     # config/locales/de.yml
+  #     de:
+  #       i18n:
+  #         transliterate:
+  #           rule:
+  #             ü: "ue"
+  #             ö: "oe"
+  #             etc...
+  #
+  #     movie = Movie.create! :title => "Der Preis fürs Überleben"
+  #     movie.slug #=> "der-preis-fuers-ueberleben"
+  #
+  # This functionality was in fact taken from earlier versions of FriendlyId.
+  #
+  # #### Gotchas: Common Problems
+  #
+  # FriendlyId uses a before_validation callback to generate and set the slug. This
+  # means that if you create two model instances before saving them, it's possible
+  # they will generate the same slug, and the second save will fail.
+  #
+  # This can happen in two fairly normal cases: the first, when a model using nested
+  # attributes creates more than one record for a model that uses friendly_id. The
+  # second, in concurrent code, either in threads or multiple processes.
+  #
+  # To solve the nested attributes issue, I recommend simply avoiding them when
+  # creating more than one nested record for a model that uses FriendlyId. See [this
+  # Github issue](https://github.com/norman/friendly_id/issues/185) for discussion.
+  #
+  # @guide end
+  module Slugged
+    # Sets up behavior and configuration options for FriendlyId's slugging
+    # feature.
+    def self.included(model_class)
+      model_class.friendly_id_config.instance_eval do
+        self.class.send :include, Configuration
+        self.slug_generator_class ||= SlugGenerator
+        defaults[:slug_column] ||= "slug"
+        defaults[:sequence_separator] ||= "-"
+      end
+      model_class.before_validation :set_slug
+      model_class.before_save :set_slug
+      model_class.after_validation :unset_slug_if_invalid
+    end
+
+    # Process the given value to make it suitable for use as a slug.
+    #
+    # This method is not intended to be invoked directly; FriendlyId uses it
+    # internally to process strings into slugs.
+    #
+    # However, if FriendlyId's default slug generation 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 upper case and with underscores
+    #       def normalize_friendly_id(string)
+    #         super.upcase.gsub("-", "_")
+    #       end
+    #     end
+    #
+    #     bob = Person.create! :name => "Bob Smith", :location => "New York City"
+    #     bob.friendly_id #=> "BOB_SMITH_FROM_NEW_YORK_CITY"
+    #
+    # ### More Resources
+    #
+    # You might want to look into Babosa[https://github.com/norman/babosa],
+    # which is the slugging library used by FriendlyId prior to version 4, which
+    # offers some specialized functionality missing from Active Support.
+    #
+    # @param [#to_s] value The value used as the basis of the slug.
+    # @return The candidate slug text, without a sequence.
+    def normalize_friendly_id(value)
+      value = value.to_s.parameterize
+      value = value[0...friendly_id_config.slug_limit] if friendly_id_config.slug_limit
+      value
+    end
+
+    # Whether to generate a new slug.
+    #
+    # You can override this method in your model if, for example, you only want
+    # slugs to be generated once, and then never updated.
+    def should_generate_new_friendly_id?
+      send(friendly_id_config.slug_column).nil? && !send(friendly_id_config.base).nil?
+    end
+
+    # Public: Resolve conflicts.
+    #
+    # This method adds UUID to first candidate and truncates (if `slug_limit` is set).
+    #
+    # Examples:
+    #
+    #   resolve_friendly_id_conflict(['12345'])
+    #   # => '12345-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
+    #
+    #   FriendlyId.defaults { |config| config.slug_limit = 40 }
+    #   resolve_friendly_id_conflict(['12345'])
+    #   # => '123-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
+    #
+    # candidates - the Array with candidates.
+    #
+    # Returns the String with new slug.
+    def resolve_friendly_id_conflict(candidates)
+      uuid = SecureRandom.uuid
+      [
+        apply_slug_limit(candidates.first, uuid),
+        uuid
+      ].compact.join(friendly_id_config.sequence_separator)
+    end
+
+    # Private: Apply slug limit to candidate.
+    #
+    # candidate - the String with candidate.
+    # uuid      - the String with UUID.
+    #
+    # Return the String with truncated candidate.
+    def apply_slug_limit(candidate, uuid)
+      return candidate unless candidate && friendly_id_config.slug_limit
+
+      candidate[0...candidate_limit(uuid)]
+    end
+    private :apply_slug_limit
+
+    # Private: Get max length of candidate.
+    #
+    # uuid - the String with UUID.
+    #
+    # Returns the Integer with max length.
+    def candidate_limit(uuid)
+      [
+        friendly_id_config.slug_limit - uuid.size - friendly_id_config.sequence_separator.size,
+        0
+      ].max
+    end
+    private :candidate_limit
+
+    # Sets the slug.
+    def set_slug(normalized_slug = nil)
+      if should_generate_new_friendly_id?
+        candidates = FriendlyId::Candidates.new(self, normalized_slug || send(friendly_id_config.base))
+        slug = slug_generator.generate(candidates) || resolve_friendly_id_conflict(candidates)
+        send "#{friendly_id_config.slug_column}=", slug
+      end
+    end
+    private :set_slug
+
+    def scope_for_slug_generator
+      scope = self.class.base_class.unscoped
+      scope = scope.friendly unless scope.respond_to?(:exists_by_friendly_id?)
+      primary_key_name = self.class.primary_key
+      scope.where(self.class.base_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 unset_slug_if_invalid
+      if errors.key?(friendly_id_config.query_field) && attribute_changed?(friendly_id_config.query_field.to_s)
+        diff = changes[friendly_id_config.query_field]
+        send "#{friendly_id_config.slug_column}=", diff.first
+      end
+    end
+    private :unset_slug_if_invalid
+
+    # This module adds the `:slug_column`, and `:slug_limit`, and `:sequence_separator`,
+    # and `:slug_generator_class` configuration options to
+    # {FriendlyId::Configuration FriendlyId::Configuration}.
+    module Configuration
+      attr_writer :slug_column, :slug_limit, :sequence_separator
+      attr_accessor :slug_generator_class, :treat_numeric_as_conflict
+
+      # Makes FriendlyId use the slug column for querying.
+      # @return String The slug column.
+      def query_field
+        slug_column
+      end
+
+      # The string used to separate a slug base from a numeric sequence.
+      #
+      # You can change the default separator by setting the
+      # {FriendlyId::Slugged::Configuration#sequence_separator
+      # sequence_separator} configuration option.
+      # @return String The sequence separator string. Defaults to "`-`".
+      def sequence_separator
+        @sequence_separator ||= defaults[:sequence_separator]
+      end
+
+      # The column that will be used to store the generated slug.
+      def slug_column
+        @slug_column ||= defaults[:slug_column]
+      end
+
+      # The limit that will be used for slug.
+      def slug_limit
+        @slug_limit ||= defaults[:slug_limit]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+module FriendlyId
+  VERSION = "5.7.0".freeze
+end