super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the indentation of here document closings.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     def bar
+      #       <<~SQL
+      #         'Hi'
+      #     SQL
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def bar
+      #       <<~SQL
+      #         'Hi'
+      #       SQL
+      #     end
+      #   end
+      #
+      #   # bad
+      #
+      #   # heredoc contents is before closing heredoc.
+      #   foo arg,
+      #       <<~EOS
+      #     Hi
+      #       EOS
+      #
+      #   # good
+      #   foo arg,
+      #       <<~EOS
+      #     Hi
+      #   EOS
+      #
+      #   # good
+      #   foo arg,
+      #       <<~EOS
+      #         Hi
+      #       EOS
+      #
+      class ClosingHeredocIndentation < Base
+        include Heredoc
+        extend AutoCorrector
+
+        SIMPLE_HEREDOC = '<<'
+        MSG = '`%<closing>s` is not aligned with `%<opening>s`.'
+        MSG_ARG = '`%<closing>s` is not aligned with `%<opening>s` or ' \
+                  'beginning of method definition.'
+
+        def on_heredoc(node)
+          return if heredoc_type(node) == SIMPLE_HEREDOC ||
+                    opening_indentation(node) == closing_indentation(node) ||
+                    argument_indentation_correct?(node)
+
+          message = message(node)
+          add_offense(node.loc.heredoc_end, message: message) do |corrector|
+            corrector.replace(node.loc.heredoc_end, indented_end(node))
+          end
+        end
+
+        private
+
+        def opening_indentation(node)
+          indent_level(heredoc_opening(node))
+        end
+
+        def argument_indentation_correct?(node)
+          return false unless node.argument? || node.chained?
+
+          opening_indentation(
+            find_node_used_heredoc_argument(node.parent)
+          ) == closing_indentation(node)
+        end
+
+        def closing_indentation(node)
+          indent_level(heredoc_closing(node))
+        end
+
+        def heredoc_opening(node)
+          node.source_range.source_line
+        end
+
+        def heredoc_closing(node)
+          node.loc.heredoc_end.source_line
+        end
+
+        def indented_end(node)
+          closing_indent = closing_indentation(node)
+          opening_indent = opening_indentation(node)
+          closing_text = heredoc_closing(node)
+          closing_text.gsub(/^\s{#{closing_indent}}/, ' ' * opening_indent)
+        end
+
+        def find_node_used_heredoc_argument(node)
+          if node.parent&.send_type?
+            find_node_used_heredoc_argument(node.parent)
+          else
+            node
+          end
+        end
+
+        def message(node)
+          format(
+            node.argument? ? MSG_ARG : MSG,
+            closing: heredoc_closing(node).strip,
+            opening: heredoc_opening(node).strip
+          )
+        end
+
+        def indent_level(source_line)
+          source_line[/\A */].length
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the indentation of hanging closing parentheses in
+      # method calls, method definitions, and grouped expressions. A hanging
+      # closing parenthesis means `)` preceded by a line break.
+      #
+      # @example
+      #
+      #   # bad
+      #   some_method(
+      #     a,
+      #     b
+      #     )
+      #
+      #   some_method(
+      #     a, b
+      #     )
+      #
+      #   some_method(a, b, c
+      #     )
+      #
+      #   some_method(a,
+      #               b,
+      #               c
+      #     )
+      #
+      #   some_method(a,
+      #     x: 1,
+      #     y: 2
+      #     )
+      #
+      #   # Scenario 1: When First Parameter Is On Its Own Line
+      #
+      #   # good: when first param is on a new line, right paren is *always*
+      #   #       outdented by IndentationWidth
+      #   some_method(
+      #     a,
+      #     b
+      #   )
+      #
+      #   # good
+      #   some_method(
+      #     a, b
+      #   )
+      #
+      #   # Scenario 2: When First Parameter Is On The Same Line
+      #
+      #   # good: when all other params are also on the same line, outdent
+      #   #       right paren by IndentationWidth
+      #   some_method(a, b, c
+      #              )
+      #
+      #   # good: when all other params are on multiple lines, but are lined
+      #   #       up, align right paren with left paren
+      #   some_method(a,
+      #               b,
+      #               c
+      #              )
+      #
+      #   # good: when other params are not lined up on multiple lines, outdent
+      #   #       right paren by IndentationWidth
+      #   some_method(a,
+      #     x: 1,
+      #     y: 2
+      #   )
+      #
+      #
+      class ClosingParenthesisIndentation < Base
+        include Alignment
+        extend AutoCorrector
+
+        MSG_INDENT = 'Indent `)` to column %<expected>d (not %<actual>d)'
+
+        MSG_ALIGN = 'Align `)` with `(`.'
+
+        def on_send(node)
+          check(node, node.arguments)
+        end
+        alias on_csend on_send
+
+        def on_begin(node)
+          check(node, node.children)
+        end
+
+        def on_def(node)
+          check(node.arguments, node.arguments)
+        end
+        alias on_defs on_def
+
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
+        def check(node, elements)
+          if elements.empty?
+            check_for_no_elements(node)
+          else
+            check_for_elements(node, elements)
+          end
+        end
+
+        def check_for_elements(node, elements)
+          left_paren  = node.loc.begin
+          right_paren = node.loc.end
+
+          return unless right_paren && begins_its_line?(right_paren)
+
+          correct_column = expected_column(left_paren, elements)
+
+          @column_delta = correct_column - right_paren.column
+
+          return if @column_delta.zero?
+
+          message = message(correct_column, left_paren, right_paren)
+          add_offense(right_paren, message: message) do |corrector|
+            autocorrect(corrector, right_paren)
+          end
+        end
+
+        def check_for_no_elements(node)
+          left_paren = node.loc.begin
+          right_paren = node.loc.end
+          return unless right_paren && begins_its_line?(right_paren)
+
+          candidates = correct_column_candidates(node, left_paren)
+
+          return if candidates.include?(right_paren.column)
+
+          # Although there are multiple choices for a correct column,
+          # select the first one of candidates to determine a specification.
+          correct_column = candidates.first
+          @column_delta = correct_column - right_paren.column
+          message = message(correct_column, left_paren, right_paren)
+          add_offense(right_paren, message: message) do |corrector|
+            autocorrect(corrector, right_paren)
+          end
+        end
+
+        def expected_column(left_paren, elements)
+          if line_break_after_left_paren?(left_paren, elements)
+            source_indent = processed_source.line_indentation(first_argument_line(elements))
+            new_indent    = source_indent - configured_indentation_width
+
+            new_indent.negative? ? 0 : new_indent
+          elsif all_elements_aligned?(elements)
+            left_paren.column
+          else
+            processed_source.line_indentation(first_argument_line(elements))
+          end
+        end
+
+        def all_elements_aligned?(elements)
+          if elements.first.hash_type?
+            elements.first.each_child_node.map { |child| child.loc.column }
+          else
+            elements.flat_map do |e|
+              e.loc.column
+            end
+          end.uniq.one?
+        end
+
+        def first_argument_line(elements)
+          elements.first.loc.first_line
+        end
+
+        def correct_column_candidates(node, left_paren)
+          [
+            processed_source.line_indentation(left_paren.line),
+            left_paren.column,
+            node.loc.column
+          ]
+        end
+
+        def message(correct_column, left_paren, right_paren)
+          if correct_column == left_paren.column
+            MSG_ALIGN
+          else
+            format(MSG_INDENT, expected: correct_column, actual: right_paren.column)
+          end
+        end
+
+        def line_break_after_left_paren?(left_paren, elements)
+          elements.first && elements.first.loc.line > left_paren.line
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/layout/comment_indentation.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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
+      #
+      # @example AllowForAlignment: false (default)
+      #   # bad
+      #   a = 1 # A really long comment
+      #         # spanning two lines.
+      #
+      #   # good
+      #   # A really long comment spanning one line.
+      #   a = 1
+      #
+      # @example AllowForAlignment: true
+      #   # good
+      #   a = 1 # A really long comment
+      #         # spanning two lines.
+      class CommentIndentation < Base
+        include Alignment
+        extend AutoCorrector
+
+        MSG = 'Incorrect indentation detected (column %<column>d ' \
+              'instead of %<correct_comment_indentation>d).'
+
+        def on_new_investigation
+          processed_source.comments.each_with_index { |comment, ix| check(comment, ix) }
+        end
+
+        private
+
+        def autocorrect(corrector, comment)
+          autocorrect_preceding_comments(corrector, comment)
+
+          autocorrect_one(corrector, comment)
+        end
+
+        # 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(corrector, comment)
+          comments = processed_source.comments
+          index = comments.index(comment)
+
+          comments[0..index]
+            .reverse_each
+            .each_cons(2)
+            .take_while { |below, above| should_correct?(above, below) }
+            .map { |_, above| autocorrect_one(corrector, above) }
+        end
+
+        def should_correct?(preceding_comment, reference_comment)
+          loc = preceding_comment.loc
+          ref_loc = reference_comment.loc
+          loc.line == ref_loc.line - 1 && loc.column == ref_loc.column
+        end
+
+        def autocorrect_one(corrector, comment)
+          AlignmentCorrector.correct(corrector, processed_source, comment, @column_delta)
+        end
+
+        def check(comment, comment_index)
+          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
+
+          return if correctly_aligned_with_preceding_comment?(comment_index, column)
+
+          add_offense(comment, message: message(column, correct_comment_indentation)) do |corrector|
+            autocorrect(corrector, comment)
+          end
+        end
+
+        # Returns true if:
+        # a) the cop is configured to allow extra indentation for alignment, and
+        # b) the currently inspected comment is aligned with the nearest preceding end-of-line
+        #    comment.
+        def correctly_aligned_with_preceding_comment?(comment_index, column)
+          return false unless cop_config['AllowForAlignment']
+
+          processed_source.comments[0...comment_index].reverse_each do |other_comment|
+            return other_comment.loc.column == column unless own_line_comment?(other_comment)
+          end
+
+          false
+        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]
+          /\A\s*#/.match?(own_line)
+        end
+
+        def line_after_comment(comment)
+          lines = processed_source.lines
+          lines[comment.loc.line..].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)
+          rule = config.for_cop('Layout/AccessModifierIndentation')['EnforcedStyle'] == 'outdent'
+          access_modifier = 'private|protected|public'
+          /\A\s*(end\b|[)}\]])/.match?(line) || (rule && /\A\s*(#{access_modifier})\b/.match?(line))
+        end
+
+        def two_alternatives?(line)
+          /^\s*(else|elsif|when|in|rescue|ensure)\b/.match?(line)
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/layout/condition_position.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for conditions that are not on the same line as
+      # if/while/until.
+      #
+      # @example
+      #
+      #   # bad
+      #   if
+      #     some_condition
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if some_condition
+      #     do_something
+      #   end
+      class ConditionPosition < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Place the condition on the same line as `%<keyword>s`.'
+
+        def on_if(node)
+          return if node.ternary?
+
+          check(node)
+        end
+
+        def on_while(node)
+          check(node)
+        end
+        alias on_until on_while
+
+        private
+
+        def check(node)
+          return if node.modifier_form? || node.single_line_condition?
+
+          condition = node.condition
+          message = message(condition)
+
+          add_offense(condition, message: message) do |corrector|
+            corrector.insert_after(condition.parent.loc.keyword, " #{condition.source}")
+            corrector.remove(removal_range(node, condition))
+          end
+        end
+
+        def message(condition)
+          format(MSG, keyword: condition.parent.keyword)
+        end
+
+        # When a body statement shares the condition's line (e.g. `while\n cond; body\nend`),
+        # removing the whole line would delete the body too. In that case only remove the
+        # condition and its trailing separator, preserving the body statement.
+        def removal_range(node, condition)
+          body = node.body
+          if body && body.source_range.line == condition.source_range.last_line
+            range_between(condition.source_range.begin_pos, body.source_range.begin_pos)
+          else
+            range_by_whole_lines(condition.source_range, include_final_newline: true)
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/layout/def_end_alignment.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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 < Base
+        include EndKeywordAlignment
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'
+
+        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(:any_def).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
+
+        private
+
+        def autocorrect(corrector, node)
+          if style == :start_of_line && node.parent&.send_type?
+            AlignmentCorrector.align_end(corrector, processed_source, node, node.parent)
+          else
+            AlignmentCorrector.align_end(corrector, processed_source, node, node)
+          end
+        end
+      end
+    end
+  end
+end