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/indentation_consistency.rb

@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for inconsistent indentation.
-      #
-      # The difference between `rails` and `normal` is that the `rails` style
-      # prescribes that in classes and modules the `protected` and `private`
-      # modifier keywords shall be indented the same as public methods and that
-      # protected and private members shall be indented one step more than the
-      # modifiers. Other than that, both styles mean that entities on the same
-      # logical depth shall have the same indentation.
-      #
-      # @example EnforcedStyle: normal (default)
-      #   # bad
-      #   class A
-      #     def test
-      #       puts 'hello'
-      #        puts 'world'
-      #     end
-      #   end
-      #
-      #   # bad
-      #   class A
-      #     def test
-      #       puts 'hello'
-      #       puts 'world'
-      #     end
-      #
-      #     protected
-      #
-      #       def foo
-      #       end
-      #
-      #     private
-      #
-      #       def bar
-      #       end
-      #   end
-      #
-      #   # good
-      #   class A
-      #     def test
-      #       puts 'hello'
-      #       puts 'world'
-      #     end
-      #   end
-      #
-      #   # good
-      #   class A
-      #     def test
-      #       puts 'hello'
-      #       puts 'world'
-      #     end
-      #
-      #     protected
-      #
-      #     def foo
-      #     end
-      #
-      #     private
-      #
-      #     def bar
-      #     end
-      #   end
-      #
-      # @example EnforcedStyle: rails
-      #   # bad
-      #   class A
-      #     def test
-      #       puts 'hello'
-      #        puts 'world'
-      #     end
-      #   end
-      #
-      #   # bad
-      #   class A
-      #     def test
-      #       puts 'hello'
-      #       puts 'world'
-      #     end
-      #
-      #     protected
-      #
-      #     def foo
-      #     end
-      #
-      #     private
-      #
-      #     def bar
-      #     end
-      #   end
-      #
-      #   # good
-      #   class A
-      #     def test
-      #       puts 'hello'
-      #       puts 'world'
-      #     end
-      #   end
-      #
-      #   # good
-      #   class A
-      #     def test
-      #       puts 'hello'
-      #       puts 'world'
-      #     end
-      #
-      #     protected
-      #
-      #       def foo
-      #       end
-      #
-      #     private
-      #
-      #       def bar
-      #       end
-      #   end
-      class IndentationConsistency < Cop
-        include Alignment
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Inconsistent indentation detected.'.freeze
-
-        def on_begin(node)
-          check(node)
-        end
-
-        def on_kwbegin(node)
-          check(node)
-        end
-
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
-        end
-
-        private
-
-        # Not all nodes define `bare_access_modifier?` (for example,
-        # `RuboCop::AST::DefNode` does not), so we must check `send_type?` first
-        # to avoid a NoMethodError.
-        def bare_access_modifier?(node)
-          node.send_type? && node.bare_access_modifier?
-        end
-
-        # Returns an integer representing the correct indentation, or nil to
-        # indicate that the correct indentation is that of the first child that
-        # is not an access modifier.
-        def base_column_for_normal_style(node)
-          first_child = node.children.first
-          return unless first_child && bare_access_modifier?(first_child)
-
-          # If, as is most common, the access modifier is indented deeper than
-          # the module (`access_modifier_indent > module_indent`) then the
-          # indentation of the access modifier determines the correct
-          # indentation.
-          #
-          # Otherwise, in the rare event that the access modifier is outdented
-          # to the level of the module (see `AccessModifierIndentation` cop) we
-          # return nil so that `check_alignment` will derive the correct
-          # indentation from the first child that is not an access modifier.
-          module_indent = display_column(node.parent.source_range)
-          access_modifier_indent = display_column(first_child.source_range)
-          access_modifier_indent if access_modifier_indent > module_indent
-        end
-
-        def check(node)
-          if style == :rails
-            check_rails_style(node)
-          else
-            check_normal_style(node)
-          end
-        end
-
-        def check_normal_style(node)
-          check_alignment(
-            node.children.reject { |child| bare_access_modifier?(child) },
-            base_column_for_normal_style(node)
-          )
-        end
-
-        def check_rails_style(node)
-          children_to_check = [[]]
-          node.children.each do |child|
-            # Modifier nodes have special indentation and will be checked by
-            # the AccessModifierIndentation cop. This cop uses them as dividers
-            # in rails mode. Then consistency is checked only within each
-            # section delimited by a modifier node.
-            if bare_access_modifier?(child)
-              children_to_check << []
-            else
-              children_to_check.last << child
-            end
-          end
-          children_to_check.each { |group| check_alignment(group) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,364 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for indentation that doesn't use the specified number
-      # of spaces.
-      #
-      # See also the IndentationConsistency cop which is the companion to this
-      # one.
-      #
-      # @example
-      #   # bad
-      #   class A
-      #    def test
-      #     puts 'hello'
-      #    end
-      #   end
-      #
-      #   # good
-      #   class A
-      #     def test
-      #       puts 'hello'
-      #     end
-      #   end
-      #
-      # @example IgnoredPatterns: ['^\s*module']
-      #   # bad
-      #   module A
-      #   class B
-      #     def test
-      #     puts 'hello'
-      #     end
-      #   end
-      #   end
-      #
-      #   # good
-      #   module A
-      #   class B
-      #     def test
-      #       puts 'hello'
-      #     end
-      #   end
-      #   end
-      class IndentationWidth < Cop # rubocop:disable Metrics/ClassLength
-        include EndKeywordAlignment
-        include Alignment
-        include CheckAssignment
-        include IgnoredPattern
-        include RangeHelp
-
-        MSG = 'Use %<configured_indentation_width>d (not %<indentation>d) ' \
-              'spaces for%<name>s indentation.'.freeze
-
-        SPECIAL_MODIFIERS = %w[private protected].freeze
-
-        def_node_matcher :access_modifier?, <<-PATTERN
-          [(send ...) access_modifier?]
-        PATTERN
-
-        def on_rescue(node)
-          _begin_node, *_rescue_nodes, else_node = *node
-          check_indentation(node.loc.else, else_node)
-        end
-
-        def on_ensure(node)
-          check_indentation(node.loc.keyword, node.body)
-        end
-
-        alias on_resbody on_ensure
-        alias on_for     on_ensure
-
-        def on_kwbegin(node)
-          # Check indentation against end keyword but only if it's first on its
-          # line.
-          return unless begins_its_line?(node.loc.end)
-
-          check_indentation(node.loc.end, node.children.first)
-        end
-
-        def on_block(node)
-          end_loc = node.loc.end
-
-          return unless begins_its_line?(end_loc)
-
-          check_indentation(end_loc, node.body)
-
-          return unless indentation_consistency_style == 'rails'
-
-          check_members(end_loc, [node.body])
-        end
-
-        def on_module(node)
-          _module_name, *members = *node
-          check_members(node.loc.keyword, members)
-        end
-
-        def on_class(node)
-          _class_name, _base_class, *members = *node
-          check_members(node.loc.keyword, members)
-        end
-
-        def on_sclass(node)
-          _class_name, *members = *node
-
-          check_members(node.loc.keyword, members)
-        end
-
-        def on_send(node)
-          super
-          return unless node.adjacent_def_modifier?
-
-          *_, body = *node.first_argument
-
-          def_end_config = config.for_cop('Layout/DefEndAlignment')
-          style = def_end_config['EnforcedStyleAlignWith'] || 'start_of_line'
-          base = if style == 'def'
-                   node.first_argument
-                 else
-                   leftmost_modifier_of(node) || node
-                 end
-
-          check_indentation(base.source_range, body)
-          ignore_node(node.first_argument)
-        end
-        alias on_csend on_send
-
-        def on_def(node)
-          return if ignored_node?(node)
-
-          check_indentation(node.loc.keyword, node.body)
-        end
-        alias on_defs on_def
-
-        def on_while(node, base = node)
-          return if ignored_node?(node)
-
-          return unless node.single_line_condition?
-
-          check_indentation(base.loc, node.body)
-        end
-
-        alias on_until on_while
-
-        def on_case(case_node)
-          case_node.each_when do |when_node|
-            check_indentation(when_node.loc.keyword, when_node.body)
-          end
-
-          check_indentation(case_node.when_branches.last.loc.keyword,
-                            case_node.else_branch)
-        end
-
-        def on_if(node, base = node)
-          return if ignored_node?(node)
-          return if node.ternary? || node.modifier_form?
-
-          check_if(node, node.body, node.else_branch, base.loc)
-        end
-
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
-        end
-
-        private
-
-        def check_members(base, members)
-          check_indentation(base, select_check_member(members.first))
-
-          return unless members.any? && members.first.begin_type?
-
-          if indentation_consistency_style == 'rails'
-            check_members_for_rails_style(members)
-          else
-            members.first.children.each do |member|
-              next if member.send_type? && member.access_modifier?
-
-              check_indentation(base, member)
-            end
-          end
-        end
-
-        def select_check_member(member)
-          return unless member
-
-          if access_modifier?(member.children.first)
-            member.children.first
-          else
-            member
-          end
-        end
-
-        def check_members_for_rails_style(members)
-          each_member(members) do |member, previous_modifier|
-            check_indentation(previous_modifier, member,
-                              indentation_consistency_style)
-          end
-        end
-
-        def each_member(members)
-          previous_modifier = nil
-          members.first.children.each do |member|
-            if member.send_type? && special_modifier?(member)
-              previous_modifier = member
-            elsif previous_modifier
-              yield member, previous_modifier.source_range
-              previous_modifier = nil
-            end
-          end
-        end
-
-        def special_modifier?(node)
-          node.bare_access_modifier? && SPECIAL_MODIFIERS.include?(node.source)
-        end
-
-        def indentation_consistency_style
-          config.for_cop('Layout/IndentationConsistency')['EnforcedStyle']
-        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
-
-          case rhs.type
-          when :if            then on_if(rhs, base)
-          when :while, :until then on_while(rhs, base)
-          else                     return
-          end
-
-          ignore_node(rhs)
-        end
-
-        def check_if(node, body, else_clause, base_loc)
-          return if node.ternary?
-
-          check_indentation(base_loc, body)
-          return unless else_clause
-
-          # If the else clause is an elsif, it will get its own on_if call so
-          # we don't need to process it here.
-          return if else_clause.if_type? && else_clause.elsif?
-
-          check_indentation(node.loc.else, else_clause)
-        end
-
-        def check_indentation(base_loc, body_node, style = 'normal')
-          return unless indentation_to_check?(base_loc, body_node)
-
-          indentation = column_offset_between(body_node.loc, base_loc)
-          @column_delta = configured_indentation_width - indentation
-          return if @column_delta.zero?
-
-          offense(body_node, indentation, style)
-        end
-
-        def offense(body_node, indentation, style)
-          # This cop only auto-corrects the first statement in a def body, for
-          # example.
-          if body_node.begin_type? && !parentheses?(body_node)
-            body_node = body_node.children.first
-          end
-
-          # Since autocorrect changes a number of lines, and not only the line
-          # where the reported offending range is, we avoid auto-correction if
-          # this cop has already found other offenses is the same
-          # range. Otherwise, two corrections can interfere with each other,
-          # resulting in corrupted code.
-          node = if autocorrect? && other_offense_in_same_range?(body_node)
-                   nil
-                 else
-                   body_node
-                 end
-
-          name = style == 'normal' ? '' : " #{style}"
-          message = message(configured_indentation_width, indentation, name)
-
-          add_offense(node, location: offending_range(body_node, indentation),
-                            message: message)
-        end
-
-        def message(configured_indentation_width, indentation, name)
-          format(
-            MSG,
-            configured_indentation_width: configured_indentation_width,
-            indentation: indentation,
-            name: name
-          )
-        end
-
-        # Returns true if the given node is within another node that has
-        # already been marked for auto-correction by this cop.
-        def other_offense_in_same_range?(node)
-          expr = node.source_range
-          @offense_ranges ||= []
-
-          return true if @offense_ranges.any? { |r| within?(expr, r) }
-
-          @offense_ranges << expr
-          false
-        end
-
-        def indentation_to_check?(base_loc, body_node)
-          return false if skip_check?(base_loc, body_node)
-
-          if %i[rescue ensure].include?(body_node.type)
-            block_body, = *body_node
-            return unless block_body
-          end
-
-          true
-        end
-
-        def skip_check?(base_loc, body_node)
-          return true if ignored_line?(base_loc)
-          return true unless body_node
-
-          # Don't check if expression is on same line as "then" keyword, etc.
-          return true if body_node.loc.line == base_loc.line
-
-          return true if starts_with_access_modifier?(body_node)
-
-          # Don't check indentation if the line doesn't start with the body.
-          # For example, lines like "else do_something".
-          first_char_pos_on_line = body_node.source_range.source_line =~ /\S/
-          return true unless body_node.loc.column == first_char_pos_on_line
-        end
-
-        def offending_range(body_node, indentation)
-          expr = body_node.source_range
-          begin_pos = expr.begin_pos
-          ind = expr.begin_pos - indentation
-          pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
-          range_between(pos.begin, pos.end)
-        end
-
-        def starts_with_access_modifier?(body_node)
-          return unless body_node.begin_type?
-
-          starting_node = body_node.children.first
-          return unless starting_node
-
-          starting_node.send_type? && starting_node.bare_access_modifier?
-        end
-
-        def configured_indentation_width
-          cop_config['Width']
-        end
-
-        def leftmost_modifier_of(node)
-          return node unless node.parent && node.parent.send_type?
-
-          leftmost_modifier_of(node.parent)
-        end
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for indentation of the first non-blank non-comment
-      # line in a file.
-      #
-      # @example
-      #   # bad
-      #      class A
-      #        def foo; end
-      #      end
-      #
-      #   # good
-      #   class A
-      #     def foo; end
-      #   end
-      #
-      class InitialIndentation < Cop
-        include RangeHelp
-
-        MSG = 'Indentation of first line in file detected.'.freeze
-
-        def investigate(_processed_source)
-          space_before(first_token) do |space|
-            add_offense(space, location: first_token.pos)
-          end
-        end
-
-        def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
-        end
-
-        private
-
-        def first_token
-          processed_source.find_token { |t| !t.text.start_with?('#') }
-        end
-
-        def space_before(token)
-          return unless token
-          return if token.column.zero?
-
-          space_range =
-            range_with_surrounding_space(range: token.pos,
-                                         side: :left,
-                                         newlines: false)
-          # If the file starts with a byte order mark (BOM), the column can be
-          # non-zero, but then we find out here if there's no space to the left
-          # of the first token.
-          return if space_range == token.pos
-
-          yield range_between(space_range.begin_pos, token.begin_pos)
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks for unnecessary leading blank lines at the beginning
-      # of a file.
-      #
-      # @example
-      #
-      #   # bad
-      #   # (start of file)
-      #
-      #   class Foo
-      #   end
-      #
-      #   # bad
-      #   # (start of file)
-      #
-      #   # a comment
-      #
-      #   # good
-      #   # (start of file)
-      #   class Foo
-      #   end
-      #
-      #   # good
-      #   # (start of file)
-      #   # a comment
-      class LeadingBlankLines < Cop
-        MSG = 'Unnecessary blank line at the beginning of the source.'.freeze
-
-        def investigate(processed_source)
-          token = processed_source.tokens[0]
-          return unless token && token.line > 1
-
-          add_offense(processed_source.tokens[0],
-                      location: processed_source.tokens[0].pos)
-        end
-
-        def autocorrect(node)
-          range = Parser::Source::Range.new(processed_source.buffer,
-                                            0,
-                                            node.begin_pos)
-
-          lambda do |corrector|
-            corrector.remove(range)
-          end
-        end
-      end
-    end
-  end
-end