super-pro-sys 0.0.1

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for a newline after the final magic comment.
+      #
+      # @example
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   # Some documentation for Person
+      #   class Person
+      #     # Some code
+      #   end
+      #
+      #   # bad
+      #   # frozen_string_literal: true
+      #   # Some documentation for Person
+      #   class Person
+      #     # Some code
+      #   end
+      class EmptyLineAfterMagicComment < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Add an empty line after magic comments.'
+
+        def on_new_investigation
+          return unless (last_magic_comment = last_magic_comment(processed_source))
+          return unless (next_line = processed_source[last_magic_comment.loc.line])
+          return if next_line.strip.empty?
+
+          offending_range = offending_range(last_magic_comment)
+
+          add_offense(offending_range) do |corrector|
+            corrector.insert_before(offending_range, "\n")
+          end
+        end
+
+        private
+
+        def offending_range(last_magic_comment)
+          source_range(processed_source.buffer, last_magic_comment.loc.line + 1, 0)
+        end
+
+        # Find the last magic comment in the source file.
+        #
+        # Take all comments that precede the first line of code (or just take
+        # them all in the case when there is no code), select the
+        # magic comments, and return the last magic comment in the file.
+        #
+        # @return [Parser::Source::Comment] if magic comments exist before code
+        # @return [nil] otherwise
+        def last_magic_comment(source)
+          comments_before_code(source)
+            .reverse
+            .find { |comment| MagicComment.parse(comment.text).any? }
+        end
+
+        def comments_before_code(source)
+          if source.ast
+            source.comments.take_while { |comment| comment.loc.line < source.ast.loc.line }
+          else
+            source.comments
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Enforces empty line after multiline condition.
+      #
+      # @example
+      #   # bad
+      #   if multiline &&
+      #     condition
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if multiline &&
+      #     condition
+      #
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   case x
+      #   when foo,
+      #     bar
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   case x
+      #   when foo,
+      #     bar
+      #
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue FooError,
+      #     BarError
+      #     handle_error
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue FooError,
+      #     BarError
+      #
+      #     handle_error
+      #   end
+      #
+      class EmptyLineAfterMultilineCondition < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use empty line after multiline condition.'
+
+        def on_if(node)
+          return if node.ternary?
+
+          if node.modifier_form?
+            check_condition(node.condition) if node.right_sibling
+          else
+            check_condition(node.condition)
+          end
+        end
+
+        def on_while(node)
+          check_condition(node.condition)
+        end
+        alias on_until on_while
+
+        def on_while_post(node)
+          return unless node.right_sibling
+
+          check_condition(node.condition)
+        end
+        alias on_until_post on_while_post
+
+        def on_case(node)
+          node.when_branches.each do |when_node|
+            last_condition = when_node.conditions.last
+
+            next if !multiline_when_condition?(when_node) ||
+                    next_line_empty?(last_condition.last_line)
+
+            add_offense(when_node, &autocorrect(last_condition))
+          end
+        end
+
+        def on_rescue(node)
+          node.resbody_branches.each do |resbody|
+            rescued_exceptions = resbody.exceptions
+            next if !multiline_rescue_exceptions?(rescued_exceptions) ||
+                    next_line_empty?(rescued_exceptions.last.last_line)
+
+            add_offense(resbody, &autocorrect(rescued_exceptions.last))
+          end
+        end
+
+        private
+
+        def check_condition(condition)
+          return unless condition.multiline?
+          return if next_line_empty?(condition.last_line)
+
+          add_offense(condition, &autocorrect(condition))
+        end
+
+        def next_line_empty?(line)
+          processed_source[line].blank?
+        end
+
+        def multiline_when_condition?(when_node)
+          when_node.conditions.first.first_line != when_node.conditions.last.last_line
+        end
+
+        def multiline_rescue_exceptions?(exception_nodes)
+          return false if exception_nodes.size <= 1
+
+          first, *_rest, last = *exception_nodes
+          first.first_line != last.last_line
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_by_whole_lines(node.source_range)
+            corrector.insert_after(range, "\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks whether class/module/method definitions are
+      # separated by one or more empty lines.
+      #
+      # `NumberOfEmptyLines` can be an integer (default is 1) or
+      # an array (e.g. [1, 2]) to specify a minimum and maximum
+      # number of empty lines permitted.
+      #
+      # `AllowAdjacentOneLineDefs` configures whether adjacent
+      # one-line definitions are considered an offense.
+      #
+      # @example EmptyLineBetweenMethodDefs: true (default)
+      #   # checks for empty lines between method definitions.
+      #
+      #   # bad
+      #   def a
+      #   end
+      #   def b
+      #   end
+      #
+      #   # good
+      #   def a
+      #   end
+      #
+      #   def b
+      #   end
+      #
+      # @example EmptyLineBetweenClassDefs: true (default)
+      #   # checks for empty lines between class definitions.
+      #
+      #   # bad
+      #   class A
+      #   end
+      #   class B
+      #   end
+      #   def b
+      #   end
+      #
+      #   # good
+      #   class A
+      #   end
+      #
+      #   class B
+      #   end
+      #
+      #   def b
+      #   end
+      #
+      # @example EmptyLineBetweenModuleDefs: true (default)
+      #   # checks for empty lines between module definitions.
+      #
+      #   # bad
+      #   module A
+      #   end
+      #   module B
+      #   end
+      #   def b
+      #   end
+      #
+      #   # good
+      #   module A
+      #   end
+      #
+      #   module B
+      #   end
+      #
+      #   def b
+      #   end
+      #
+      # @example AllowAdjacentOneLineDefs: true (default)
+      #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #   class ErrorB < BaseError; end
+      #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #
+      #   class ErrorB < BaseError; end
+      #
+      #   # good - DefLikeMacros: [memoize]
+      #   memoize :attribute_a
+      #   memoize :attribute_b
+      #
+      #   # good
+      #   memoize :attribute_a
+      #
+      #   memoize :attribute_b
+      #
+      # @example AllowAdjacentOneLineDefs: false
+      #
+      #   # bad
+      #   class ErrorA < BaseError; end
+      #   class ErrorB < BaseError; end
+      #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #
+      #   class ErrorB < BaseError; end
+      #
+      #   # bad - DefLikeMacros: [memoize]
+      #   memoize :attribute_a
+      #   memoize :attribute_b
+      #
+      #   # good
+      #   memoize :attribute_a
+      #
+      #   memoize :attribute_b
+      #
+      class EmptyLineBetweenDefs < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Expected %<expected>s between %<type>s definitions; found %<actual>d.'
+
+        def self.autocorrect_incompatible_with
+          [Layout::EmptyLines]
+        end
+
+        # We operate on `begin` nodes, instead of using `OnMethodDef`,
+        # so that we can walk over pairs of consecutive nodes and
+        # efficiently access a node's predecessor; #prev_node ends up
+        # doing a linear scan over siblings, so we don't want to call
+        # it on each def.
+        def on_begin(node)
+          node.children.each_cons(2) do |prev, n|
+            nodes = [prev, n]
+            check_defs(nodes) if nodes.all? { |def_candidate| candidate?(def_candidate) }
+          end
+        end
+
+        def check_defs(nodes)
+          count = blank_lines_count_between(*nodes)
+
+          return if line_count_allowed?(count)
+          return if multiple_blank_lines_groups?(*nodes)
+          return if nodes.all?(&:single_line?) && cop_config['AllowAdjacentOneLineDefs']
+
+          correction_node = nodes.last
+
+          location = def_location(correction_node)
+          add_offense(location, message: message(correction_node, count: count)) do |corrector|
+            autocorrect(corrector, *nodes, count)
+          end
+        end
+
+        def autocorrect(corrector, prev_def, node, count)
+          # finds position of first newline
+          end_pos = end_loc(prev_def).end_pos
+          source_buffer = end_loc(prev_def).source_buffer
+          newline_pos = source_buffer.source.index("\n", end_pos)
+
+          # Handle the case when multiple one-liners are on the same line.
+          begin_pos = node.source_range.begin_pos
+          newline_pos = begin_pos - 1 if newline_pos > begin_pos
+
+          if count > maximum_empty_lines
+            autocorrect_remove_lines(corrector, newline_pos, count)
+          else
+            autocorrect_insert_lines(corrector, newline_pos, count)
+          end
+        end
+
+        private
+
+        def def_location(correction_node)
+          if correction_node.any_block_type?
+            correction_node.source_range.join(correction_node.children.first.source_range)
+          elsif correction_node.send_type?
+            correction_node.source_range
+          else
+            correction_node.loc.keyword.join(correction_node.loc.name)
+          end
+        end
+
+        def candidate?(node)
+          return false unless node
+
+          method_candidate?(node) || class_candidate?(node) || module_candidate?(node) ||
+            macro_candidate?(node)
+        end
+
+        def empty_line_between_macros
+          @empty_line_between_macros ||= cop_config.fetch('DefLikeMacros', []).map(&:to_sym).freeze
+        end
+
+        def macro_candidate?(node)
+          macro_candidate = if node.any_block_type?
+                              node.send_node
+                            elsif node.send_type?
+                              node
+                            end
+          return false unless macro_candidate
+
+          macro_candidate.macro? && empty_line_between_macros.include?(macro_candidate.method_name)
+        end
+
+        def method_candidate?(node)
+          cop_config['EmptyLineBetweenMethodDefs'] && node.any_def_type?
+        end
+
+        def class_candidate?(node)
+          cop_config['EmptyLineBetweenClassDefs'] && node.class_type?
+        end
+
+        def module_candidate?(node)
+          cop_config['EmptyLineBetweenModuleDefs'] && node.module_type?
+        end
+
+        def message(node, count: nil)
+          type = node_type(node)
+
+          format(MSG, type: type, expected: expected_lines, actual: count)
+        end
+
+        def expected_lines
+          if allowance_range?
+            "#{minimum_empty_lines..maximum_empty_lines} empty lines"
+          else
+            lines = maximum_empty_lines == 1 ? 'line' : 'lines'
+            "#{maximum_empty_lines} empty #{lines}"
+          end
+        end
+
+        def multiple_blank_lines_groups?(first_def_node, second_def_node)
+          lines = lines_between_defs(first_def_node, second_def_node)
+          blank_start = lines.each_index.select { |i| lines[i].blank? }.max
+          non_blank_end = lines.each_index.reject { |i| lines[i].blank? }.min
+          return false if blank_start.nil? || non_blank_end.nil?
+
+          blank_start > non_blank_end
+        end
+
+        def line_count_allowed?(count)
+          (minimum_empty_lines..maximum_empty_lines).cover?(count)
+        end
+
+        def blank_lines_count_between(first_def_node, second_def_node)
+          lines_between_defs(first_def_node, second_def_node).count(&:blank?)
+        end
+
+        def minimum_empty_lines
+          Array(cop_config['NumberOfEmptyLines']).first
+        end
+
+        def maximum_empty_lines
+          Array(cop_config['NumberOfEmptyLines']).last
+        end
+
+        def lines_between_defs(first_def_node, second_def_node)
+          begin_line_num = def_end(first_def_node)
+          end_line_num = def_start(second_def_node) - 2
+          return [] if end_line_num.negative?
+
+          processed_source.lines[begin_line_num..end_line_num]
+        end
+
+        def def_start(node)
+          node = node.send_node if node.any_block_type?
+
+          if node.send_type?
+            node.source_range.line
+          else
+            node.loc.keyword.line
+          end
+        end
+
+        def def_end(node)
+          end_loc(node).line
+        end
+
+        def end_loc(node)
+          end_location = node.source_range.end
+          trailing_heredoc_end(node, end_location) || end_location
+        end
+
+        # For an endless method whose body is a heredoc (e.g. `def a = <<~TEXT`), the
+        # node's source range ends at the heredoc opening line, before the heredoc body.
+        # Use the heredoc's closing delimiter so the def's real end is located after the
+        # heredoc and blank-line insertion does not land inside the heredoc body.
+        def trailing_heredoc_end(node, end_location)
+          heredocs = node.each_descendant(:any_str).select(&:heredoc?)
+          return if heredocs.empty?
+
+          heredoc_end = heredocs.map { |heredoc| heredoc.loc.heredoc_end }.max_by(&:end_pos)
+          heredoc_end if heredoc_end.end_pos > end_location.end_pos
+        end
+
+        def autocorrect_remove_lines(corrector, newline_pos, count)
+          difference = count - maximum_empty_lines
+          range_to_remove = range_between(newline_pos, newline_pos + difference)
+
+          corrector.remove(range_to_remove)
+        end
+
+        def autocorrect_insert_lines(corrector, newline_pos, count)
+          difference = minimum_empty_lines - count
+          where_to_insert = range_between(newline_pos, newline_pos + 1)
+
+          corrector.insert_after(where_to_insert, "\n" * difference)
+        end
+
+        def node_type(node)
+          case node.type
+          when :def, :defs
+            :method
+          when :numblock, :itblock
+            :block
+          else
+            node.type
+          end
+        end
+
+        def allowance_range?
+          minimum_empty_lines != maximum_empty_lines
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for two or more consecutive blank lines.
+      #
+      # @example
+      #
+      #   # bad - It has two empty lines.
+      #   some_method
+      #   # one empty line
+      #   # two empty lines
+      #   some_method
+      #
+      #   # good
+      #   some_method
+      #   # one empty line
+      #   some_method
+      #
+      class EmptyLines < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Extra blank line detected.'
+        LINE_OFFSET = 2
+
+        def on_new_investigation
+          return if processed_source.tokens.empty?
+          # Quick check if we possibly have consecutive blank lines.
+          return unless processed_source.raw_source.include?("\n\n\n")
+
+          lines = Set.new
+          processed_source.tokens.each { |token| lines << token.line }
+
+          each_extra_empty_line(lines.sort) do |range|
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
+          end
+        end
+
+        private
+
+        def each_extra_empty_line(lines)
+          prev_line = 1
+
+          lines.each do |cur_line|
+            if exceeds_line_offset?(cur_line - prev_line)
+              # we need to be wary of comments since they
+              # don't show up in the tokens
+              ((prev_line + 1)...cur_line).each do |line|
+                next unless previous_and_current_lines_empty?(line)
+
+                yield source_range(processed_source.buffer, line, 0)
+              end
+            end
+
+            prev_line = cur_line
+          end
+        end
+
+        def exceeds_line_offset?(line_diff)
+          line_diff > LINE_OFFSET
+        end
+
+        def previous_and_current_lines_empty?(line)
+          processed_source[line - 2].empty? && processed_source[line - 1].empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for an empty line after a module inclusion method (`extend`,
+      # `include` and `prepend`), or a group of them.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     include Bar
+      #     attr_reader :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     include Bar
+      #
+      #     attr_reader :baz
+      #   end
+      #
+      #   # also good - multiple module inclusions grouped together
+      #   class Foo
+      #     extend Bar
+      #     include Baz
+      #     prepend Qux
+      #   end
+      #
+      class EmptyLinesAfterModuleInclusion < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Add an empty line after module inclusion.'
+
+        MODULE_INCLUSION_METHODS = %i[include extend prepend].freeze
+
+        RESTRICT_ON_SEND = MODULE_INCLUSION_METHODS
+
+        def on_send(node)
+          return if node.receiver || node.arguments.empty?
+          return if node.parent&.type?(:send, :any_block, :array)
+
+          return if next_line_empty_or_enable_directive_comment?(node.last_line)
+
+          next_line_node = next_line_node(node)
+          return unless require_empty_line?(next_line_node)
+
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          node_range = range_by_whole_lines(node.source_range)
+
+          next_line = node_range.last_line + 1
+          if enable_directive_comment?(next_line)
+            node_range = processed_source.comment_at_line(next_line)
+          end
+
+          corrector.insert_after(node_range, "\n")
+        end
+
+        def next_line_empty_or_enable_directive_comment?(line)
+          line_empty?(line) || (enable_directive_comment?(line + 1) && line_empty?(line + 1))
+        end
+
+        def enable_directive_comment?(line)
+          return false unless (comment = processed_source.comment_at_line(line))
+
+          DirectiveComment.new(comment).enabled?
+        end
+
+        def line_empty?(line)
+          processed_source[line].nil? || processed_source[line].blank?
+        end
+
+        def require_empty_line?(node)
+          return false unless node
+
+          !allowed_method?(node)
+        end
+
+        def allowed_method?(node)
+          node = node.body if node.respond_to?(:modifier_form?) && node.modifier_form?
+
+          return false unless node.send_type?
+
+          MODULE_INCLUSION_METHODS.include?(node.method_name)
+        end
+
+        def next_line_node(node)
+          return if node.parent.if_type?
+
+          node.right_sibling
+        end
+      end
+    end
+  end
+end