primary_connect_proto 0.4.0 → 0.5.0

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/extra_spacing.rb

@@ -1,246 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for extra/unnecessary whitespace.
-      #
-      # @example
-      #
-      #   # good if AllowForAlignment is true
-      #   name      = "RuboCop"
-      #   # Some comment and an empty line
-      #
-      #   website  += "/rubocop-hq/rubocop" unless cond
-      #   puts        "rubocop"          if     debug
-      #
-      #   # bad for any configuration
-      #   set_app("RuboCop")
-      #   website  = "https://github.com/rubocop-hq/rubocop"
-      #
-      #   # good only if AllowBeforeTrailingComments is true
-      #   object.method(arg)  # this is a comment
-      #
-      #   # good even if AllowBeforeTrailingComments is false or not set
-      #   object.method(arg) # this is a comment
-      #
-      #   # good with either AllowBeforeTrailingComments or AllowForAlignment
-      #   object.method(arg)         # this is a comment
-      #   another_object.method(arg) # this is another comment
-      #   some_object.method(arg)    # this is some comment
-      class ExtraSpacing < Cop
-        include PrecedingFollowingAlignment
-        include RangeHelp
-
-        MSG_UNNECESSARY = 'Unnecessary spacing detected.'.freeze
-        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s ' \
-                             'assignment.'.freeze
-
-        def investigate(processed_source)
-          return if processed_source.blank?
-
-          if force_equal_sign_alignment?
-            @asgn_tokens = assignment_tokens
-            @asgn_lines  = @asgn_tokens.map(&:line)
-            # Don't attempt to correct the same = more than once
-            @corrected   = Set.new
-          end
-
-          processed_source.tokens.each_cons(2) do |token1, token2|
-            check_tokens(processed_source.ast, token1, token2)
-          end
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            if range.source.end_with?('=')
-              align_equal_signs(range, corrector)
-            else
-              corrector.remove(range)
-            end
-          end
-        end
-
-        private
-
-        def assignment_tokens
-          tokens = processed_source.tokens.select(&:equal_sign?)
-          # we don't want to operate on equals signs which are part of an
-          #   optarg in a method definition
-          # e.g.: def method(optarg = default_val); end
-          tokens = remove_optarg_equals(tokens, processed_source)
-
-          # Only attempt to align the first = on each line
-          Set.new(tokens.uniq(&:line))
-        end
-
-        def check_tokens(ast, token1, token2)
-          return if token2.type == :tNL
-
-          if force_equal_sign_alignment? &&
-             @asgn_tokens.include?(token2) &&
-             (@asgn_lines.include?(token2.line - 1) ||
-              @asgn_lines.include?(token2.line + 1))
-            check_assignment(token2)
-          else
-            check_other(token1, token2, ast)
-          end
-        end
-
-        def check_assignment(token)
-          assignment_line = ''
-          message = ''
-          if should_aligned_with_preceding_line?(token)
-            assignment_line = processed_source.preceding_line(token)
-            message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
-          else
-            assignment_line = processed_source.following_line(token)
-            message = format(MSG_UNALIGNED_ASGN, location: 'following')
-          end
-          return if aligned_assignment?(token.pos, assignment_line)
-
-          add_offense(token.pos, location: token.pos, message: message)
-        end
-
-        def should_aligned_with_preceding_line?(token)
-          @asgn_lines.include?(token.line - 1)
-        end
-
-        def check_other(token1, token2, ast)
-          return false if allow_for_trailing_comments? &&
-                          token2.text.start_with?('#')
-
-          extra_space_range(token1, token2) do |range|
-            # Unary + doesn't appear as a token and needs special handling.
-            next if ignored_range?(ast, range.begin_pos)
-            next if unary_plus_non_offense?(range)
-
-            add_offense(range, location: range, message: MSG_UNNECESSARY)
-          end
-        end
-
-        def extra_space_range(token1, token2)
-          return if token1.line != token2.line
-
-          start_pos = token1.end_pos
-          end_pos = token2.begin_pos - 1
-          return if end_pos <= start_pos
-
-          return if allow_for_alignment? && aligned_tok?(token2)
-
-          yield range_between(start_pos, end_pos)
-        end
-
-        def aligned_tok?(token)
-          if token.comment?
-            aligned_comments?(token)
-          else
-            aligned_with_something?(token.pos)
-          end
-        end
-
-        def ignored_range?(ast, start_pos)
-          ignored_ranges(ast).any? { |r| r.include?(start_pos) }
-        end
-
-        def unary_plus_non_offense?(range)
-          range.resize(range.size + 1).source =~ /^ ?\+$/
-        end
-
-        # Returns an array of ranges that should not be reported. It's the
-        # extra spaces between the keys and values in a multiline hash,
-        # since those are handled by the Style/AlignHash cop.
-        def ignored_ranges(ast)
-          return [] unless ast
-
-          @ignored_ranges ||= on_node(:pair, ast).map do |pair|
-            next if pair.parent.single_line?
-
-            key, value = *pair
-            key.source_range.end_pos...value.source_range.begin_pos
-          end.compact
-        end
-
-        def aligned_comments?(comment_token)
-          ix = processed_source.comments.index do |comment|
-            comment.loc.expression.begin_pos == comment_token.begin_pos
-          end
-          aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
-        end
-
-        def aligned_with_previous_comment?(index)
-          index > 0 && comment_column(index - 1) == comment_column(index)
-        end
-
-        def aligned_with_next_comment?(index)
-          index < processed_source.comments.length - 1 &&
-            comment_column(index + 1) == comment_column(index)
-        end
-
-        def comment_column(index)
-          processed_source.comments[index].loc.column
-        end
-
-        def force_equal_sign_alignment?
-          cop_config['ForceEqualSignAlignment']
-        end
-
-        def align_equal_signs(range, corrector)
-          lines  = contiguous_assignment_lines(range)
-          tokens = @asgn_tokens.select { |t| lines.include?(t.line) }
-
-          columns  = tokens.map { |t| align_column(t) }
-          align_to = columns.max
-
-          tokens.each { |token| align_equal_sign(corrector, token, align_to) }
-        end
-
-        def align_equal_sign(corrector, token, align_to)
-          return unless @corrected.add?(token)
-
-          diff = align_to - token.pos.last_column
-
-          if diff > 0
-            corrector.insert_before(token.pos, ' ' * diff)
-          elsif diff < 0
-            corrector.remove_preceding(token.pos, -diff)
-          end
-        end
-
-        def contiguous_assignment_lines(range)
-          result = [range.line]
-
-          range.line.downto(1) do |lineno|
-            @asgn_lines.include?(lineno) ? result << lineno : break
-          end
-          range.line.upto(processed_source.lines.size) do |lineno|
-            @asgn_lines.include?(lineno) ? result << lineno : break
-          end
-
-          result.sort!
-        end
-
-        def align_column(asgn_token)
-          # if we removed unneeded spaces from the beginning of this =,
-          # what column would it end from?
-          line    = processed_source.lines[asgn_token.line - 1]
-          leading = line[0...asgn_token.column]
-          spaces  = leading.size - (leading =~ / *\Z/)
-          asgn_token.pos.last_column - spaces + 1
-        end
-
-        def remove_optarg_equals(asgn_tokens, processed_source)
-          optargs    = processed_source.ast.each_node(:optarg)
-          optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
-          asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
-        end
-
-        def allow_for_trailing_comments?
-          cop_config['AllowBeforeTrailingComments']
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/first_array_element_line_break.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for a line break before the first element in a
-      # multi-line array.
-      #
-      # @example
-      #
-      #     # bad
-      #     [ :a,
-      #       :b]
-      #
-      #     # good
-      #     [
-      #       :a,
-      #       :b]
-      #
-      class FirstArrayElementLineBreak < Cop
-        include FirstElementLineBreak
-
-        MSG = 'Add a line break before the first element of a ' \
-              'multi-line array.'.freeze
-
-        def on_array(node)
-          return if !node.loc.begin && !assignment_on_same_line?(node)
-
-          check_children_line_break(node, node.children)
-        end
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
-
-        private
-
-        def assignment_on_same_line?(node)
-          source = node.source_range.source_line[0...node.loc.column]
-          source =~ /\s*\=\s*$/
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/first_hash_element_line_break.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for a line break before the first element in a
-      # multi-line hash.
-      #
-      # @example
-      #
-      #     # bad
-      #     { a: 1,
-      #       b: 2}
-      #
-      #     # good
-      #     {
-      #       a: 1,
-      #       b: 2 }
-      class FirstHashElementLineBreak < Cop
-        include FirstElementLineBreak
-
-        MSG = 'Add a line break before the first element of a ' \
-              'multi-line hash.'.freeze
-
-        def on_hash(node)
-          # node.loc.begin tells us whether the hash opens with a {
-          # If it doesn't, Style/FirstMethodArgumentLineBreak will handle it
-          check_children_line_break(node, node.children) if node.loc.begin
-        end
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/first_method_argument_line_break.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for a line break before the first argument in a
-      # multi-line method call.
-      #
-      # @example
-      #
-      #     # bad
-      #     method(foo, bar,
-      #       baz)
-      #
-      #     # good
-      #     method(
-      #       foo, bar,
-      #       baz)
-      #
-      #     # ignored
-      #     method foo, bar,
-      #       baz
-      class FirstMethodArgumentLineBreak < Cop
-        include FirstElementLineBreak
-
-        MSG = 'Add a line break before the first argument of a ' \
-              'multi-line method argument list.'.freeze
-
-        def on_send(node)
-          args = node.arguments
-
-          # If there is a trailing hash arg without explicit braces, like this:
-          #
-          #    method(1, 'key1' => value1, 'key2' => value2)
-          #
-          # ...then each key/value pair is treated as a method 'argument'
-          # when determining where line breaks should appear.
-          if (last_arg = args.last)
-            if last_arg.hash_type? && !last_arg.braces?
-              args = args.concat(args.pop.children)
-            end
-          end
-
-          check_method_line_break(node, args)
-        end
-        alias on_csend on_send
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/first_method_parameter_line_break.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for a line break before the first parameter in a
-      # multi-line method parameter definition.
-      #
-      # @example
-      #
-      #     # bad
-      #     def method(foo, bar,
-      #         baz)
-      #       do_something
-      #     end
-      #
-      #     # good
-      #     def method(
-      #         foo, bar,
-      #         baz)
-      #       do_something
-      #     end
-      #
-      #     # ignored
-      #     def method foo,
-      #         bar
-      #       do_something
-      #     end
-      class FirstMethodParameterLineBreak < Cop
-        include FirstElementLineBreak
-
-        MSG = 'Add a line break before the first parameter of a ' \
-              'multi-line method parameter list.'.freeze
-
-        def on_def(node)
-          check_method_line_break(node, node.arguments)
-        end
-        alias on_defs on_def
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/first_parameter_indentation.rb

