logstash-output-scalyr 0.1.5 → 0.1.10.beta

data/vendor/bundle/jruby/2.5.0/gems/rspec-support-3.9.3/lib/rspec/support/directory_maker.rb

@@ -1,63 +0,0 @@
-RSpec::Support.require_rspec_support 'ruby_features'
-
-module RSpec
-  module Support
-    # @api private
-    #
-    # Replacement for fileutils#mkdir_p because we don't want to require parts
-    # of stdlib in RSpec.
-    class DirectoryMaker
-      # @api private
-      #
-      # Implements nested directory construction
-      def self.mkdir_p(path)
-        stack = generate_stack(path)
-        path.split(File::SEPARATOR).each do |part|
-          stack = generate_path(stack, part)
-          begin
-            Dir.mkdir(stack) unless directory_exists?(stack)
-          rescue Errno::EEXIST => e
-            raise e unless directory_exists?(stack)
-          rescue Errno::ENOTDIR => e
-            raise Errno::EEXIST, e.message
-          end
-        end
-      end
-
-      if OS.windows_file_path?
-        def self.generate_stack(path)
-          if path.start_with?(File::SEPARATOR)
-            File::SEPARATOR
-          elsif path[1] == ':'
-            ''
-          else
-            '.'
-          end
-        end
-        def self.generate_path(stack, part)
-          if stack == ''
-            part
-          elsif stack == File::SEPARATOR
-            File.join('', part)
-          else
-            File.join(stack, part)
-          end
-        end
-      else
-        def self.generate_stack(path)
-          path.start_with?(File::SEPARATOR) ? File::SEPARATOR : "."
-        end
-        def self.generate_path(stack, part)
-          File.join(stack, part)
-        end
-      end
-
-      def self.directory_exists?(dirname)
-        File.exist?(dirname) && File.directory?(dirname)
-      end
-      private_class_method :directory_exists?
-      private_class_method :generate_stack
-      private_class_method :generate_path
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-support-3.9.3/lib/rspec/support/encoded_string.rb

