super-pro-sys 0.0.1

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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 < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        def self.autocorrect_incompatible_with
+          [Style::RedundantSelf]
+        end
+
+        def on_send(node)
+          return unless node.dot? || node.safe_navigation?
+
+          return correct_style_detected if proper_dot_position?(node)
+
+          opposite_style_detected
+          dot = node.loc.dot
+          message = message(dot)
+
+          add_offense(dot, message: message) { |corrector| autocorrect(corrector, dot, node) }
+        end
+        alias on_csend on_send
+
+        private
+
+        def autocorrect(corrector, dot, node)
+          dot_range = if processed_source[dot.line - 1].strip == '.'
+                        range_by_whole_lines(dot, include_final_newline: true)
+                      else
+                        dot
+                      end
+          corrector.remove(dot_range)
+          case style
+          when :leading
+            corrector.insert_before(selector_range(node), dot.source)
+          when :trailing
+            corrector.insert_after(node.receiver, dot.source)
+          end
+        end
+
+        def message(dot)
+          "Place the #{dot.source} 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)
+          selector_range = selector_range(node)
+
+          return true if same_line?(selector_range, end_range(node.receiver))
+
+          selector_line = selector_range.line
+          receiver_line = receiver_end_line(node.receiver)
+          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)
+          # Also, in the case of a heredoc, the receiver will end after the dot,
+          # because the heredoc body is on subsequent lines, so use the highest
+          # line to compare to.
+          return true if line_between?(selector_line, [receiver_line, dot_line].max)
+
+          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 receiver_end_line(node)
+          if (line = last_heredoc_line(node))
+            line
+          else
+            node.source_range.end.line
+          end
+        end
+
+        def last_heredoc_line(node)
+          if node.call_type?
+            node.arguments.select { |arg| heredoc?(arg) }.map { |arg| arg.loc.heredoc_end.line }.max
+          elsif heredoc?(node)
+            node.loc.heredoc_end.line
+          end
+        end
+
+        def heredoc?(node)
+          node.any_str_type? && node.heredoc?
+        end
+
+        def end_range(node)
+          node.source_range.end
+        end
+
+        def selector_range(node)
+          return node unless node.call_type?
+
+          # l.(1) has no selector, so we use the opening parenthesis instead
+          node.loc.selector || node.loc.begin
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the alignment of else keywords. Normally they should
+      # be aligned with an if/unless/while/until/begin/def/rescue 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 < Base
+        include EndKeywordAlignment
+        include Alignment
+        include CheckAssignment
+        extend AutoCorrector
+
+        MSG = 'Align `%<else_range>s` with `%<base_range>s`.'
+
+        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?(: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 on_case_match(node)
+          return unless node.else?
+
+          check_alignment(node.in_pattern_branches.last.loc.keyword, node.loc.else)
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
+        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, :numblock, :itblock
+            assignment_node = assignment_node(parent)
+            if same_line?(parent, assignment_node)
+              assignment_node.source_range
+            else
+              parent.send_node.source_range
+            end
+          else node.loc.keyword
+          end
+        end
+
+        def base_for_method_definition(node)
+          parent = node.parent
+          if 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, message: message) do |corrector|
+            autocorrect(corrector, else_range)
+          end
+        end
+
+        def assignment_node(node)
+          assignment_node = node.ancestors.first
+          return unless assignment_node&.assignment?
+
+          assignment_node
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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 < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Source code comment is empty.'
+
+        def on_new_investigation
+          if allow_margin_comment?
+            comments = concat_consecutive_comments(processed_source.comments)
+
+            investigate(comments)
+          else
+            processed_source.comments.each do |comment|
+              next unless empty_comment_only?(comment_text(comment))
+
+              add_offense(comment) { |corrector| autocorrect(corrector, comment) }
+            end
+          end
+        end
+
+        private
+
+        def investigate(comments)
+          comments.each do |comment|
+            next unless empty_comment_only?(comment[0])
+
+            comment[1].each do |offense_comment|
+              add_offense(offense_comment) do |corrector|
+                autocorrect(corrector, offense_comment)
+              end
+            end
+          end
+        end
+
+        def autocorrect(corrector, node)
+          range = if inline_comment?(node)
+                    range_with_surrounding_space(node.source_range, newlines: false)
+                  else
+                    range_by_whole_lines(node.source_range, include_final_newline: true)
+                  end
+
+          corrector.remove(range)
+        end
+
+        def concat_consecutive_comments(comments)
+          consecutive_comments = comments.chunk_while do |i, j|
+            i.loc.line.succ == j.loc.line && i.loc.column == j.loc.column
+          end
+
+          consecutive_comments.map do |chunk|
+            joined_text = chunk.map { |c| comment_text(c) }.join
+            [joined_text, chunk]
+          end
+        end
+
+        def empty_comment_only?(comment_text)
+          empty_comment_pattern = if allow_border_comment?
+                                    /\A(#\n)+\z/
+                                  else
+                                    /\A(#+\n)+\z/
+                                  end
+
+          empty_comment_pattern.match?(comment_text)
+        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
+
+        # A comment is inline when code precedes it on the same line. Detecting this
+        # from the source (rather than the token stream) is required because, for a
+        # comment trailing a heredoc opener, the preceding token is the heredoc end on
+        # a later line, which would wrongly trigger whole-line removal of the opener.
+        def inline_comment?(comment)
+          preceding_source = processed_source.lines[comment.loc.line - 1][0...comment.loc.column]
+          !preceding_source.strip.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Enforces empty line after guard clause.
+      #
+      # This cop allows a SimpleCov directive comment after guard clause because
+      # SimpleCov excludes code from the coverage report by wrapping it in such directives.
+      # Both the legacy `# :nocov:` comment and the newer `# simplecov:disable` /
+      # `# simplecov:enable` comments are recognized:
+      #
+      # [source,ruby]
+      # ----
+      # def foo
+      #   # :nocov:
+      #   return if condition
+      #   # :nocov:
+      #   bar
+      # end
+      #
+      # def foo
+      #   # simplecov:disable
+      #   return if condition
+      #   # simplecov:enable
+      #   bar
+      # end
+      # ----
+      #
+      # Refer to SimpleCov's documentation for more details:
+      # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo
+      #     return if need_return?
+      #     bar
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     return if need_return?
+      #
+      #     bar
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     return if something?
+      #     return if something_different?
+      #
+      #     bar
+      #   end
+      #
+      #   # also good
+      #   def foo
+      #     if something?
+      #       do_something
+      #       return if need_return?
+      #     end
+      #   end
+      class EmptyLineAfterGuardClause < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend Util
+
+        MSG = 'Add empty line after guard clause.'
+        END_OF_HEREDOC_LINE = 1
+        SIMPLECOV_COMMENT_PATTERN = /\A#\s*(?::nocov:|simplecov\s*:\s*(?:disable|enable)\b)/.freeze
+
+        # @!method guard_clause_branch?(node)
+        def_node_matcher :guard_clause_branch?, <<~PATTERN
+          {(send nil? {:raise :fail} ...) return break next}
+        PATTERN
+
+        def on_if(node)
+          return if correct_style?(node)
+          return if multiple_statements_on_line?(node)
+
+          if node.modifier_form? && (heredoc_node = last_heredoc_argument(node))
+            if next_line_empty_or_allowed_directive_comment?(heredoc_line(node, heredoc_node))
+              return
+            end
+
+            add_offense(heredoc_node.loc.heredoc_end) do |corrector|
+              autocorrect(corrector, heredoc_node)
+            end
+          else
+            return if next_line_empty_or_allowed_directive_comment?(node.last_line)
+
+            add_offense(offense_location(node)) { |corrector| autocorrect(corrector, node) }
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          node_range = if heredoc?(node)
+                         range_by_whole_lines(node.loc.heredoc_body)
+                       else
+                         range_by_whole_lines(node.source_range)
+                       end
+
+          next_line = node_range.last_line + 1
+          if next_line_allowed_directive_comment?(next_line)
+            node_range = processed_source.comment_at_line(next_line)
+          end
+
+          corrector.insert_after(node_range, "\n")
+        end
+
+        def correct_style?(node)
+          !node.if_branch&.guard_clause? ||
+            next_line_rescue_or_ensure?(node) ||
+            next_sibling_parent_empty_or_else?(node) ||
+            next_sibling_empty_or_guard_clause?(node)
+        end
+
+        def contains_guard_clause?(node)
+          return false unless (branch = node.if_branch)
+
+          branch.guard_clause? || guard_clause_branch?(branch)
+        end
+
+        def next_line_empty_or_allowed_directive_comment?(line)
+          return true if next_line_empty?(line)
+
+          next_line = line + 1
+          next_line_allowed_directive_comment?(next_line) && next_line_empty?(next_line)
+        end
+
+        def next_line_empty?(line)
+          processed_source[line].blank?
+        end
+
+        def next_line_allowed_directive_comment?(line)
+          return false unless (comment = processed_source.comment_at_line(line))
+
+          DirectiveComment.new(comment).enabled? || simplecov_directive_comment?(comment)
+        end
+
+        def next_line_rescue_or_ensure?(node)
+          parent = node.parent
+          parent.nil? || parent.rescue_type? || parent.ensure_type?
+        end
+
+        def next_sibling_parent_empty_or_else?(node)
+          next_sibling = node.right_sibling
+          return true unless next_sibling.is_a?(AST::Node)
+
+          parent = next_sibling.parent
+
+          parent&.if_type? && parent.else?
+        end
+
+        def next_sibling_empty_or_guard_clause?(node)
+          next_sibling = node.right_sibling
+          return true if next_sibling.nil?
+
+          next_sibling.if_type? && contains_guard_clause?(next_sibling)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def last_heredoc_argument(node)
+          n = last_heredoc_argument_node(node)
+          n = n.children.first while n.respond_to?(:begin_type?) && n.begin_type?
+
+          return n if heredoc?(n)
+          return unless n.respond_to?(:arguments)
+
+          n.arguments.each do |argument|
+            node = last_heredoc_argument(argument)
+            return node if node
+          end
+
+          last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def last_heredoc_argument_node(node)
+          return node unless node.respond_to?(:if_branch)
+
+          if node.if_branch.and_type?
+            node.if_branch.children.first
+          elsif use_heredoc_in_condition?(node.condition)
+            node.condition
+          else
+            node.if_branch.children.last
+          end
+        end
+
+        def heredoc_line(node, heredoc_node)
+          heredoc_body = heredoc_node.loc.heredoc_body
+          num_of_heredoc_lines = heredoc_body.last_line - heredoc_body.first_line
+
+          node.last_line + num_of_heredoc_lines + END_OF_HEREDOC_LINE
+        end
+
+        def heredoc?(node)
+          node.respond_to?(:heredoc?) && node.heredoc?
+        end
+
+        def use_heredoc_in_condition?(condition)
+          condition.descendants.any? do |descendant|
+            descendant.respond_to?(:heredoc?) && descendant.heredoc?
+          end
+        end
+
+        def offense_location(node)
+          if node.loc?(:end)
+            node.loc.end
+          else
+            node
+          end
+        end
+
+        def multiple_statements_on_line?(node)
+          parent = node.parent
+          return false unless parent
+
+          parent.begin_type? && same_line?(node, node.right_sibling)
+        end
+
+        # SimpleCov excludes code from the coverage report by wrapping it in directive comments:
+        # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
+        def simplecov_directive_comment?(comment)
+          SIMPLECOV_COMMENT_PATTERN.match?(comment.text)
+        end
+      end
+    end
+  end
+end