@@ -1,244 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # rubocop:disable Metrics/LineLength
-    module Layout
-      # This cop checks the indentation of the first parameter in a method call.
-      # Parameters after the first one are checked by Layout/AlignParameters,
-      # not by this cop.
-      #
-      # @example
-      #
-      #   # bad
-      #   some_method(
-      #   first_param,
-      #   second_param)
-      #
-      #   foo = some_method(
-      #   first_param,
-      #   second_param)
-      #
-      #   foo = some_method(nested_call(
-      #   nested_first_param),
-      #   second_param)
-      #
-      #   foo = some_method(
-      #   nested_call(
-      #   nested_first_param),
-      #   second_param)
-      #
-      #   some_method nested_call(
-      #   nested_first_param),
-      #   second_param
-      #
-      # @example EnforcedStyle: consistent
-      #   # The first parameter should always be indented one step more than the
-      #   # preceding line.
-      #
-      #   # good
-      #   some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(nested_call(
-      #     nested_first_param),
-      #   second_param)
-      #
-      #   foo = some_method(
-      #     nested_call(
-      #       nested_first_param),
-      #   second_param)
-      #
-      #   some_method nested_call(
-      #     nested_first_param),
-      #   second_param
-      #
-      # @example EnforcedStyle: consistent_relative_to_receiver
-      #   # The first parameter should always be indented one level relative to
-      #   # the parent that is receiving the parameter
-      #
-      #   # good
-      #   some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(
-      #           first_param,
-      #   second_param)
-      #
-      #   foo = some_method(nested_call(
-      #                       nested_first_param),
-      #   second_param)
-      #
-      #   foo = some_method(
-      #           nested_call(
-      #             nested_first_param),
-      #   second_param)
-      #
-      #   some_method nested_call(
-      #                 nested_first_param),
-      #   second_params
-      #
-      # @example EnforcedStyle: special_for_inner_method_call
-      #   # The first parameter should normally be indented one step more than
-      #   # the preceding line, but if it's a parameter for a method call that
-      #   # is itself a parameter in a method call, then the inner parameter
-      #   # should be indented relative to the inner method.
-      #
-      #   # good
-      #   some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(nested_call(
-      #                       nested_first_param),
-      #   second_param)
-      #
-      #   foo = some_method(
-      #     nested_call(
-      #       nested_first_param),
-      #   second_param)
-      #
-      #   some_method nested_call(
-      #                 nested_first_param),
-      #   second_param
-      #
-      # @example EnforcedStyle: special_for_inner_method_call_in_parentheses (default)
-      #   # Same as `special_for_inner_method_call` except that the special rule
-      #   # only applies if the outer method call encloses its arguments in
-      #   # parentheses.
-      #
-      #   # good
-      #   some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(nested_call(
-      #                       nested_first_param),
-      #   second_param)
-      #
-      #   foo = some_method(
-      #     nested_call(
-      #       nested_first_param),
-      #   second_param)
-      #
-      #   some_method nested_call(
-      #     nested_first_param),
-      #   second_param
-      #
-      class FirstParameterIndentation < Cop
-        # rubocop:enable Metrics/LineLength
-        include Alignment
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-
-        MSG = 'Indent the first parameter one step more than %<base>s.'.freeze
-
-        def on_send(node)
-          return if !node.arguments? || node.operator_method?
-
-          indent = base_indentation(node) + configured_indentation_width
-
-          check_alignment([node.first_argument], indent)
-        end
-        alias on_csend on_send
-
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
-        end
-
-        private
-
-        def message(arg_node)
-          return 'Bad indentation of the first parameter.' unless arg_node
-
-          send_node = arg_node.parent
-          text = base_range(send_node, arg_node).source.strip
-          base = if text !~ /\n/ && special_inner_call_indentation?(send_node)
-                   "`#{text}`"
-                 elsif comment_line?(text.lines.reverse_each.first)
-                   'the start of the previous line (not counting the comment)'
-                 else
-                   'the start of the previous line'
-                 end
-
-          format(MSG, base: base)
-        end
-
-        def base_indentation(node)
-          if special_inner_call_indentation?(node)
-            column_of(base_range(node, node.first_argument))
-          else
-            previous_code_line(node.first_argument.first_line) =~ /\S/
-          end
-        end
-
-        def special_inner_call_indentation?(node)
-          return false if style == :consistent
-          return true  if style == :consistent_relative_to_receiver
-
-          parent = node.parent
-
-          return false unless eligible_method_call?(parent)
-          return false if !parent.parenthesized? &&
-                          style == :special_for_inner_method_call_in_parentheses
-
-          # The node must begin inside the parent, otherwise node is the first
-          # part of a chained method call.
-          node.source_range.begin_pos > parent.source_range.begin_pos
-        end
-
-        def_node_matcher :eligible_method_call?, <<-PATTERN
-          (send _ !:[]= ...)
-        PATTERN
-
-        def base_range(send_node, arg_node)
-          range_between(send_node.source_range.begin_pos,
-                        arg_node.source_range.begin_pos)
-        end
-
-        # Returns the column of the given range. For single line ranges, this
-        # is simple. For ranges with line breaks, we look a the last code line.
-        def column_of(range)
-          source = range.source.strip
-          if source.include?("\n")
-            previous_code_line(range.line + source.count("\n") + 1) =~ /\S/
-          else
-            display_column(range)
-          end
-        end
-
-        # Takes the line number of a given code line and returns a string
-        # containing the previous line that's not a comment line or a blank
-        # line.
-        def previous_code_line(line_number)
-          @comment_lines ||=
-            processed_source
-            .comments
-            .select { |c| begins_its_line?(c.loc.expression) }
-            .map { |c| c.loc.line }
-
-          line = ''
-          while line.blank? || @comment_lines.include?(line_number)
-            line_number -= 1
-            line = processed_source.lines[line_number - 1]
-          end
-          line
-        end
-      end
-    end
-  end
-end