ric 0.14.2 → 0.14.6

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/message_verifier.rb

@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-require "active_support/core_ext/object/blank"
-require "active_support/security_utils"
-require "active_support/messages/metadata"
-require "active_support/messages/rotator"
-
-module ActiveSupport
-  # +MessageVerifier+ makes it easy to generate and verify messages which are
-  # signed to prevent tampering.
-  #
-  # This is useful for cases like remember-me tokens and auto-unsubscribe links
-  # where the session store isn't suitable or available.
-  #
-  # Remember Me:
-  #   cookies[:remember_me] = @verifier.generate([@user.id, 2.weeks.from_now])
-  #
-  # In the authentication filter:
-  #
-  #   id, time = @verifier.verify(cookies[:remember_me])
-  #   if Time.now < time
-  #     self.current_user = User.find(id)
-  #   end
-  #
-  # By default it uses Marshal to serialize the message. If you want to use
-  # another serialization method, you can set the serializer in the options
-  # hash upon initialization:
-  #
-  #   @verifier = ActiveSupport::MessageVerifier.new('s3Krit', serializer: YAML)
-  #
-  # +MessageVerifier+ creates HMAC signatures using SHA1 hash algorithm by default.
-  # If you want to use a different hash algorithm, you can change it by providing
-  # +:digest+ key as an option while initializing the verifier:
-  #
-  #   @verifier = ActiveSupport::MessageVerifier.new('s3Krit', digest: 'SHA256')
-  #
-  # === Confining messages to a specific purpose
-  #
-  # By default any message can be used throughout your app. But they can also be
-  # confined to a specific +:purpose+.
-  #
-  #   token = @verifier.generate("this is the chair", purpose: :login)
-  #
-  # Then that same purpose must be passed when verifying to get the data back out:
-  #
-  #   @verifier.verified(token, purpose: :login)    # => "this is the chair"
-  #   @verifier.verified(token, purpose: :shipping) # => nil
-  #   @verifier.verified(token)                     # => nil
-  #
-  #   @verifier.verify(token, purpose: :login)      # => "this is the chair"
-  #   @verifier.verify(token, purpose: :shipping)   # => ActiveSupport::MessageVerifier::InvalidSignature
-  #   @verifier.verify(token)                       # => ActiveSupport::MessageVerifier::InvalidSignature
-  #
-  # Likewise, if a message has no purpose it won't be returned when verifying with
-  # a specific purpose.
-  #
-  #   token = @verifier.generate("the conversation is lively")
-  #   @verifier.verified(token, purpose: :scare_tactics) # => nil
-  #   @verifier.verified(token)                          # => "the conversation is lively"
-  #
-  #   @verifier.verify(token, purpose: :scare_tactics)   # => ActiveSupport::MessageVerifier::InvalidSignature
-  #   @verifier.verify(token)                            # => "the conversation is lively"
-  #
-  # === Making messages expire
-  #
-  # By default messages last forever and verifying one year from now will still
-  # return the original value. But messages can be set to expire at a given
-  # time with +:expires_in+ or +:expires_at+.
-  #
-  #   @verifier.generate(parcel, expires_in: 1.month)
-  #   @verifier.generate(doowad, expires_at: Time.now.end_of_year)
-  #
-  # Then the messages can be verified and returned up to the expire time.
-  # Thereafter, the +verified+ method returns +nil+ while +verify+ raises
-  # <tt>ActiveSupport::MessageVerifier::InvalidSignature</tt>.
-  #
-  # === Rotating keys
-  #
-  # MessageVerifier also supports rotating out old configurations by falling
-  # back to a stack of verifiers. Call +rotate+ to build and add a verifier to
-  # so either +verified+ or +verify+ will also try verifying with the fallback.
-  #
-  # By default any rotated verifiers use the values of the primary
-  # verifier unless specified otherwise.
-  #
-  # You'd give your verifier the new defaults:
-  #
-  #   verifier = ActiveSupport::MessageVerifier.new(@secret, digest: "SHA512", serializer: JSON)
-  #
-  # Then gradually rotate the old values out by adding them as fallbacks. Any message
-  # generated with the old values will then work until the rotation is removed.
-  #
-  #   verifier.rotate old_secret          # Fallback to an old secret instead of @secret.
-  #   verifier.rotate digest: "SHA256"    # Fallback to an old digest instead of SHA512.
-  #   verifier.rotate serializer: Marshal # Fallback to an old serializer instead of JSON.
-  #
-  # Though the above would most likely be combined into one rotation:
-  #
-  #   verifier.rotate old_secret, digest: "SHA256", serializer: Marshal
-  class MessageVerifier
-    prepend Messages::Rotator::Verifier
-
-    class InvalidSignature < StandardError; end
-
-    def initialize(secret, digest: nil, serializer: nil)
-      raise ArgumentError, "Secret should not be nil." unless secret
-      @secret = secret
-      @digest = digest || "SHA1"
-      @serializer = serializer || Marshal
-    end
-
-    # Checks if a signed message could have been generated by signing an object
-    # with the +MessageVerifier+'s secret.
-    #
-    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
-    #   signed_message = verifier.generate 'a private message'
-    #   verifier.valid_message?(signed_message) # => true
-    #
-    #   tampered_message = signed_message.chop # editing the message invalidates the signature
-    #   verifier.valid_message?(tampered_message) # => false
-    def valid_message?(signed_message)
-      return if signed_message.nil? || !signed_message.valid_encoding? || signed_message.blank?
-
-      data, digest = signed_message.split("--")
-      data.present? && digest.present? && ActiveSupport::SecurityUtils.secure_compare(digest, generate_digest(data))
-    end
-
-    # Decodes the signed message using the +MessageVerifier+'s secret.
-    #
-    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
-    #
-    #   signed_message = verifier.generate 'a private message'
-    #   verifier.verified(signed_message) # => 'a private message'
-    #
-    # Returns +nil+ if the message was not signed with the same secret.
-    #
-    #   other_verifier = ActiveSupport::MessageVerifier.new 'd1ff3r3nt-s3Krit'
-    #   other_verifier.verified(signed_message) # => nil
-    #
-    # Returns +nil+ if the message is not Base64-encoded.
-    #
-    #   invalid_message = "f--46a0120593880c733a53b6dad75b42ddc1c8996d"
-    #   verifier.verified(invalid_message) # => nil
-    #
-    # Raises any error raised while decoding the signed message.
-    #
-    #   incompatible_message = "test--dad7b06c94abba8d46a15fafaef56c327665d5ff"
-    #   verifier.verified(incompatible_message) # => TypeError: incompatible marshal file format
-    def verified(signed_message, purpose: nil, **)
-      if valid_message?(signed_message)
-        begin
-          data = signed_message.split("--")[0]
-          message = Messages::Metadata.verify(decode(data), purpose)
-          @serializer.load(message) if message
-        rescue ArgumentError => argument_error
-          return if argument_error.message.include?("invalid base64")
-          raise
-        end
-      end
-    end
-
-    # Decodes the signed message using the +MessageVerifier+'s secret.
-    #
-    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
-    #   signed_message = verifier.generate 'a private message'
-    #
-    #   verifier.verify(signed_message) # => 'a private message'
-    #
-    # Raises +InvalidSignature+ if the message was not signed with the same
-    # secret or was not Base64-encoded.
-    #
-    #   other_verifier = ActiveSupport::MessageVerifier.new 'd1ff3r3nt-s3Krit'
-    #   other_verifier.verify(signed_message) # => ActiveSupport::MessageVerifier::InvalidSignature
-    def verify(*args, **options)
-      verified(*args, **options) || raise(InvalidSignature)
-    end
-
-    # Generates a signed message for the provided value.
-    #
-    # The message is signed with the +MessageVerifier+'s secret.
-    # Returns Base64-encoded message joined with the generated signature.
-    #
-    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
-    #   verifier.generate 'a private message' # => "BAhJIhRwcml2YXRlLW1lc3NhZ2UGOgZFVA==--e2d724331ebdee96a10fb99b089508d1c72bd772"
-    def generate(value, expires_at: nil, expires_in: nil, purpose: nil)
-      data = encode(Messages::Metadata.wrap(@serializer.dump(value), expires_at: expires_at, expires_in: expires_in, purpose: purpose))
-      "#{data}--#{generate_digest(data)}"
-    end
-
-    private
-      def encode(data)
-        ::Base64.strict_encode64(data)
-      end
-
-      def decode(data)
-        ::Base64.strict_decode64(data)
-      end
-
-      def generate_digest(data)
-        require "openssl" unless defined?(OpenSSL)
-        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@digest).new, @secret, data)
-      end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/messages/metadata.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-
-module ActiveSupport
-  module Messages #:nodoc:
-    class Metadata #:nodoc:
-      def initialize(message, expires_at = nil, purpose = nil)
-        @message, @purpose = message, purpose
-        @expires_at = expires_at.is_a?(String) ? parse_expires_at(expires_at) : expires_at
-      end
-
-      def as_json(options = {})
-        { _rails: { message: @message, exp: @expires_at, pur: @purpose } }
-      end
-
-      class << self
-        def wrap(message, expires_at: nil, expires_in: nil, purpose: nil)
-          if expires_at || expires_in || purpose
-            JSON.encode new(encode(message), pick_expiry(expires_at, expires_in), purpose)
-          else
-            message
-          end
-        end
-
-        def verify(message, purpose)
-          extract_metadata(message).verify(purpose)
-        end
-
-        private
-          def pick_expiry(expires_at, expires_in)
-            if expires_at
-              expires_at.utc.iso8601(3)
-            elsif expires_in
-              Time.now.utc.advance(seconds: expires_in).iso8601(3)
-            end
-          end
-
-          def extract_metadata(message)
-            data = JSON.decode(message) rescue nil
-
-            if data.is_a?(Hash) && data.key?("_rails")
-              new(decode(data["_rails"]["message"]), data["_rails"]["exp"], data["_rails"]["pur"])
-            else
-              new(message)
-            end
-          end
-
-          def encode(message)
-            ::Base64.strict_encode64(message)
-          end
-
-          def decode(message)
-            ::Base64.strict_decode64(message)
-          end
-      end
-
-      def verify(purpose)
-        @message if match?(purpose) && fresh?
-      end
-
-      private
-        def match?(purpose)
-          @purpose.to_s == purpose.to_s
-        end
-
-        def fresh?
-          @expires_at.nil? || Time.now.utc < @expires_at
-        end
-
-        def parse_expires_at(expires_at)
-          if ActiveSupport.use_standard_json_time_format
-            Time.iso8601(expires_at)
-          else
-            Time.parse(expires_at)
-          end
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/messages/rotation_configuration.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  module Messages
-    class RotationConfiguration # :nodoc:
-      attr_reader :signed, :encrypted
-
-      def initialize
-        @signed, @encrypted = [], []
-      end
-
-      def rotate(kind, *args, **options)
-        args << options unless options.empty?
-        case kind
-        when :signed
-          @signed << args
-        when :encrypted
-          @encrypted << args
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/messages/rotator.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  module Messages
-    module Rotator # :nodoc:
-      def initialize(*secrets, on_rotation: nil, **options)
-        super(*secrets, **options)
-
-        @options   = options
-        @rotations = []
-        @on_rotation = on_rotation
-      end
-
-      def rotate(*secrets, **options)
-        @rotations << build_rotation(*secrets, @options.merge(options))
-      end
-
-      module Encryptor
-        include Rotator
-
-        def decrypt_and_verify(*args, on_rotation: @on_rotation, **options)
-          super
-        rescue MessageEncryptor::InvalidMessage, MessageVerifier::InvalidSignature
-          run_rotations(on_rotation) { |encryptor| encryptor.decrypt_and_verify(*args, **options) } || raise
-        end
-
-        private
-          def build_rotation(secret = @secret, sign_secret = @sign_secret, options)
-            self.class.new(secret, sign_secret, **options)
-          end
-      end
-
-      module Verifier
-        include Rotator
-
-        def verified(*args, on_rotation: @on_rotation, **options)
-          super || run_rotations(on_rotation) { |verifier| verifier.verified(*args, **options) }
-        end
-
-        private
-          def build_rotation(secret = @secret, options)
-            self.class.new(secret, **options)
-          end
-      end
-
-      private
-        def run_rotations(on_rotation)
-          @rotations.find do |rotation|
-            if message = yield(rotation) rescue next
-              on_rotation&.call
-              return message
-            end
-          end
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/multibyte/chars.rb

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/json"
-require "active_support/core_ext/string/access"
-require "active_support/core_ext/string/behavior"
-require "active_support/core_ext/symbol/starts_ends_with"
-require "active_support/core_ext/module/delegation"
-
-module ActiveSupport #:nodoc:
-  module Multibyte #:nodoc:
-    # Chars enables you to work transparently with UTF-8 encoding in the Ruby
-    # String class without having extensive knowledge about the encoding. A
-    # Chars object accepts a string upon initialization and proxies String
-    # methods in an encoding safe manner. All the normal String methods are also
-    # implemented on the proxy.
-    #
-    # String methods are proxied through the Chars object, and can be accessed
-    # through the +mb_chars+ method. Methods which would normally return a
-    # String object now return a Chars object so methods can be chained.
-    #
-    #   'The Perfect String  '.mb_chars.downcase.strip
-    #   # => #<ActiveSupport::Multibyte::Chars:0x007fdc434ccc10 @wrapped_string="the perfect string">
-    #
-    # Chars objects are perfectly interchangeable with String objects as long as
-    # no explicit class checks are made. If certain methods do explicitly check
-    # the class, call +to_s+ before you pass chars objects to them.
-    #
-    #   bad.explicit_checking_method 'T'.mb_chars.downcase.to_s
-    #
-    # The default Chars implementation assumes that the encoding of the string
-    # is UTF-8, if you want to handle different encodings you can write your own
-    # multibyte string handler and configure it through
-    # ActiveSupport::Multibyte.proxy_class.
-    #
-    #   class CharsForUTF32
-    #     def size
-    #       @wrapped_string.size / 4
-    #     end
-    #
-    #     def self.accepts?(string)
-    #       string.length % 4 == 0
-    #     end
-    #   end
-    #
-    #   ActiveSupport::Multibyte.proxy_class = CharsForUTF32
-    class Chars
-      include Comparable
-      attr_reader :wrapped_string
-      alias to_s wrapped_string
-      alias to_str wrapped_string
-
-      delegate :<=>, :=~, :match?, :acts_like_string?, to: :wrapped_string
-
-      # Creates a new Chars instance by wrapping _string_.
-      def initialize(string)
-        @wrapped_string = string
-        @wrapped_string.force_encoding(Encoding::UTF_8) unless @wrapped_string.frozen?
-      end
-
-      # Forward all undefined methods to the wrapped string.
-      def method_missing(method, *args, &block)
-        result = @wrapped_string.__send__(method, *args, &block)
-        if method.end_with?("!")
-          self if result
-        else
-          result.kind_of?(String) ? chars(result) : result
-        end
-      end
-
-      # Returns +true+ if _obj_ responds to the given method. Private methods
-      # are included in the search only if the optional second parameter
-      # evaluates to +true+.
-      def respond_to_missing?(method, include_private)
-        @wrapped_string.respond_to?(method, include_private)
-      end
-
-      # Works just like <tt>String#split</tt>, with the exception that the items
-      # in the resulting list are Chars instances instead of String. This makes
-      # chaining methods easier.
-      #
-      #   'Café périferôl'.mb_chars.split(/é/).map { |part| part.upcase.to_s } # => ["CAF", " P", "RIFERÔL"]
-      def split(*args)
-        @wrapped_string.split(*args).map { |i| self.class.new(i) }
-      end
-
-      # Works like <tt>String#slice!</tt>, but returns an instance of
-      # Chars, or +nil+ if the string was not modified. The string will not be
-      # modified if the range given is out of bounds
-      #
-      #   string = 'Welcome'
-      #   string.mb_chars.slice!(3)    # => #<ActiveSupport::Multibyte::Chars:0x000000038109b8 @wrapped_string="c">
-      #   string # => 'Welome'
-      #   string.mb_chars.slice!(0..3) # => #<ActiveSupport::Multibyte::Chars:0x00000002eb80a0 @wrapped_string="Welo">
-      #   string # => 'me'
-      def slice!(*args)
-        string_sliced = @wrapped_string.slice!(*args)
-        if string_sliced
-          chars(string_sliced)
-        end
-      end
-
-      # Reverses all characters in the string.
-      #
-      #   'Café'.mb_chars.reverse.to_s # => 'éfaC'
-      def reverse
-        chars(@wrapped_string.scan(/\X/).reverse.join)
-      end
-
-      # Limits the byte size of the string to a number of bytes without breaking
-      # characters. Usable when the storage for a string is limited for some
-      # reason.
-      #
-      #   'こんにちは'.mb_chars.limit(7).to_s # => "こん"
-      def limit(limit)
-        chars(@wrapped_string.truncate_bytes(limit, omission: nil))
-      end
-
-      # Capitalizes the first letter of every word, when possible.
-      #
-      #   "ÉL QUE SE ENTERÓ".mb_chars.titleize.to_s    # => "Él Que Se Enteró"
-      #   "日本語".mb_chars.titleize.to_s               # => "日本語"
-      def titleize
-        chars(downcase.to_s.gsub(/\b('?\S)/u) { $1.upcase })
-      end
-      alias_method :titlecase, :titleize
-
-      # Performs canonical decomposition on all the characters.
-      #
-      #   'é'.length                         # => 2
-      #   'é'.mb_chars.decompose.to_s.length # => 3
-      def decompose
-        chars(Unicode.decompose(:canonical, @wrapped_string.codepoints.to_a).pack("U*"))
-      end
-
-      # Performs composition on all the characters.
-      #
-      #   'é'.length                       # => 3
-      #   'é'.mb_chars.compose.to_s.length # => 2
-      def compose
-        chars(Unicode.compose(@wrapped_string.codepoints.to_a).pack("U*"))
-      end
-
-      # Returns the number of grapheme clusters in the string.
-      #
-      #   'क्षि'.mb_chars.length   # => 4
-      #   'क्षि'.mb_chars.grapheme_length # => 3
-      def grapheme_length
-        @wrapped_string.scan(/\X/).length
-      end
-
-      # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
-      # resulting in a valid UTF-8 string.
-      #
-      # Passing +true+ will forcibly tidy all bytes, assuming that the string's
-      # encoding is entirely CP1252 or ISO-8859-1.
-      def tidy_bytes(force = false)
-        chars(Unicode.tidy_bytes(@wrapped_string, force))
-      end
-
-      def as_json(options = nil) #:nodoc:
-        to_s.as_json(options)
-      end
-
-      %w(reverse tidy_bytes).each do |method|
-        define_method("#{method}!") do |*args|
-          @wrapped_string = public_send(method, *args).to_s
-          self
-        end
-      end
-
-      private
-        def chars(string)
-          self.class.new(string)
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/multibyte/unicode.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  module Multibyte
-    module Unicode
-      extend self
-
-      # The Unicode version that is supported by the implementation
-      UNICODE_VERSION = RbConfig::CONFIG["UNICODE_VERSION"]
-
-      def default_normalization_form
-        ActiveSupport::Deprecation.warn(
-          "ActiveSupport::Multibyte::Unicode.default_normalization_form is deprecated and will be removed in Rails 6.2."
-        )
-      end
-
-      def default_normalization_form=(_)
-        ActiveSupport::Deprecation.warn(
-          "ActiveSupport::Multibyte::Unicode.default_normalization_form= is deprecated and will be removed in Rails 6.2."
-        )
-      end
-
-      # Decompose composed characters to the decomposed form.
-      def decompose(type, codepoints)
-        if type == :compatibility
-          codepoints.pack("U*").unicode_normalize(:nfkd).codepoints
-        else
-          codepoints.pack("U*").unicode_normalize(:nfd).codepoints
-        end
-      end
-
-      # Compose decomposed characters to the composed form.
-      def compose(codepoints)
-        codepoints.pack("U*").unicode_normalize(:nfc).codepoints
-      end
-
-      # Rubinius' String#scrub, however, doesn't support ASCII-incompatible chars.
-      if !defined?(Rubinius)
-        # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
-        # resulting in a valid UTF-8 string.
-        #
-        # Passing +true+ will forcibly tidy all bytes, assuming that the string's
-        # encoding is entirely CP1252 or ISO-8859-1.
-        def tidy_bytes(string, force = false)
-          return string if string.empty? || string.ascii_only?
-          return recode_windows1252_chars(string) if force
-          string.scrub { |bad| recode_windows1252_chars(bad) }
-        end
-      else
-        def tidy_bytes(string, force = false)
-          return string if string.empty?
-          return recode_windows1252_chars(string) if force
-
-          # We can't transcode to the same format, so we choose a nearly-identical encoding.
-          # We're going to 'transcode' bytes from UTF-8 when possible, then fall back to
-          # CP1252 when we get errors. The final string will be 'converted' back to UTF-8
-          # before returning.
-          reader = Encoding::Converter.new(Encoding::UTF_8, Encoding::UTF_16LE)
-
-          source = string.dup
-          out = "".force_encoding(Encoding::UTF_16LE)
-
-          loop do
-            reader.primitive_convert(source, out)
-            _, _, _, error_bytes, _ = reader.primitive_errinfo
-            break if error_bytes.nil?
-            out << error_bytes.encode(Encoding::UTF_16LE, Encoding::Windows_1252, invalid: :replace, undef: :replace)
-          end
-
-          reader.finish
-
-          out.encode!(Encoding::UTF_8)
-        end
-      end
-
-      private
-        def recode_windows1252_chars(string)
-          string.encode(Encoding::UTF_8, Encoding::Windows_1252, invalid: :replace, undef: :replace)
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/multibyte.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport #:nodoc:
-  module Multibyte
-    autoload :Chars, "active_support/multibyte/chars"
-    autoload :Unicode, "active_support/multibyte/unicode"
-
-    # The proxy class returned when calling mb_chars. You can use this accessor
-    # to configure your own proxy class so you can support other encodings. See
-    # the ActiveSupport::Multibyte::Chars implementation for an example how to
-    # do this.
-    #
-    #   ActiveSupport::Multibyte.proxy_class = CharsForUTF32
-    def self.proxy_class=(klass)
-      @proxy_class = klass
-    end
-
-    # Returns the current proxy class.
-    def self.proxy_class
-      @proxy_class ||= ActiveSupport::Multibyte::Chars
-    end
-  end
-end