@@ -1,161 +0,0 @@
-module RSpec
-  module Support
-    # @private
-    class EncodedString
-      # Reduce allocations by storing constants.
-      UTF_8    = "UTF-8"
-      US_ASCII = "US-ASCII"
-
-      # Ruby's default replacement string is:
-      #   U+FFFD ("\xEF\xBF\xBD"), for Unicode encoding forms, else
-      #   ?      ("\x3F")
-      REPLACE = "?"
-
-      def initialize(string, encoding=nil)
-        @encoding = encoding
-        @source_encoding = detect_source_encoding(string)
-        @string = matching_encoding(string)
-      end
-      attr_reader :source_encoding
-
-      delegated_methods = String.instance_methods.map(&:to_s) & %w[eql? lines == encoding empty?]
-      delegated_methods.each do |name|
-        define_method(name) { |*args, &block| @string.__send__(name, *args, &block) }
-      end
-
-      def <<(string)
-        @string << matching_encoding(string)
-      end
-
-      if Ruby.jruby?
-        def split(regex_or_string)
-          @string.split(matching_encoding(regex_or_string))
-        rescue ArgumentError
-          # JRuby raises an ArgumentError when splitting a source string that
-          # contains invalid bytes.
-          remove_invalid_bytes(@string).split regex_or_string
-        end
-      else
-        def split(regex_or_string)
-          @string.split(matching_encoding(regex_or_string))
-        end
-      end
-
-      def to_s
-        @string
-      end
-      alias :to_str :to_s
-
-      if String.method_defined?(:encoding)
-
-        private
-
-        # Encoding Exceptions:
-        #
-        # Raised by Encoding and String methods:
-        #   Encoding::UndefinedConversionError:
-        #     when a transcoding operation fails
-        #     if the String contains characters invalid for the target encoding
-        #     e.g. "\x80".encode('UTF-8','ASCII-8BIT')
-        #     vs "\x80".encode('UTF-8','ASCII-8BIT', undef: :replace, replace: '<undef>')
-        #     # => '<undef>'
-        #   Encoding::CompatibilityError
-        #     when Encoding.compatibile?(str1, str2) is nil
-        #     e.g. utf_16le_emoji_string.split("\n")
-        #     e.g. valid_unicode_string.encode(utf8_encoding) << ascii_string
-        #   Encoding::InvalidByteSequenceError:
-        #     when the string being transcoded contains a byte invalid for
-        #     either the source or target encoding
-        #     e.g. "\x80".encode('UTF-8','US-ASCII')
-        #     vs "\x80".encode('UTF-8','US-ASCII', invalid: :replace, replace: '<byte>')
-        #     # => '<byte>'
-        #   ArgumentError
-        #     when operating on a string with invalid bytes
-        #     e.g."\x80".split("\n")
-        #   TypeError
-        #     when a symbol is passed as an encoding
-        #     Encoding.find(:"UTF-8")
-        #     when calling force_encoding on an object
-        #     that doesn't respond to #to_str
-        #
-        # Raised by transcoding methods:
-        #   Encoding::ConverterNotFoundError:
-        #     when a named encoding does not correspond with a known converter
-        #     e.g. 'abc'.force_encoding('UTF-8').encode('foo')
-        #     or a converter path cannot be found
-        #     e.g. "\x80".force_encoding('ASCII-8BIT').encode('Emacs-Mule')
-        #
-        # Raised by byte <-> char conversions
-        #   RangeError: out of char range
-        #     e.g. the UTF-16LE emoji: 128169.chr
-        def matching_encoding(string)
-          string = remove_invalid_bytes(string)
-          string.encode(@encoding)
-        rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
-          # Originally defined as a constant to avoid uneeded allocations, this hash must
-          # be defined inline (without {}) to avoid warnings on Ruby 2.7
-          #
-          # In MRI 2.1 'invalid: :replace' changed to also replace an invalid byte sequence
-          # see https://github.com/ruby/ruby/blob/v2_1_0/NEWS#L176
-          # https://www.ruby-forum.com/topic/6861247
-          # https://twitter.com/nalsh/status/553413844685438976
-          #
-          # For example, given:
-          #   "\x80".force_encoding("Emacs-Mule").encode(:invalid => :replace).bytes.to_a
-          #
-          # On MRI 2.1 or above: 63  # '?'
-          # else               : 128 # "\x80"
-          #
-          string.encode(@encoding, :invalid => :replace, :undef => :replace, :replace => REPLACE)
-        rescue Encoding::ConverterNotFoundError
-          # Originally defined as a constant to avoid uneeded allocations, this hash must
-          # be defined inline (without {}) to avoid warnings on Ruby 2.7
-          string.dup.force_encoding(@encoding).encode(:invalid => :replace, :replace => REPLACE)
-        end
-
-        # Prevents raising ArgumentError
-        if String.method_defined?(:scrub)
-          # https://github.com/ruby/ruby/blob/eeb05e8c11/doc/NEWS-2.1.0#L120-L123
-          # https://github.com/ruby/ruby/blob/v2_1_0/string.c#L8242
-          # https://github.com/hsbt/string-scrub
-          # https://github.com/rubinius/rubinius/blob/v2.5.2/kernel/common/string.rb#L1913-L1972
-          def remove_invalid_bytes(string)
-            string.scrub(REPLACE)
-          end
-        else
-          # http://stackoverflow.com/a/8711118/879854
-          # Loop over chars in a string replacing chars
-          # with invalid encoding, which is a pretty good proxy
-          # for the invalid byte sequence that causes an ArgumentError
-          def remove_invalid_bytes(string)
-            string.chars.map do |char|
-              char.valid_encoding? ? char : REPLACE
-            end.join
-          end
-        end
-
-        def detect_source_encoding(string)
-          string.encoding
-        end
-
-        def self.pick_encoding(source_a, source_b)
-          Encoding.compatible?(source_a, source_b) || Encoding.default_external
-        end
-      else
-
-        def self.pick_encoding(_source_a, _source_b)
-        end
-
-        private
-
-        def matching_encoding(string)
-          string
-        end
-
-        def detect_source_encoding(_string)
-          US_ASCII
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-support-3.9.3/lib/rspec/support/fuzzy_matcher.rb

