primary_connect_proto 0.4.0 → 0.5.0

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_after_comma.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for comma (,) not followed by some kind of space.
-      #
-      # @example
-      #
-      #   # bad
-      #   [1,2]
-      #   { foo:bar,}
-      #
-      #   # good
-      #   [1, 2]
-      #   { foo:bar, }
-      class SpaceAfterComma < Cop
-        include SpaceAfterPunctuation
-
-        def autocorrect(comma)
-          PunctuationCorrector.add_space(comma)
-        end
-
-        def space_style_before_rcurly
-          cfg = config.for_cop('Layout/SpaceInsideHashLiteralBraces')
-          cfg['EnforcedStyle'] || 'space'
-        end
-
-        def kind(token)
-          'comma' if token.comma?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_after_method_name.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for space between a method name and a left parenthesis in defs.
-      #
-      # @example
-      #
-      #   # bad
-      #   def func (x) end
-      #   def method= (y) end
-      #
-      #   # good
-      #   def func(x) end
-      #   def method=(y) end
-      class SpaceAfterMethodName < Cop
-        include RangeHelp
-
-        MSG = 'Do not put a space between a method name and the opening ' \
-              'parenthesis.'.freeze
-
-        def on_def(node)
-          args = node.arguments
-          return unless args.loc.begin && args.loc.begin.is?('(')
-
-          expr = args.source_range
-          pos_before_left_paren = range_between(expr.begin_pos - 1,
-                                                expr.begin_pos)
-          return unless pos_before_left_paren.source.start_with?(' ')
-
-          add_offense(pos_before_left_paren, location: pos_before_left_paren)
-        end
-        alias on_defs on_def
-
-        def autocorrect(pos_before_left_paren)
-          ->(corrector) { corrector.remove(pos_before_left_paren) }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_after_not.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for space after `!`.
-      #
-      # @example
-      #   # bad
-      #   ! something
-      #
-      #   # good
-      #   !something
-      class SpaceAfterNot < Cop
-        include RangeHelp
-
-        MSG = 'Do not leave space between `!` and its argument.'.freeze
-
-        def on_send(node)
-          return unless node.prefix_bang? && whitespace_after_operator?(node)
-
-          add_offense(node)
-        end
-
-        def whitespace_after_operator?(node)
-          node.receiver.loc.column - node.loc.column > 1
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(
-              range_between(node.loc.selector.end_pos,
-                            node.receiver.source_range.begin_pos)
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_after_semicolon.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for semicolon (;) not followed by some kind of space.
-      #
-      # @example
-      #   # bad
-      #   x = 1;y = 2
-      #
-      #   # good
-      #   x = 1; y = 2
-      class SpaceAfterSemicolon < Cop
-        include SpaceAfterPunctuation
-
-        def autocorrect(semicolon)
-          PunctuationCorrector.add_space(semicolon)
-        end
-
-        def space_style_before_rcurly
-          cfg = config.for_cop('Layout/SpaceInsideBlockBraces')
-          cfg['EnforcedStyle'] || 'space'
-        end
-
-        def kind(token)
-          'semicolon' if token.semicolon?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_around_block_parameters.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks the spacing inside and after block parameters pipes.
-      #
-      # @example EnforcedStyleInsidePipes: no_space (default)
-      #   # bad
-      #   {}.each { | x,  y |puts x }
-      #   ->( x,  y ) { puts x }
-      #
-      #   # good
-      #   {}.each { |x, y| puts x }
-      #   ->(x, y) { puts x }
-      #
-      # @example EnforcedStyleInsidePipes: space
-      #   # bad
-      #   {}.each { |x,  y| puts x }
-      #   ->(x,  y) { puts x }
-      #
-      #   # good
-      #   {}.each { | x, y | puts x }
-      #   ->( x, y ) { puts x }
-      class SpaceAroundBlockParameters < Cop
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-
-        def on_block(node)
-          arguments = node.arguments
-
-          return unless node.arguments? && pipes?(arguments)
-
-          check_inside_pipes(arguments)
-          check_after_closing_pipe(arguments) if node.body
-          check_each_arg(arguments)
-        end
-
-        # @param target [RuboCop::AST::Node,Parser::Source::Range]
-        def autocorrect(target)
-          lambda do |corrector|
-            if target.is_a?(RuboCop::AST::Node)
-              if target.parent.children.first == target
-                corrector.insert_before(target.source_range, ' ')
-              else
-                corrector.insert_after(target.source_range, ' ')
-              end
-            elsif target.source =~ /^\s+$/
-              corrector.remove(target)
-            else
-              corrector.insert_after(target, ' ')
-            end
-          end
-        end
-
-        private
-
-        def pipes(arguments)
-          [arguments.loc.begin, arguments.loc.end]
-        end
-
-        def pipes?(arguments)
-          pipes(arguments).none?(&:nil?)
-        end
-
-        def style_parameter_name
-          'EnforcedStyleInsidePipes'
-        end
-
-        def check_inside_pipes(arguments)
-          opening_pipe, closing_pipe = pipes(arguments)
-
-          if style == :no_space
-            check_no_space_style_inside_pipes(arguments.children,
-                                              opening_pipe,
-                                              closing_pipe)
-          elsif style == :space
-            check_space_style_inside_pipes(arguments.children,
-                                           opening_pipe,
-                                           closing_pipe)
-          end
-        end
-
-        def check_after_closing_pipe(arguments)
-          _opening_pipe, closing_pipe = pipes(arguments)
-          block = arguments.parent
-
-          check_space(closing_pipe.end_pos, block.body.source_range.begin_pos,
-                      closing_pipe, 'after closing `|`')
-        end
-
-        def check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe)
-          first = args.first.source_range
-          last = args.last.source_range
-
-          check_no_space(opening_pipe.end_pos, first.begin_pos,
-                         'Space before first')
-          check_no_space(last_end_pos_inside_pipes(last.end_pos),
-                         closing_pipe.begin_pos, 'Space after last')
-        end
-
-        def check_space_style_inside_pipes(args, opening_pipe, closing_pipe)
-          check_opening_pipe_space(args, opening_pipe)
-          check_closing_pipe_space(args, closing_pipe)
-        end
-
-        def check_opening_pipe_space(args, opening_pipe)
-          first_arg = args.first
-          range = first_arg.source_range
-
-          check_space(opening_pipe.end_pos, range.begin_pos, range,
-                      'before first block parameter', first_arg)
-          check_no_space(opening_pipe.end_pos, range.begin_pos - 1,
-                         'Extra space before first')
-        end
-
-        def check_closing_pipe_space(args, closing_pipe)
-          last         = args.last.source_range
-          last_end_pos = last_end_pos_inside_pipes(last.end_pos)
-
-          check_space(last_end_pos, closing_pipe.begin_pos, last,
-                      'after last block parameter')
-          check_no_space(last_end_pos + 1, closing_pipe.begin_pos,
-                         'Extra space after last')
-        end
-
-        def last_end_pos_inside_pipes(pos)
-          processed_source.buffer.source[pos] == ',' ? pos + 1 : pos
-        end
-
-        def check_each_arg(args)
-          args.children.each do |arg|
-            check_arg(arg)
-          end
-        end
-
-        def check_arg(arg)
-          arg.children.each { |a| check_arg(a) } if arg.mlhs_type?
-
-          expr = arg.source_range
-          check_no_space(
-            range_with_surrounding_space(range: expr, side: :left).begin_pos,
-            expr.begin_pos - 1,
-            'Extra space before'
-          )
-        end
-
-        def check_space(space_begin_pos, space_end_pos, range, msg, node = nil)
-          return if space_begin_pos != space_end_pos
-
-          target = node || range
-          add_offense(target, location: range, message: "Space #{msg} missing.")
-        end
-
-        def check_no_space(space_begin_pos, space_end_pos, msg)
-          return if space_begin_pos >= space_end_pos
-
-          range = range_between(space_begin_pos, space_end_pos)
-          add_offense(range, location: range,
-                             message: "#{msg} block parameter detected.")
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks that the equals signs in parameter default assignments
-      # have or don't have surrounding space depending on configuration.
-      #
-      # @example EnforcedStyle: space (default)
-      #   # bad
-      #   def some_method(arg1=:default, arg2=nil, arg3=[])
-      #     # do something...
-      #   end
-      #
-      #   # good
-      #   def some_method(arg1 = :default, arg2 = nil, arg3 = [])
-      #     # do something...
-      #   end
-      #
-      # @example EnforcedStyle: no_space
-      #   # bad
-      #   def some_method(arg1 = :default, arg2 = nil, arg3 = [])
-      #     # do something...
-      #   end
-      #
-      #   # good
-      #   def some_method(arg1=:default, arg2=nil, arg3=[])
-      #     # do something...
-      #   end
-      class SpaceAroundEqualsInParameterDefault < Cop
-        include SurroundingSpace
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-
-        MSG = 'Surrounding space %<type>s in default value assignment.'.freeze
-
-        def on_optarg(node)
-          index = index_of_first_token(node)
-          arg, equals, value = processed_source.tokens[index, 3]
-          check_optarg(arg, equals, value)
-        end
-
-        def autocorrect(range)
-          m = range.source.match(/=\s*(\S+)/)
-          rest = m ? m.captures[0] : ''
-          replacement = style == :space ? ' = ' : '='
-          ->(corrector) { corrector.replace(range, replacement + rest) }
-        end
-
-        private
-
-        def check_optarg(arg, equals, value)
-          space_on_both_sides = space_on_both_sides?(arg, equals)
-          no_surrounding_space = no_surrounding_space?(arg, equals)
-
-          if style == :space && space_on_both_sides ||
-             style == :no_space && no_surrounding_space
-            correct_style_detected
-          else
-            incorrect_style_detected(arg, value, space_on_both_sides,
-                                     no_surrounding_space)
-          end
-        end
-
-        def incorrect_style_detected(arg, value, space_on_both_sides,
-                                     no_surrounding_space)
-          range = range_between(arg.end_pos, value.begin_pos)
-          add_offense(range, location: range) do
-            if style == :space && no_surrounding_space ||
-               style == :no_space && space_on_both_sides
-              opposite_style_detected
-            else
-              unrecognized_style_detected
-            end
-          end
-        end
-
-        def space_on_both_sides?(arg, equals)
-          arg.space_after? && equals.space_after?
-        end
-
-        def no_surrounding_space?(arg, equals)
-          !arg.space_after? && !equals.space_after?
-        end
-
-        def message(_node)
-          format(MSG, type: style == :space ? 'missing' : 'detected')
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/space_around_keyword.rb

