ric 0.13.0 → 0.14.0

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/inflector/transliterate.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/string/multibyte"
-require "active_support/i18n"
-
-module ActiveSupport
-  module Inflector
-    # 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:
-    #
-    #   I18n.locale = :en
-    #   transliterate('Jürgen')
-    #   # => "Jurgen"
-    #
-    #   I18n.locale = :de
-    #   transliterate('Jürgen')
-    #   # => "Juergen"
-    def transliterate(string, replacement = "?".freeze)
-      raise ArgumentError, "Can only transliterate strings. Received #{string.class.name}" unless string.is_a?(String)
-
-      I18n.transliterate(
-        ActiveSupport::Multibyte::Unicode.normalize(
-          ActiveSupport::Multibyte::Unicode.tidy_bytes(string), :c),
-        replacement: replacement)
-    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--"
-    #
-    def parameterize(string, separator: "-", preserve_case: false)
-      # Replace accented chars with their ASCII equivalents.
-      parameterized_string = transliterate(string)
-
-      # Turn unwanted chars into the separator.
-      parameterized_string.gsub!(/[^a-z0-9\-_]+/i, separator)
-
-      unless separator.nil? || separator.empty?
-        if separator == "-".freeze
-          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, "".freeze)
-      end
-
-      parameterized_string.downcase! unless preserve_case
-      parameterized_string
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/json/decoding.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/attribute_accessors"
-require "active_support/core_ext/module/delegation"
-require "json"
-
-module ActiveSupport
-  # Look for and parse json strings that look like ISO 8601 times.
-  mattr_accessor :parse_json_times
-
-  module JSON
-    # matches YAML-formatted dates
-    DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/
-    DATETIME_REGEX = /^(?:\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[T \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?(([ \t]*)Z|[-+]\d{2}?(:\d{2})?)?)$/
-
-    class << self
-      # Parses a JSON string (JavaScript Object Notation) into a hash.
-      # See http://www.json.org for more info.
-      #
-      #   ActiveSupport::JSON.decode("{\"team\":\"rails\",\"players\":\"36\"}")
-      #   => {"team" => "rails", "players" => "36"}
-      def decode(json)
-        data = ::JSON.parse(json, quirks_mode: true)
-
-        if ActiveSupport.parse_json_times
-          convert_dates_from(data)
-        else
-          data
-        end
-      end
-
-      # Returns the class of the error that will be raised when there is an
-      # error in decoding JSON. Using this method means you won't directly
-      # depend on the ActiveSupport's JSON implementation, in case it changes
-      # in the future.
-      #
-      #   begin
-      #     obj = ActiveSupport::JSON.decode(some_string)
-      #   rescue ActiveSupport::JSON.parse_error
-      #     Rails.logger.warn("Attempted to decode invalid JSON: #{some_string}")
-      #   end
-      def parse_error
-        ::JSON::ParserError
-      end
-
-      private
-
-      def convert_dates_from(data)
-        case data
-        when nil
-          nil
-        when DATE_REGEX
-          begin
-            Date.parse(data)
-          rescue ArgumentError
-            data
-          end
-        when DATETIME_REGEX
-          begin
-            Time.zone.parse(data)
-          rescue ArgumentError
-            data
-          end
-        when Array
-          data.map! { |d| convert_dates_from(d) }
-        when Hash
-          data.each do |key, value|
-            data[key] = convert_dates_from(value)
-          end
-        else
-          data
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/json/encoding.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/json"
-require "active_support/core_ext/module/delegation"
-
-module ActiveSupport
-  class << self
-    delegate :use_standard_json_time_format, :use_standard_json_time_format=,
-      :time_precision, :time_precision=,
-      :escape_html_entities_in_json, :escape_html_entities_in_json=,
-      :json_encoder, :json_encoder=,
-      to: :'ActiveSupport::JSON::Encoding'
-  end
-
-  module JSON
-    # Dumps objects in JSON (JavaScript Object Notation).
-    # See http://www.json.org for more info.
-    #
-    #   ActiveSupport::JSON.encode({ team: 'rails', players: '36' })
-    #   # => "{\"team\":\"rails\",\"players\":\"36\"}"
-    def self.encode(value, options = nil)
-      Encoding.json_encoder.new(options).encode(value)
-    end
-
-    module Encoding #:nodoc:
-      class JSONGemEncoder #:nodoc:
-        attr_reader :options
-
-        def initialize(options = nil)
-          @options = options || {}
-        end
-
-        # Encode the given object into a JSON string
-        def encode(value)
-          stringify jsonify value.as_json(options.dup)
-        end
-
-        private
-          # Rails does more escaping than the JSON gem natively does (we
-          # escape \u2028 and \u2029 and optionally >, <, & to work around
-          # certain browser problems).
-          ESCAPED_CHARS = {
-            "\u2028" => '\u2028',
-            "\u2029" => '\u2029',
-            ">"      => '\u003e',
-            "<"      => '\u003c',
-            "&"      => '\u0026',
-            }
-
-          ESCAPE_REGEX_WITH_HTML_ENTITIES = /[\u2028\u2029><&]/u
-          ESCAPE_REGEX_WITHOUT_HTML_ENTITIES = /[\u2028\u2029]/u
-
-          # This class wraps all the strings we see and does the extra escaping
-          class EscapedString < String #:nodoc:
-            def to_json(*)
-              if Encoding.escape_html_entities_in_json
-                super.gsub ESCAPE_REGEX_WITH_HTML_ENTITIES, ESCAPED_CHARS
-              else
-                super.gsub ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, ESCAPED_CHARS
-              end
-            end
-
-            def to_s
-              self
-            end
-          end
-
-          # Mark these as private so we don't leak encoding-specific constructs
-          private_constant :ESCAPED_CHARS, :ESCAPE_REGEX_WITH_HTML_ENTITIES,
-            :ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, :EscapedString
-
-          # Convert an object into a "JSON-ready" representation composed of
-          # primitives like Hash, Array, String, Numeric,
-          # and +true+/+false+/+nil+.
-          # Recursively calls #as_json to the object to recursively build a
-          # fully JSON-ready object.
-          #
-          # This allows developers to implement #as_json without having to
-          # worry about what base types of objects they are allowed to return
-          # or having to remember to call #as_json recursively.
-          #
-          # Note: the +options+ hash passed to +object.to_json+ is only passed
-          # to +object.as_json+, not any of this method's recursive +#as_json+
-          # calls.
-          def jsonify(value)
-            case value
-            when String
-              EscapedString.new(value)
-            when Numeric, NilClass, TrueClass, FalseClass
-              value.as_json
-            when Hash
-              Hash[value.map { |k, v| [jsonify(k), jsonify(v)] }]
-            when Array
-              value.map { |v| jsonify(v) }
-            else
-              jsonify value.as_json
-            end
-          end
-
-          # Encode a "jsonified" Ruby data structure using the JSON gem
-          def stringify(jsonified)
-            ::JSON.generate(jsonified, quirks_mode: true, max_nesting: false)
-          end
-      end
-
-      class << self
-        # If true, use ISO 8601 format for dates and times. Otherwise, fall back
-        # to the Active Support legacy format.
-        attr_accessor :use_standard_json_time_format
-
-        # If true, encode >, <, & as escaped unicode sequences (e.g. > as \u003e)
-        # as a safety measure.
-        attr_accessor :escape_html_entities_in_json
-
-        # Sets the precision of encoded time values.
-        # Defaults to 3 (equivalent to millisecond precision)
-        attr_accessor :time_precision
-
-        # Sets the encoder used by Rails to encode Ruby objects into JSON strings
-        # in +Object#to_json+ and +ActiveSupport::JSON.encode+.
-        attr_accessor :json_encoder
-      end
-
-      self.use_standard_json_time_format = true
-      self.escape_html_entities_in_json  = true
-      self.json_encoder = JSONGemEncoder
-      self.time_precision = 3
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/key_generator.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require "concurrent/map"
-require "openssl"
-
-module ActiveSupport
-  # KeyGenerator is a simple wrapper around OpenSSL's implementation of PBKDF2.
-  # It can be used to derive a number of keys for various purposes from a given secret.
-  # This lets Rails applications have a single secure secret, but avoid reusing that
-  # key in multiple incompatible contexts.
-  class KeyGenerator
-    def initialize(secret, options = {})
-      @secret = secret
-      # The default iterations are higher than required for our key derivation uses
-      # on the off chance someone uses this for password storage
-      @iterations = options[:iterations] || 2**16
-    end
-
-    # Returns a derived key suitable for use.  The default key_size is chosen
-    # to be compatible with the default settings of ActiveSupport::MessageVerifier.
-    # i.e. OpenSSL::Digest::SHA1#block_length
-    def generate_key(salt, key_size = 64)
-      OpenSSL::PKCS5.pbkdf2_hmac_sha1(@secret, salt, @iterations, key_size)
-    end
-  end
-
-  # CachingKeyGenerator is a wrapper around KeyGenerator which allows users to avoid
-  # re-executing the key generation process when it's called using the same salt and
-  # key_size.
-  class CachingKeyGenerator
-    def initialize(key_generator)
-      @key_generator = key_generator
-      @cache_keys = Concurrent::Map.new
-    end
-
-    # Returns a derived key suitable for use.
-    def generate_key(*args)
-      @cache_keys[args.join] ||= @key_generator.generate_key(*args)
-    end
-  end
-
-  class LegacyKeyGenerator # :nodoc:
-    SECRET_MIN_LENGTH = 30 # Characters
-
-    def initialize(secret)
-      ensure_secret_secure(secret)
-      @secret = secret
-    end
-
-    def generate_key(salt)
-      @secret
-    end
-
-    private
-
-      # To prevent users from using something insecure like "Password" we make sure that the
-      # secret they've provided is at least 30 characters in length.
-      def ensure_secret_secure(secret)
-        if secret.blank?
-          raise ArgumentError, "A secret is required to generate an integrity hash " \
-            "for cookie session data. Set a secret_key_base of at least " \
-            "#{SECRET_MIN_LENGTH} characters in via `bin/rails credentials:edit`."
-        end
-
-        if secret.length < SECRET_MIN_LENGTH
-          raise ArgumentError, "Secret should be something secure, " \
-            "like \"#{SecureRandom.hex(16)}\". The value you " \
-            "provided, \"#{secret}\", is shorter than the minimum length " \
-            "of #{SECRET_MIN_LENGTH} characters."
-        end
-      end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/lazy_load_hooks.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  # lazy_load_hooks allows Rails to lazily load a lot of components and thus
-  # making the app boot faster. Because of this feature now there is no need to
-  # require <tt>ActiveRecord::Base</tt> at boot time purely to apply
-  # configuration. Instead a hook is registered that applies configuration once
-  # <tt>ActiveRecord::Base</tt> is loaded. Here <tt>ActiveRecord::Base</tt> is
-  # used as example but this feature can be applied elsewhere too.
-  #
-  # Here is an example where +on_load+ method is called to register a hook.
-  #
-  #   initializer 'active_record.initialize_timezone' do
-  #     ActiveSupport.on_load(:active_record) do
-  #       self.time_zone_aware_attributes = true
-  #       self.default_timezone = :utc
-  #     end
-  #   end
-  #
-  # When the entirety of +ActiveRecord::Base+ has been
-  # evaluated then +run_load_hooks+ is invoked. The very last line of
-  # +ActiveRecord::Base+ is:
-  #
-  #   ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
-  module LazyLoadHooks
-    def self.extended(base) # :nodoc:
-      base.class_eval do
-        @load_hooks = Hash.new { |h, k| h[k] = [] }
-        @loaded     = Hash.new { |h, k| h[k] = [] }
-        @run_once   = Hash.new { |h, k| h[k] = [] }
-      end
-    end
-
-    # Declares a block that will be executed when a Rails component is fully
-    # loaded.
-    #
-    # Options:
-    #
-    # * <tt>:yield</tt> - Yields the object that run_load_hooks to +block+.
-    # * <tt>:run_once</tt> - Given +block+ will run only once.
-    def on_load(name, options = {}, &block)
-      @loaded[name].each do |base|
-        execute_hook(name, base, options, block)
-      end
-
-      @load_hooks[name] << [block, options]
-    end
-
-    def run_load_hooks(name, base = Object)
-      @loaded[name] << base
-      @load_hooks[name].each do |hook, options|
-        execute_hook(name, base, options, hook)
-      end
-    end
-
-    private
-
-      def with_execution_control(name, block, once)
-        unless @run_once[name].include?(block)
-          @run_once[name] << block if once
-
-          yield
-        end
-      end
-
-      def execute_hook(name, base, options, block)
-        with_execution_control(name, block, options[:run_once]) do
-          if options[:yield]
-            block.call(base)
-          else
-            base.instance_eval(&block)
-          end
-        end
-      end
-  end
-
-  extend LazyLoadHooks
-end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/locale/en.yml

@@ -1,135 +0,0 @@
-en:
-  date:
-    formats:
-      # Use the strftime parameters for formats.
-      # When no format has been given, it uses default.
-      # You can provide other formats here if you like!
-      default: "%Y-%m-%d"
-      short: "%b %d"
-      long: "%B %d, %Y"
-
-    day_names: [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
-    abbr_day_names: [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
-
-    # Don't forget the nil at the beginning; there's no such thing as a 0th month
-    month_names: [~, January, February, March, April, May, June, July, August, September, October, November, December]
-    abbr_month_names: [~, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
-    # Used in date_select and datetime_select.
-    order:
-      - year
-      - month
-      - day
-
-  time:
-    formats:
-      default: "%a, %d %b %Y %H:%M:%S %z"
-      short: "%d %b %H:%M"
-      long: "%B %d, %Y %H:%M"
-    am: "am"
-    pm: "pm"
-
-# Used in array.to_sentence.
-  support:
-    array:
-      words_connector: ", "
-      two_words_connector: " and "
-      last_word_connector: ", and "
-  number:
-    # Used in NumberHelper.number_to_delimited()
-    # These are also the defaults for 'currency', 'percentage', 'precision', and 'human'
-    format:
-      # Sets the separator between the units, for more precision (e.g. 1.0 / 2.0 == 0.5)
-      separator: "."
-      # Delimits thousands (e.g. 1,000,000 is a million) (always in groups of three)
-      delimiter: ","
-      # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
-      precision: 3
-      # If set to true, precision will mean the number of significant digits instead
-      # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
-      significant: false
-      # If set, the zeros after the decimal separator will always be stripped (eg.: 1.200 will be 1.2)
-      strip_insignificant_zeros: false
-
-    # Used in NumberHelper.number_to_currency()
-    currency:
-      format:
-        # Where is the currency sign? %u is the currency unit, %n the number (default: $5.00)
-        format: "%u%n"
-        unit: "$"
-        # These five are to override number.format and are optional
-        separator: "."
-        delimiter: ","
-        precision: 2
-        significant: false
-        strip_insignificant_zeros: false
-
-    # Used in NumberHelper.number_to_percentage()
-    percentage:
-      format:
-        # These five are to override number.format and are optional
-        # separator:
-        delimiter: ""
-        # precision:
-        # significant: false
-        # strip_insignificant_zeros: false
-        format: "%n%"
-
-    # Used in NumberHelper.number_to_rounded()
-    precision:
-      format:
-        # These five are to override number.format and are optional
-        # separator:
-        delimiter: ""
-        # precision:
-        # significant: false
-        # strip_insignificant_zeros: false
-
-    # Used in NumberHelper.number_to_human_size() and NumberHelper.number_to_human()
-    human:
-      format:
-        # These five are to override number.format and are optional
-        # separator:
-        delimiter: ""
-        precision: 3
-        significant: true
-        strip_insignificant_zeros: true
-      # Used in number_to_human_size()
-      storage_units:
-        # Storage units output formatting.
-        # %u is the storage unit, %n is the number (default: 2 MB)
-        format: "%n %u"
-        units:
-          byte:
-            one:   "Byte"
-            other: "Bytes"
-          kb: "KB"
-          mb: "MB"
-          gb: "GB"
-          tb: "TB"
-          pb: "PB"
-          eb: "EB"
-      # Used in NumberHelper.number_to_human()
-      decimal_units:
-        format: "%n %u"
-        # Decimal units output formatting
-        # By default we will only quantify some of the exponents
-        # but the commented ones might be defined or overridden
-        # by the user.
-        units:
-          # femto: Quadrillionth
-          # pico: Trillionth
-          # nano: Billionth
-          # micro: Millionth
-          # mili: Thousandth
-          # centi: Hundredth
-          # deci: Tenth
-          unit: ""
-          # ten:
-          #   one: Ten
-          #   other: Tens
-          # hundred: Hundred
-          thousand: Thousand
-          million: Million
-          billion: Billion
-          trillion: Trillion
-          quadrillion: Quadrillion