primary_connect_proto 0.20.0 → 0.22.0

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_around_operators.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks that operators have space around them, except for **
-      # which should not have surrounding space.
-      #
-      # @example
-      #   # bad
-      #   total = 3*4
-      #   "apple"+"juice"
-      #   my_number = 38/4
-      #   a ** b
-      #
-      #   # good
-      #   total = 3 * 4
-      #   "apple" + "juice"
-      #   my_number = 38 / 4
-      #   a**b
-      class SpaceAroundOperators < Cop
-        include PrecedingFollowingAlignment
-        include RangeHelp
-
-        IRREGULAR_METHODS = %i[[] ! []=].freeze
-        EXCESSIVE_SPACE = '  '.freeze
-
-        def self.autocorrect_incompatible_with
-          [Style::SelfAssignment]
-        end
-
-        def on_pair(node)
-          return unless node.hash_rocket?
-
-          return if hash_table_style? && !node.parent.pairs_on_same_line?
-
-          check_operator(node.loc.operator, node.source_range)
-        end
-
-        def on_if(node)
-          return unless node.ternary?
-
-          check_operator(node.loc.question, node.if_branch.source_range)
-          check_operator(node.loc.colon, node.else_branch.source_range)
-        end
-
-        def on_resbody(node)
-          return unless node.loc.assoc
-
-          _, variable, = *node
-
-          check_operator(node.loc.assoc, variable.source_range)
-        end
-
-        def on_send(node)
-          if node.setter_method?
-            on_special_asgn(node)
-          elsif regular_operator?(node)
-            check_operator(node.loc.selector, node.first_argument.source_range)
-          end
-        end
-
-        def on_binary(node)
-          _, rhs, = *node
-
-          return unless rhs
-
-          check_operator(node.loc.operator, rhs.source_range)
-        end
-
-        def on_special_asgn(node)
-          _, _, right, = *node
-
-          return unless right
-
-          check_operator(node.loc.operator, right.source_range)
-        end
-
-        alias on_or       on_binary
-        alias on_and      on_binary
-        alias on_lvasgn   on_binary
-        alias on_masgn    on_binary
-        alias on_casgn    on_special_asgn
-        alias on_ivasgn   on_binary
-        alias on_cvasgn   on_binary
-        alias on_gvasgn   on_binary
-        alias on_class    on_binary
-        alias on_or_asgn  on_binary
-        alias on_and_asgn on_binary
-        alias on_op_asgn  on_special_asgn
-
-        def autocorrect(range)
-          lambda do |corrector|
-            if range.source =~ /\*\*/
-              corrector.replace(range, '**')
-            elsif range.source.end_with?("\n")
-              corrector.replace(range, " #{range.source.strip}\n")
-            else
-              corrector.replace(range, " #{range.source.strip} ")
-            end
-          end
-        end
-
-        private
-
-        def regular_operator?(send_node)
-          !send_node.unary_operation? && !send_node.dot? &&
-            operator_with_regular_syntax?(send_node)
-        end
-
-        def operator_with_regular_syntax?(send_node)
-          send_node.operator_method? &&
-            !IRREGULAR_METHODS.include?(send_node.method_name)
-        end
-
-        def check_operator(operator, right_operand)
-          with_space = range_with_surrounding_space(range: operator)
-          return if with_space.source.start_with?("\n")
-
-          offense(operator, with_space, right_operand) do |msg|
-            add_offense(with_space, location: operator, message: msg)
-          end
-        end
-
-        def offense(operator, with_space, right_operand)
-          msg = offense_message(operator, with_space, right_operand)
-          yield msg if msg
-        end
-
-        def offense_message(operator, with_space, right_operand)
-          if operator.is?('**')
-            'Space around operator `**` detected.' unless with_space.is?('**')
-          elsif with_space.source !~ /^\s.*\s$/
-            "Surrounding space missing for operator `#{operator.source}`."
-          elsif excess_leading_space?(operator, with_space) ||
-                excess_trailing_space?(right_operand, with_space)
-            "Operator `#{operator.source}` should be surrounded " \
-            'by a single space.'
-          end
-        end
-
-        def excess_leading_space?(operator, with_space)
-          with_space.source.start_with?(EXCESSIVE_SPACE) &&
-            (!allow_for_alignment? || !aligned_with_operator?(operator))
-        end
-
-        def excess_trailing_space?(right_operand, with_space)
-          with_space.source.end_with?(EXCESSIVE_SPACE) &&
-            (!allow_for_alignment? || !aligned_with_something?(right_operand))
-        end
-
-        def align_hash_cop_config
-          config.for_cop('Layout/AlignHash')
-        end
-
-        def hash_table_style?
-          align_hash_cop_config &&
-            align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_before_block_braces.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks that block braces have or don't have a space before the opening
-      # brace depending on configuration.
-      #
-      # @example EnforcedStyle: space (default)
-      #   # bad
-      #   foo.map{ |a|
-      #     a.bar.to_s
-      #   }
-      #
-      #   # good
-      #   foo.map { |a|
-      #     a.bar.to_s
-      #   }
-      #
-      # @example EnforcedStyle: no_space
-      #   # bad
-      #   foo.map { |a|
-      #     a.bar.to_s
-      #   }
-      #
-      #   # good
-      #   foo.map{ |a|
-      #     a.bar.to_s
-      #   }
-      class SpaceBeforeBlockBraces < Cop
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-
-        MISSING_MSG = 'Space missing to the left of {.'.freeze
-        DETECTED_MSG = 'Space detected to the left of {.'.freeze
-
-        def self.autocorrect_incompatible_with
-          [Style::SymbolProc]
-        end
-
-        def on_block(node)
-          return if node.keywords?
-
-          left_brace = node.loc.begin
-          space_plus_brace = range_with_surrounding_space(range: left_brace)
-          used_style =
-            space_plus_brace.source.start_with?('{') ? :no_space : :space
-
-          if empty_braces?(node.loc)
-            check_empty(left_brace, space_plus_brace, used_style)
-          else
-            check_non_empty(left_brace, space_plus_brace, used_style)
-          end
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            case range.source
-            when /\s/ then corrector.remove(range)
-            else           corrector.insert_before(range, ' ')
-            end
-          end
-        end
-
-        private
-
-        def check_empty(left_brace, space_plus_brace, used_style)
-          return if style_for_empty_braces == used_style
-
-          config_to_allow_offenses['EnforcedStyleForEmptyBraces'] =
-            used_style.to_s
-
-          if style_for_empty_braces == :space
-            add_offense(left_brace, location: left_brace, message: MISSING_MSG)
-          else
-            space = range_between(space_plus_brace.begin_pos,
-                                  left_brace.begin_pos)
-            add_offense(space, location: space, message: DETECTED_MSG)
-          end
-        end
-
-        def check_non_empty(left_brace, space_plus_brace, used_style)
-          case used_style
-          when style  then correct_style_detected
-          when :space then space_detected(left_brace, space_plus_brace)
-          else             space_missing(left_brace)
-          end
-        end
-
-        def space_missing(left_brace)
-          add_offense(left_brace, location: left_brace, message: MISSING_MSG) do
-            opposite_style_detected
-          end
-        end
-
-        def space_detected(left_brace, space_plus_brace)
-          space = range_between(space_plus_brace.begin_pos,
-                                left_brace.begin_pos)
-          add_offense(space, location: space, message: DETECTED_MSG) do
-            opposite_style_detected
-          end
-        end
-
-        def style_for_empty_braces
-          case cop_config['EnforcedStyleForEmptyBraces']
-          when 'space'    then :space
-          when 'no_space' then :no_space
-          when nil then style
-          else raise 'Unknown EnforcedStyleForEmptyBraces selected!'
-          end
-        end
-
-        def empty_braces?(loc)
-          loc.begin.end_pos == loc.end.begin_pos
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_before_comma.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for comma (,) preceded by space.
-      #
-      # @example
-      #   # bad
-      #   [1 , 2 , 3]
-      #   a(1 , 2)
-      #   each { |a , b| }
-      #
-      #   # good
-      #   [1, 2, 3]
-      #   a(1, 2)
-      #   each { |a, b| }
-      class SpaceBeforeComma < Cop
-        include SpaceBeforePunctuation
-
-        def autocorrect(space)
-          PunctuationCorrector.remove_space(space)
-        end
-
-        def kind(token)
-          'comma' if token.comma?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_before_comment.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for missing space between a token and a comment on the
-      # same line.
-      #
-      # @example
-      #   # bad
-      #   1 + 1# this operation does ...
-      #
-      #   # good
-      #   1 + 1 # this operation does ...
-      class SpaceBeforeComment < Cop
-        MSG = 'Put a space before an end-of-line comment.'.freeze
-
-        def investigate(processed_source)
-          processed_source.tokens.each_cons(2) do |token1, token2|
-            next unless token2.comment?
-            next unless token1.line == token2.line
-
-            if token1.pos.end == token2.pos.begin
-              add_offense(token2.pos, location: token2.pos)
-            end
-          end
-        end
-
-        def autocorrect(range)
-          ->(corrector) { corrector.insert_before(range, ' ') }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_before_first_arg.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks that exactly one space is used between a method name and the
-      # first argument for method calls without parentheses.
-      #
-      # Alternatively, extra spaces can be added to align the argument with
-      # something on a preceding or following line, if the AllowForAlignment
-      # config parameter is true.
-      #
-      # @example
-      #   # bad
-      #   something  x
-      #   something   y, z
-      #   something'hello'
-      #
-      #   # good
-      #   something x
-      #   something y, z
-      #   something 'hello'
-      #
-      class SpaceBeforeFirstArg < Cop
-        include PrecedingFollowingAlignment
-        include RangeHelp
-
-        MSG = 'Put one space between the method name and ' \
-              'the first argument.'.freeze
-
-        def on_send(node)
-          return unless regular_method_call_with_arguments?(node)
-          return unless expect_params_after_method_name?(node)
-
-          first_arg = node.first_argument.source_range
-          first_arg_with_space = range_with_surrounding_space(range: first_arg,
-                                                              side: :left)
-          space = range_between(first_arg_with_space.begin_pos,
-                                first_arg.begin_pos)
-
-          add_offense(space, location: space) if space.length != 1
-        end
-        alias on_csend on_send
-
-        def autocorrect(range)
-          ->(corrector) { corrector.replace(range, ' ') }
-        end
-
-        private
-
-        def regular_method_call_with_arguments?(node)
-          node.arguments? && !node.operator_method? && !node.setter_method?
-        end
-
-        def expect_params_after_method_name?(node)
-          return false if node.parenthesized?
-
-          first_arg = node.first_argument
-
-          same_line?(first_arg, node) &&
-            !(allow_for_alignment? &&
-              aligned_with_something?(first_arg.source_range))
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_before_semicolon.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for semicolon (;) preceded by space.
-      #
-      # @example
-      #   # bad
-      #   x = 1 ; y = 2
-      #
-      #   # good
-      #   x = 1; y = 2
-      class SpaceBeforeSemicolon < Cop
-        include SpaceBeforePunctuation
-
-        def autocorrect(space)
-          PunctuationCorrector.remove_space(space)
-        end
-
-        def kind(token)
-          'semicolon' if token.semicolon?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_in_lambda_literal.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for spaces between `->` and opening parameter
-      # parenthesis (`(`) in lambda literals.
-      #
-      # @example EnforcedStyle: require_no_space (default)
-      #     # bad
-      #     a = -> (x, y) { x + y }
-      #
-      #     # good
-      #     a = ->(x, y) { x + y }
-      #
-      # @example EnforcedStyle: require_space
-      #     # bad
-      #     a = ->(x, y) { x + y }
-      #
-      #     # good
-      #     a = -> (x, y) { x + y }
-      class SpaceInLambdaLiteral < Cop
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-
-        ARROW = '->'.freeze
-        MSG_REQUIRE_SPACE = 'Use a space between `->` and ' \
-                            '`(` in lambda literals.'.freeze
-        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and ' \
-                               '`(` in lambda literals.'.freeze
-
-        def on_send(node)
-          return unless arrow_lambda_with_args?(node)
-
-          if style == :require_space && !space_after_arrow?(node)
-            add_offense(node,
-                        location: range_of_offense(node),
-                        message: MSG_REQUIRE_SPACE)
-          elsif style == :require_no_space && space_after_arrow?(node)
-            add_offense(node,
-                        location: range_of_offense(node),
-                        message: MSG_REQUIRE_NO_SPACE)
-          end
-        end
-
-        def autocorrect(lambda_node)
-          children = lambda_node.parent.children
-          lambda do |corrector|
-            if style == :require_space
-              corrector.insert_before(children[1].source_range, ' ')
-            else
-              space_range = range_between(children[0].source_range.end_pos,
-                                          children[1].source_range.begin_pos)
-              corrector.remove(space_range)
-            end
-          end
-        end
-
-        private
-
-        def arrow_lambda_with_args?(node)
-          lambda_node?(node) && arrow_form?(node) && args?(node)
-        end
-
-        def lambda_node?(node)
-          receiver, call = *node
-          receiver.nil? && call == :lambda
-        end
-
-        def arrow_form?(lambda_node)
-          lambda_node.loc.selector.source == ARROW
-        end
-
-        def args?(lambda_node)
-          _call, args, _body = *lambda_node.parent
-          !args.children.empty?
-        end
-
-        def space_after_arrow?(lambda_node)
-          arrow = lambda_node.parent.children[0]
-          parentheses = lambda_node.parent.children[1]
-          parentheses.source_range.begin_pos - arrow.source_range.end_pos > 0
-        end
-
-        def range_of_offense(node)
-          range_between(
-            node.parent.loc.expression.begin_pos,
-            node.parent.arguments.loc.expression.end_pos
-          )
-        end
-      end
-    end
-  end
-end