@@ -1,48 +0,0 @@
-module RSpec
-  module Support
-    # Provides a means to fuzzy-match between two arbitrary objects.
-    # Understands array/hash nesting. Uses `===` or `==` to
-    # perform the matching.
-    module FuzzyMatcher
-      # @api private
-      def self.values_match?(expected, actual)
-        if Hash === actual
-          return hashes_match?(expected, actual) if Hash === expected
-        elsif Array === expected && Enumerable === actual && !(Struct === actual)
-          return arrays_match?(expected, actual.to_a)
-        end
-
-        return true if expected == actual
-
-        begin
-          expected === actual
-        rescue ArgumentError
-          # Some objects, like 0-arg lambdas on 1.9+, raise
-          # ArgumentError for `expected === actual`.
-          false
-        end
-      end
-
-      # @private
-      def self.arrays_match?(expected_list, actual_list)
-        return false if expected_list.size != actual_list.size
-
-        expected_list.zip(actual_list).all? do |expected, actual|
-          values_match?(expected, actual)
-        end
-      end
-
-      # @private
-      def self.hashes_match?(expected_hash, actual_hash)
-        return false if expected_hash.size != actual_hash.size
-
-        expected_hash.all? do |expected_key, expected_value|
-          actual_value = actual_hash.fetch(expected_key) { return false }
-          values_match?(expected_value, actual_value)
-        end
-      end
-
-      private_class_method :arrays_match?, :hashes_match?
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-support-3.9.3/lib/rspec/support/hunk_generator.rb

@@ -1,47 +0,0 @@
-require 'diff/lcs'
-require 'diff/lcs/hunk'
-
-module RSpec
-  module Support
-    # @private
-    class HunkGenerator
-      def initialize(actual, expected)
-        @actual = actual
-        @expected = expected
-      end
-
-      def hunks
-        @file_length_difference = 0
-        @hunks ||= diffs.map do |piece|
-          build_hunk(piece)
-        end
-      end
-
-    private
-
-      def diffs
-        Diff::LCS.diff(expected_lines, actual_lines)
-      end
-
-      def expected_lines
-        @expected.split("\n").map! { |e| e.chomp }
-      end
-
-      def actual_lines
-        @actual.split("\n").map! { |e| e.chomp }
-      end
-
-      def build_hunk(piece)
-        Diff::LCS::Hunk.new(
-          expected_lines, actual_lines, piece, context_lines, @file_length_difference
-        ).tap do |h|
-          @file_length_difference = h.file_length_difference
-        end
-      end
-
-      def context_lines
-        3
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-support-3.9.3/lib/rspec/support/matcher_definition.rb

@@ -1,42 +0,0 @@
-module RSpec
-  module Support
-    # @private
-    def self.matcher_definitions
-      @matcher_definitions ||= []
-    end
-
-    # Used internally to break cyclic dependency between mocks, expectations,
-    # and support. We don't currently have a consistent implementation of our
-    # matchers, though we are considering changing that:
-    # https://github.com/rspec/rspec-mocks/issues/513
-    #
-    # @private
-    def self.register_matcher_definition(&block)
-      matcher_definitions << block
-    end
-
-    # Remove a previously registered matcher. Useful for cleaning up after
-    # yourself in specs.
-    #
-    # @private
-    def self.deregister_matcher_definition(&block)
-      matcher_definitions.delete(block)
-    end
-
-    # @private
-    def self.is_a_matcher?(object)
-      matcher_definitions.any? { |md| md.call(object) }
-    end
-
-    # @api private
-    #
-    # gives a string representation of an object for use in RSpec descriptions
-    def self.rspec_description_for_object(object)
-      if RSpec::Support.is_a_matcher?(object) && object.respond_to?(:description)
-        object.description
-      else
-        object
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-support-3.9.3/lib/rspec/support/method_signature_verifier.rb