@@ -1,232 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks the spacing around the keywords.
-      #
-      # @example
-      #
-      #   # bad
-      #   something 'test'do|x|
-      #   end
-      #
-      #   while(something)
-      #   end
-      #
-      #   something = 123if test
-      #
-      #   # good
-      #   something 'test' do |x|
-      #   end
-      #
-      #   while (something)
-      #   end
-      #
-      #   something = 123 if test
-      class SpaceAroundKeyword < Cop
-        MSG_BEFORE = 'Space before keyword `%<range>s` is missing.'.freeze
-        MSG_AFTER = 'Space after keyword `%<range>s` is missing.'.freeze
-
-        DO = 'do'.freeze
-        SAFE_NAVIGATION = '&.'.freeze
-        ACCEPT_LEFT_PAREN =
-          %w[break defined? next not rescue return super yield].freeze
-        ACCEPT_LEFT_SQUARE_BRACKET =
-          %w[super yield].freeze
-
-        def on_and(node)
-          check(node, [:operator].freeze) if node.keyword?
-        end
-
-        def on_block(node)
-          check(node, %i[begin end].freeze)
-        end
-
-        def on_break(node)
-          check(node, [:keyword].freeze)
-        end
-
-        def on_case(node)
-          check(node, %i[keyword else].freeze)
-        end
-
-        def on_ensure(node)
-          check(node, [:keyword].freeze)
-        end
-
-        def on_for(node)
-          check(node, %i[begin end].freeze)
-        end
-
-        def on_if(node)
-          check(node, %i[keyword else begin end].freeze, 'then'.freeze)
-        end
-
-        def on_kwbegin(node)
-          check(node, %i[begin end].freeze, nil)
-        end
-
-        def on_next(node)
-          check(node, [:keyword].freeze)
-        end
-
-        def on_or(node)
-          check(node, [:operator].freeze) if node.keyword?
-        end
-
-        def on_postexe(node)
-          check(node, [:keyword].freeze)
-        end
-
-        def on_preexe(node)
-          check(node, [:keyword].freeze)
-        end
-
-        def on_resbody(node)
-          check(node, [:keyword].freeze)
-        end
-
-        def on_rescue(node)
-          check(node, [:else].freeze)
-        end
-
-        def on_return(node)
-          check(node, [:keyword].freeze)
-        end
-
-        def on_send(node)
-          check(node, [:selector].freeze) if node.prefix_not?
-        end
-
-        def on_super(node)
-          check(node, [:keyword].freeze)
-        end
-
-        def on_zsuper(node)
-          check(node, [:keyword].freeze)
-        end
-
-        def on_until(node)
-          check(node, %i[begin end keyword].freeze)
-        end
-
-        def on_when(node)
-          check(node, [:keyword].freeze)
-        end
-
-        def on_while(node)
-          check(node, %i[begin end keyword].freeze)
-        end
-
-        def on_yield(node)
-          check(node, [:keyword].freeze)
-        end
-
-        def on_defined?(node)
-          check(node, [:keyword].freeze)
-        end
-
-        def autocorrect(range)
-          if space_before_missing?(range)
-            ->(corrector) { corrector.insert_before(range, ' '.freeze) }
-          else
-            ->(corrector) { corrector.insert_after(range, ' '.freeze) }
-          end
-        end
-
-        private
-
-        def check(node, locations, begin_keyword = DO)
-          locations.each do |loc|
-            next unless node.loc.respond_to?(loc)
-
-            range = node.loc.public_send(loc)
-            next unless range
-
-            case loc
-            when :begin then check_begin(node, range, begin_keyword)
-            when :end then check_end(node, range, begin_keyword)
-            else check_keyword(node, range)
-            end
-          end
-        end
-
-        def check_begin(node, range, begin_keyword)
-          return if begin_keyword && !range.is?(begin_keyword)
-
-          check_keyword(node, range)
-        end
-
-        def check_end(node, range, begin_keyword)
-          return if begin_keyword == DO && !do?(node)
-
-          offense(range, MSG_BEFORE) if space_before_missing?(range)
-        end
-
-        def do?(node)
-          node.loc.begin && node.loc.begin.is?(DO)
-        end
-
-        def check_keyword(node, range)
-          offense(range, MSG_BEFORE) if space_before_missing?(range) &&
-                                        !preceded_by_operator?(node, range)
-          offense(range, MSG_AFTER) if space_after_missing?(range)
-        end
-
-        def offense(range, msg)
-          add_offense(range,
-                      location: range,
-                      message: format(msg, range: range.source))
-        end
-
-        def space_before_missing?(range)
-          pos = range.begin_pos - 1
-          return false if pos < 0
-
-          range.source_buffer.source[pos] !~ /[\s\(\|\{\[;,\*\=]/
-        end
-
-        def space_after_missing?(range)
-          pos = range.end_pos
-          char = range.source_buffer.source[pos]
-
-          return false if accepted_opening_delimiter?(range, char)
-          return false if safe_navigation_call?(range, pos)
-
-          char !~ /[\s;,#\\\)\}\]\.]/
-        end
-
-        def accepted_opening_delimiter?(range, char)
-          return true unless char
-
-          accept_left_square_bracket?(range) && char == '[' ||
-            accept_left_parenthesis?(range) && char == '('
-        end
-
-        def accept_left_parenthesis?(range)
-          ACCEPT_LEFT_PAREN.include?(range.source)
-        end
-
-        def accept_left_square_bracket?(range)
-          ACCEPT_LEFT_SQUARE_BRACKET.include?(range.source)
-        end
-
-        def safe_navigation_call?(range, pos)
-          range.source_buffer.source[pos, 2].start_with?(SAFE_NAVIGATION)
-        end
-
-        def preceded_by_operator?(node, _range)
-          # regular dotted method calls bind more tightly than operators
-          # so we need to climb up the AST past them
-          node.each_ancestor do |ancestor|
-            return true if ancestor.and_type? || ancestor.or_type?
-            return false unless ancestor.send_type?
-            return true if ancestor.operator_method?
-          end
-          false
-        end
-      end
-    end
-  end
-end