super-pro-sys 0.0.1

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for unnecessary additional spaces inside the delimiters of
+      # %i/%w/%x literals.
+      #
+      # @example
+      #
+      #   # bad
+      #   %i( foo bar baz )
+      #
+      #   # good
+      #   %i(foo bar baz)
+      #
+      #   # bad
+      #   %w( foo bar baz )
+      #
+      #   # good
+      #   %w(foo bar baz)
+      #
+      #   # bad
+      #   %x(  ls -l )
+      #
+      #   # good
+      #   %x(ls -l)
+      #
+      #   # bad
+      #   %w( )
+      #   %w(
+      #   )
+      #
+      #   # good
+      #   %w()
+      class SpaceInsidePercentLiteralDelimiters < Base
+        include MatchRange
+        include PercentLiteral
+        extend AutoCorrector
+
+        MSG = 'Do not use spaces inside percent literal delimiters.'
+        BEGIN_REGEX = /\A( +)/.freeze
+        END_REGEX = /(?<!\\)( +)\z/.freeze
+
+        def on_array(node)
+          process(node, '%i', '%I', '%w', '%W')
+        end
+
+        def on_xstr(node)
+          process(node, '%x')
+        end
+
+        def on_percent_literal(node)
+          add_offenses_for_blank_spaces(node)
+          add_offenses_for_unnecessary_spaces(node)
+        end
+
+        private
+
+        def add_offenses_for_blank_spaces(node)
+          range = body_range(node)
+          return if range.source.empty? || !range.source.strip.empty?
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        def add_offenses_for_unnecessary_spaces(node)
+          return unless node.single_line?
+
+          regex_matches(node) do |match_range|
+            add_offense(match_range) do |corrector|
+              corrector.remove(match_range)
+            end
+          end
+        end
+
+        def regex_matches(node, &blk)
+          [BEGIN_REGEX, END_REGEX].each do |regex|
+            each_match_range(contents_range(node), regex, &blk)
+          end
+        end
+
+        def body_range(node)
+          node.source_range.with(
+            begin_pos: node.location.begin.end_pos,
+            end_pos: node.location.end.begin_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for spaces inside range literals.
+      #
+      # @example
+      #   # bad
+      #   1 .. 3
+      #
+      #   # good
+      #   1..3
+      #
+      #   # bad
+      #   'a' .. 'z'
+      #
+      #   # good
+      #   'a'..'z'
+      class SpaceInsideRangeLiteral < Base
+        extend AutoCorrector
+
+        MSG = 'Space inside range literal.'
+
+        def on_irange(node)
+          check(node)
+        end
+
+        def on_erange(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          expression = node.source
+          op = node.loc.operator.source
+          escaped_op = op.gsub('.', '\.')
+
+          # account for multiline range literals
+          expression.sub!(/#{escaped_op}\n\s*/, op)
+
+          return unless /(\s#{escaped_op})|(#{escaped_op}\s)/.match?(expression)
+
+          add_offense(node) do |corrector|
+            corrector.replace(
+              node, expression.sub(/\s+#{escaped_op}/, op).sub(/#{escaped_op}\s+/, op)
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that reference brackets have or don't have
+      # surrounding space depending on configuration.
+      #
+      # @example EnforcedStyle: no_space (default)
+      #   # The `no_space` style enforces that reference brackets have
+      #   # no surrounding space.
+      #
+      #   # bad
+      #   hash[ :key ]
+      #   array[ index ]
+      #
+      #   # good
+      #   hash[:key]
+      #   array[index]
+      #
+      # @example EnforcedStyle: space
+      #   # The `space` style enforces that reference brackets have
+      #   # surrounding space.
+      #
+      #   # bad
+      #   hash[:key]
+      #   array[index]
+      #
+      #   # good
+      #   hash[ :key ]
+      #   array[ index ]
+      #
+      #
+      # @example EnforcedStyleForEmptyBrackets: no_space (default)
+      #   # The `no_space` EnforcedStyleForEmptyBrackets style enforces that
+      #   # empty reference brackets do not contain spaces.
+      #
+      #   # bad
+      #   foo[ ]
+      #   foo[     ]
+      #   foo[
+      #   ]
+      #
+      #   # good
+      #   foo[]
+      #
+      # @example EnforcedStyleForEmptyBrackets: space
+      #   # The `space` EnforcedStyleForEmptyBrackets style enforces that
+      #   # empty reference brackets contain exactly one space.
+      #
+      #   # bad
+      #   foo[]
+      #   foo[    ]
+      #   foo[
+      #   ]
+      #
+      #   # good
+      #   foo[ ]
+      #
+      class SpaceInsideReferenceBrackets < Base
+        include SurroundingSpace
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = '%<command>s space inside reference brackets.'
+        EMPTY_MSG = '%<command>s space inside empty reference brackets.'
+
+        RESTRICT_ON_SEND = %i[[] []=].freeze
+
+        def on_send(node)
+          tokens = processed_source.tokens_within(node)
+          left_token = left_ref_bracket(node, tokens)
+          return unless left_token
+
+          right_token = closing_bracket(tokens, left_token)
+
+          if empty_brackets?(left_token, right_token, tokens: tokens)
+            return empty_offenses(node, left_token, right_token, EMPTY_MSG)
+          end
+
+          return if node.multiline?
+
+          if style == :no_space
+            no_space_offenses(node, left_token, right_token, MSG)
+          else
+            space_offenses(node, left_token, right_token, MSG)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          tokens, left, right = reference_brackets(node)
+
+          if empty_brackets?(left, right, tokens: tokens)
+            SpaceCorrector.empty_corrections(processed_source, corrector, empty_config, left, right)
+          elsif style == :no_space
+            SpaceCorrector.remove_space(processed_source, corrector, left, right)
+          else
+            SpaceCorrector.add_space(processed_source, corrector, left, right)
+          end
+        end
+
+        def reference_brackets(node)
+          tokens = processed_source.tokens_within(node)
+          left = left_ref_bracket(node, tokens)
+          [tokens, left, closing_bracket(tokens, left)]
+        end
+
+        def left_ref_bracket(node, tokens)
+          current_token = tokens.reverse.find(&:left_ref_bracket?)
+          previous_token = previous_token(current_token)
+
+          if node.method?(:[]=) || (previous_token && !previous_token.right_bracket?)
+            tokens.find(&:left_ref_bracket?)
+          else
+            current_token
+          end
+        end
+
+        def closing_bracket(tokens, opening_bracket)
+          i = tokens.index(opening_bracket)
+          inner_left_brackets_needing_closure = 0
+
+          tokens[i..].each do |token|
+            inner_left_brackets_needing_closure += 1 if token.left_bracket?
+            inner_left_brackets_needing_closure -= 1 if token.right_bracket?
+            return token if inner_left_brackets_needing_closure.zero? && token.right_bracket?
+          end
+        end
+
+        def previous_token(current_token)
+          index = processed_source.tokens.index(current_token)
+          index.nil? || index.zero? ? nil : processed_source.tokens[index - 1]
+        end
+
+        def empty_config
+          cop_config['EnforcedStyleForEmptyBrackets']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for whitespace within string interpolations.
+      #
+      # @example EnforcedStyle: no_space (default)
+      #   # bad
+      #      var = "This is the #{ space } example"
+      #
+      #   # good
+      #      var = "This is the #{no_space} example"
+      #
+      # @example EnforcedStyle: space
+      #   # bad
+      #      var = "This is the #{no_space} example"
+      #
+      #   # good
+      #      var = "This is the #{ space } example"
+      class SpaceInsideStringInterpolation < Base
+        include Interpolation
+        include SurroundingSpace
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = '%<command>s space inside string interpolation.'
+
+        def on_interpolation(begin_node)
+          return if begin_node.multiline?
+
+          tokens = processed_source.tokens_within(begin_node)
+          left, right = delimiters(begin_node)
+          return if empty_brackets?(left, right, tokens: tokens)
+
+          if style == :no_space
+            no_space_offenses(begin_node, left, right, MSG)
+          else
+            space_offenses(begin_node, left, right, MSG)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, begin_node)
+          delims = delimiters(begin_node)
+
+          if style == :no_space
+            SpaceCorrector.remove_space(processed_source, corrector, *delims)
+          else
+            SpaceCorrector.add_space(processed_source, corrector, *delims)
+          end
+        end
+
+        def delimiters(begin_node)
+          left = processed_source.first_token_of(begin_node)
+          right = processed_source.last_token_of(begin_node)
+          [left, right]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Looks for trailing blank lines and a final newline in the
+      # source code.
+      #
+      # @example EnforcedStyle: final_newline (default)
+      #   # `final_newline` looks for one newline at the end of files.
+      #
+      #   # bad
+      #   class Foo; end
+      #
+      #   # EOF
+      #
+      #   # bad
+      #   class Foo; end # EOF
+      #
+      #   # good
+      #   class Foo; end
+      #   # EOF
+      #
+      # @example EnforcedStyle: final_blank_line
+      #   # `final_blank_line` looks for one blank line followed by a new line
+      #   # at the end of files.
+      #
+      #   # bad
+      #   class Foo; end
+      #   # EOF
+      #
+      #   # bad
+      #   class Foo; end # EOF
+      #
+      #   # good
+      #   class Foo; end
+      #
+      #   # EOF
+      #
+      class TrailingEmptyLines < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          return if buffer.source.empty?
+
+          # The extra text that comes after the last token could be __END__
+          # followed by some data to read. If so, we don't check it because
+          # there could be good reasons why it needs to end with a certain
+          # number of newlines.
+          return if ends_in_end?(processed_source)
+          return if end_with_percent_blank_string?(processed_source)
+
+          whitespace_at_end = buffer.source[/\s*\Z/]
+          blank_lines = whitespace_at_end.count("\n") - 1
+          wanted_blank_lines = style == :final_newline ? 0 : 1
+
+          return unless blank_lines != wanted_blank_lines
+
+          offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end)
+        end
+
+        private
+
+        def offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end)
+          begin_pos = buffer.source.length - whitespace_at_end.length
+          autocorrect_range = range_between(begin_pos, buffer.source.length)
+          begin_pos += 1 unless whitespace_at_end.empty?
+          report_range = range_between(begin_pos, buffer.source.length)
+
+          add_offense(
+            report_range, message: message(wanted_blank_lines, blank_lines)
+          ) do |corrector|
+            corrector.replace(autocorrect_range, style == :final_newline ? "\n" : "\n\n")
+          end
+        end
+
+        def ends_in_end?(processed_source)
+          buffer = processed_source.buffer
+
+          return true if buffer.source.match?(/\s*__END__/)
+          return false if processed_source.tokens.empty?
+
+          extra = buffer.source[processed_source.tokens.last.end_pos..]
+          extra&.strip&.start_with?('__END__')
+        end
+
+        def end_with_percent_blank_string?(processed_source)
+          processed_source.buffer.source.end_with?("%\n\n")
+        end
+
+        def message(wanted_blank_lines, blank_lines)
+          case blank_lines
+          when -1
+            'Final newline missing.'
+          when 0
+            'Trailing blank line missing.'
+          else
+            instead_of = if wanted_blank_lines.zero?
+                           ''
+                         else
+                           "instead of #{wanted_blank_lines} "
+                         end
+            format('%<current>d trailing blank lines %<prefer>sdetected.',
+                   current: blank_lines, prefer: instead_of)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Looks for trailing whitespace in the source code.
+      #
+      # @example
+      #   # The line in this example contains spaces after the 0.
+      #   # bad
+      #   x = 0
+      #
+      #   # The line in this example ends directly after the 0.
+      #   # good
+      #   x = 0
+      #
+      # @example AllowInHeredoc: false (default)
+      #   # The line in this example contains spaces after the 0.
+      #   # bad
+      #   code = <<~RUBY
+      #     x = 0
+      #   RUBY
+      #
+      #   # ok
+      #   code = <<~RUBY
+      #     x = 0 #{}
+      #   RUBY
+      #
+      #   # good
+      #   trailing_whitespace = ' '
+      #   code = <<~RUBY
+      #     x = 0#{trailing_whitespace}
+      #   RUBY
+      #
+      # @example AllowInHeredoc: true
+      #   # The line in this example contains spaces after the 0.
+      #   # good
+      #   code = <<~RUBY
+      #     x = 0
+      #   RUBY
+      #
+      class TrailingWhitespace < Base
+        include RangeHelp
+        include Heredoc
+        extend AutoCorrector
+
+        MSG = 'Trailing whitespace detected.'
+
+        def on_new_investigation
+          processed_source.lines.each_with_index do |line, index|
+            next unless line.match?(/[[:blank:]]\z/)
+
+            process_line(line, index + 1)
+          end
+        end
+
+        def on_heredoc(_node); end
+
+        private
+
+        def process_line(line, lineno)
+          heredoc = find_heredoc(lineno)
+          return if skip_heredoc? && heredoc
+
+          range = offense_range(lineno, line)
+          add_offense(range) do |corrector|
+            if heredoc
+              process_line_in_heredoc(corrector, range, heredoc)
+            else
+              corrector.remove(range)
+            end
+          end
+        end
+
+        def process_line_in_heredoc(corrector, range, heredoc)
+          indent_level = indent_level(find_heredoc(range.line).loc.heredoc_body.source)
+          whitespace_only = whitespace_only?(range)
+          if whitespace_only && whitespace_is_indentation?(range, indent_level)
+            corrector.remove(range)
+          elsif !static?(heredoc)
+            range = range_between(range.begin_pos + indent_level, range.end_pos) if whitespace_only
+            corrector.wrap(range, "\#{'", "'}")
+          end
+        end
+
+        def whitespace_is_indentation?(range, level)
+          range.source[/[[:blank:]]+/].length <= level
+        end
+
+        def whitespace_only?(range)
+          source = range_with_surrounding_space(range).source
+          source.start_with?("\n") && source.end_with?("\n")
+        end
+
+        def static?(heredoc)
+          heredoc.source.end_with? "'"
+        end
+
+        def skip_heredoc?
+          cop_config.fetch('AllowInHeredoc', false)
+        end
+
+        def find_heredoc(line_number)
+          heredocs.each { |node, r| return node if r.include?(line_number) }
+          nil
+        end
+
+        def heredocs
+          @heredocs ||= extract_heredocs(processed_source.ast)
+        end
+
+        def extract_heredocs(ast)
+          return [] unless ast
+
+          heredocs = []
+          ast.each_node(:any_str) do |node|
+            next unless node.heredoc?
+
+            body = node.location.heredoc_body
+            heredocs << [node, body.first_line...body.last_line]
+          end
+          heredocs
+        end
+
+        def offense_range(lineno, line)
+          source_range(
+            processed_source.buffer, lineno, (line.sub(/[[:blank:]]+\z/, '').length)...(line.length)
+          )
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/legacy/corrections_proxy.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legacy
+      # Legacy support for Corrector#corrections
+      # See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
+      class CorrectionsProxy
+        def initialize(corrector)
+          @corrector = corrector
+        end
+
+        def <<(callable)
+          suppress_clobbering { @corrector.transaction { callable.call(@corrector) } }
+        end
+
+        def empty?
+          @corrector.empty?
+        end
+
+        def concat(corrections)
+          if corrections.is_a?(CorrectionsProxy)
+            suppress_clobbering { corrector.merge!(corrections.corrector) }
+          else
+            corrections.each { |correction| self << correction }
+          end
+        end
+
+        protected
+
+        attr_reader :corrector
+
+        private
+
+        def suppress_clobbering
+          yield
+        rescue ::Parser::ClobberingError
+          # ignore Clobbering errors
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/legacy/corrector.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legacy
+      # Legacy Corrector for v0 API support.
+      # See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
+      class Corrector < RuboCop::Cop::Corrector
+        # Support legacy second argument
+        def initialize(source, corr = [])
+          super(source)
+          if corr.is_a?(CorrectionsProxy)
+            merge!(corr.send(:corrector))
+          else
+            unless corr.empty?
+              warn Rainbow(<<~WARNING).yellow, uplevel: 1
+                `Corrector.new` with corrections is deprecated.
+                See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
+              WARNING
+            end
+
+            corr.each { |c| corrections << c }
+          end
+        end
+
+        def corrections
+          warn Rainbow(<<~WARNING).yellow, uplevel: 1
+            `Corrector#corrections` is deprecated. Open an issue if you have a valid usecase.
+            See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
+          WARNING
+
+          CorrectionsProxy.new(self)
+        end
+      end
+    end
+  end
+end