omg-activesupport 8.0.0.alpha1

data/lib/active_support/inflector/methods.rb

@@ -0,0 +1,387 @@
+# frozen_string_literal: true
+
+require "active_support/inflections"
+
+module ActiveSupport
+  # = Active Support \Inflector
+  #
+  # The Inflector transforms words from singular to plural, class names to table
+  # names, modularized class names to ones without, and class names to foreign
+  # keys. The default inflections for pluralization, singularization, and
+  # uncountable words are kept in inflections.rb.
+  #
+  # The \Rails core team has stated patches for the inflections library will not
+  # be accepted in order to avoid breaking legacy applications which may be
+  # relying on errant inflections. If you discover an incorrect inflection and
+  # require it for your application or wish to define rules for languages other
+  # than English, please correct or add them yourself (explained below).
+  module Inflector
+    extend self
+
+    # Returns the plural form of the word in the string.
+    #
+    # If passed an optional +locale+ parameter, the word will be
+    # pluralized using rules defined for that language. By default,
+    # this parameter is set to <tt>:en</tt>.
+    #
+    #   pluralize('post')             # => "posts"
+    #   pluralize('octopus')          # => "octopi"
+    #   pluralize('sheep')            # => "sheep"
+    #   pluralize('words')            # => "words"
+    #   pluralize('CamelOctopus')     # => "CamelOctopi"
+    #   pluralize('ley', :es)         # => "leyes"
+    def pluralize(word, locale = :en)
+      apply_inflections(word, inflections(locale).plurals, locale)
+    end
+
+    # The reverse of #pluralize, returns the singular form of a word in a
+    # string.
+    #
+    # If passed an optional +locale+ parameter, the word will be
+    # singularized using rules defined for that language. By default,
+    # this parameter is set to <tt>:en</tt>.
+    #
+    #   singularize('posts')            # => "post"
+    #   singularize('octopi')           # => "octopus"
+    #   singularize('sheep')            # => "sheep"
+    #   singularize('word')             # => "word"
+    #   singularize('CamelOctopi')      # => "CamelOctopus"
+    #   singularize('leyes', :es)       # => "ley"
+    def singularize(word, locale = :en)
+      apply_inflections(word, inflections(locale).singulars, locale)
+    end
+
+    # Converts strings to UpperCamelCase.
+    # If the +uppercase_first_letter+ parameter is set to false, then produces
+    # lowerCamelCase.
+    #
+    # Also converts '/' to '::' which is useful for converting
+    # paths to namespaces.
+    #
+    #   camelize('active_model')                # => "ActiveModel"
+    #   camelize('active_model', false)         # => "activeModel"
+    #   camelize('active_model/errors')         # => "ActiveModel::Errors"
+    #   camelize('active_model/errors', false)  # => "activeModel::Errors"
+    #
+    # As a rule of thumb you can think of +camelize+ as the inverse of
+    # #underscore, though there are cases where that does not hold:
+    #
+    #   camelize(underscore('SSLError'))        # => "SslError"
+    def camelize(term, uppercase_first_letter = true)
+      string = term.to_s
+      # String#camelize takes a symbol (:upper or :lower), so here we also support :lower to keep the methods consistent.
+      if !uppercase_first_letter || uppercase_first_letter == :lower
+        string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase! || match }
+      elsif string.match?(/\A[a-z\d]*\z/)
+        return inflections.acronyms[string]&.dup || string.capitalize
+      else
+        string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize! || match }
+      end
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) do
+        word = $2
+        substituted = inflections.acronyms[word] || word.capitalize! || word
+        $1 ? "::#{substituted}" : substituted
+      end
+      string
+    end
+
+    # Makes an underscored, lowercase form from the expression in the string.
+    #
+    # Changes '::' to '/' to convert namespaces to paths.
+    #
+    #   underscore('ActiveModel')         # => "active_model"
+    #   underscore('ActiveModel::Errors') # => "active_model/errors"
+    #
+    # As a rule of thumb you can think of +underscore+ as the inverse of
+    # #camelize, though there are cases where that does not hold:
+    #
+    #   camelize(underscore('SSLError'))  # => "SslError"
+    def underscore(camel_cased_word)
+      return camel_cased_word.to_s.dup unless /[A-Z-]|::/.match?(camel_cased_word)
+      word = camel_cased_word.to_s.gsub("::", "/")
+      word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_' }#{$2.downcase}" }
+      word.gsub!(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, "_")
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    # Tweaks an attribute name for display to end users.
+    #
+    # Specifically, performs these transformations:
+    #
+    # * Applies human inflection rules to the argument.
+    # * Deletes leading underscores, if any.
+    # * Removes an "_id" suffix if present.
+    # * Replaces underscores with spaces, if any.
+    # * Downcases all words except acronyms.
+    # * Capitalizes the first word.
+    # The capitalization of the first word can be turned off by setting the
+    # +:capitalize+ option to false (default is true).
+    #
+    # The trailing '_id' can be kept and capitalized by setting the
+    # optional parameter +keep_id_suffix+ to true (default is false).
+    #
+    #   humanize('employee_salary')                  # => "Employee salary"
+    #   humanize('author_id')                        # => "Author"
+    #   humanize('author_id', capitalize: false)     # => "author"
+    #   humanize('_id')                              # => "Id"
+    #   humanize('author_id', keep_id_suffix: true)  # => "Author id"
+    #
+    # If "SSL" was defined to be an acronym:
+    #
+    #   humanize('ssl_error') # => "SSL error"
+    #
+    def humanize(lower_case_and_underscored_word, capitalize: true, keep_id_suffix: false)
+      result = lower_case_and_underscored_word.to_s.dup
+
+      inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+
+      result.tr!("_", " ")
+      result.lstrip!
+      if !keep_id_suffix && lower_case_and_underscored_word&.end_with?("_id")
+        result.delete_suffix!(" id")
+      end
+
+      result.gsub!(/([a-z\d]+)/i) do |match|
+        match.downcase!
+        inflections.acronyms[match] || match
+      end
+
+      if capitalize
+        result.sub!(/\A\w/) do |match|
+          match.upcase!
+          match
+        end
+      end
+
+      result
+    end
+
+    # Converts the first character in the string to uppercase.
+    #
+    #   upcase_first('what a Lovely Day') # => "What a Lovely Day"
+    #   upcase_first('w')                 # => "W"
+    #   upcase_first('')                  # => ""
+    def upcase_first(string)
+      string.length > 0 ? string[0].upcase.concat(string[1..-1]) : +""
+    end
+
+    # Converts the first character in the string to lowercase.
+    #
+    #   downcase_first('If they enjoyed The Matrix') # => "if they enjoyed The Matrix"
+    #   downcase_first('I')                          # => "i"
+    #   downcase_first('')                           # => ""
+    def downcase_first(string)
+      string.length > 0 ? string[0].downcase.concat(string[1..-1]) : +""
+    end
+
+    # Capitalizes all the words and replaces some characters in the string to
+    # create a nicer looking title. +titleize+ is meant for creating pretty
+    # output. It is not used in the \Rails internals.
+    #
+    # The trailing '_id','Id'.. can be kept and capitalized by setting the
+    # optional parameter +keep_id_suffix+ to true.
+    # By default, this parameter is false.
+    #
+    #   titleize('man from the boondocks')                       # => "Man From The Boondocks"
+    #   titleize('x-men: the last stand')                        # => "X Men: The Last Stand"
+    #   titleize('TheManWithoutAPast')                           # => "The Man Without A Past"
+    #   titleize('raiders_of_the_lost_ark')                      # => "Raiders Of The Lost Ark"
+    #   titleize('string_ending_with_id', keep_id_suffix: true)  # => "String Ending With Id"
+    def titleize(word, keep_id_suffix: false)
+      humanize(underscore(word), keep_id_suffix: keep_id_suffix).gsub(/\b(?<!\w['’`()])[a-z]/) do |match|
+        match.capitalize
+      end
+    end
+
+    # Creates the name of a table like \Rails does for models to table names.
+    # This method uses the #pluralize method on the last word in the string.
+    #
+    #   tableize('RawScaledScorer') # => "raw_scaled_scorers"
+    #   tableize('ham_and_egg')     # => "ham_and_eggs"
+    #   tableize('fancyCategory')   # => "fancy_categories"
+    def tableize(class_name)
+      pluralize(underscore(class_name))
+    end
+
+    # Creates a class name from a plural table name like \Rails does for table
+    # names to models. Note that this returns a string and not a Class. (To
+    # convert to an actual class follow +classify+ with #constantize.)
+    #
+    #   classify('ham_and_eggs') # => "HamAndEgg"
+    #   classify('posts')        # => "Post"
+    #
+    # Singular names are not handled correctly:
+    #
+    #   classify('calculus')     # => "Calculu"
+    def classify(table_name)
+      # strip out any leading schema name
+      camelize(singularize(table_name.to_s.sub(/.*\./, "")))
+    end
+
+    # Replaces underscores with dashes in the string.
+    #
+    #   dasherize('puni_puni') # => "puni-puni"
+    def dasherize(underscored_word)
+      underscored_word.tr("_", "-")
+    end
+
+    # Removes the module part from the expression in the string.
+    #
+    #   demodulize('ActiveSupport::Inflector::Inflections') # => "Inflections"
+    #   demodulize('Inflections')                           # => "Inflections"
+    #   demodulize('::Inflections')                         # => "Inflections"
+    #   demodulize('')                                      # => ""
+    #
+    # See also #deconstantize.
+    def demodulize(path)
+      path = path.to_s
+      if i = path.rindex("::")
+        path[(i + 2), path.length]
+      else
+        path
+      end
+    end
+
+    # Removes the rightmost segment from the constant expression in the string.
+    #
+    #   deconstantize('Net::HTTP')   # => "Net"
+    #   deconstantize('::Net::HTTP') # => "::Net"
+    #   deconstantize('String')      # => ""
+    #   deconstantize('::String')    # => ""
+    #   deconstantize('')            # => ""
+    #
+    # See also #demodulize.
+    def deconstantize(path)
+      path.to_s[0, path.rindex("::") || 0] # implementation based on the one in facets' Module#spacename
+    end
+
+    # Creates a foreign key name from a class name.
+    # +separate_class_name_and_id_with_underscore+ sets whether
+    # the method should put '_' between the name and 'id'.
+    #
+    #   foreign_key('Message')        # => "message_id"
+    #   foreign_key('Message', false) # => "messageid"
+    #   foreign_key('Admin::Post')    # => "post_id"
+    def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
+      underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
+    end
+
+    # Tries to find a constant with the name specified in the argument string.
+    #
+    #   constantize('Module')   # => Module
+    #   constantize('Foo::Bar') # => Foo::Bar
+    #
+    # The name is assumed to be the one of a top-level constant, no matter
+    # whether it starts with "::" or not. No lexical context is taken into
+    # account:
+    #
+    #   C = 'outside'
+    #   module M
+    #     C = 'inside'
+    #     C                # => 'inside'
+    #     constantize('C') # => 'outside', same as ::C
+    #   end
+    #
+    # NameError is raised when the name is not in CamelCase or the constant is
+    # unknown.
+    def constantize(camel_cased_word)
+      Object.const_get(camel_cased_word)
+    end
+
+    # Tries to find a constant with the name specified in the argument string.
+    #
+    #   safe_constantize('Module')   # => Module
+    #   safe_constantize('Foo::Bar') # => Foo::Bar
+    #
+    # The name is assumed to be the one of a top-level constant, no matter
+    # whether it starts with "::" or not. No lexical context is taken into
+    # account:
+    #
+    #   C = 'outside'
+    #   module M
+    #     C = 'inside'
+    #     C                     # => 'inside'
+    #     safe_constantize('C') # => 'outside', same as ::C
+    #   end
+    #
+    # +nil+ is returned when the name is not in CamelCase or the constant (or
+    # part of it) is unknown.
+    #
+    #   safe_constantize('blargle')                  # => nil
+    #   safe_constantize('UnknownModule')            # => nil
+    #   safe_constantize('UnknownModule::Foo::Bar')  # => nil
+    def safe_constantize(camel_cased_word)
+      constantize(camel_cased_word)
+    rescue NameError => e
+      raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
+        e.name.to_s == camel_cased_word.to_s)
+    rescue LoadError => e
+      message = e.respond_to?(:original_message) ? e.original_message : e.message
+      raise unless /Unable to autoload constant #{const_regexp(camel_cased_word)}/.match?(message)
+    end
+
+    # Returns the suffix that should be added to a number to denote the position
+    # in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+    #
+    #   ordinal(1)     # => "st"
+    #   ordinal(2)     # => "nd"
+    #   ordinal(1002)  # => "nd"
+    #   ordinal(1003)  # => "rd"
+    #   ordinal(-11)   # => "th"
+    #   ordinal(-1021) # => "st"
+    def ordinal(number)
+      I18n.translate("number.nth.ordinals", number: number)
+    end
+
+    # Turns a number into an ordinal string used to denote the position in an
+    # ordered sequence such as 1st, 2nd, 3rd, 4th.
+    #
+    #   ordinalize(1)     # => "1st"
+    #   ordinalize(2)     # => "2nd"
+    #   ordinalize(1002)  # => "1002nd"
+    #   ordinalize(1003)  # => "1003rd"
+    #   ordinalize(-11)   # => "-11th"
+    #   ordinalize(-1021) # => "-1021st"
+    def ordinalize(number)
+      I18n.translate("number.nth.ordinalized", number: number)
+    end
+
+    private
+      # Mounts a regular expression, returned as a string to ease interpolation,
+      # that will match part by part the given constant.
+      #
+      #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
+      #   const_regexp("::")            # => "::"
+      def const_regexp(camel_cased_word)
+        parts = camel_cased_word.split("::")
+
+        return Regexp.escape(camel_cased_word) if parts.empty?
+
+        last = parts.pop
+
+        parts.reverse!.inject(last) do |acc, part|
+          part.empty? ? acc : "#{part}(::#{acc})?"
+        end
+      end
+
+      # Applies inflection rules for +singularize+ and +pluralize+.
+      #
+      # If passed an optional +locale+ parameter, the uncountables will be
+      # found for that locale.
+      #
+      #   apply_inflections('post', inflections.plurals, :en)    # => "posts"
+      #   apply_inflections('posts', inflections.singulars, :en) # => "post"
+      def apply_inflections(word, rules, locale = :en)
+        result = word.to_s.dup
+
+        if word.empty? || inflections(locale).uncountables.uncountable?(result)
+          result
+        else
+          rules.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+          result
+        end
+      end
+  end
+end

data/lib/active_support/inflector/transliterate.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/multibyte"
+require "active_support/i18n"
+
+module ActiveSupport
+  module Inflector
+    ALLOWED_ENCODINGS_FOR_TRANSLITERATE = [Encoding::UTF_8, Encoding::US_ASCII, Encoding::GB18030].freeze
+
+    # Replaces non-ASCII characters with an ASCII approximation, or if none
+    # exists, a replacement character which defaults to "?".
+    #
+    #    transliterate('Ærøskøbing')
+    #    # => "AEroskobing"
+    #
+    # Default approximations are provided for Western/Latin characters,
+    # e.g, "ø", "ñ", "é", "ß", etc.
+    #
+    # This method is I18n aware, so you can set up custom approximations for a
+    # locale. This can be useful, for example, to transliterate German's "ü"
+    # and "ö" to "ue" and "oe", or to add support for transliterating Russian
+    # to ASCII.
+    #
+    # In order to make your custom transliterations available, you must set
+    # them as the <tt>i18n.transliterate.rule</tt> i18n key:
+    #
+    #   # Store the transliterations in locales/de.yml
+    #   i18n:
+    #     transliterate:
+    #       rule:
+    #         ü: "ue"
+    #         ö: "oe"
+    #
+    #   # Or set them using Ruby
+    #   I18n.backend.store_translations(:de, i18n: {
+    #     transliterate: {
+    #       rule: {
+    #         'ü' => 'ue',
+    #         'ö' => 'oe'
+    #       }
+    #     }
+    #   })
+    #
+    # The value for <tt>i18n.transliterate.rule</tt> can be a simple Hash that
+    # maps characters to ASCII approximations as shown above, or, for more
+    # complex requirements, a Proc:
+    #
+    #   I18n.backend.store_translations(:de, i18n: {
+    #     transliterate: {
+    #       rule: ->(string) { MyTransliterator.transliterate(string) }
+    #     }
+    #   })
+    #
+    # Now you can have different transliterations for each locale:
+    #
+    #   transliterate('Jürgen', locale: :en)
+    #   # => "Jurgen"
+    #
+    #   transliterate('Jürgen', locale: :de)
+    #   # => "Juergen"
+    #
+    # Transliteration is restricted to UTF-8, US-ASCII, and GB18030 strings.
+    # Other encodings will raise an ArgumentError.
+    def transliterate(string, replacement = "?", locale: nil)
+      raise ArgumentError, "Can only transliterate strings. Received #{string.class.name}" unless string.is_a?(String)
+      raise ArgumentError, "Cannot transliterate strings with #{string.encoding} encoding" unless ALLOWED_ENCODINGS_FOR_TRANSLITERATE.include?(string.encoding)
+
+      return string.dup if string.ascii_only?
+      string = string.dup if string.frozen?
+
+      input_encoding = string.encoding
+
+      # US-ASCII is a subset of UTF-8 so we'll force encoding as UTF-8 if
+      # US-ASCII is given. This way we can let tidy_bytes handle the string
+      # in the same way as we do for UTF-8
+      string.force_encoding(Encoding::UTF_8) if string.encoding == Encoding::US_ASCII
+
+      # GB18030 is Unicode compatible but is not a direct mapping so needs to be
+      # transcoded. Using invalid/undef :replace will result in loss of data in
+      # the event of invalid characters, but since tidy_bytes will replace
+      # invalid/undef with a "?" we're safe to do the same beforehand
+      string.encode!(Encoding::UTF_8, invalid: :replace, undef: :replace) if string.encoding == Encoding::GB18030
+
+      transliterated = I18n.transliterate(
+        ActiveSupport::Multibyte::Unicode.tidy_bytes(string).unicode_normalize(:nfc),
+        replacement: replacement,
+        locale: locale
+      )
+
+      # Restore the string encoding of the input if it was not UTF-8.
+      # Apply invalid/undef :replace as tidy_bytes does
+      transliterated.encode!(input_encoding, invalid: :replace, undef: :replace) if input_encoding != transliterated.encoding
+
+      transliterated
+    end
+
+    # Replaces special characters in a string so that it may be used as part of
+    # a 'pretty' URL.
+    #
+    #   parameterize("Donald E. Knuth") # => "donald-e-knuth"
+    #   parameterize("^très|Jolie-- ")  # => "tres-jolie"
+    #
+    # To use a custom separator, override the +separator+ argument.
+    #
+    #   parameterize("Donald E. Knuth", separator: '_') # => "donald_e_knuth"
+    #   parameterize("^très|Jolie__ ", separator: '_')  # => "tres_jolie"
+    #
+    # To preserve the case of the characters in a string, use the +preserve_case+ argument.
+    #
+    #   parameterize("Donald E. Knuth", preserve_case: true) # => "Donald-E-Knuth"
+    #   parameterize("^très|Jolie-- ", preserve_case: true) # => "tres-Jolie"
+    #
+    # It preserves dashes and underscores unless they are used as separators:
+    #
+    #   parameterize("^très|Jolie__ ")                 # => "tres-jolie__"
+    #   parameterize("^très|Jolie-- ", separator: "_") # => "tres_jolie--"
+    #   parameterize("^très_Jolie-- ", separator: ".") # => "tres_jolie--"
+    #
+    # If the optional parameter +locale+ is specified,
+    # the word will be parameterized as a word of that language.
+    # By default, this parameter is set to <tt>nil</tt> and it will use
+    # the configured <tt>I18n.locale</tt>.
+    def parameterize(string, separator: "-", preserve_case: false, locale: nil)
+      # Replace accented chars with their ASCII equivalents.
+      parameterized_string = transliterate(string, locale: locale)
+
+      # Turn unwanted chars into the separator.
+      parameterized_string.gsub!(/[^a-z0-9\-_]+/i, separator)
+
+      unless separator.nil? || separator.empty?
+        if separator == "-"
+          re_duplicate_separator        = /-{2,}/
+          re_leading_trailing_separator = /^-|-$/i
+        else
+          re_sep = Regexp.escape(separator)
+          re_duplicate_separator        = /#{re_sep}{2,}/
+          re_leading_trailing_separator = /^#{re_sep}|#{re_sep}$/i
+        end
+        # No more than one of the separator in a row.
+        parameterized_string.gsub!(re_duplicate_separator, separator)
+        # Remove leading/trailing separator.
+        parameterized_string.gsub!(re_leading_trailing_separator, "")
+      end
+
+      parameterized_string.downcase! unless preserve_case
+      parameterized_string
+    end
+  end
+end

data/lib/active_support/inflector.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# in case active_support/inflector is required without the rest of active_support
+require "active_support/inflector/inflections"
+require "active_support/inflector/transliterate"
+require "active_support/inflector/methods"
+
+require "active_support/inflections"
+require "active_support/core_ext/string/inflections"

data/lib/active_support/isolated_execution_state.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+
+module ActiveSupport
+  module IsolatedExecutionState # :nodoc:
+    @isolation_level = nil
+
+    Thread.attr_accessor :active_support_execution_state
+    Fiber.attr_accessor :active_support_execution_state
+
+    class << self
+      attr_reader :isolation_level, :scope
+
+      def isolation_level=(level)
+        return if level == @isolation_level
+
+        unless %i(thread fiber).include?(level)
+          raise ArgumentError, "isolation_level must be `:thread` or `:fiber`, got: `#{level.inspect}`"
+        end
+
+        clear if @isolation_level
+
+        @scope =
+          case level
+          when :thread; Thread
+          when :fiber; Fiber
+          end
+
+        @isolation_level = level
+      end
+
+      def unique_id
+        self[:__id__] ||= Object.new
+      end
+
+      def [](key)
+        state[key]
+      end
+
+      def []=(key, value)
+        state[key] = value
+      end
+
+      def key?(key)
+        state.key?(key)
+      end
+
+      def delete(key)
+        state.delete(key)
+      end
+
+      def clear
+        state.clear
+      end
+
+      def context
+        scope.current
+      end
+
+      def share_with(other)
+        # Action Controller streaming spawns a new thread and copy thread locals.
+        # We do the same here for backward compatibility, but this is very much a hack
+        # and streaming should be rethought.
+        context.active_support_execution_state = other.active_support_execution_state.dup
+      end
+
+      private
+        def state
+          context.active_support_execution_state ||= {}
+        end
+    end
+
+    self.isolation_level = :thread
+  end
+end