primary_connect_proto 0.19.0 → 0.20.0

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of comments.
+      #
+      # @example
+      #   # bad
+      #     # comment here
+      #   def method_name
+      #   end
+      #
+      #     # comment here
+      #   a = 'hello'
+      #
+      #   # yet another comment
+      #     if true
+      #       true
+      #     end
+      #
+      #   # good
+      #   # comment here
+      #   def method_name
+      #   end
+      #
+      #   # comment here
+      #   a = 'hello'
+      #
+      #   # yet another comment
+      #   if true
+      #     true
+      #   end
+      #
+      class CommentIndentation < Cop
+        include Alignment
+
+        MSG = 'Incorrect indentation detected (column %<column>d ' \
+          'instead of %<correct_comment_indentation>d).'.freeze
+
+        def investigate(processed_source)
+          processed_source.each_comment { |comment| check(comment) }
+        end
+
+        def autocorrect(comment)
+          corrections = autocorrect_preceding_comments(comment) <<
+                        autocorrect_one(comment)
+          ->(corrector) { corrections.each { |corr| corr.call(corrector) } }
+        end
+
+        private
+
+        # Corrects all comment lines that occur immediately before the given
+        # comment and have the same indentation. This is to avoid a long chain
+        # of correcting, saving the file, parsing and inspecting again, and
+        # then correcting one more line, and so on.
+        def autocorrect_preceding_comments(comment)
+          corrections = []
+          line_no = comment.loc.line
+          column = comment.loc.column
+          comments = processed_source.comments
+          (comments.index(comment) - 1).downto(0) do |ix|
+            previous_comment = comments[ix]
+            break unless should_correct?(previous_comment, column, line_no - 1)
+
+            corrections << autocorrect_one(previous_comment)
+            line_no -= 1
+          end
+          corrections
+        end
+
+        def should_correct?(comment, column, line_no)
+          loc = comment.loc
+          loc.line == line_no && loc.column == column
+        end
+
+        def autocorrect_one(comment)
+          AlignmentCorrector.correct(processed_source, comment, @column_delta)
+        end
+
+        def check(comment)
+          return unless own_line_comment?(comment)
+
+          next_line = line_after_comment(comment)
+          correct_comment_indentation = correct_indentation(next_line)
+          column = comment.loc.column
+
+          @column_delta = correct_comment_indentation - column
+          return if @column_delta.zero?
+
+          if two_alternatives?(next_line)
+            # Try the other
+            correct_comment_indentation += configured_indentation_width
+            # We keep @column_delta unchanged so that autocorrect changes to
+            # the preferred style of aligning the comment with the keyword.
+            return if column == correct_comment_indentation
+          end
+
+          add_offense(
+            comment,
+            message: message(column, correct_comment_indentation)
+          )
+        end
+
+        def message(column, correct_comment_indentation)
+          format(
+            MSG,
+            column: column,
+            correct_comment_indentation: correct_comment_indentation
+          )
+        end
+
+        def own_line_comment?(comment)
+          own_line = processed_source.lines[comment.loc.line - 1]
+          own_line =~ /\A\s*#/
+        end
+
+        def line_after_comment(comment)
+          lines = processed_source.lines
+          lines[comment.loc.line..-1].find { |line| !line.blank? }
+        end
+
+        def correct_indentation(next_line)
+          return 0 unless next_line
+
+          indentation_of_next_line = next_line =~ /\S/
+          indentation_of_next_line + if less_indented?(next_line)
+                                       configured_indentation_width
+                                     else
+                                       0
+                                     end
+        end
+
+        def less_indented?(line)
+          line =~ /^\s*(end\b|[)}\]])/
+        end
+
+        def two_alternatives?(line)
+          line =~ /^\s*(else|elsif|when|rescue|ensure)\b/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for conditions that are not on the same line as
+      # if/while/until.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   if
+      #     some_condition
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   if some_condition
+      #     do_something
+      #   end
+      class ConditionPosition < Cop
+        MSG = 'Place the condition on the same line as `%<keyword>s`.'.freeze
+
+        def on_if(node)
+          return if node.ternary?
+
+          check(node)
+        end
+
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return if node.modifier_form? || node.single_line_condition?
+
+          add_offense(node.condition)
+        end
+
+        def message(node)
+          format(MSG, keyword: node.parent.keyword)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether the end keywords of method definitions are
+      # aligned properly.
+      #
+      # Two modes are supported through the EnforcedStyleAlignWith configuration
+      # parameter. If it's set to `start_of_line` (which is the default), the
+      # `end` shall be aligned with the start of the line where the `def`
+      # keyword is. If it's set to `def`, the `end` shall be aligned with the
+      # `def` keyword.
+      #
+      # @example EnforcedStyleAlignWith: start_of_line (default)
+      #   # bad
+      #
+      #   private def foo
+      #               end
+      #
+      #   # good
+      #
+      #   private def foo
+      #   end
+      #
+      # @example EnforcedStyleAlignWith: def
+      #   # bad
+      #
+      #   private def foo
+      #               end
+      #
+      #   # good
+      #
+      #   private def foo
+      #           end
+      class DefEndAlignment < Cop
+        include EndKeywordAlignment
+        include RangeHelp
+
+        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'.freeze
+
+        def on_def(node)
+          check_end_kw_in_node(node)
+        end
+        alias on_defs on_def
+
+        def on_send(node)
+          return unless node.def_modifier?
+
+          method_def = node.each_descendant(:def, :defs).first
+          expr = node.source_range
+
+          line_start = range_between(expr.begin_pos,
+                                     method_def.loc.keyword.end_pos)
+          align_with = {
+            def: method_def.loc.keyword,
+            start_of_line: line_start
+          }
+
+          check_end_kw_alignment(method_def, align_with)
+          ignore_node(method_def) # Don't check the same `end` again.
+        end
+
+        def autocorrect(node)
+          if style == :start_of_line && node.parent && node.parent.send_type?
+            AlignmentCorrector.align_end(processed_source, node, node.parent)
+          else
+            AlignmentCorrector.align_end(processed_source, node, node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks the . position in multi-line method calls.
+      #
+      # @example EnforcedStyle: leading (default)
+      #   # bad
+      #   something.
+      #     method
+      #
+      #   # good
+      #   something
+      #     .method
+      #
+      # @example EnforcedStyle: trailing
+      #   # bad
+      #   something
+      #     .method
+      #
+      #   # good
+      #   something.
+      #     method
+      class DotPosition < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_send(node)
+          return unless node.dot? || ampersand_dot?(node)
+
+          if proper_dot_position?(node)
+            correct_style_detected
+          else
+            add_offense(node, location: :dot) { opposite_style_detected }
+          end
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          lambda do |corrector|
+            dot = node.loc.dot.source
+            corrector.remove(node.loc.dot)
+            case style
+            when :leading
+              corrector.insert_before(selector_range(node), dot)
+            when :trailing
+              corrector.insert_after(node.receiver.source_range, dot)
+            end
+          end
+        end
+
+        private
+
+        def message(node)
+          dot = node.loc.dot.source
+          "Place the #{dot} on the " +
+            case style
+            when :leading
+              'next line, together with the method name.'
+            when :trailing
+              'previous line, together with the method call receiver.'
+            end
+        end
+
+        def proper_dot_position?(node)
+          receiver_line = node.receiver.source_range.end.line
+          selector_line = selector_range(node).line
+
+          # receiver and selector are on the same line
+          return true if selector_line == receiver_line
+
+          dot_line = node.loc.dot.line
+
+          # don't register an offense if there is a line comment between the
+          # dot and the selector otherwise, we might break the code while
+          # "correcting" it (even if there is just an extra blank line, treat
+          # it the same)
+          return true if line_between?(selector_line, dot_line)
+
+          correct_dot_position_style?(dot_line, selector_line)
+        end
+
+        def line_between?(first_line, second_line)
+          (first_line - second_line) > 1
+        end
+
+        def correct_dot_position_style?(dot_line, selector_line)
+          case style
+          when :leading then dot_line == selector_line
+          when :trailing then dot_line != selector_line
+          end
+        end
+
+        def selector_range(node)
+          # l.(1) has no selector, so we use the opening parenthesis instead
+          node.loc.selector || node.loc.begin
+        end
+
+        def ampersand_dot?(node)
+          node.loc.respond_to?(:dot) && node.loc.dot && node.loc.dot.is?('&.')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks the alignment of else keywords. Normally they should
+      # be aligned with an if/unless/while/until/begin/def keyword, but there
+      # are special cases when they should follow the same rules as the
+      # alignment of end.
+      #
+      # @example
+      #   # bad
+      #   if something
+      #     code
+      #    else
+      #     code
+      #   end
+      #
+      #   # bad
+      #   if something
+      #     code
+      #    elsif something
+      #     code
+      #   end
+      #
+      #   # good
+      #   if something
+      #     code
+      #   else
+      #     code
+      #   end
+      class ElseAlignment < Cop
+        include EndKeywordAlignment
+        include Alignment
+        include CheckAssignment
+
+        MSG = 'Align `%<else_range>s` with `%<base_range>s`.'.freeze
+
+        def on_if(node, base = nil)
+          return if ignored_node?(node)
+          return unless node.else? && begins_its_line?(node.loc.else)
+
+          check_alignment(base_range_of_if(node, base), node.loc.else)
+
+          return unless node.elsif_conditional?
+
+          check_nested(node.else_branch, base)
+        end
+
+        def on_rescue(node)
+          return unless node.loc.respond_to?(:else) && node.loc.else
+
+          check_alignment(base_range_of_rescue(node), node.loc.else)
+        end
+
+        def on_case(node)
+          return unless node.else?
+
+          check_alignment(node.when_branches.last.loc.keyword, node.loc.else)
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+
+        private
+
+        def check_nested(node, base)
+          on_if(node, base)
+          ignore_node(node)
+        end
+
+        def base_range_of_if(node, base)
+          if base
+            base.source_range
+          else
+            lineage = [node, *node.each_ancestor(:if)]
+            lineage.find { |parent| parent.if? || parent.unless? }.loc.keyword
+          end
+        end
+
+        def base_range_of_rescue(node)
+          parent = node.parent
+          parent = parent.parent if parent.ensure_type?
+          case parent.type
+          when :def, :defs then base_for_method_definition(parent)
+          when :kwbegin then parent.loc.begin
+          when :block then parent.send_node.source_range
+          else node.loc.keyword
+          end
+        end
+
+        def base_for_method_definition(node)
+          parent = node.parent
+          if parent && parent.send_type?
+            parent.loc.selector # For example "private def ..."
+          else
+            node.loc.keyword
+          end
+        end
+
+        def check_assignment(node, rhs)
+          # If there are method calls chained to the right hand side of the
+          # assignment, we let rhs be the receiver of those method calls before
+          # we check its indentation.
+          rhs = first_part_of_call_chain(rhs)
+          return unless rhs
+
+          end_config = config.for_cop('Layout/EndAlignment')
+          style = end_config['EnforcedStyleAlignWith'] || 'keyword'
+          base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
+
+          return unless rhs.if_type?
+
+          check_nested(rhs, base)
+        end
+
+        def check_alignment(base_range, else_range)
+          return unless begins_its_line?(else_range)
+
+          @column_delta = column_offset_between(base_range, else_range)
+          return if @column_delta.zero?
+
+          message = format(
+            MSG,
+            else_range: else_range.source,
+            base_range: base_range.source[/^\S*/]
+          )
+          add_offense(else_range, location: else_range, message: message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks empty comment.
+      #
+      # @example
+      #   # bad
+      #
+      #   #
+      #   class Foo
+      #   end
+      #
+      #   # good
+      #
+      #   #
+      #   # Description of `Foo` class.
+      #   #
+      #   class Foo
+      #   end
+      #
+      # @example AllowBorderComment: true (default)
+      #   # good
+      #
+      #   def foo
+      #   end
+      #
+      #   #################
+      #
+      #   def bar
+      #   end
+      #
+      # @example AllowBorderComment: false
+      #   # bad
+      #
+      #   def foo
+      #   end
+      #
+      #   #################
+      #
+      #   def bar
+      #   end
+      #
+      # @example AllowMarginComment: true (default)
+      #   # good
+      #
+      #   #
+      #   # Description of `Foo` class.
+      #   #
+      #   class Foo
+      #   end
+      #
+      # @example AllowMarginComment: false
+      #   # bad
+      #
+      #   #
+      #   # Description of `Foo` class.
+      #   #
+      #   class Foo
+      #   end
+      #
+      class EmptyComment < Cop
+        include RangeHelp
+
+        MSG = 'Source code comment is empty.'.freeze
+
+        def investigate(processed_source)
+          if allow_margin_comment?
+            comments = concat_consecutive_comments(processed_source.comments)
+
+            comments.each do |comment|
+              next unless empty_comment_only?(comment[0])
+
+              comment[1].each do |offense_comment|
+                add_offense(offense_comment)
+              end
+            end
+          else
+            processed_source.comments.each do |comment|
+              next unless empty_comment_only?(comment_text(comment))
+
+              add_offense(comment)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            previous_token = previous_token(node)
+            range = if previous_token && node.loc.line == previous_token.line
+                      range_with_surrounding_space(range: node.loc.expression,
+                                                   newlines: false)
+                    else
+                      range_by_whole_lines(node.loc.expression,
+                                           include_final_newline: true)
+                    end
+
+            corrector.remove(range)
+          end
+        end
+
+        private
+
+        def concat_consecutive_comments(comments)
+          prev_line = nil
+
+          comments.each_with_object([]) do |comment, concatenated_comments|
+            if prev_line && comment.loc.line == prev_line.next
+              last_concatenated_comment = concatenated_comments.last
+
+              last_concatenated_comment[0] << comment_text(comment)
+              last_concatenated_comment[1] << comment
+            else
+              concatenated_comments << [comment_text(comment).dup, [comment]]
+            end
+
+            prev_line = comment.loc.line
+          end
+        end
+
+        def empty_comment_only?(comment_text)
+          empty_comment_pattern = if allow_border_comment?
+                                    /\A(#\n)+\z/
+                                  else
+                                    /\A(#+\n)+\z/
+                                  end
+
+          !(comment_text =~ empty_comment_pattern).nil?
+        end
+
+        def comment_text(comment)
+          "#{comment.text.strip}\n"
+        end
+
+        def allow_border_comment?
+          cop_config['AllowBorderComment']
+        end
+
+        def allow_margin_comment?
+          cop_config['AllowMarginComment']
+        end
+
+        def current_token(node)
+          processed_source.find_token do |token|
+            token.pos.column == node.loc.column &&
+              token.pos.last_column == node.loc.last_column &&
+              token.line == node.loc.line
+          end
+        end
+
+        def previous_token(node)
+          current_token = current_token(node)
+          index = processed_source.tokens.index(current_token)
+          index.zero? ? nil : processed_source.tokens[index - 1]
+        end
+      end
+    end
+  end
+end