super-pro-sys 0.0.1

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks whether comments have a leading space after the
+      # `#` denoting the start of the comment. The leading space is not
+      # required for some RDoc special syntax, like `#++`, `#--`,
+      # `#:nodoc`, `=begin`- and `=end` comments, "shebang" directives,
+      # or rackup options.
+      #
+      # @example
+      #
+      #   # bad
+      #   #Some comment
+      #
+      #   # good
+      #   # Some comment
+      #
+      # @example AllowDoxygenCommentStyle: false (default)
+      #
+      #   # bad
+      #
+      #   #**
+      #   # Some comment
+      #   # Another line of comment
+      #   #*
+      #
+      # @example AllowDoxygenCommentStyle: true
+      #
+      #   # good
+      #
+      #   #**
+      #   # Some comment
+      #   # Another line of comment
+      #   #*
+      #
+      # @example AllowGemfileRubyComment: false (default)
+      #
+      #   # bad
+      #
+      #   #ruby=2.7.0
+      #   #ruby-gemset=myproject
+      #
+      # @example AllowGemfileRubyComment: true
+      #
+      #   # good
+      #
+      #   #ruby=2.7.0
+      #   #ruby-gemset=myproject
+      #
+      # @example AllowRBSInlineAnnotation: false (default)
+      #
+      #   # bad
+      #
+      #   include Enumerable #[Integer]
+      #
+      #   attr_reader :name #: String
+      #   attr_reader :age  #: Integer?
+      #
+      #   #: (
+      #   #|   Integer,
+      #   #|   String
+      #   #| ) -> void
+      #   def foo; end
+      #
+      # @example AllowRBSInlineAnnotation: true
+      #
+      #   # good
+      #
+      #   include Enumerable #[Integer]
+      #
+      #   attr_reader :name #: String
+      #   attr_reader :age  #: Integer?
+      #
+      #   #: (
+      #   #|   Integer,
+      #   #|   String
+      #   #| ) -> void
+      #   def foo; end
+      #
+      # @example AllowSteepAnnotation: false (default)
+      #
+      #   # bad
+      #   [1, 2, 3].each_with_object([]) do |n, list| #$ Array[Integer]
+      #     list << n
+      #   end
+      #
+      #   name = 'John'      #: String
+      #
+      # @example AllowSteepAnnotation: true
+      #
+      #   # good
+      #
+      #   [1, 2, 3].each_with_object([]) do |n, list| #$ Array[Integer]
+      #     list << n
+      #   end
+      #
+      #   name = 'John'      #: String
+      #
+      class LeadingCommentSpace < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Missing space after `#`.'
+
+        def on_new_investigation # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          processed_source.comments.each do |comment|
+            next unless /\A(?!#\+\+|#--)(#+[^#\s=])/.match?(comment.text)
+            next if comment.loc.line == 1 && allowed_on_first_line?(comment)
+            next if shebang_continuation?(comment)
+            next if doxygen_comment_style?(comment)
+            next if gemfile_ruby_comment?(comment)
+            next if rbs_inline_annotation?(comment)
+            next if steep_annotation?(comment)
+
+            add_offense(comment) do |corrector|
+              expr = comment.source_range
+
+              corrector.insert_after(hash_mark(expr), ' ')
+            end
+          end
+        end
+
+        private
+
+        def hash_mark(expr)
+          range_between(expr.begin_pos, expr.begin_pos + 1)
+        end
+
+        def allowed_on_first_line?(comment)
+          shebang?(comment) || (rackup_config_file? && rackup_options?(comment))
+        end
+
+        def shebang?(comment)
+          comment.text.start_with?('#!')
+        end
+
+        def shebang_continuation?(comment)
+          return false unless shebang?(comment)
+          return true if comment.loc.line == 1
+
+          previous_line_comment = processed_source.comment_at_line(comment.loc.line - 1)
+          return false unless previous_line_comment
+
+          # If the comment is a shebang but not on the first line, check if the previous
+          # line has a shebang comment that wasn't marked as an offense; if so, this comment
+          # continues the shebang and is acceptable.
+          shebang?(previous_line_comment) &&
+            !current_offense_locations.include?(previous_line_comment.source_range)
+        end
+
+        def rackup_options?(comment)
+          comment.text.start_with?('#\\')
+        end
+
+        def rackup_config_file?
+          File.basename(processed_source.file_path).eql?('config.ru')
+        end
+
+        def allow_doxygen_comment?
+          cop_config['AllowDoxygenCommentStyle']
+        end
+
+        def doxygen_comment_style?(comment)
+          allow_doxygen_comment? && comment.text.start_with?('#*')
+        end
+
+        def allow_gemfile_ruby_comment?
+          cop_config['AllowGemfileRubyComment']
+        end
+
+        def gemfile?
+          File.basename(processed_source.file_path).eql?('Gemfile')
+        end
+
+        def ruby_comment_in_gemfile?(comment)
+          gemfile? && comment.text.start_with?('#ruby')
+        end
+
+        def gemfile_ruby_comment?(comment)
+          allow_gemfile_ruby_comment? && ruby_comment_in_gemfile?(comment)
+        end
+
+        def allow_rbs_inline_annotation?
+          cop_config['AllowRBSInlineAnnotation']
+        end
+
+        def rbs_inline_annotation?(comment)
+          allow_rbs_inline_annotation? && comment.text.start_with?(/#:|#\[.+\]|#\|/)
+        end
+
+        def allow_steep_annotation?
+          cop_config['AllowSteepAnnotation']
+        end
+
+        def steep_annotation?(comment)
+          allow_steep_annotation? && comment.text.start_with?(/#[$:]/)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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 LeadingEmptyLines < Base
+        extend AutoCorrector
+
+        MSG = 'Unnecessary blank line at the beginning of the source.'
+
+        def on_new_investigation
+          token = processed_source.tokens[0]
+          return unless token && token.line > 1
+
+          add_offense(token.pos) do |corrector|
+            range = Parser::Source::Range.new(processed_source.buffer, 0, token.begin_pos)
+
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that strings broken over multiple lines (by a backslash) contain
+      # trailing spaces instead of leading spaces (default) or leading spaces
+      # instead of trailing spaces.
+      #
+      # @example EnforcedStyle: trailing (default)
+      #   # bad
+      #   'this text contains a lot of' \
+      #   '               spaces'
+      #
+      #   # good
+      #   'this text contains a lot of               ' \
+      #   'spaces'
+      #
+      #   # bad
+      #   'this text is too' \
+      #   ' long'
+      #
+      #   # good
+      #   'this text is too ' \
+      #   'long'
+      #
+      # @example EnforcedStyle: leading
+      #   # bad
+      #   'this text contains a lot of               ' \
+      #   'spaces'
+      #
+      #   # good
+      #   'this text contains a lot of' \
+      #   '               spaces'
+      #
+      #   # bad
+      #   'this text is too ' \
+      #   'long'
+      #
+      #   # good
+      #   'this text is too' \
+      #   ' long'
+      class LineContinuationLeadingSpace < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        LINE_1_ENDING = /['"]\s*\\\n/.freeze
+        LINE_2_BEGINNING = /\A\s*['"]/.freeze
+        LEADING_STYLE_OFFENSE = /(?<trailing_spaces>\s+)(?<ending>#{LINE_1_ENDING})/.freeze
+        TRAILING_STYLE_OFFENSE = /(?<beginning>#{LINE_2_BEGINNING})(?<leading_spaces>\s+)/.freeze
+        private_constant :LINE_1_ENDING, :LINE_2_BEGINNING,
+                         :LEADING_STYLE_OFFENSE, :TRAILING_STYLE_OFFENSE
+
+        # When both cops are activated and run in the same iteration of the correction loop,
+        # `Style/StringLiterals` undoes the moving of spaces that
+        # `Layout/LineContinuationLeadingSpace` performs. This is because `Style/StringLiterals`
+        # takes the original string content and transforms it, rather than just modifying the
+        # delimiters, in order to handle escaping for quotes within the string.
+        def self.autocorrect_incompatible_with
+          [Style::StringLiterals]
+        end
+
+        def on_dstr(node)
+          # Quick check if we possibly have line continuations.
+          return unless node.source.include?('\\')
+
+          end_of_first_line = node.source_range.begin_pos - node.source_range.column
+
+          lines = raw_lines(node)
+          lines.each_cons(2).with_index(node.first_line) do |(raw_line_one, raw_line_two), line_num|
+            end_of_first_line += raw_line_one.length
+
+            next unless continuation?(raw_line_one, line_num, node)
+
+            investigate(raw_line_one, raw_line_two, end_of_first_line)
+          end
+        end
+
+        private
+
+        def raw_lines(node)
+          processed_source.raw_source.lines[node.first_line - 1, line_range(node).size]
+        end
+
+        def investigate(first_line, second_line, end_of_first_line)
+          if enforced_style_leading?
+            investigate_leading_style(first_line, second_line, end_of_first_line)
+          else
+            investigate_trailing_style(first_line, second_line, end_of_first_line)
+          end
+        end
+
+        def investigate_leading_style(first_line, second_line, end_of_first_line)
+          matches = first_line.match(LEADING_STYLE_OFFENSE)
+          return if matches.nil?
+
+          offense_range = leading_offense_range(end_of_first_line, matches)
+          add_offense(offense_range) do |corrector|
+            insert_pos = end_of_first_line + second_line[LINE_2_BEGINNING].length
+            autocorrect(corrector, offense_range, insert_pos, matches[:trailing_spaces])
+          end
+        end
+
+        def investigate_trailing_style(first_line, second_line, end_of_first_line)
+          matches = second_line.match(TRAILING_STYLE_OFFENSE)
+          return if matches.nil?
+
+          offense_range = trailing_offense_range(end_of_first_line, matches)
+          add_offense(offense_range) do |corrector|
+            insert_pos = end_of_first_line - first_line[LINE_1_ENDING].length
+            autocorrect(corrector, offense_range, insert_pos, matches[:leading_spaces])
+          end
+        end
+
+        def continuation?(line, line_num, node)
+          return false unless line.end_with?("\\\n")
+
+          # Ensure backslash isn't part of a token spanning to the next line.
+          node.children.none? { |c| (c.first_line...c.last_line).cover?(line_num) && c.multiline? }
+        end
+
+        def autocorrect(corrector, offense_range, insert_pos, spaces)
+          corrector.remove(offense_range)
+          corrector.replace(range_between(insert_pos, insert_pos), spaces)
+        end
+
+        def leading_offense_range(end_of_first_line, matches)
+          end_pos = end_of_first_line - matches[:ending].length
+          begin_pos = end_pos - matches[:trailing_spaces].length
+          range_between(begin_pos, end_pos)
+        end
+
+        def trailing_offense_range(end_of_first_line, matches)
+          begin_pos = end_of_first_line + matches[:beginning].length
+          end_pos = begin_pos + matches[:leading_spaces].length
+          range_between(begin_pos, end_pos)
+        end
+
+        def message(_range)
+          if enforced_style_leading?
+            'Move trailing spaces to the start of the next line.'
+          else
+            'Move leading spaces to the end of the previous line.'
+          end
+        end
+
+        def enforced_style_leading?
+          cop_config['EnforcedStyle'] == 'leading'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that the backslash of a line continuation is separated from
+      # preceding text by exactly one space (default) or zero spaces.
+      #
+      # @example EnforcedStyle: space (default)
+      #   # bad
+      #   'a'\
+      #   'b'  \
+      #   'c'
+      #
+      #   # good
+      #   'a' \
+      #   'b' \
+      #   'c'
+      #
+      # @example EnforcedStyle: no_space
+      #   # bad
+      #   'a' \
+      #   'b'  \
+      #   'c'
+      #
+      #   # good
+      #   'a'\
+      #   'b'\
+      #   'c'
+      class LineContinuationSpacing < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        def on_new_investigation
+          return unless processed_source.raw_source.include?('\\')
+
+          last_line = last_line(processed_source)
+
+          processed_source.raw_source.lines.each_with_index do |line, index|
+            break if index >= last_line
+
+            line_number = index + 1
+            investigate(line, line_number)
+          end
+        end
+
+        private
+
+        def investigate(line, line_number)
+          offensive_spacing = find_offensive_spacing(line)
+          return unless offensive_spacing
+
+          range = source_range(
+            processed_source.buffer,
+            line_number,
+            line.length - offensive_spacing.length - 1,
+            offensive_spacing.length
+          )
+
+          return if ignore_range?(range)
+
+          add_offense(range) { |corrector| autocorrect(corrector, range) }
+        end
+
+        def find_offensive_spacing(line)
+          if no_space_style?
+            line[/\s+\\$/, 0]
+          elsif space_style?
+            line[/((?<!\s)|\s{2,})\\$/, 0]
+          end
+        end
+
+        def message(_range)
+          if no_space_style?
+            'Use zero spaces in front of backslash.'
+          elsif space_style?
+            'Use one space in front of backslash.'
+          end
+        end
+
+        def autocorrect(corrector, range)
+          correction = if no_space_style?
+                         '\\'
+                       elsif space_style?
+                         ' \\'
+                       end
+          corrector.replace(range, correction)
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def ignored_literal_ranges(ast)
+          # which lines start inside a string literal?
+          return [] if ast.nil?
+
+          ast.each_node(:str, :dstr, :array).with_object(Set.new) do |literal, ranges|
+            loc = literal.location
+
+            if literal.array_type?
+              next unless literal.percent_literal?
+
+              ranges << loc.expression
+            elsif literal.heredoc?
+              ranges << loc.heredoc_body
+            elsif literal.loc?(:begin) || ignored_parent?(literal)
+              ranges << loc.expression
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def comment_ranges(comments)
+          comments.map(&:source_range)
+        end
+
+        def last_line(processed_source)
+          last_token = processed_source.tokens.last
+
+          last_token ? last_token.line : processed_source.lines.length
+        end
+
+        def ignore_range?(backtick_range)
+          ignored_ranges.any? { |range| range.contains?(backtick_range) }
+        end
+
+        def ignored_ranges
+          @ignored_ranges ||= ignored_literal_ranges(processed_source.ast) +
+                              comment_ranges(processed_source.comments)
+        end
+
+        def ignored_parent?(node)
+          return false unless node.parent
+
+          node.parent.type?(:regexp, :xstr)
+        end
+
+        def no_space_style?
+          cop_config['EnforcedStyle'] == 'no_space'
+        end
+
+        def space_style?
+          cop_config['EnforcedStyle'] == 'space'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the indentation of the next line after a line that ends with a string
+      # literal and a backslash.
+      #
+      # If `EnforcedStyle: aligned` is set, the concatenated string parts shall be aligned with the
+      # first part. There are some exceptions, such as implicit return values, where the
+      # concatenated string parts shall be indented regardless of `EnforcedStyle` configuration.
+      #
+      # If `EnforcedStyle: indented` is set, it's the second line that shall be indented one step
+      # more than the first line. Lines 3 and forward shall be aligned with line 2.
+      #
+      # @example
+      #   # bad
+      #   def some_method
+      #     'x' \
+      #     'y' \
+      #     'z'
+      #   end
+      #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
+      #   # good
+      #   def some_method
+      #     'x' \
+      #       'y' \
+      #       'z'
+      #   end
+      #
+      # @example EnforcedStyle: aligned (default)
+      #   # bad
+      #   puts 'x' \
+      #     'y'
+      #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
+      #   # good
+      #   puts 'x' \
+      #        'y'
+      #
+      #   my_hash = {
+      #     first: 'a message' \
+      #            'in two parts'
+      #   }
+      #
+      # @example EnforcedStyle: indented
+      #   # bad
+      #   result = 'x' \
+      #            'y'
+      #
+      #   my_hash = {
+      #     first: 'a message' \
+      #            'in two parts'
+      #   }
+      #
+      #   # good
+      #   result = 'x' \
+      #     'y'
+      #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
+      class LineEndStringConcatenationIndentation < Base
+        include ConfigurableEnforcedStyle
+        include Alignment
+        extend AutoCorrector
+
+        MSG_ALIGN = 'Align parts of a string concatenated with backslash.'
+        MSG_INDENT = 'Indent the first part of a string concatenated with backslash.'
+        PARENT_TYPES_FOR_INDENTED = [nil, :block, :begin, :def, :defs, :if].freeze
+
+        def on_dstr(node)
+          return unless strings_concatenated_with_backslash?(node)
+
+          children = node.children
+          return if children.empty?
+
+          if style == :aligned && !always_indented?(node)
+            check_aligned(children, 1)
+          else
+            check_indented(children)
+            check_aligned(children, 2)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
+        private
+
+        def strings_concatenated_with_backslash?(dstr_node)
+          dstr_node.multiline? &&
+            dstr_node.children.all? { |c| c.type?(:str, :dstr) } &&
+            dstr_node.children.none?(&:multiline?)
+        end
+
+        def always_indented?(dstr_node)
+          PARENT_TYPES_FOR_INDENTED.include?(dstr_node.parent&.type)
+        end
+
+        def check_aligned(children, start_index)
+          base_column = children[start_index - 1].loc.column
+          children[start_index..].each do |child|
+            @column_delta = base_column - child.loc.column
+            add_offense_and_correction(child, MSG_ALIGN) if @column_delta != 0
+            base_column = child.loc.column
+          end
+        end
+
+        def check_indented(children)
+          @column_delta = base_column(children[0]) + configured_indentation_width -
+                          children[1].loc.column
+          add_offense_and_correction(children[1], MSG_INDENT) if @column_delta != 0
+        end
+
+        def base_column(child)
+          grandparent = child.parent.parent
+          if grandparent&.pair_type?
+            grandparent.loc.column
+          else
+            child.source_range.source_line =~ /\S/
+          end
+        end
+
+        def add_offense_and_correction(node, message)
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+      end
+    end
+  end
+end