ultra-clean-kit 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 197f4d14fac828fe32b54aa660baf21d2c9351fbbe793112eee9e7aa53bec536
+  data.tar.gz: 88433d57d59c808ead4e43743697d856724a279309628165ede5591db796010f
+SHA512:
+  metadata.gz: 4f6d825d871da8311972bef4656a2ecc78a393f1be97eab5dc51789ba743f5fd2d9f3ac349e755b6862cddd4bb7b0ebaa9e96b6fb70809a751091dbe5d4055bf
+  data.tar.gz: 02054dd30069f876a510672bc6f90c6f1aed855f9a11936ca1164bcdcb860360cc770fe33200c6459e74a644ca51a112f8b3e0bf0554154a83aef0077f483820

data/babosa-2.1.0/Changelog.md

@@ -0,0 +1,119 @@
+# Babosa Changelog
+
+## 2.0.0
+
+This release contains no important changes. I had a week off from work and
+decided to refactor the code.  However there are some small breaking changes so
+I have released it as 2.0.0.
+
+* Refactor internals for simplicity
+* Use built-in Ruby UTF-8 support in places of other gems.
+* Drop support for Ruby < 2.5.0.
+* `Babosa::Identifier#word_chars` no longer removes dashes
+* `Babosa::Identifier#to_ruby_method` default argument `allow_bangs` is now a keyword argument
+
+## 1.0.4
+
+* Fix nil being cast to frozen string (https://github.com/norman/babosa/pull/52)
+
+## 1.0.3
+
+* Fix Active Support 6 deprecations (https://github.com/norman/babosa/pull/50)
+
+## 1.0.2
+
+* Fix regression in ActiveSupport UTF8 proxy.
+
+## 1.0.1
+
+* Fix error with tidy_bytes on Rubinius.
+* Simplify Active Support UTF8 proxy.
+* Fix `allow_bangs` argument to to_ruby_method being silently ignored.
+* Raise error when generating an impossible Ruby method name.
+
+## 1.0.0
+
+* Adopt semantic versioning.
+* When using Active Support, require 3.2 or greater.
+* Require Ruby 2.0 or greater.
+* Fix Ruby warnings.
+* Improve support for Ukrainian.
+* Support some additional punctuation characters used by Chinese and others.
+* Add Polish spec.
+* Use native Unicode normalization on Ruby 2.2 in UTF8::DumbProxy.
+* Invoke Ruby-native upcase/downcase in UTF8::DumbProxy.
+* Proxy `tidy_bytes` method to Active Support when possible.
+* Remove SlugString constant.
+
+## 0.3.11
+
+*  Add support for Vietnamese.
+
+## 0.3.10
+
+*  Fix Macedonian "S/S". Don't `include JRuby` unnecessarily.
+
+## 0.3.9
+
+* Add missing Greek vowels with diaeresis.
+
+## 0.3.8
+
+* Correct and improve Macedonian support.
+
+## 0.3.7
+
+* Fix compatibility with Ruby 1.8.7.
+* Add Swedish support.
+
+## 0.3.6
+
+* Allow multiple transliterators.
+* Add Greek support.
+
+## 0.3.5
+
+* Don't strip underscores from identifiers.
+
+## 0.3.4
+
+* Add Romanian support.
+
+## 0.3.3
+
+* Add Norwegian support.
+
+## 0.3.2
+
+* Improve Macedonian support.
+
+## 0.3.1
+
+* Small fixes to Cyrillic.
+
+## 0.3.0
+
+* Cyrillic support.
+* Improve support for various Unicode spaces and dashes.
+
+## 0.2.2
+
+* Fix for "smart" quote handling.
+
+## 0.2.1
+
+* Implement #empty? for compatiblity with Active Support's #blank?.
+
+## 0.2.0
+
+* Add support for Danish.
+* Add method to generate Ruby identifiers.
+* Improve performance.
+
+## 0.1.1
+
+* Add support for Serbian.
+
+## 0.1.0
+
+* Initial extraction from FriendlyId.

data/babosa-2.1.0/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Norman Clarke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/babosa-2.1.0/README.md

@@ -0,0 +1,243 @@
+# Babosa
+
+[![Build Status](https://github.com/norman/babosa/actions/workflows/main.yml/badge.svg)](https://github.com/norman/babosa/actions)
+
+Babosa is a library for creating human-friendly identifiers, aka "slugs". It can
+also be useful for normalizing and sanitizing data.
+
+It is an extraction and improvement of the string code from
+[FriendlyId](http://github.com/norman/friendly_id). I have released this as a
+separate library to help developers who want to create libraries similar to
+FriendlyId.
+
+## Features / Usage
+
+### Transliterate UTF-8 characters to ASCII
+
+```ruby
+"Gölcük, Turkey".to_slug.transliterate.to_s #=> "Golcuk, Turkey"
+```
+
+### Locale sensitive transliteration, with support for many languages
+
+```ruby
+"Jürgen Müller".to_slug.transliterate.to_s           #=> "Jurgen Muller"
+"Jürgen Müller".to_slug.transliterate(:german).to_s  #=> "Juergen Mueller"
+```
+
+Currently supported languages include:
+
+* Bulgarian
+* Danish
+* German
+* Greek
+* Hindi
+* Macedonian
+* Norwegian
+* Romanian
+* Russian
+* Serbian
+* Spanish
+* Swedish
+* Turkish
+* Ukrainian
+* Vietnamese
+
+Additionally there are generic transliterators for transliterating from the
+Cyrillic alphabet and Latin alphabet with diacritics. The Latin transliterator
+can be used, for example, with Czech. There is also a transliterator named
+"Hindi" which may be sufficient for other Indic languages using Devanagari, but
+I do not know enough to say whether the transliterations would make sense.
+
+I'll gladly accept contributions from fluent speakers to support more languages.
+
+### Strip non-ASCII characters
+
+```ruby
+"Gölcük, Turkey".to_slug.to_ascii.to_s #=> "Glck, Turkey"
+```
+
+### Truncate by characters
+
+```ruby
+"üüü".to_slug.truncate(2).to_s #=> "üü"
+```
+
+### Truncate by bytes
+
+This can be useful to ensure the generated slug will fit in a database column
+whose length is limited by bytes rather than UTF-8 characters.
+
+```ruby
+"üüü".to_slug.truncate_bytes(2).to_s #=> "ü"
+```
+
+### Remove punctuation chars
+
+```ruby
+"this is, um, **really** cool, huh?".to_slug.word_chars.to_s #=> "this is um really cool huh"
+```
+
+### All-in-one
+
+```ruby
+"Gölcük, Turkey".to_slug.normalize.to_s #=> "golcuk-turkey"
+```
+
+### Other stuff
+
+#### Using Babosa With FriendlyId 4+
+
+```ruby
+require "babosa"
+
+class Person < ActiveRecord::Base
+  friendly_id :name, use: :slugged
+
+  def normalize_friendly_id(input)
+    input.to_slug.transliterate(:ukrainian).normalize.to_s
+  end
+end
+```
+
+#### UTF-8 support
+
+Babosa normalizes all input strings [to NFC](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).
+
+#### Ruby Method Names
+
+Babosa can generate strings for Ruby method names. (Yes, Ruby 1.9+ can use
+UTF-8 chars in method names, but you may not want to):
+
+
+```ruby
+"this is a method".to_slug.to_ruby_method! #=> this_is_a_method
+"über cool stuff!".to_slug.to_ruby_method! #=> uber_cool_stuff!
+
+# You can also disallow trailing punctuation chars
+"über cool stuff!".to_slug.to_ruby_method(allow_bangs: false) #=> uber_cool_stuff
+```
+
+#### Easy to Extend
+
+You can add custom transliterators for your language with very little code. For
+example here's the transliterator for German:
+
+```ruby
+module Babosa
+  module Transliterator
+    class German < Latin
+      APPROXIMATIONS = {
+        "ä" => "ae",
+        "ö" => "oe",
+        "ü" => "ue",
+        "Ä" => "Ae",
+        "Ö" => "Oe",
+        "Ü" => "Ue"
+      }
+    end
+  end
+end
+```
+
+And a spec (you can use this as a template):
+
+```ruby
+require "spec_helper"
+
+describe Babosa::Transliterator::German do
+  let(:t) { described_class.instance }
+  it_behaves_like "a latin transliterator"
+
+  it "should transliterate Eszett" do
+    t.transliterate("ß").should eql("ss")
+  end
+
+  it "should transliterate vowels with umlauts" do
+    t.transliterate("üöä").should eql("ueoeae")
+  end
+end
+```
+
+### Rails 3.x and higher
+
+Some of Babosa's functionality was added to Active Support 3.0.0.
+
+Babosa now differs from ActiveSupport primarily in that it supports non-Latin
+strings by default, and has per-locale ASCII transliterations already baked-in.
+If you are considering using Babosa with Rails, you may want to first take a
+look at Active Support's
+[transliterate](http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-transliterate)
+and
+[parameterize](http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-parameterize)
+to see if they suit your needs.
+
+Please see the [API docs](http://rubydoc.info/github/norman/babosa/master/frames) and source code for
+more info.
+
+## Getting it
+
+Babosa can be installed via Rubygems:
+
+    gem install babosa
+
+You can get the source code from its [Github repository](http://github.com/norman/babosa).
+
+## Reporting bugs
+
+Please use Babosa's [Github issue
+tracker](http://github.com/norman/babosa/issues).
+
+
+## Misc
+
+"Babosa" means "slug" in Spanish.
+
+## Maintainers
+
+* [Philip Arndt](https://github.com/parndt)
+* [Norman Clarke](https://github.com/norman/)
+
+## Contributors
+
+Many thanks to the following people for their help:
+
+* [Dmitry A. Ilyashevich](https://github.com/dmitry-ilyashevich) - Deprecation fixes
+* [anhkind](https://github.com/anhkind) - Vietnamese support
+* [Martins Zakis](https://github.com/martins) - Bug fixes
+* [Vassilis Rodokanakis](https://github.com/vrodokanakis) - Greek support
+* [Peco Danajlovski](https://github.com/Vortex) - Macedonian support
+* [Philip Arndt](https://github.com/parndt) - Bug fixes
+* [Jonas Forsberg](https://github.com/himynameisjonas) - Swedish support
+* [Jaroslav Kalistsuk](https://github.com/jarosan) - Greek support
+* [Steven Heidel](https://github.com/stevenheidel) - Bug fixes
+* [Edgars Beigarts](https://github.com/ebeigarts) - Support for multiple transliterators
+* [Tiberiu C. Turbureanu](https://gitorious.org/~tct) - Romanian support
+* [Kim Joar Bekkelund](https://github.com/kjbekkelund) - Norwegian support
+* [Alexey Shkolnikov](https://github.com/grlm) - Russian support
+* [Martin Petrov](https://github.com/martin-petrov) - Bulgarian support
+* [Molte Emil Strange Andersen](https://github.com/molte) - Danish support
+* [Milan Dobrota](https://github.com/milandobrota) - Serbian support
+* [Norman Clarke](https://github.com/norman) - Original author
+
+## Copyright
+
+Copyright (c) 2010-2021 Norman Clarke and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/babosa-2.1.0/Rakefile

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "rubygems"
+require "bundler/gem_helper"
+require "rake/testtask"
+require "rake/clean"
+require "rubygems/package_task"
+
+task default: [:spec]
+task test: :spec
+
+CLEAN << "pkg" << "doc" << "coverage" << ".yardoc"
+
+begin
+  require "yard"
+  YARD::Rake::YardocTask.new do |t|
+    t.options = ["--output-dir=doc"]
+  end
+rescue LoadError
+  puts "Yard not present"
+end
+
+begin
+  desc "Run SimpleCov"
+  task :coverage do
+    ENV["COV"] = "true"
+    Rake::Task["spec"].execute
+  end
+rescue LoadError
+  puts "SimpleCov not present"
+end
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+Bundler::GemHelper.install_tasks(name: "babosa")

data/babosa-2.1.0/lib/babosa/identifier.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module Babosa
+  # This class provides some string-manipulation methods specific to slugs.
+  #
+  # Note that this class includes many "bang methods" such as {#clean!} and
+  # {#normalize!} that perform actions on the string in-place. Each of these
+  # methods has a corresponding "bangless" method (i.e., +Identifier#clean!+
+  # and +Identifier#clean+) which does not appear in the documentation because
+  # it is generated dynamically.
+  #
+  # All of the bang methods return an instance of String, while the bangless
+  # versions return an instance of {Babosa::Identifier}, so that calls to methods
+  # specific to this class can be chained:
+  #
+  #   string = Identifier.new("hello world")
+  #   string.with_separators! # => "hello-world"
+  #   string.with_separators  # => <Babosa::Identifier:0x000001013e1590 @wrapped_string="hello-world">
+  #
+  # @see http://www.utf8-chartable.de/unicode-utf8-table.pl?utf8=dec Unicode character table
+  class Identifier
+    Error = Class.new(StandardError)
+
+    attr_reader :wrapped_string
+    alias_method :to_s, :wrapped_string
+
+    def method_missing(symbol, *args, &block)
+      @wrapped_string.__send__(symbol, *args, &block)
+    end
+
+    def respond_to_missing?(name, include_all)
+      @wrapped_string.respond_to?(name, include_all)
+    end
+
+    # @param string [#to_s] The string to use as the basis of the Identifier.
+    def initialize(string)
+      @wrapped_string = string.to_s.dup
+      tidy_bytes!
+      normalize_utf8!
+    end
+
+    def ==(other)
+      to_s == other.to_s
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    # Approximate an ASCII string. This works only for strings using characters
+    # that are Roman-alphabet characters + diacritics. Non-letter characters
+    # are left unmodified.
+    #
+    #   string = Identifier.new "Łódź, Poland"
+    #   string.transliterate                 # => "Lodz, Poland"
+    #   string = Identifier.new "日本"
+    #   string.transliterate                 # => "日本"
+    #
+    # You can pass the names of any transliterator class as arguments. This
+    # allows for contextual approximations. Various languages are supported,
+    # you can see which ones by looking at the source of
+    # {Babosa::Transliterator::Base}.
+    #
+    #   string = Identifier.new "Jürgen Müller"
+    #   string.transliterate                 # => "Jurgen Muller"
+    #   string.transliterate :german         # => "Juergen Mueller"
+    #   string = Identifier.new "¡Feliz año!"
+    #   string.transliterate                 # => "¡Feliz ano!"
+    #   string.transliterate :spanish        # => "¡Feliz anio!"
+    #
+    # The approximations are an array, which you can modify if you choose:
+    #
+    #   # Make Spanish use "nh" rather than "nn"
+    #   Babosa::Transliterator::Spanish::APPROXIMATIONS["ñ"] = "nh"
+    #
+    # Notice that this method does not simply convert to ASCII; if you want
+    # to remove non-ASCII characters such as "¡" and "¿", use {#to_ascii!}:
+    #
+    #   string.transliterate!(:spanish)       # => "¡Feliz anio!"
+    #   string.to_ascii!                      # => "Feliz anio!"
+    #
+    # @param *args <Symbol>
+    # @return String
+    def transliterate!(*kinds)
+      kinds.compact!
+      kinds = [:latin] if kinds.empty?
+      kinds.each do |kind|
+        transliterator = Transliterator.get(kind).instance
+        @wrapped_string = transliterator.transliterate(@wrapped_string)
+      end
+      to_s
+    end
+
+    # Converts dashes to spaces, removes leading and trailing spaces, and
+    # replaces multiple whitespace characters with a single space.
+    #
+    # @return String
+    def clean!
+      gsub!(/[- ]+/, " ")
+      strip!
+      to_s
+    end
+
+    # Remove any non-word characters. For this library's purposes, this means
+    # anything other than letters, numbers, spaces, underscores, dashes,
+    # newlines, and linefeeds.
+    #
+    # @return String
+    def word_chars!
+      # `^\p{letter}` = Any non-Unicode letter
+      # `&&` = add the following character class
+      # `[^ _\n\r\p{Extended_Pictographic}]` = Anything other than space, underscore, newline, linefeed or emojis
+      gsub!(/[[^\p{letter}]&&[^ \d_\-\n\r\p{Extended_Pictographic}]]/, "")
+      to_s
+    end
+
+    # Normalize the string for use as a URL slug. Note that in this context,
+    # +normalize+ means, strip, remove non-letters/numbers, downcasing,
+    # truncating to 255 bytes and converting whitespace to dashes.
+    #
+    # @param options [Hash]
+    # @return String
+    def normalize!(options = {})
+      options = default_normalize_options.merge(options)
+
+      if options[:transliterate]
+        option = options[:transliterate]
+        if option == true
+          transliterate!(*options[:transliterations])
+        else
+          transliterate!(*option)
+        end
+      end
+      to_ascii! if options[:to_ascii]
+      word_chars!
+      clean!
+      downcase!
+      truncate_bytes!(options[:max_length])
+      with_separators!(options[:separator])
+    end
+
+    # Normalize a string so that it can safely be used as a Ruby method name.
+    #
+    # @param allow_bangs [Boolean]
+    # @return String
+    def to_ruby_method!(allow_bangs: true)
+      last_char = self[-1]
+      transliterate!
+      to_ascii!
+      word_chars!
+      strip_leading_digits!
+      clean!
+      @wrapped_string += last_char if allow_bangs && ["!", "?"].include?(last_char)
+      raise Error, "Input generates impossible Ruby method name" if self == ""
+
+      with_separators!("_")
+    end
+
+    # Delete any non-ascii characters.
+    #
+    # @return String
+    def to_ascii!
+      gsub!(/[^\x00-\x7f]/u, "")
+      to_s
+    end
+
+    # Truncate the string to +max+ characters.
+    #
+    # @example
+    #   "üéøá".to_identifier.truncate(3) #=> "üéø"
+    #
+    # @param max [Integer] The maximum number of characters.
+    # @return String
+    def truncate!(max)
+      @wrapped_string = slice(0, max)
+    end
+
+    # Truncate the string to +max+ bytes. This can be useful for ensuring that
+    # a UTF-8 string will always fit into a database column with a certain max
+    # byte length. The resulting string may be less than +max+ if the string must
+    # be truncated at a multibyte character boundary.
+    #
+    # @example
+    #   "üéøá".to_identifier.truncate_bytes(3) #=> "ü"
+    #
+    # @param max [Integer] The maximum number of bytes.
+    # @return String
+    def truncate_bytes!(max)
+      truncate!(max)
+      chop! until bytesize <= max
+    end
+
+    # Replaces whitespace with dashes ("-").
+    #
+    # @param char [String] the separator character to use.
+    # @return String
+    def with_separators!(char = "-")
+      gsub!(/\s/u, char)
+      to_s
+    end
+
+    # Perform Unicode composition on the wrapped string.
+    #
+    # @return String
+    def normalize_utf8!
+      unicode_normalize!(:nfc)
+      to_s
+    end
+
+    # Strip any leading digits.
+    #
+    # @return String
+    def strip_leading_digits!
+      gsub!(/^\d+/, "")
+      to_s
+    end
+
+    # Attempt to convert characters encoded using CP1252 and IS0-8859-1 to
+    # UTF-8.
+    # @return String
+    def tidy_bytes!
+      scrub! do |bad|
+        bad.encode(Encoding::UTF_8, Encoding::Windows_1252, invalid: :replace, undef: :replace)
+      end
+      to_s
+    end
+
+    %w[clean downcase normalize normalize_utf8 strip_leading_digits
+      tidy_bytes to_ascii transliterate truncate truncate_bytes upcase
+      with_separators word_chars].each do |method|
+      class_eval(<<-METHOD, __FILE__, __LINE__ + 1)
+        def #{method}(*args)
+          with_new_instance { |id| id.send(:#{method}!, *args) }
+        end
+      METHOD
+    end
+
+    def to_ruby_method(allow_bangs: true)
+      with_new_instance { |id| id.to_ruby_method!(allow_bangs: allow_bangs) }
+    end
+
+    def to_identifier
+      self
+    end
+
+    # The default options for {#normalize!}. Override to set your own defaults.
+    def default_normalize_options
+      {transliterate: :latin, max_length: 255, separator: "-"}
+    end
+
+    alias_method :approximate_ascii, :transliterate
+    alias_method :approximate_ascii!, :transliterate!
+    alias_method :with_dashes, :with_separators
+    alias_method :with_dashes!, :with_separators!
+    alias_method :to_slug, :to_identifier
+
+    private
+
+    # Used as the basis of the non-mutating (bangless) methods.
+    def with_new_instance
+      Identifier.allocate.tap do |id|
+        id.instance_variable_set :@wrapped_string, to_s
+
+        yield id
+      end
+    end
+  end
+end