primary_connect_proto 0.20.0 → 0.22.0

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/redundant_freeze.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop check for uses of Object#freeze on immutable objects.
-      #
-      # @example
-      #   # bad
-      #   CONST = 1.freeze
-      #
-      #   # good
-      #   CONST = 1
-      class RedundantFreeze < Cop
-        include FrozenStringLiteral
-
-        MSG = 'Do not freeze immutable objects, as freezing them has no ' \
-              'effect.'.freeze
-
-        def on_send(node)
-          return unless node.receiver && node.method?(:freeze) &&
-                        (immutable_literal?(node.receiver) ||
-                         operation_produces_immutable_object?(node.receiver))
-
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.loc.dot)
-            corrector.remove(node.loc.selector)
-          end
-        end
-
-        private
-
-        def immutable_literal?(node)
-          node = strip_parenthesis(node)
-
-          return true if node.immutable_literal?
-
-          FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
-            frozen_string_literals_enabled?
-        end
-
-        def strip_parenthesis(node)
-          if node.begin_type? && node.children.first
-            node.children.first
-          else
-            node
-          end
-        end
-
-        def_node_matcher :operation_produces_immutable_object?, <<-PATTERN
-          {
-            (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
-            (begin (send _ {:+ :- :* :** :/ :%} {float int}))
-            (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
-            (send (const nil? :ENV) :[] _)
-            (send _ {:count :length :size} ...)
-            (block (send _ {:count :length :size} ...) ...)
-          }
-        PATTERN
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/redundant_parentheses.rb

@@ -1,222 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for redundant parentheses.
-      #
-      # @example
-      #
-      #   # bad
-      #   (x) if ((y.z).nil?)
-      #
-      #   # good
-      #   x if y.z.nil?
-      #
-      class RedundantParentheses < Cop
-        include Parentheses
-
-        ALLOWED_LITERALS = %i[irange erange].freeze
-
-        def_node_matcher :square_brackets?,
-                         '(send {(send _recv _msg) str array hash} :[] ...)'
-        def_node_matcher :range_end?, '^^{irange erange}'
-        def_node_matcher :method_node_and_args, '$(send _recv _msg $...)'
-        def_node_matcher :rescue?, '{^resbody ^^resbody}'
-        def_node_matcher :arg_in_call_with_block?,
-                         '^^(block (send _ _ equal?(%0) ...) ...)'
-
-        def on_begin(node)
-          return if !parentheses?(node) || parens_allowed?(node)
-
-          check(node)
-        end
-
-        def autocorrect(node)
-          ParenthesesCorrector.correct(node)
-        end
-
-        private
-
-        def parens_allowed?(node)
-          empty_parentheses?(node) ||
-            hash_literal_as_first_arg?(node) ||
-            rescue?(node) ||
-            allowed_expression?(node)
-        end
-
-        def allowed_expression?(node)
-          allowed_ancestor?(node) ||
-            allowed_method_call?(node) ||
-            allowed_array_or_hash_element?(node) ||
-            allowed_multiple_expression?(node)
-        end
-
-        def allowed_ancestor?(node)
-          # Don't flag `break(1)`, etc
-          keyword_ancestor?(node) && parens_required?(node)
-        end
-
-        def allowed_method_call?(node)
-          # Don't flag `method (arg) { }`
-          arg_in_call_with_block?(node) && !parentheses?(node.parent)
-        end
-
-        def allowed_multiple_expression?(node)
-          return false if node.children.one?
-
-          ancestor = node.ancestors.first
-          return false unless ancestor
-
-          !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
-        end
-
-        def empty_parentheses?(node)
-          # Don't flag `()`
-          node.children.empty?
-        end
-
-        def hash_literal_as_first_arg?(node)
-          # Don't flag `method ({key: value})`
-          node.children.first.hash_type? && first_argument?(node) &&
-            !parentheses?(node.parent)
-        end
-
-        def check(begin_node)
-          node = begin_node.children.first
-          if keyword_with_redundant_parentheses?(node)
-            return offense(begin_node, 'a keyword')
-          end
-          if disallowed_literal?(begin_node, node)
-            return offense(begin_node, 'a literal')
-          end
-          return offense(begin_node, 'a variable') if node.variable?
-          return offense(begin_node, 'a constant') if node.const_type?
-
-          check_send(begin_node, node) if node.send_type?
-        end
-
-        def check_send(begin_node, node)
-          return check_unary(begin_node, node) if node.unary_operation?
-
-          return unless method_call_with_redundant_parentheses?(node)
-          return if call_chain_starts_with_int?(begin_node, node)
-
-          offense(begin_node, 'a method call')
-        end
-
-        def check_unary(begin_node, node)
-          return if begin_node.chained?
-
-          node = node.children.first while suspect_unary?(node)
-
-          if node.send_type?
-            return unless method_call_with_redundant_parentheses?(node)
-          end
-
-          offense(begin_node, 'an unary operation')
-        end
-
-        def offense(node, msg)
-          add_offense(node, message: "Don't use parentheses around #{msg}.")
-        end
-
-        def suspect_unary?(node)
-          node.send_type? && node.unary_operation? && !node.prefix_not?
-        end
-
-        def keyword_ancestor?(node)
-          node.parent && node.parent.keyword?
-        end
-
-        def allowed_array_or_hash_element?(node)
-          # Don't flag
-          # ```
-          # { a: (1
-          #      ), }
-          # ```
-          (hash_element?(node) || array_element?(node)) &&
-            only_closing_paren_before_comma?(node)
-        end
-
-        def hash_element?(node)
-          node.parent && node.parent.pair_type?
-        end
-
-        def array_element?(node)
-          node.parent && node.parent.array_type?
-        end
-
-        def only_closing_paren_before_comma?(node)
-          source_buffer = node.source_range.source_buffer
-          line_range = source_buffer.line_range(node.loc.end.line)
-
-          line_range.source =~ /^\s*\)\s*,/
-        end
-
-        def disallowed_literal?(begin_node, node)
-          node.literal? &&
-            !ALLOWED_LITERALS.include?(node.type) &&
-            !raised_to_power_negative_numeric?(begin_node, node)
-        end
-
-        def raised_to_power_negative_numeric?(begin_node, node)
-          return false unless node.numeric_type?
-
-          siblings = begin_node.parent && begin_node.parent.children
-          return false if siblings.nil?
-
-          next_sibling = siblings[begin_node.sibling_index + 1]
-          base_value = node.children.first
-
-          base_value < 0 && next_sibling == :**
-        end
-
-        def keyword_with_redundant_parentheses?(node)
-          return false unless node.keyword?
-          return true if node.special_keyword?
-
-          args = *node
-
-          if only_begin_arg?(args)
-            parentheses?(args.first)
-          else
-            args.empty? || parentheses?(node)
-          end
-        end
-
-        def method_call_with_redundant_parentheses?(node)
-          return false unless node.send_type?
-          return false if node.prefix_not?
-          return false if range_end?(node)
-
-          send_node, args = method_node_and_args(node)
-
-          args.empty? || parentheses?(send_node) || square_brackets?(send_node)
-        end
-
-        def only_begin_arg?(args)
-          args.one? && args.first.begin_type?
-        end
-
-        def first_argument?(node)
-          first_send_argument?(node) || first_super_argument?(node)
-        end
-
-        def_node_matcher :first_send_argument?, <<-PATTERN
-          ^(send _ _ equal?(%0) ...)
-        PATTERN
-
-        def_node_matcher :first_super_argument?, <<-PATTERN
-          ^(super equal?(%0) ...)
-        PATTERN
-
-        def call_chain_starts_with_int?(begin_node, send_node)
-          recv = first_part_of_call_chain(send_node)
-          recv && recv.int_type? && (parent = begin_node.parent) &&
-            parent.send_type? && (parent.method?(:-@) || parent.method?(:+@))
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/redundant_return.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for redundant `return` expressions.
-      #
-      # @example
-      #   # These bad cases should be extended to handle methods whose body is
-      #   # if/else or a case expression with a default branch.
-      #
-      #   # bad
-      #   def test
-      #     return something
-      #   end
-      #
-      #   # bad
-      #   def test
-      #     one
-      #     two
-      #     three
-      #     return something
-      #   end
-      #
-      #   # good
-      #   def test
-      #     return something if something_else
-      #   end
-      #
-      #   # good
-      #   def test
-      #     if x
-      #     elsif y
-      #     else
-      #     end
-      #   end
-      #
-      class RedundantReturn < Cop
-        include RangeHelp
-
-        MSG = 'Redundant `return` detected.'.freeze
-        MULTI_RETURN_MSG = 'To return multiple values, use an array.'.freeze
-
-        def on_def(node)
-          return unless node.body
-
-          check_branch(node.body)
-        end
-        alias on_defs on_def
-
-        def autocorrect(node) # rubocop:disable Metrics/MethodLength
-          lambda do |corrector|
-            unless arguments?(node.children)
-              corrector.replace(node.source_range, 'nil')
-              next
-            end
-
-            return_value, = *node
-            if node.children.size > 1
-              add_brackets(corrector, node)
-            elsif return_value.hash_type?
-              add_braces(corrector, return_value) unless return_value.braces?
-            end
-            return_kw = range_with_surrounding_space(range: node.loc.keyword,
-                                                     side: :right)
-            corrector.remove(return_kw)
-          end
-        end
-
-        private
-
-        def add_brackets(corrector, node)
-          kids = node.children.map(&:source_range)
-          corrector.insert_before(kids.first, '[')
-          corrector.insert_after(kids.last, ']')
-        end
-
-        def add_braces(corrector, node)
-          kids = node.children.map(&:source_range)
-          corrector.insert_before(kids.first, '{')
-          corrector.insert_after(kids.last, '}')
-        end
-
-        def arguments?(args)
-          return false if args.empty?
-          return true if args.size > 1
-
-          !args.first.begin_type? || !args.first.children.empty?
-        end
-
-        # rubocop:disable Metrics/CyclomaticComplexity
-        def check_branch(node)
-          case node.type
-          when :return then check_return_node(node)
-          when :case   then check_case_node(node)
-          when :if     then check_if_node(node)
-          when :rescue, :resbody
-            check_rescue_node(node)
-          when :ensure then check_ensure_node(node)
-          when :begin, :kwbegin
-            check_begin_node(node)
-          end
-        end
-        # rubocop:enable Metrics/CyclomaticComplexity
-
-        def check_return_node(node)
-          return if cop_config['AllowMultipleReturnValues'] &&
-                    node.children.size > 1
-
-          add_offense(node, location: :keyword)
-        end
-
-        def check_case_node(node)
-          _cond, *when_nodes, else_node = *node
-          when_nodes.each { |when_node| check_when_node(when_node) }
-          check_branch(else_node) if else_node
-        end
-
-        def check_when_node(node)
-          return unless node
-
-          _cond, body = *node
-          check_branch(body) if body
-        end
-
-        def check_if_node(node)
-          return if node.modifier_form? || node.ternary?
-
-          _cond, if_node, else_node = *node.node_parts
-
-          check_branch(if_node) if if_node
-          check_branch(else_node) if else_node
-        end
-
-        def check_rescue_node(node)
-          node.child_nodes.each do |child_node|
-            check_branch(child_node)
-          end
-        end
-
-        def check_ensure_node(node)
-          rescue_node = node.node_parts[0]
-          check_branch(rescue_node)
-        end
-
-        def check_begin_node(node)
-          expressions = *node
-          last_expr = expressions.last
-
-          return unless last_expr && last_expr.return_type?
-
-          check_return_node(last_expr)
-        end
-
-        def allow_multiple_return_values?
-          cop_config['AllowMultipleReturnValues'] || false
-        end
-
-        def message(node)
-          if !allow_multiple_return_values? && node.children.size > 1
-            "#{MSG} #{MULTI_RETURN_MSG}"
-          else
-            MSG
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/redundant_self.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for redundant uses of `self`.
-      #
-      # The usage of `self` is only needed when:
-      #
-      # * Sending a message to same object with zero arguments in
-      #   presence of a method name clash with an argument or a local
-      #   variable.
-      #
-      # * Calling an attribute writer to prevent an local variable assignment.
-      #
-      # Note, with using explicit self you can only send messages with public or
-      # protected scope, you cannot send private messages this way.
-      #
-      # Note we allow uses of `self` with operators because it would be awkward
-      # otherwise.
-      #
-      # @example
-      #
-      #   # bad
-      #   def foo(bar)
-      #     self.baz
-      #   end
-      #
-      #   # good
-      #   def foo(bar)
-      #     self.bar  # Resolves name clash with the argument.
-      #   end
-      #
-      #   def foo
-      #     bar = 1
-      #     self.bar  # Resolves name clash with the local variable.
-      #   end
-      #
-      #   def foo
-      #     %w[x y z].select do |bar|
-      #       self.bar == bar  # Resolves name clash with argument of the block.
-      #     end
-      #   end
-      class RedundantSelf < Cop
-        MSG = 'Redundant `self` detected.'.freeze
-        KERNEL_METHODS = Kernel.methods(false)
-
-        def self.autocorrect_incompatible_with
-          [ColonMethodCall]
-        end
-
-        def initialize(config = nil, options = nil)
-          super
-          @allowed_send_nodes = []
-          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }
-        end
-
-        # Assignment of self.x
-
-        def on_or_asgn(node)
-          lhs, _rhs = *node
-          allow_self(lhs)
-        end
-        alias on_and_asgn on_or_asgn
-
-        def on_op_asgn(node)
-          lhs, _op, _rhs = *node
-          allow_self(lhs)
-        end
-
-        # Using self.x to distinguish from local variable x
-
-        def on_def(node)
-          add_scope(node)
-        end
-        alias on_defs on_def
-
-        def on_args(node)
-          node.children.each { |arg| on_argument(arg) }
-        end
-
-        def on_blockarg(node)
-          on_argument(node)
-        end
-
-        def on_lvasgn(node)
-          lhs, rhs = *node
-          @local_variables_scopes[rhs] << lhs
-        end
-
-        def on_send(node)
-          return unless node.self_receiver? && regular_method_call?(node)
-          return if node.parent && node.parent.mlhs_type?
-
-          return if allowed_send_node?(node)
-
-          add_offense(node)
-        end
-
-        def on_block(node)
-          add_scope(node, @local_variables_scopes[node])
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.receiver.source_range)
-            corrector.remove(node.loc.dot)
-          end
-        end
-
-        private
-
-        def add_scope(node, local_variables = [])
-          node.descendants.each do |child_node|
-            @local_variables_scopes[child_node] = local_variables
-          end
-        end
-
-        def allowed_send_node?(node)
-          @allowed_send_nodes.include?(node) ||
-            @local_variables_scopes[node].include?(node.method_name) ||
-            KERNEL_METHODS.include?(node.method_name)
-        end
-
-        def regular_method_call?(node)
-          !(node.operator_method? ||
-            keyword?(node.method_name) ||
-            node.camel_case_method? ||
-            node.setter_method? ||
-            node.implicit_call?)
-        end
-
-        def on_argument(node)
-          name, = *node
-          @local_variables_scopes[node] << name
-        end
-
-        def keyword?(method_name)
-          %i[alias and begin break case class def defined? do
-             else elsif end ensure false for if in module
-             next nil not or redo rescue retry return self
-             super then true undef unless until when while
-             yield __FILE__ __LINE__ __ENCODING__].include?(method_name)
-        end
-
-        def allow_self(node)
-          return unless node.send_type? && node.self_receiver?
-
-          @allowed_send_nodes << node
-        end
-      end
-    end
-  end
-end