primary_connect_proto 0.20.0 → 0.22.0

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/unless_else.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop looks for *unless* expressions with *else* clauses.
-      #
-      # @example
-      #   # bad
-      #   unless foo_bar.nil?
-      #     # do something...
-      #   else
-      #     # do a different thing...
-      #   end
-      #
-      #   # good
-      #   if foo_bar.present?
-      #     # do something...
-      #   else
-      #     # do a different thing...
-      #   end
-      class UnlessElse < Cop
-        include RangeHelp
-
-        MSG = 'Do not use `unless` with `else`. Rewrite these with the ' \
-              'positive case first.'.freeze
-
-        def on_if(node)
-          return unless node.unless? && node.else?
-
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          condition, = *node
-          body_range = range_between_condition_and_else(node, condition)
-          else_range = range_between_else_and_end(node)
-
-          lambda do |corrector|
-            corrector.replace(node.loc.keyword, 'if'.freeze)
-            corrector.replace(body_range, else_range.source)
-            corrector.replace(else_range, body_range.source)
-          end
-        end
-
-        def range_between_condition_and_else(node, condition)
-          range_between(condition.source_range.end_pos, node.loc.else.begin_pos)
-        end
-
-        def range_between_else_and_end(node)
-          range_between(node.loc.else.end_pos, node.loc.end.begin_pos)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/unneeded_capital_w.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for usage of the %W() syntax when %w() would do.
-      #
-      # @example
-      #   # bad
-      #   %W(cat dog pig)
-      #   %W[door wall floor]
-      #
-      #   # good
-      #   %w/swim run bike/
-      #   %w[shirt pants shoes]
-      #   %W(apple #{fruit} grape)
-      class UnneededCapitalW < Cop
-        include PercentLiteral
-
-        MSG = 'Do not use `%W` unless interpolation is needed. ' \
-              'If not, use `%w`.'.freeze
-
-        def on_array(node)
-          process(node, '%W')
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            src = node.loc.begin.source
-            corrector.replace(node.loc.begin, src.tr('W', 'w'))
-          end
-        end
-
-        private
-
-        def on_percent_literal(node)
-          return if requires_interpolation?(node)
-
-          add_offense(node)
-        end
-
-        def requires_interpolation?(node)
-          node.child_nodes.any? do |string|
-            string.dstr_type? ||
-              double_quotes_required?(string.source)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/unneeded_condition.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for unnecessary conditional expressions.
-      #
-      # @example
-      #   # bad
-      #   a = b ? b : c
-      #
-      #   # good
-      #   a = b || c
-      #
-      # @example
-      #   # bad
-      #   if b
-      #     b
-      #   else
-      #     c
-      #   end
-      #
-      #   # good
-      #   b || c
-      #
-      #   # good
-      #   if b
-      #     b
-      #   elsif cond
-      #     c
-      #   end
-      #
-      class UnneededCondition < Cop
-        include RangeHelp
-
-        MSG = 'Use double pipes `||` instead.'.freeze
-        UNNEEDED_CONDITION = 'This condition is not needed.'.freeze
-
-        def on_if(node)
-          return if node.elsif_conditional?
-          return unless offense?(node)
-
-          add_offense(node, location: range_of_offense(node))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.ternary?
-              corrector.replace(range_of_offense(node), '||')
-            elsif node.modifier_form? || !node.else_branch
-              corrector.replace(node.source_range, node.if_branch.source)
-            else
-              corrected = make_ternary_form(node)
-
-              corrector.replace(node.source_range, corrected)
-            end
-          end
-        end
-
-        private
-
-        def message(node)
-          if node.modifier_form? || !node.else_branch
-            UNNEEDED_CONDITION
-          else
-            MSG
-          end
-        end
-
-        def range_of_offense(node)
-          return :expression unless node.ternary?
-
-          range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
-        end
-
-        def offense?(node)
-          condition, if_branch, else_branch = *node
-
-          return false if use_if_branch?(else_branch)
-
-          condition == if_branch && !node.elsif? && (
-            node.ternary? ||
-            !else_branch.instance_of?(AST::Node) ||
-            else_branch.single_line?
-          )
-        end
-
-        def use_if_branch?(else_branch)
-          else_branch && else_branch.if_type?
-        end
-
-        def else_source(else_branch)
-          wrap_else =
-            else_branch.basic_conditional? && else_branch.modifier_form?
-          wrap_else ? "(#{else_branch.source})" : else_branch.source
-        end
-
-        def make_ternary_form(node)
-          _condition, if_branch, else_branch = *node
-          ternary_form = [if_branch.source,
-                          else_source(else_branch)].join(' || ')
-
-          if node.parent && node.parent.send_type?
-            "(#{ternary_form})"
-          else
-            ternary_form
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/unneeded_interpolation.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for strings that are just an interpolated expression.
-      #
-      # @example
-      #
-      #   # bad
-      #   "#{@var}"
-      #
-      #   # good
-      #   @var.to_s
-      #
-      #   # good if @var is already a String
-      #   @var
-      class UnneededInterpolation < Cop
-        include PercentLiteral
-
-        MSG = 'Prefer `to_s` over string interpolation.'.freeze
-
-        def self.autocorrect_incompatible_with
-          [Style::LineEndConcatenation]
-        end
-
-        def on_dstr(node)
-          add_offense(node) if single_interpolation?(node)
-        end
-
-        def autocorrect(node)
-          embedded_node = node.children.first
-
-          if variable_interpolation?(embedded_node)
-            autocorrect_variable_interpolation(embedded_node, node)
-          elsif single_variable_interpolation?(embedded_node)
-            autocorrect_single_variable_interpolation(embedded_node, node)
-          else
-            autocorrect_other(embedded_node, node)
-          end
-        end
-
-        private
-
-        def single_interpolation?(node)
-          node.children.one? &&
-            interpolation?(node.children.first) &&
-            !implicit_concatenation?(node) &&
-            !embedded_in_percent_array?(node)
-        end
-
-        def single_variable_interpolation?(node)
-          node.children.one? && variable_interpolation?(node.children.first)
-        end
-
-        def interpolation?(node)
-          variable_interpolation?(node) || node.begin_type?
-        end
-
-        def variable_interpolation?(node)
-          node.variable? || node.reference?
-        end
-
-        def implicit_concatenation?(node)
-          node.parent && node.parent.dstr_type?
-        end
-
-        def embedded_in_percent_array?(node)
-          node.parent && node.parent.array_type? &&
-            percent_literal?(node.parent)
-        end
-
-        def autocorrect_variable_interpolation(embedded_node, node)
-          replacement = "#{embedded_node.loc.expression.source}.to_s"
-          ->(corrector) { corrector.replace(node.loc.expression, replacement) }
-        end
-
-        def autocorrect_single_variable_interpolation(embedded_node, node)
-          variable_loc = embedded_node.children.first.loc
-          replacement = "#{variable_loc.expression.source}.to_s"
-          ->(corrector) { corrector.replace(node.loc.expression, replacement) }
-        end
-
-        def autocorrect_other(embedded_node, node)
-          loc = node.loc
-          embedded_loc = embedded_node.loc
-
-          lambda do |corrector|
-            corrector.replace(loc.begin, '')
-            corrector.replace(loc.end, '')
-            corrector.replace(embedded_loc.begin, '(')
-            corrector.replace(embedded_loc.end, ').to_s')
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/unneeded_percent_q.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for usage of the %q/%Q syntax when '' or "" would do.
-      #
-      # @example
-      #
-      #   # bad
-      #   name = %q(Bruce Wayne)
-      #   time = %q(8 o'clock)
-      #   question = %q("What did you say?")
-      #
-      #   # good
-      #   name = 'Bruce Wayne'
-      #   time = "8 o'clock"
-      #   question = '"What did you say?"'
-      #
-      class UnneededPercentQ < Cop
-        MSG = 'Use `%<q_type>s` only for strings that contain both ' \
-              'single quotes and double quotes%<extra>s.'.freeze
-        DYNAMIC_MSG = ', or for dynamic strings that contain ' \
-                      'double quotes'.freeze
-        SINGLE_QUOTE = "'".freeze
-        QUOTE = '"'.freeze
-        EMPTY = ''.freeze
-        PERCENT_Q = '%q'.freeze
-        PERCENT_CAPITAL_Q = '%Q'.freeze
-        STRING_INTERPOLATION_REGEXP = /#\{.+}/.freeze
-        ESCAPED_NON_BACKSLASH = /\\[^\\]/.freeze
-
-        def on_dstr(node)
-          return unless string_literal?(node)
-
-          check(node)
-        end
-
-        def on_str(node)
-          # Interpolated strings that contain more than just interpolation
-          # will call `on_dstr` for the entire string and `on_str` for the
-          # non interpolated portion of the string
-          return unless string_literal?(node)
-
-          check(node)
-        end
-
-        def autocorrect(node)
-          delimiter =
-            node.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, delimiter)
-            corrector.replace(node.loc.end, delimiter)
-          end
-        end
-
-        private
-
-        def check(node)
-          return unless start_with_percent_q_variant?(node)
-          return if interpolated_quotes?(node) || allowed_percent_q?(node)
-
-          add_offense(node)
-        end
-
-        def interpolated_quotes?(node)
-          node.source.include?(SINGLE_QUOTE) && node.source.include?(QUOTE)
-        end
-
-        def allowed_percent_q?(node)
-          node.source.start_with?(PERCENT_Q) && acceptable_q?(node) ||
-            node.source.start_with?(PERCENT_CAPITAL_Q) &&
-              acceptable_capital_q?(node)
-        end
-
-        def message(node)
-          src = node.source
-          extra = if src.start_with?(PERCENT_CAPITAL_Q)
-                    DYNAMIC_MSG
-                  else
-                    EMPTY
-                  end
-          format(MSG, q_type: src[0, 2], extra: extra)
-        end
-
-        def string_literal?(node)
-          node.loc.respond_to?(:begin) && node.loc.respond_to?(:end) &&
-            node.loc.begin && node.loc.end
-        end
-
-        def start_with_percent_q_variant?(string)
-          string.source.start_with?(PERCENT_Q, PERCENT_CAPITAL_Q)
-        end
-
-        def acceptable_q?(node)
-          src = node.source
-
-          return true if src =~ STRING_INTERPOLATION_REGEXP
-
-          src.scan(/\\./).any? { |s| s =~ ESCAPED_NON_BACKSLASH }
-        end
-
-        def acceptable_capital_q?(node)
-          src = node.source
-          src.include?(QUOTE) &&
-            (src =~ STRING_INTERPOLATION_REGEXP ||
-            (node.str_type? && double_quotes_required?(src)))
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/unpack_first.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for accessing the first element of `String#unpack`
-      # which can be replaced with the shorter method `unpack1`.
-      #
-      # @example
-      #
-      #   # bad
-      #   'foo'.unpack('h*').first
-      #   'foo'.unpack('h*')[0]
-      #   'foo'.unpack('h*').slice(0)
-      #   'foo'.unpack('h*').at(0)
-      #
-      #   # good
-      #   'foo'.unpack1('h*')
-      #
-      class UnpackFirst < Cop
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.4
-
-        MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
-          '`%<receiver>s.unpack(%<format>s)%<method>s`.'.freeze
-
-        def_node_matcher :unpack_and_first_element?, <<-PATTERN
-          {
-            (send $(send (...) :unpack $(...)) :first)
-            (send $(send (...) :unpack $(...)) {:[] :slice :at} (int 0))
-          }
-        PATTERN
-
-        def on_send(node)
-          unpack_and_first_element?(node) do |unpack_call, unpack_arg|
-            range = first_element_range(node, unpack_call)
-            message = format(MSG,
-                             receiver: unpack_call.receiver.source,
-                             format: unpack_arg.source,
-                             method: range.source)
-            add_offense(node, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          unpack_and_first_element?(node) do |unpack_call, _unpack_arg|
-            lambda do |corrector|
-              corrector.remove(first_element_range(node, unpack_call))
-              corrector.replace(unpack_call.loc.selector, 'unpack1')
-            end
-          end
-        end
-
-        private
-
-        def first_element_range(node, unpack_call)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    unpack_call.loc.expression.end_pos,
-                                    node.loc.expression.end_pos)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/variable_interpolation.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for variable interpolation (like "#@ivar").
-      #
-      # @example
-      #   # bad
-      #   "His name is #$name"
-      #   /check #$pattern/
-      #   "Let's go to the #@store"
-      #
-      #   # good
-      #   "His name is #{$name}"
-      #   /check #{$pattern}/
-      #   "Let's go to the #{@store}"
-      class VariableInterpolation < Cop
-        MSG = 'Replace interpolated variable `%<variable>s` ' \
-              'with expression `#{%<variable>s}`.'.freeze
-
-        def on_dstr(node)
-          check_for_interpolation(node)
-        end
-
-        def on_regexp(node)
-          check_for_interpolation(node)
-        end
-
-        def on_xstr(node)
-          check_for_interpolation(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, "{#{node.source}}")
-          end
-        end
-
-        private
-
-        def check_for_interpolation(node)
-          var_nodes(node.children).each do |var_node|
-            add_offense(var_node)
-          end
-        end
-
-        def message(node)
-          format(MSG, variable: node.source)
-        end
-
-        def var_nodes(nodes)
-          nodes.select { |n| n.variable? || n.reference? }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/when_then.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for *when;* uses in *case* expressions.
-      #
-      # @example
-      #   # bad
-      #   case foo
-      #   when 1; 'baz'
-      #   when 2; 'bar'
-      #   end
-      #
-      #   # good
-      #   case foo
-      #   when 1 then 'baz'
-      #   when 2 then 'bar'
-      #   end
-      class WhenThen < Cop
-        MSG = 'Do not use `when x;`. Use `when x then` instead.'.freeze
-
-        def on_when(node)
-          return if node.multiline? || node.then? || !node.body
-
-          add_offense(node, location: :begin)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, ' then')
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/while_until_do.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for uses of `do` in multi-line `while/until` statements.
-      #
-      # @example
-      #
-      #   # bad
-      #   while x.any? do
-      #     do_something(x.pop)
-      #   end
-      #
-      #   # good
-      #   while x.any?
-      #     do_something(x.pop)
-      #   end
-      #
-      # @example
-      #
-      #   # bad
-      #   until x.empty? do
-      #     do_something(x.pop)
-      #   end
-      #
-      #   # good
-      #   until x.empty?
-      #     do_something(x.pop)
-      #   end
-      class WhileUntilDo < Cop
-        MSG = 'Do not use `do` with multi-line `%<keyword>s`.'.freeze
-
-        def on_while(node)
-          handle(node)
-        end
-
-        def on_until(node)
-          handle(node)
-        end
-
-        def handle(node)
-          return unless node.multiline? && node.do?
-
-          add_offense(node, location: :begin,
-                            message: format(MSG, keyword: node.keyword))
-        end
-
-        def autocorrect(node)
-          do_range = node.condition.source_range.end.join(node.loc.begin)
-
-          lambda do |corrector|
-            corrector.remove(do_range)
-          end
-        end
-      end
-    end
-  end
-end