primary_connect_proto 0.12.1 → 0.14.0

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking `rescue` nodes.
-    module RescueNode
-      def investigate(processed_source)
-        @modifier_locations = processed_source
-                              .tokens
-                              .select(&:rescue_modifier?)
-                              .map(&:pos)
-      end
-
-      private
-
-      def rescue_modifier?(node)
-        node &&
-          node.resbody_type? &&
-          @modifier_locations.include?(node.loc.keyword)
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for safe assignment. By safe assignment we mean
-    # putting parentheses around an assignment to indicate "I know I'm using an
-    # assignment as a condition. It's not a mistake."
-    module SafeAssignment
-      extend NodePattern::Macros
-
-      private
-
-      def_node_matcher :empty_condition?, '(begin)'
-      def_node_matcher :setter_method?, '[(send ...) setter_method?]'
-      def_node_matcher :safe_assignment?,
-                       '(begin {equals_asgn? #setter_method?})'
-
-      def safe_assignment_allowed?
-        cop_config['AllowSafeAssignment']
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for Rails safe mode.
-    module SafeMode
-      private
-
-      def rails_safe_mode?
-        safe_mode? || rails?
-      end
-
-      def safe_mode?
-        cop_config['SafeMode']
-      end
-
-      def rails?
-        config['Rails'] && config['Rails'].fetch('Enabled')
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for cops checking for missing space after
-    # punctuation.
-    module SpaceAfterPunctuation
-      MSG = 'Space missing after %<token>s.'.freeze
-
-      def investigate(processed_source)
-        each_missing_space(processed_source.tokens) do |token|
-          add_offense(token, location: token.pos,
-                             message: format(MSG, token: kind(token)))
-        end
-      end
-
-      private
-
-      def each_missing_space(tokens)
-        tokens.each_cons(2) do |token1, token2|
-          next unless kind(token1)
-          next unless space_missing?(token1, token2)
-          next unless space_required_before?(token2)
-
-          yield token1
-        end
-      end
-
-      def space_missing?(token1, token2)
-        token1.line == token2.line &&
-          token2.column == token1.column + offset
-      end
-
-      def space_required_before?(token)
-        !(allowed_type?(token) ||
-          (token.right_curly_brace? && space_forbidden_before_rcurly?))
-      end
-
-      def allowed_type?(token)
-        %i[tRPAREN tRBRACK tPIPE].include?(token.type)
-      end
-
-      def space_forbidden_before_rcurly?
-        style = space_style_before_rcurly
-        style == 'no_space'
-      end
-
-      # The normal offset, i.e., the distance from the punctuation
-      # token where a space should be, is 1.
-      def offset
-        1
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for cops checking for space before
-    # punctuation.
-    module SpaceBeforePunctuation
-      include RangeHelp
-
-      MSG = 'Space found before %<token>s.'.freeze
-
-      def investigate(processed_source)
-        each_missing_space(processed_source.tokens) do |token, pos_before|
-          add_offense(pos_before, location: pos_before,
-                                  message: format(MSG, token: kind(token)))
-        end
-      end
-
-      private
-
-      def each_missing_space(tokens)
-        tokens.each_cons(2) do |token1, token2|
-          next unless kind(token2)
-          next unless space_missing?(token1, token2)
-          next if space_required_after?(token1)
-
-          pos_before_punctuation = range_between(token1.end_pos,
-                                                 token2.begin_pos)
-
-          yield token2, pos_before_punctuation
-        end
-      end
-
-      def space_missing?(token1, token2)
-        token1.line == token2.line && token2.begin_pos > token1.end_pos
-      end
-
-      def space_required_after?(token)
-        token.left_curly_brace? && space_required_after_lcurly?
-      end
-
-      def space_required_after_lcurly?
-        cfg = config.for_cop('Layout/SpaceInsideBlockBraces')
-        style = cfg['EnforcedStyle'] || 'space'
-        style == 'space'
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for modifier cops.
-    module StatementModifier
-      private
-
-      def single_line_as_modifier?(node)
-        return false if non_eligible_node?(node) ||
-                        non_eligible_body?(node.body) ||
-                        non_eligible_condition?(node.condition)
-
-        modifier_fits_on_single_line?(node)
-      end
-
-      def non_eligible_node?(node)
-        node.nonempty_line_count > 3 ||
-          !node.modifier_form? &&
-            processed_source.commented?(node.loc.end)
-      end
-
-      def non_eligible_body?(body)
-        body.nil? ||
-          body.empty_source? ||
-          body.begin_type? ||
-          processed_source.commented?(body.source_range)
-      end
-
-      def non_eligible_condition?(condition)
-        condition.each_node.any?(&:lvasgn_type?)
-      end
-
-      def modifier_fits_on_single_line?(node)
-        return true unless max_line_length
-
-        modifier_length = length_in_modifier_form(node, node.condition,
-                                                  node.body.source_length)
-
-        modifier_length <= max_line_length
-      end
-
-      def length_in_modifier_form(node, cond, body_length)
-        indentation = node.loc.keyword.column * indentation_multiplier
-        kw_length = node.loc.keyword.size
-        cond_length = cond.source_range.size
-        space = 1
-        indentation + body_length + space + kw_length + space + cond_length
-      end
-
-      def max_line_length
-        return unless config.for_cop('Metrics/LineLength')['Enabled']
-
-        config.for_cop('Metrics/LineLength')['Max']
-      end
-
-      def indentation_multiplier
-        return 1 if config.for_cop('Layout/Tab')['Enabled']
-
-        default_configuration = RuboCop::ConfigLoader.default_configuration
-        config.for_cop('Layout/Tab')['IndentationWidth'] ||
-          config.for_cop('Layout/IndentationWidth')['Width'] ||
-          default_configuration.for_cop('Layout/Tab')['IndentationWidth'] ||
-          default_configuration.for_cop('Layout/IndentationWidth')['Width']
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Classes that include this module just implement functions to determine
-    # what is an offense and how to do auto-correction. They get help with
-    # adding offenses for the faulty string nodes, and with filtering out
-    # nodes.
-    module StringHelp
-      def on_str(node)
-        # Constants like __FILE__ are handled as strings,
-        # but don't respond to begin.
-        return unless node.loc.respond_to?(:begin) && node.loc.begin
-        return if part_of_ignored_node?(node)
-
-        if offense?(node)
-          add_offense(node) { opposite_style_detected }
-        else
-          correct_style_detected
-        end
-      end
-
-      def on_regexp(node)
-        ignore_node(node)
-      end
-
-      private
-
-      def inside_interpolation?(node)
-        # A :begin node inside a :dstr node is an interpolation.
-        node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for cops checking single/double quotes.
-    module StringLiteralsHelp
-      include StringHelp
-
-      private
-
-      def wrong_quotes?(node)
-        src = node.source
-        return false if src.start_with?('%', '?')
-
-        if style == :single_quotes
-          !double_quotes_required?(src)
-        else
-          src !~ /" | \\[^'] | \#(@|\{)/x
-        end
-      end
-    end
-  end
-end

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

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking and correcting surrounding whitespace.
-    module SurroundingSpace
-      include RangeHelp
-
-      NO_SPACE_COMMAND = 'Do not use'.freeze
-      SPACE_COMMAND = 'Use'.freeze
-
-      private
-
-      def side_space_range(range:, side:)
-        buffer = @processed_source.buffer
-        src = buffer.source
-
-        begin_pos = range.begin_pos
-        end_pos = range.end_pos
-        if side == :left
-          begin_pos = reposition(src, begin_pos, -1)
-          end_pos -= 1
-        end
-        if side == :right
-          begin_pos += 1
-          end_pos = reposition(src, end_pos, 1)
-        end
-        Parser::Source::Range.new(buffer, begin_pos, end_pos)
-      end
-
-      def index_of_first_token(node)
-        range = node.source_range
-        token_table[range.line][range.column]
-      end
-
-      def index_of_last_token(node)
-        range = node.source_range
-        table_row = token_table[range.last_line]
-        (0...range.last_column).reverse_each do |c|
-          ix = table_row[c]
-          return ix if ix
-        end
-      end
-
-      def token_table
-        @token_table ||= begin
-          table = {}
-          @processed_source.tokens.each_with_index do |t, ix|
-            table[t.line] ||= {}
-            table[t.line][t.column] = ix
-          end
-          table
-        end
-      end
-
-      def no_space_offenses(node, # rubocop:disable Metrics/ParameterLists
-                            left_token,
-                            right_token,
-                            message,
-                            start_ok: false,
-                            end_ok: false)
-        if extra_space?(left_token, :left) && !start_ok
-          space_offense(node, left_token, :right, message, NO_SPACE_COMMAND)
-        end
-        return if !extra_space?(right_token, :right) || end_ok
-
-        space_offense(node, right_token, :left, message, NO_SPACE_COMMAND)
-      end
-
-      def space_offenses(node, # rubocop:disable Metrics/ParameterLists
-                         left_token,
-                         right_token,
-                         message,
-                         start_ok: false,
-                         end_ok: false)
-        unless extra_space?(left_token, :left) || start_ok
-          space_offense(node, left_token, :none, message, SPACE_COMMAND)
-        end
-        return if extra_space?(right_token, :right) || end_ok
-
-        space_offense(node, right_token, :none, message, SPACE_COMMAND)
-      end
-
-      def extra_space?(token, side)
-        return false unless token
-
-        if side == :left
-          String(token.space_after?) == ' '
-        else
-          String(token.space_before?) == ' '
-        end
-      end
-
-      def reposition(src, pos, step)
-        offset = step == -1 ? -1 : 0
-        pos += step while src[pos + offset] =~ /[ \t]/
-        pos < 0 ? 0 : pos
-      end
-
-      def space_offense(node, token, side, message, command)
-        range = side_space_range(range: token.pos, side: side)
-        add_offense(node, location: range,
-                          message: format(message, command: command))
-      end
-
-      def empty_offenses(node, left, right, message)
-        range = range_between(left.begin_pos, right.end_pos)
-        if offending_empty_space?(empty_config, left, right)
-          empty_offense(node, range, message, 'Use one')
-        end
-        return unless offending_empty_no_space?(empty_config, left, right)
-
-        empty_offense(node, range, message, 'Do not use')
-      end
-
-      def empty_offense(node, range, message, command)
-        add_offense(node, location: range,
-                          message: format(message, command: command))
-      end
-
-      def empty_brackets?(left_bracket_token, right_bracket_token)
-        left_index = processed_source.tokens.index(left_bracket_token)
-        right_index = processed_source.tokens.index(right_bracket_token)
-        right_index && left_index == right_index - 1
-      end
-
-      def offending_empty_space?(config, left_token, right_token)
-        config == 'space' && !space_between?(left_token, right_token)
-      end
-
-      def offending_empty_no_space?(config, left_token, right_token)
-        config == 'no_space' && !no_space_between?(left_token, right_token)
-      end
-
-      def space_between?(left_bracket_token, right_bracket_token)
-        left_bracket_token.end_pos + 1 == right_bracket_token.begin_pos
-      end
-
-      def no_space_between?(left_bracket_token, right_bracket_token)
-        left_bracket_token.end_pos == right_bracket_token.begin_pos
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking target rails version.
-    module TargetRailsVersion
-      def minimum_target_rails_version(version)
-        @minimum_target_rails_version = version
-      end
-
-      def support_target_rails_version?(version)
-        @minimum_target_rails_version <= version
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking target ruby version.
-    module TargetRubyVersion
-      def minimum_target_ruby_version(version)
-        @minimum_target_ruby_version = version
-      end
-
-      def support_target_ruby_version?(version)
-        @minimum_target_ruby_version <= version
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking for too many lines.
-    module TooManyLines
-      include ConfigurableMax
-      include CodeLength
-
-      MSG = '%<label>s has too many lines. [%<length>d/%<max>d]'.freeze
-
-      private
-
-      def message(length, max_length)
-        format(MSG, label: cop_label, length: length, max: max_length)
-      end
-
-      def code_length(node)
-        body = extract_body(node)
-        lines = body && body.source.lines || []
-
-        lines.count { |line| !irrelevant_line(line) }
-      end
-
-      def extract_body(node)
-        case node.type
-        when :block, :def
-          _receiver_or_method, _args, body = *node
-        when :defs
-          _self, _method, _args, body = *node
-        else
-          body = node
-        end
-
-        body
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common methods shared by TrailingBody cops
-    module TrailingBody
-      def trailing_body?(node)
-        body = node.to_a.reverse[0]
-        body && node.multiline? &&
-          body_on_first_line?(node, body)
-      end
-
-      def body_on_first_line?(node, body)
-        node.source_range.first_line == body.source_range.first_line
-      end
-
-      def first_part_of(body)
-        if body.begin_type?
-          body.children.first.source_range
-        else
-          body.source_range
-        end
-      end
-    end
-  end
-end