primary_connect_proto 0.12.1 → 0.14.0

data/vendor/bundle/ruby/2.7.0/gems/rubocop-0.66.0/lib/rubocop/cop/lint/void.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for operators, variables, literals, and nonmutating
-      # methods used in void context.
-      #
-      # @example
-      #
-      #   # bad
-      #
-      #   def some_method
-      #     some_num * 10
-      #     do_something
-      #   end
-      #
-      # @example
-      #
-      #   # bad
-      #
-      #   def some_method(some_var)
-      #     some_var
-      #     do_something
-      #   end
-      #
-      # @example
-      #
-      #   # bad, when CheckForMethodsWithNoSideEffects is set true
-      #
-      #   def some_method(some_array)
-      #     some_array.sort
-      #     do_something(some_array)
-      #   end
-      #
-      # @example
-      #
-      #   # good
-      #
-      #   def some_method
-      #     do_something
-      #     some_num * 10
-      #   end
-      #
-      # @example
-      #
-      #   # good
-      #
-      #   def some_method(some_var)
-      #     do_something
-      #     some_var
-      #   end
-      #
-      # @example
-      #
-      #   # good, when CheckForMethodsWithNoSideEffects is set true
-      #
-      #   def some_method(some_array)
-      #     some_array.sort!
-      #     do_something(some_array)
-      #   end
-      class Void < Cop
-        OP_MSG = 'Operator `%<op>s` used in void context.'.freeze
-        VAR_MSG = 'Variable `%<var>s` used in void context.'.freeze
-        LIT_MSG = 'Literal `%<lit>s` used in void context.'.freeze
-        SELF_MSG = '`self` used in void context.'.freeze
-        DEFINED_MSG = '`%<defined>s` used in void context.'.freeze
-        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. ' \
-          'Did you mean `#%<method>s!`?'.freeze
-
-        BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
-        UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
-        OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
-        VOID_CONTEXT_TYPES = %i[def for block].freeze
-        NONMUTATING_METHODS = %i[capitalize chomp chop collect compact
-                                 delete_prefix delete_suffix downcase
-                                 encode flatten gsub lstrip map next reject
-                                 reverse rotate rstrip scrub select shuffle
-                                 slice sort sort_by squeeze strip sub succ
-                                 swapcase tr tr_s transform_values
-                                 unicode_normalize uniq upcase].freeze
-
-        def on_block(node)
-          return unless node.body && !node.body.begin_type?
-          return unless in_void_context?(node.body)
-
-          check_expression(node.body)
-        end
-
-        def on_begin(node)
-          check_begin(node)
-        end
-        alias on_kwbegin on_begin
-
-        private
-
-        def check_begin(node)
-          expressions = *node
-          expressions.pop unless in_void_context?(node)
-          expressions.each do |expr|
-            check_expression(expr)
-          end
-        end
-
-        def check_expression(expr)
-          check_void_op(expr)
-          check_literal(expr)
-          check_var(expr)
-          check_self(expr)
-          check_defined(expr)
-          return unless cop_config['CheckForMethodsWithNoSideEffects']
-
-          check_nonmutating(expr)
-        end
-
-        def check_void_op(node)
-          return unless node.send_type? && OPERATORS.include?(node.method_name)
-
-          add_offense(node,
-                      location: :selector,
-                      message: format(OP_MSG, op: node.method_name))
-        end
-
-        def check_var(node)
-          return unless node.variable? || node.const_type?
-
-          add_offense(node,
-                      location: :name,
-                      message: format(VAR_MSG, var: node.loc.name.source))
-        end
-
-        def check_literal(node)
-          return if !node.literal? || node.xstr_type?
-
-          add_offense(node, message: format(LIT_MSG, lit: node.source))
-        end
-
-        def check_self(node)
-          return unless node.self_type?
-
-          add_offense(node, message: SELF_MSG)
-        end
-
-        def check_defined(node)
-          return unless node.defined_type?
-
-          add_offense(node, message: format(DEFINED_MSG, defined: node.source))
-        end
-
-        def check_nonmutating(node)
-          unless node.send_type? &&
-                 NONMUTATING_METHODS.include?(node.method_name)
-            return
-          end
-
-          add_offense(node, message: format(NONMUTATING_MSG,
-                                            method: node.method_name))
-        end
-
-        def in_void_context?(node)
-          parent = node.parent
-
-          return false unless parent && parent.children.last == node
-
-          VOID_CONTEXT_TYPES.include?(parent.type) && parent.void_context?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rubocop-0.66.0/lib/rubocop/cop/message_annotator.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Message Annotator class annotates a basic offense message
-    # based on params passed into initializer.
-    #
-    # @see #initialize
-    #
-    # @example
-    #   RuboCop::Cop::MessageAnnotator.new(
-    #     config, cop_config, @options
-    #   ).annotate('message', 'Cop/CopName')
-    #  #=> 'Cop/CopName: message (http://example.org/styleguide)'
-    class MessageAnnotator
-      attr_reader :options, :config, :cop_config
-
-      @style_guide_urls = {}
-
-      class << self
-        attr_reader :style_guide_urls
-      end
-
-      # @param config [RuboCop::Config] Check configs for all cops
-      #   @note Message Annotator specifically checks the
-      #     following config options for_all_cops
-      #     :StyleGuideBaseURL [String] URL for styleguide
-      #     :DisplayStyleGuide [Boolean] Include styleguide and reference URLs
-      #     :ExtraDetails [Boolean] Include cop details
-      #     :DisplayCopNames [Boolean] Include cop name
-      #
-      # @param [Hash] cop_config configs for specific cop, from config#for_cop
-      # @option cop_config [String] :StyleGuide Extension of base styleguide URL
-      # @option cop_config [String] :Reference Full reference URL
-      # @option cop_config [String] :Details
-      #
-      # @param [Hash, nil] options optional
-      # @option options [Boolean] :display_style_guide
-      #   Include style guide and reference URLs
-      # @option options [Boolean] :extra_details
-      #   Include cop specific details
-      # @option options [Boolean] :debug
-      #   Include debug output
-      # @option options [Boolean] :display_cop_names
-      #   Include cop name
-      def initialize(config, cop_config, options)
-        @config = config
-        @cop_config = cop_config || {}
-        @options = options
-      end
-
-      # Returns the annotated message,
-      # based on params passed into initializer
-      #
-      # @return [String] annotated message
-      def annotate(message, name)
-        message = "#{name}: #{message}" if display_cop_names?
-        message += " #{details}" if extra_details? && details
-        if display_style_guide?
-          links = urls.join(', ')
-          message = "#{message} (#{links})"
-        end
-        message
-      end
-
-      def urls
-        [style_guide_url, *reference_urls].compact
-      end
-
-      private
-
-      def style_guide_url
-        url = cop_config['StyleGuide']
-        return nil if url.nil? || url.empty?
-
-        self.class.style_guide_urls[url] ||= begin
-          base_url = config.for_all_cops['StyleGuideBaseURL']
-          if base_url.nil? || base_url.empty?
-            url
-          else
-            URI.join(base_url, url).to_s
-          end
-        end
-      end
-
-      def display_style_guide?
-        (options[:display_style_guide] ||
-         config.for_all_cops['DisplayStyleGuide']) &&
-          !urls.empty?
-      end
-
-      def reference_urls
-        urls = Array(cop_config['Reference'])
-        urls.nil? || urls.empty? ? nil : urls.reject(&:empty?)
-      end
-
-      def extra_details?
-        options[:extra_details] || config.for_all_cops['ExtraDetails']
-      end
-
-      def debug?
-        options[:debug]
-      end
-
-      def display_cop_names?
-        return true if debug?
-        return false if options[:display_cop_names] == false
-        return true if options[:display_cop_names]
-
-        config.for_all_cops['DisplayCopNames']
-      end
-
-      def details
-        details = cop_config && cop_config['Details']
-        details.nil? || details.empty? ? nil : details
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rubocop-0.66.0/lib/rubocop/cop/metrics/abc_size.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      # This cop checks that the ABC size of methods is not higher than the
-      # configured maximum. The ABC size is based on assignments, branches
-      # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
-      # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
-      class AbcSize < Cop
-        include MethodComplexity
-
-        MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
-              '[%<complexity>.4g/%<max>.4g]'.freeze
-
-        private
-
-        def complexity(node)
-          Utils::AbcSizeCalculator.calculate(node)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rubocop-0.66.0/lib/rubocop/cop/metrics/block_length.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      # This cop checks if the length of a block exceeds some maximum value.
-      # Comment lines can optionally be ignored.
-      # The maximum allowed length is configurable.
-      # The cop can be configured to ignore blocks passed to certain methods.
-      class BlockLength < Cop
-        include TooManyLines
-
-        LABEL = 'Block'.freeze
-
-        def on_block(node)
-          return if excluded_method?(node)
-          return if node.class_constructor?
-
-          check_code_length(node)
-        end
-
-        private
-
-        def excluded_method?(node)
-          node_receiver = node.receiver && node.receiver.source.gsub(/\s+/, '')
-          node_method = String(node.method_name)
-
-          excluded_methods.any? do |config|
-            receiver, method = config.split('.')
-
-            unless method
-              method = receiver
-              receiver = node_receiver
-            end
-
-            method == node_method && receiver == node_receiver
-          end
-        end
-
-        def excluded_methods
-          cop_config['ExcludedMethods'] || []
-        end
-
-        def cop_label
-          LABEL
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rubocop-0.66.0/lib/rubocop/cop/metrics/block_nesting.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      # This cop checks for excessive nesting of conditional and looping
-      # constructs.
-      #
-      # You can configure if blocks are considered using the `CountBlocks`
-      # option. When set to `false` (the default) blocks are not counted
-      # towards the nesting level. Set to `true` to count blocks as well.
-      #
-      # The maximum level of nesting allowed is configurable.
-      class BlockNesting < Cop
-        include ConfigurableMax
-
-        NESTING_BLOCKS = %i[
-          case if while while_post
-          until until_post for resbody
-        ].freeze
-
-        def investigate(processed_source)
-          return if processed_source.blank?
-
-          max = cop_config['Max']
-          check_nesting_level(processed_source.ast, max, 0)
-        end
-
-        private
-
-        def check_nesting_level(node, max, current_level)
-          if consider_node?(node)
-            current_level += 1 unless node.if_type? && node.elsif?
-            if current_level > max
-              self.max = current_level
-              unless part_of_ignored_node?(node)
-                add_offense(node, message: message(max)) do
-                  ignore_node(node)
-                end
-              end
-            end
-          end
-
-          node.each_child_node do |child_node|
-            check_nesting_level(child_node, max, current_level)
-          end
-        end
-
-        def consider_node?(node)
-          return true if NESTING_BLOCKS.include?(node.type)
-
-          count_blocks? && node.block_type?
-        end
-
-        def message(max)
-          "Avoid more than #{max} levels of block nesting."
-        end
-
-        def count_blocks?
-          cop_config['CountBlocks']
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rubocop-0.66.0/lib/rubocop/cop/metrics/class_length.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      # This cop checks if the length a class exceeds some maximum value.
-      # Comment lines can optionally be ignored.
-      # The maximum allowed length is configurable.
-      class ClassLength < Cop
-        include ClassishLength
-
-        def on_class(node)
-          check_code_length(node)
-        end
-
-        def on_casgn(node)
-          class_definition?(node) do
-            check_code_length(node)
-          end
-        end
-
-        private
-
-        def_node_matcher :class_definition?, <<-PATTERN
-          (casgn nil? _ (block (send (const nil? :Class) :new) ...))
-        PATTERN
-
-        def message(length, max_length)
-          format('Class has too many lines. [%<length>d/%<max>d]',
-                 length: length,
-                 max: max_length)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rubocop-0.66.0/lib/rubocop/cop/metrics/cyclomatic_complexity.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      # This cop checks that the cyclomatic complexity of methods is not higher
-      # than the configured maximum. The cyclomatic complexity is the number of
-      # linearly independent paths through a method. The algorithm counts
-      # decision points and adds one.
-      #
-      # An if statement (or unless or ?:) increases the complexity by one. An
-      # else branch does not, since it doesn't add a decision point. The &&
-      # operator (or keyword and) can be converted to a nested if statement,
-      # and ||/or is shorthand for a sequence of ifs, so they also add one.
-      # Loops can be said to have an exit condition, so they add one.
-      class CyclomaticComplexity < Cop
-        include MethodComplexity
-
-        MSG = 'Cyclomatic complexity for %<method>s is too high. ' \
-              '[%<complexity>d/%<max>d]'.freeze
-        COUNTED_NODES = %i[if while until for
-                           rescue when and or].freeze
-
-        private
-
-        def complexity_score_for(_node)
-          1
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rubocop-0.66.0/lib/rubocop/cop/metrics/line_length.rb

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-
-module RuboCop
-  module Cop
-    module Metrics
-      # This cop checks the length of lines in the source code.
-      # The maximum length is configurable.
-      # The tab size is configured in the `IndentationWidth`
-      # of the `Layout/Tab` cop.
-      class LineLength < Cop
-        include ConfigurableMax
-        include IgnoredPattern
-        include RangeHelp
-
-        MSG = 'Line is too long. [%<length>d/%<max>d]'.freeze
-
-        def investigate(processed_source)
-          heredocs = extract_heredocs(processed_source.ast) if allow_heredoc?
-          processed_source.lines.each_with_index do |line, index|
-            check_line(line, index, heredocs)
-          end
-        end
-
-        private
-
-        def tab_indentation_width
-          config.for_cop('Layout/Tab')['IndentationWidth']
-        end
-
-        def indentation_difference(line)
-          return 0 unless tab_indentation_width
-
-          line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
-        end
-
-        def line_length(line)
-          line.length + indentation_difference(line)
-        end
-
-        def highligh_start(line)
-          max - indentation_difference(line)
-        end
-
-        def check_line(line, index, heredocs)
-          return if line_length(line) <= max
-          return if ignored_line?(line, index, heredocs)
-
-          if ignore_cop_directives? && directive_on_source_line?(index)
-            return check_directive_line(line, index)
-          end
-          return check_uri_line(line, index) if allow_uri?
-
-          register_offense(
-            source_range(
-              processed_source.buffer, index,
-              highligh_start(line)...line_length(line)
-            ),
-            line
-          )
-        end
-
-        def ignored_line?(line, index, heredocs)
-          matches_ignored_pattern?(line) ||
-            heredocs && line_in_permitted_heredoc?(heredocs, index.succ)
-        end
-
-        def register_offense(loc, line)
-          message = format(MSG, length: line_length(line), max: max)
-
-          add_offense(nil, location: loc, message: message) do
-            self.max = line_length(line)
-          end
-        end
-
-        def excess_range(uri_range, line, index)
-          excessive_position = if uri_range && uri_range.begin < max
-                                 uri_range.end
-                               else
-                                 highligh_start(line)
-                               end
-
-          source_range(processed_source.buffer, index + 1,
-                       excessive_position...(line_length(line)))
-        end
-
-        def max
-          cop_config['Max']
-        end
-
-        def allow_heredoc?
-          allowed_heredoc
-        end
-
-        def allowed_heredoc
-          cop_config['AllowHeredoc']
-        end
-
-        def extract_heredocs(ast)
-          return [] unless ast
-
-          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
-            body = node.location.heredoc_body
-            delimiter = node.location.heredoc_end.source.strip
-            [body.first_line...body.last_line, delimiter]
-          end
-        end
-
-        def line_in_permitted_heredoc?(heredocs, line_number)
-          heredocs.any? do |range, delimiter|
-            range.cover?(line_number) &&
-              (allowed_heredoc == true || allowed_heredoc.include?(delimiter))
-          end
-        end
-
-        def allow_uri?
-          cop_config['AllowURI']
-        end
-
-        def ignore_cop_directives?
-          cop_config['IgnoreCopDirectives']
-        end
-
-        def allowed_uri_position?(line, uri_range)
-          uri_range.begin < max &&
-            (uri_range.end == line_length(line) ||
-             uri_range.end == line_length(line) - 1)
-        end
-
-        def find_excessive_uri_range(line)
-          last_uri_match = match_uris(line).last
-          return nil unless last_uri_match
-
-          begin_position, end_position =
-            last_uri_match.offset(0).map do |pos|
-              pos + indentation_difference(line)
-            end
-          return nil if begin_position < max && end_position < max
-
-          begin_position...end_position
-        end
-
-        def match_uris(string)
-          matches = []
-          string.scan(uri_regexp) do
-            matches << $LAST_MATCH_INFO if valid_uri?($LAST_MATCH_INFO[0])
-          end
-          matches
-        end
-
-        def valid_uri?(uri_ish_string)
-          URI.parse(uri_ish_string)
-          true
-        rescue URI::InvalidURIError, NoMethodError
-          false
-        end
-
-        def uri_regexp
-          @uri_regexp ||=
-            URI::DEFAULT_PARSER.make_regexp(cop_config['URISchemes'])
-        end
-
-        def check_directive_line(line, index)
-          return if line_length_without_directive(line) <= max
-
-          range = max..(line_length_without_directive(line) - 1)
-          register_offense(
-            source_range(
-              processed_source.buffer,
-              index + 1,
-              range
-            ),
-            line
-          )
-        end
-
-        def directive_on_source_line?(index)
-          source_line_number = index + processed_source.buffer.first_line
-          comment =
-            processed_source
-            .comments
-            .detect { |e| e.location.line == source_line_number }
-
-          return false unless comment
-
-          comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-        end
-
-        def line_length_without_directive(line)
-          before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-          before_comment.rstrip.length
-        end
-
-        def check_uri_line(line, index)
-          uri_range = find_excessive_uri_range(line)
-          return if uri_range && allowed_uri_position?(line, uri_range)
-
-          register_offense(excess_range(uri_range, line, index), line)
-        end
-      end
-    end
-  end
-end