primary_connect_proto 0.10.2 → 0.11.0

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

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # This module contains a collection of useful utility methods.
-    module Util
-      include PathUtil
-
-      # Match literal regex characters, not including anchors, character
-      # classes, alternatives, groups, repetitions, references, etc
-      LITERAL_REGEX =
-        /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]/.freeze
-
-      module_function
-
-      def comment_line?(line_source)
-        line_source =~ /^\s*#/
-      end
-
-      def line_range(node)
-        node.first_line..node.last_line
-      end
-
-      def parentheses?(node)
-        node.loc.respond_to?(:end) && node.loc.end &&
-          node.loc.end.is?(')'.freeze)
-      end
-
-      def on_node(syms, sexp, excludes = [], &block)
-        return to_enum(:on_node, syms, sexp, excludes) unless block_given?
-
-        yield sexp if Array(syms).include?(sexp.type)
-        return if Array(excludes).include?(sexp.type)
-
-        sexp.each_child_node { |elem| on_node(syms, elem, excludes, &block) }
-      end
-
-      def begins_its_line?(range)
-        (range.source_line =~ /\S/) == range.column
-      end
-
-      # Returns, for example, a bare `if` node if the given node is an `if`
-      # with calls chained to the end of it.
-      def first_part_of_call_chain(node)
-        while node
-          case node.type
-          when :send
-            receiver, _method_name, _args = *node
-            node = receiver
-          when :block
-            method, _args, _body = *node
-            node = method
-          else
-            break
-          end
-        end
-        node
-      end
-
-      # If converting a string to Ruby string literal source code, must
-      # double quotes be used?
-      def double_quotes_required?(string)
-        # Double quotes are required for strings which either:
-        # - Contain single quotes
-        # - Contain non-printable characters, which must use an escape
-
-        # Regex matches IF there is a ' or there is a \\ in the string that is
-        # not preceded/followed by another \\ (e.g. "\\x34") but not "\\\\".
-        string =~ /'|(?<! \\) \\{2}* \\ (?![\\"])/x
-      end
-
-      def needs_escaping?(string)
-        double_quotes_required?(escape_string(string))
-      end
-
-      def escape_string(string)
-        string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
-      end
-
-      def to_string_literal(string)
-        if needs_escaping?(string) && compatible_external_encoding_for?(string)
-          string.inspect
-        else
-          "'#{string.gsub('\\') { '\\\\' }}'"
-        end
-      end
-
-      def trim_string_interporation_escape_character(str)
-        str.gsub(/\\\#{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
-      end
-
-      def interpret_string_escapes(string)
-        StringInterpreter.interpret(string)
-      end
-
-      def same_line?(node1, node2)
-        node1.respond_to?(:loc) &&
-          node2.respond_to?(:loc) &&
-          node1.loc.line == node2.loc.line
-      end
-
-      def to_supported_styles(enforced_style)
-        enforced_style
-          .sub(/^Enforced/, 'Supported')
-          .sub('Style', 'Styles')
-      end
-
-      def tokens(node)
-        @tokens ||= {}
-        return @tokens[node.object_id] if @tokens[node.object_id]
-
-        source_range = node.source_range
-        begin_pos = source_range.begin_pos
-        end_pos = source_range.end_pos
-
-        @tokens[node.object_id] = processed_source.tokens.select do |token|
-          token.end_pos <= end_pos && token.begin_pos >= begin_pos
-        end
-      end
-
-      private
-
-      def compatible_external_encoding_for?(src)
-        src = src.dup if RUBY_VERSION < '2.3' || RUBY_ENGINE == 'jruby'
-        src.force_encoding(Encoding.default_external).valid_encoding?
-      end
-    end
-  end
-end

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

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    class VariableForce
-      # This class represents each assignment of a variable.
-      class Assignment
-        include Branchable
-
-        MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
-
-        attr_reader :node, :variable, :referenced, :references
-        alias referenced? referenced
-
-        def initialize(node, variable)
-          unless VARIABLE_ASSIGNMENT_TYPES.include?(node.type)
-            raise ArgumentError,
-                  "Node type must be any of #{VARIABLE_ASSIGNMENT_TYPES}, " \
-                  "passed #{node.type}"
-          end
-
-          @node = node
-          @variable = variable
-          @referenced = false
-          @references = []
-        end
-
-        def name
-          @node.children.first
-        end
-
-        def scope
-          @variable.scope
-        end
-
-        def reference!(node)
-          @references << node
-          @referenced = true
-        end
-
-        def used?
-          @variable.captured_by_block? || @referenced
-        end
-
-        def regexp_named_capture?
-          @node.type == REGEXP_NAMED_CAPTURE_TYPE
-        end
-
-        def operator_assignment?
-          return false unless meta_assignment_node
-
-          OPERATOR_ASSIGNMENT_TYPES.include?(meta_assignment_node.type)
-        end
-
-        def multiple_assignment?
-          return false unless meta_assignment_node
-
-          meta_assignment_node.type == MULTIPLE_ASSIGNMENT_TYPE
-        end
-
-        def operator
-          assignment_node = meta_assignment_node || @node
-          assignment_node.loc.operator.source
-        end
-
-        def meta_assignment_node
-          unless instance_variable_defined?(:@meta_assignment_node)
-            @meta_assignment_node =
-              operator_assignment_node || multiple_assignment_node
-          end
-
-          @meta_assignment_node
-        end
-
-        private
-
-        def operator_assignment_node
-          return nil unless node.parent
-          return nil unless OPERATOR_ASSIGNMENT_TYPES.include?(node.parent.type)
-          return nil unless node.sibling_index.zero?
-
-          node.parent
-        end
-
-        def multiple_assignment_node
-          grandparent_node = node.parent ? node.parent.parent : nil
-          return nil unless grandparent_node
-          return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
-          return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
-
-          grandparent_node
-        end
-      end
-    end
-  end
-end

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

@@ -1,322 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    class VariableForce
-      # Namespace for branch classes for each control structure.
-      module Branch
-        def self.of(target_node, scope: nil)
-          ([target_node] + target_node.ancestors).each do |node|
-            return nil unless node.parent
-            return nil unless scope.include?(node)
-
-            klass = CLASSES_BY_TYPE[node.parent.type]
-            next unless klass
-
-            branch = klass.new(node, scope)
-            return branch if branch.branched?
-          end
-
-          nil
-        end
-
-        # rubocop:disable Metrics/BlockLength
-
-        # Abstract base class for branch classes.
-        # A branch represents a conditional branch in a scope.
-        #
-        # @example
-        #   def some_scope
-        #     do_something     # no branch
-        #
-        #     if foo
-        #       do_something   # branch A
-        #       do_something   # branch A
-        #     else
-        #       do_something   # branch B
-        #       if bar
-        #         do_something # branch C (whose parent is branch B)
-        #       end
-        #     end
-        #
-        #     do_something     # no branch
-        #   end
-        Base = Struct.new(:child_node, :scope) do
-          # rubocop:enable Metrics/BlockLength
-
-          def self.classes
-            @classes ||= []
-          end
-
-          def self.inherited(subclass)
-            classes << subclass
-          end
-
-          def self.type
-            name.split('::').last.gsub(/(.)([A-Z])/, '\1_\2').downcase.to_sym
-          end
-
-          def self.define_predicate(name, child_index: nil)
-            define_method(name) do
-              target_node = control_node.children[child_index]
-
-              # We don't use Kernel#Array here
-              # because it invokes Node#to_a rather than wrapping with an array.
-              if target_node.is_a?(Array)
-                target_node.any? { |node| node.equal?(child_node) }
-              else
-                target_node.equal?(child_node)
-              end
-            end
-          end
-
-          def control_node
-            child_node.parent
-          end
-
-          def parent
-            return @parent if instance_variable_defined?(:@parent)
-
-            @branch = Branch.of(control_node, scope: scope)
-          end
-
-          def each_ancestor(include_self: false, &block)
-            unless block_given?
-              return to_enum(__method__, include_self: include_self)
-            end
-
-            yield self if include_self
-            scan_ancestors(&block)
-            self
-          end
-
-          def branched?
-            !always_run?
-          end
-
-          def always_run?
-            raise NotImplementedError
-          end
-
-          def may_jump_to_other_branch?
-            false
-          end
-
-          def may_run_incompletely?
-            false
-          end
-
-          def exclusive_with?(other)
-            return false unless other
-            return false if may_jump_to_other_branch?
-
-            other.each_ancestor(include_self: true) do |other_ancestor|
-              if control_node.equal?(other_ancestor.control_node)
-                return !child_node.equal?(other_ancestor.child_node)
-              end
-            end
-
-            if parent
-              parent.exclusive_with?(other)
-            else
-              false
-            end
-          end
-
-          def ==(other)
-            return false unless other
-
-            control_node.equal?(other.control_node) &&
-              child_node.equal?(other.child_node)
-          end
-
-          alias_method :eql?, :==
-
-          def hash
-            control_node.object_id.hash ^ child_node.object_id.hash
-          end
-
-          private
-
-          def scan_ancestors
-            branch = self
-
-            while (branch = branch.parent)
-              yield branch
-            end
-          end
-        end
-
-        # Mix-in module for simple conditional control structures.
-        module SimpleConditional
-          def conditional_clause?
-            raise NotImplementedError
-          end
-
-          def always_run?
-            conditional_clause?
-          end
-        end
-
-        # if conditional_clause
-        #   truthy_body
-        # else
-        #   falsey_body
-        # end
-        #
-        # unless conditional_clause
-        #   falsey_body
-        # else
-        #   truthy_body
-        # end
-        class If < Base
-          include SimpleConditional
-
-          define_predicate :conditional_clause?, child_index: 0
-          define_predicate :truthy_body?,        child_index: 1
-          define_predicate :falsey_body?,        child_index: 2
-        end
-
-        # while conditional_clause
-        #   loop_body
-        # end
-        class While < Base
-          include SimpleConditional
-
-          define_predicate :conditional_clause?, child_index: 0
-          define_predicate :loop_body?,          child_index: 1
-        end
-
-        # until conditional_clause
-        #   loop_body
-        # end
-        class Until < Base
-          include SimpleConditional
-
-          define_predicate :conditional_clause?, child_index: 0
-          define_predicate :loop_body?,          child_index: 1
-        end
-
-        # begin
-        #   loop_body
-        # end while conditional_clause
-        class WhilePost < Base
-          include SimpleConditional
-
-          define_predicate :conditional_clause?, child_index: 0
-          define_predicate :loop_body?,          child_index: 1
-        end
-
-        # begin
-        #   loop_body
-        # end until conditional_clause
-        class UntilPost < Base
-          include SimpleConditional
-
-          define_predicate :conditional_clause?, child_index: 0
-          define_predicate :loop_body?,          child_index: 1
-        end
-
-        # case target
-        # when /pattern/ # when_clause
-        # else
-        #   else_body
-        # end
-        class Case < Base
-          define_predicate :target?,      child_index: 0
-          define_predicate :when_clause?, child_index: 1..-2
-          define_predicate :else_body?,   child_index: -1
-
-          def always_run?
-            target?
-          end
-        end
-
-        # for element in collection
-        #   loop_body
-        # end
-        class For < Base
-          define_predicate :element?,    child_index: 0
-          define_predicate :collection?, child_index: 1
-          define_predicate :loop_body?,  child_index: 2
-
-          def always_run?
-            element? || collection?
-          end
-        end
-
-        # Mix-in module for logical operator control structures.
-        module LogicalOperator
-          def always_run?
-            left_body?
-          end
-        end
-
-        # left_body && right_body
-        class And < Base
-          include LogicalOperator
-
-          define_predicate :left_body?,  child_index: 0
-          define_predicate :right_body?, child_index: 1
-        end
-
-        # left_body || right_body
-        class Or < Base
-          include LogicalOperator
-
-          define_predicate :left_body?,  child_index: 0
-          define_predicate :right_body?, child_index: 1
-        end
-
-        # Mix-in module for exception handling control structures.
-        module ExceptionHandler
-          def may_jump_to_other_branch?
-            main_body?
-          end
-
-          def may_run_incompletely?
-            main_body?
-          end
-        end
-
-        #   begin
-        #     main_body
-        #   rescue StandardError => error # rescue_clause
-        #   else
-        #     else_body
-        #   end
-        class Rescue < Base
-          include ExceptionHandler
-
-          define_predicate :main_body?,     child_index: 0
-          define_predicate :rescue_clause?, child_index: 1..-2
-          define_predicate :else_body?,     child_index: -1
-
-          def always_run?
-            false
-          end
-        end
-
-        #   begin
-        #     main_body
-        #   ensure
-        #     ensure_body
-        #   end
-        class Ensure < Base
-          include ExceptionHandler
-
-          define_predicate :main_body?,   child_index: 0
-          define_predicate :ensure_body?, child_index: -1
-
-          def always_run?
-            ensure_body?
-          end
-        end
-
-        CLASSES_BY_TYPE = Base.classes.each_with_object({}) do |klass, classes|
-          classes[klass.type] = klass
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    class VariableForce
-      # Mix-in module for classes which own a node and need branch information
-      # of the node. The user classes must implement #node and #scope.
-      module Branchable
-        def branch
-          return @branch if instance_variable_defined?(:@branch)
-
-          @branch = Branch.of(node, scope: scope)
-        end
-
-        def run_exclusively_with?(other)
-          return false if !branch || !other.branch
-
-          branch.exclusive_with?(other.branch)
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    class VariableForce
-      # This class represents each reference of a variable.
-      class Reference
-        include Branchable
-
-        VARIABLE_REFERENCE_TYPES = (
-          [VARIABLE_REFERENCE_TYPE] +
-          OPERATOR_ASSIGNMENT_TYPES +
-          [ZERO_ARITY_SUPER_TYPE, SEND_TYPE]
-        ).freeze
-
-        attr_reader :node, :scope
-
-        def initialize(node, scope)
-          unless VARIABLE_REFERENCE_TYPES.include?(node.type)
-            raise ArgumentError,
-                  "Node type must be any of #{VARIABLE_REFERENCE_TYPES}, " \
-                  "passed #{node.type}"
-          end
-
-          @node = node
-          @scope = scope
-        end
-
-        # There's an implicit variable reference by the zero-arity `super`:
-        #
-        #     def some_method(foo)
-        #       super
-        #     end
-        #
-        # Another case is `binding`:
-        #
-        #     def some_method(foo)
-        #       do_something(binding)
-        #     end
-        #
-        # In these cases, the variable `foo` is not explicitly referenced,
-        # but it can be considered used implicitly by the `super` or `binding`.
-        def explicit?
-          ![ZERO_ARITY_SUPER_TYPE, SEND_TYPE].include?(@node.type)
-        end
-      end
-    end
-  end
-end