@@ -1,438 +0,0 @@
-require 'rspec/support'
-RSpec::Support.require_rspec_support "ruby_features"
-RSpec::Support.require_rspec_support "matcher_definition"
-
-module RSpec
-  module Support
-    # Extracts info about the number of arguments and allowed/required
-    # keyword args of a given method.
-    #
-    # @private
-    class MethodSignature # rubocop:disable ClassLength
-      attr_reader :min_non_kw_args, :max_non_kw_args, :optional_kw_args, :required_kw_args
-
-      def initialize(method)
-        @method           = method
-        @optional_kw_args = []
-        @required_kw_args = []
-        classify_parameters
-      end
-
-      def non_kw_args_arity_description
-        case max_non_kw_args
-        when min_non_kw_args then min_non_kw_args.to_s
-        when INFINITY then "#{min_non_kw_args} or more"
-        else "#{min_non_kw_args} to #{max_non_kw_args}"
-        end
-      end
-
-      def valid_non_kw_args?(positional_arg_count, optional_max_arg_count=positional_arg_count)
-        return true if positional_arg_count.nil?
-
-        min_non_kw_args <= positional_arg_count &&
-          optional_max_arg_count <= max_non_kw_args
-      end
-
-      def classify_arity(arity=@method.arity)
-        if arity < 0
-          # `~` inverts the one's complement and gives us the
-          # number of required args
-          @min_non_kw_args = ~arity
-          @max_non_kw_args = INFINITY
-        else
-          @min_non_kw_args = arity
-          @max_non_kw_args = arity
-        end
-      end
-
-      if RubyFeatures.optional_and_splat_args_supported?
-        def description
-          @description ||= begin
-            parts = []
-
-            unless non_kw_args_arity_description == "0"
-              parts << "arity of #{non_kw_args_arity_description}"
-            end
-
-            if @optional_kw_args.any?
-              parts << "optional keyword args (#{@optional_kw_args.map(&:inspect).join(", ")})"
-            end
-
-            if @required_kw_args.any?
-              parts << "required keyword args (#{@required_kw_args.map(&:inspect).join(", ")})"
-            end
-
-            parts << "any additional keyword args" if @allows_any_kw_args
-
-            parts.join(" and ")
-          end
-        end
-
-        def missing_kw_args_from(given_kw_args)
-          @required_kw_args - given_kw_args
-        end
-
-        def invalid_kw_args_from(given_kw_args)
-          return [] if @allows_any_kw_args
-          given_kw_args - @allowed_kw_args
-        end
-
-        # If the last argument is Hash, Ruby will treat only symbol keys as keyword arguments
-        # the rest will be grouped in another Hash and passed as positional argument.
-        def has_kw_args_in?(args)
-          Hash === args.last &&
-            could_contain_kw_args?(args) &&
-            (args.last.empty? || args.last.keys.any? { |x| x.is_a?(Symbol) })
-        end
-
-        # Without considering what the last arg is, could it
-        # contain keyword arguments?
-        def could_contain_kw_args?(args)
-          return false if args.count <= min_non_kw_args
-
-          @allows_any_kw_args || @allowed_kw_args.any?
-        end
-
-        def arbitrary_kw_args?
-          @allows_any_kw_args
-        end
-
-        def unlimited_args?
-          @max_non_kw_args == INFINITY
-        end
-
-        def classify_parameters
-          optional_non_kw_args = @min_non_kw_args = 0
-          @allows_any_kw_args = false
-
-          @method.parameters.each do |(type, name)|
-            case type
-            # def foo(a:)
-            when :keyreq  then @required_kw_args << name
-            # def foo(a: 1)
-            when :key     then @optional_kw_args << name
-            # def foo(**kw_args)
-            when :keyrest then @allows_any_kw_args = true
-            # def foo(a)
-            when :req     then @min_non_kw_args += 1
-            # def foo(a = 1)
-            when :opt     then optional_non_kw_args += 1
-            # def foo(*a)
-            when :rest    then optional_non_kw_args = INFINITY
-            end
-          end
-
-          @max_non_kw_args = @min_non_kw_args  + optional_non_kw_args
-          @allowed_kw_args = @required_kw_args + @optional_kw_args
-        end
-      else
-        def description
-          "arity of #{non_kw_args_arity_description}"
-        end
-
-        def missing_kw_args_from(_given_kw_args)
-          []
-        end
-
-        def invalid_kw_args_from(_given_kw_args)
-          []
-        end
-
-        def has_kw_args_in?(_args)
-          false
-        end
-
-        def could_contain_kw_args?(*)
-          false
-        end
-
-        def arbitrary_kw_args?
-          false
-        end
-
-        def unlimited_args?
-          false
-        end
-
-        alias_method :classify_parameters, :classify_arity
-      end
-
-      INFINITY = 1 / 0.0
-    end
-
-    if RSpec::Support::Ruby.jruby?
-      # JRuby has only partial support for UnboundMethod#parameters, so we fall back on using #arity
-      # https://github.com/jruby/jruby/issues/2816 and https://github.com/jruby/jruby/issues/2817
-      if RubyFeatures.optional_and_splat_args_supported? &&
-         Java::JavaLang::String.instance_method(:char_at).parameters == []
-
-        class MethodSignature < remove_const(:MethodSignature)
-        private
-
-          def classify_parameters
-            super
-            if (arity = @method.arity) != 0 && @method.parameters.empty?
-              classify_arity(arity)
-            end
-          end
-        end
-      end
-
-      # JRuby used to always report -1 arity for Java proxy methods.
-      # The workaround essentially makes use of Java's introspection to figure
-      # out matching methods (which could be more than one partly because Java
-      # supports multiple overloads, and partly because JRuby introduces
-      # aliases to make method names look more Rubyesque). If there is only a
-      # single match, we can use that methods arity directly instead of the
-      # default -1 arity.
-      #
-      # This workaround only works for Java proxy methods, and in order to
-      # support regular methods and blocks, we need to be careful about calling
-      # owner and java_class as they might not be available
-      if Java::JavaLang::String.instance_method(:char_at).arity == -1
-        class MethodSignature < remove_const(:MethodSignature)
-        private
-
-          def classify_parameters
-            super
-            return unless @method.arity == -1
-            return unless @method.respond_to?(:owner)
-            return unless @method.owner.respond_to?(:java_class)
-            java_instance_methods = @method.owner.java_class.java_instance_methods
-            compatible_overloads = java_instance_methods.select do |java_method|
-              @method == @method.owner.instance_method(java_method.name)
-            end
-            if compatible_overloads.size == 1
-              classify_arity(compatible_overloads.first.arity)
-            end
-          end
-        end
-      end
-    end
-
-    # Encapsulates expectations about the number of arguments and
-    # allowed/required keyword args of a given method.
-    #
-    # @api private
-    class MethodSignatureExpectation
-      def initialize
-        @min_count = nil
-        @max_count = nil
-        @keywords  = []
-
-        @expect_unlimited_arguments = false
-        @expect_arbitrary_keywords  = false
-      end
-
-      attr_reader :min_count, :max_count, :keywords
-
-      attr_accessor :expect_unlimited_arguments, :expect_arbitrary_keywords
-
-      def max_count=(number)
-        raise ArgumentError, 'must be a non-negative integer or nil' \
-          unless number.nil? || (number.is_a?(Integer) && number >= 0)
-
-        @max_count = number
-      end
-
-      def min_count=(number)
-        raise ArgumentError, 'must be a non-negative integer or nil' \
-          unless number.nil? || (number.is_a?(Integer) && number >= 0)
-
-        @min_count = number
-      end
-
-      def empty?
-        @min_count.nil? &&
-          @keywords.to_a.empty? &&
-          !@expect_arbitrary_keywords &&
-          !@expect_unlimited_arguments
-      end
-
-      def keywords=(values)
-        @keywords = values.to_a || []
-      end
-    end
-
-    # Deals with the slightly different semantics of block arguments.
-    # For methods, arguments are required unless a default value is provided.
-    # For blocks, arguments are optional, even if no default value is provided.
-    #
-    # However, we want to treat block args as required since you virtually
-    # always want to pass a value for each received argument and our
-    # `and_yield` has treated block args as required for many years.
-    #
-    # @api private
-    class BlockSignature < MethodSignature
-      if RubyFeatures.optional_and_splat_args_supported?
-        def classify_parameters
-          super
-          @min_non_kw_args = @max_non_kw_args unless @max_non_kw_args == INFINITY
-        end
-      end
-    end
-
-    # Abstract base class for signature verifiers.
-    #
-    # @api private
-    class MethodSignatureVerifier
-      attr_reader :non_kw_args, :kw_args, :min_non_kw_args, :max_non_kw_args
-
-      def initialize(signature, args=[])
-        @signature = signature
-        @non_kw_args, @kw_args = split_args(*args)
-        @min_non_kw_args = @max_non_kw_args = @non_kw_args
-        @arbitrary_kw_args = @unlimited_args = false
-      end
-
-      def with_expectation(expectation) # rubocop:disable MethodLength
-        return self unless MethodSignatureExpectation === expectation
-
-        if expectation.empty?
-          @min_non_kw_args = @max_non_kw_args = @non_kw_args = nil
-          @kw_args     = []
-        else
-          @min_non_kw_args = @non_kw_args = expectation.min_count || 0
-          @max_non_kw_args                = expectation.max_count || @min_non_kw_args
-
-          if RubyFeatures.optional_and_splat_args_supported?
-            @unlimited_args = expectation.expect_unlimited_arguments
-          else
-            @unlimited_args = false
-          end
-
-          if RubyFeatures.kw_args_supported?
-            @kw_args           = expectation.keywords
-            @arbitrary_kw_args = expectation.expect_arbitrary_keywords
-          else
-            @kw_args           = []
-            @arbitrary_kw_args = false
-          end
-        end
-
-        self
-      end
-
-      def valid?
-        missing_kw_args.empty? &&
-          invalid_kw_args.empty? &&
-          valid_non_kw_args? &&
-          arbitrary_kw_args? &&
-          unlimited_args?
-      end
-
-      def error_message
-        if missing_kw_args.any?
-          "Missing required keyword arguments: %s" % [
-            missing_kw_args.join(", ")
-          ]
-        elsif invalid_kw_args.any?
-          "Invalid keyword arguments provided: %s" % [
-            invalid_kw_args.join(", ")
-          ]
-        elsif !valid_non_kw_args?
-          "Wrong number of arguments. Expected %s, got %s." % [
-            @signature.non_kw_args_arity_description,
-            non_kw_args
-          ]
-        end
-      end
-
-    private
-
-      def valid_non_kw_args?
-        @signature.valid_non_kw_args?(min_non_kw_args, max_non_kw_args)
-      end
-
-      def missing_kw_args
-        @signature.missing_kw_args_from(kw_args)
-      end
-
-      def invalid_kw_args
-        @signature.invalid_kw_args_from(kw_args)
-      end
-
-      def arbitrary_kw_args?
-        !@arbitrary_kw_args || @signature.arbitrary_kw_args?
-      end
-
-      def unlimited_args?
-        !@unlimited_args || @signature.unlimited_args?
-      end
-
-      def split_args(*args)
-        kw_args = if @signature.has_kw_args_in?(args)
-                    last = args.pop
-                    non_kw_args = last.reject { |k, _| k.is_a?(Symbol) }
-                    if non_kw_args.empty?
-                      last.keys
-                    else
-                      args << non_kw_args
-                      last.select { |k, _| k.is_a?(Symbol) }.keys
-                    end
-                  else
-                    []
-                  end
-
-        [args.length, kw_args]
-      end
-    end
-
-    # Figures out wether a given method can accept various arguments.
-    # Surprisingly non-trivial.
-    #
-    # @private
-    StrictSignatureVerifier = MethodSignatureVerifier
-
-    # Allows matchers to be used instead of providing keyword arguments. In
-    # practice, when this happens only the arity of the method is verified.
-    #
-    # @private
-    class LooseSignatureVerifier < MethodSignatureVerifier
-    private
-
-      def split_args(*args)
-        if RSpec::Support.is_a_matcher?(args.last) && @signature.could_contain_kw_args?(args)
-          args.pop
-          @signature = SignatureWithKeywordArgumentsMatcher.new(@signature)
-        end
-
-        super(*args)
-      end
-
-      # If a matcher is used in a signature in place of keyword arguments, all
-      # keyword argument validation needs to be skipped since the matcher is
-      # opaque.
-      #
-      # Instead, keyword arguments will be validated when the method is called
-      # and they are actually known.
-      #
-      # @private
-      class SignatureWithKeywordArgumentsMatcher
-        def initialize(signature)
-          @signature = signature
-        end
-
-        def missing_kw_args_from(_kw_args)
-          []
-        end
-
-        def invalid_kw_args_from(_kw_args)
-          []
-        end
-
-        def non_kw_args_arity_description
-          @signature.non_kw_args_arity_description
-        end
-
-        def valid_non_kw_args?(*args)
-          @signature.valid_non_kw_args?(*args)
-        end
-
-        def has_kw_args_in?(args)
-          @signature.has_kw_args_in?(args)
-        end
-      end
-    end
-  end
-end