super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/cop/style/encoding.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks that source files have no utf-8 encoding comments.
+      # Since Ruby 2.0, UTF-8 is the default source encoding, so
+      # these comments are no longer necessary and just add noise.
+      #
+      # @example
+      #   # bad
+      #   # encoding: UTF-8
+      #   # coding: UTF-8
+      #   # -*- coding: UTF-8 -*-
+      #
+      #   # good
+      #   # No encoding comment needed
+      class Encoding < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Unnecessary utf-8 encoding comment.'
+        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
+        SHEBANG = '#!'
+
+        def on_new_investigation
+          return if processed_source.buffer.source.empty?
+
+          comments.each do |line_number, comment|
+            next unless offense?(comment)
+
+            register_offense(line_number, comment)
+          end
+        end
+
+        private
+
+        def comments
+          processed_source.lines.each.with_index.with_object({}) do |(line, line_number), comments|
+            next if line.start_with?(SHEBANG)
+
+            comment = MagicComment.parse(line)
+            return comments unless comment.valid?
+
+            comments[line_number + 1] = comment
+          end
+        end
+
+        def offense?(comment)
+          comment.encoding_specified? && comment.encoding.casecmp('utf-8').zero?
+        end
+
+        def register_offense(line_number, comment)
+          range = processed_source.buffer.line_range(line_number)
+
+          add_offense(range) do |corrector|
+            text = comment.without(:encoding)
+
+            if text.blank?
+              corrector.remove(range_with_surrounding_space(range, side: :right))
+            else
+              corrector.replace(range, text)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/style/end_block.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `END` blocks. `END` blocks are Perl-style constructs
+      # and `Kernel#at_exit` is the idiomatic Ruby alternative, as it's
+      # explicit and can be used anywhere.
+      #
+      # @example
+      #   # bad
+      #   END { puts 'Goodbye!' }
+      #
+      #   # good
+      #   at_exit { puts 'Goodbye!' }
+      #
+      class EndBlock < Base
+        extend AutoCorrector
+
+        MSG = 'Avoid the use of `END` blocks. Use `Kernel#at_exit` instead.'
+
+        def on_postexe(node)
+          add_offense(node.loc.keyword) do |corrector|
+            corrector.replace(node.loc.keyword, 'at_exit')
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/style/endless_method.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for endless methods.
+      #
+      # It can enforce endless method definitions whenever possible or with single line methods.
+      # It can also disallow multiline endless method definitions or all endless definitions.
+      #
+      # `require_single_line` style enforces endless method definitions for single line methods.
+      # `require_always` style enforces endless method definitions for single statement methods.
+      #
+      # Other method definition types are not considered by this cop.
+      #
+      # The supported styles are:
+      #
+      # * allow_single_line (default) - only single line endless method definitions are allowed.
+      # * allow_always - all endless method definitions are allowed.
+      # * disallow - all endless method definitions are disallowed.
+      # * require_single_line - endless method definitions are required for single line methods.
+      # * require_always - all endless method definitions are required.
+      #
+      # NOTE: Incorrect endless method definitions will always be
+      # corrected to a multi-line definition.
+      #
+      # @example EnforcedStyle: allow_single_line (default)
+      #   # bad, multi-line endless method
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
+      #   # good
+      #   def my_method
+      #     x
+      #   end
+      #
+      #   # good
+      #   def my_method = x
+      #
+      #   # good
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
+      #
+      # @example EnforcedStyle: allow_always
+      #   # good
+      #   def my_method
+      #     x
+      #   end
+      #
+      #   # good
+      #   def my_method = x
+      #
+      #   # good
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
+      #   # good
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
+      #
+      # @example EnforcedStyle: disallow
+      #   # bad
+      #   def my_method = x
+      #
+      #   # bad
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
+      #   # good
+      #   def my_method
+      #     x
+      #   end
+      #
+      #   # good
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
+      #
+      # @example EnforcedStyle: require_single_line
+      #   # bad
+      #   def my_method
+      #     x
+      #   end
+      #
+      #   # bad
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
+      #   # good
+      #   def my_method = x
+      #
+      #   # good
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
+      #
+      # @example EnforcedStyle: require_always
+      #   # bad
+      #   def my_method
+      #     x
+      #   end
+      #
+      #   # bad
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
+      #
+      #   # good
+      #   def my_method = x
+      #
+      #   # good
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
+      class EndlessMethod < Base
+        include ConfigurableEnforcedStyle
+        include EndlessMethodRewriter
+        extend TargetRubyVersion
+        extend AutoCorrector
+
+        minimum_target_ruby_version 3.0
+
+        CORRECTION_STYLES = %w[multiline single_line].freeze
+        MSG = 'Avoid endless method definitions.'
+        MSG_MULTI_LINE = 'Avoid endless method definitions with multiple lines.'
+        MSG_REQUIRE_SINGLE = 'Use endless method definitions for single line methods.'
+        MSG_REQUIRE_ALWAYS = 'Use endless method definitions.'
+
+        def on_def(node)
+          return if node.assignment_method? || use_heredoc?(node)
+
+          case style
+          when :allow_single_line, :allow_always
+            handle_allow_style(node)
+          when :disallow
+            handle_disallow_style(node)
+          when :require_single_line
+            handle_require_single_line_style(node)
+          when :require_always
+            handle_require_always_style(node)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def handle_allow_style(node)
+          return unless node.endless?
+          return if node.single_line? || style == :allow_always
+
+          add_offense(node, message: MSG_MULTI_LINE) do |corrector|
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        def handle_require_single_line_style(node)
+          if node.endless? && node.multiline?
+            add_offense(node, message: MSG_MULTI_LINE) do |corrector|
+              correct_to_multiline(corrector, node)
+            end
+          elsif !node.endless? && can_be_made_endless?(node) && node.body.single_line?
+            return if too_long_when_made_endless?(node)
+
+            add_offense(node, message: MSG_REQUIRE_SINGLE) do |corrector|
+              corrector.replace(node, endless_replacement(node))
+            end
+          end
+        end
+
+        def handle_require_always_style(node)
+          return if node.endless? || !can_be_made_endless?(node)
+          return if too_long_when_made_endless?(node)
+
+          add_offense(node, message: MSG_REQUIRE_ALWAYS) do |corrector|
+            corrector.replace(node, endless_replacement(node))
+          end
+        end
+
+        def handle_disallow_style(node)
+          return unless node.endless?
+
+          add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
+        end
+
+        def use_heredoc?(node)
+          return false unless (body = node.body)
+          return true if body.any_str_type? && body.heredoc?
+
+          body.each_descendant(:str).any?(&:heredoc?)
+        end
+
+        def correct_to_multiline(corrector, node)
+          replacement = <<~RUBY.strip
+            def #{receiver(node)}#{node.method_name}#{arguments(node)}
+              #{node.body.source}
+            end
+          RUBY
+
+          corrector.replace(node, replacement)
+        end
+
+        def endless_replacement(node)
+          <<~RUBY.strip
+            def #{receiver(node)}#{node.method_name}#{arguments(node)} = #{node.body.source}
+          RUBY
+        end
+
+        def receiver(node)
+          node.receiver ? "#{node.receiver.source}#{node.loc.operator.source}" : ''
+        end
+
+        def arguments(node, missing = '')
+          node.arguments.any? ? node.arguments.source : missing
+        end
+
+        def can_be_made_endless?(node)
+          node.body && !node.body.begin_type? && !node.body.kwbegin_type?
+        end
+
+        def too_long_when_made_endless?(node)
+          return false unless config.cop_enabled?('Layout/LineLength')
+
+          offset = modifier_offset(node)
+
+          endless_replacement(node).length + offset > max_line_length
+        end
+
+        def modifier_offset(node)
+          same_line?(node.parent, node) ? node.loc.column - node.parent.loc.column : 0
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/style/env_home.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for consistent usage of `ENV['HOME']`. If `nil` is used as
+      # the second argument of `ENV.fetch`, it is treated as a bad case like `ENV[]`.
+      #
+      # @safety
+      #   The cop is unsafe because the result when `nil` is assigned to `ENV['HOME']` changes:
+      #
+      #   [source,ruby]
+      #   ----
+      #   ENV['HOME'] = nil
+      #   ENV['HOME'] # => nil
+      #   Dir.home    # => '/home/foo'
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   ENV['HOME']
+      #   ENV.fetch('HOME', nil)
+      #
+      #   # good
+      #   Dir.home
+      #
+      #   # good
+      #   ENV.fetch('HOME', default)
+      #
+      class EnvHome < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Dir.home` instead.'
+        RESTRICT_ON_SEND = %i[[] fetch].freeze
+
+        # @!method env_home?(node)
+        def_node_matcher :env_home?, <<~PATTERN
+          (send
+            (const {cbase nil?} :ENV) {:[] :fetch}
+            (str "HOME")
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return unless env_home?(node)
+          return if node.arguments.count == 2 && !node.arguments[1].nil_type?
+          # `ENV.fetch('HOME') { default }` supplies a fallback, just like
+          # `ENV.fetch('HOME', default)`. `Dir.home` ignores the block, so
+          # converting would silently drop it.
+          return if node.block_node
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, 'Dir.home')
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/style/eval_with_location.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Ensures that eval methods (`eval`, `instance_eval`, `class_eval`
+      # and `module_eval`) are given filename and line number values (`+__FILE__+`
+      # and `+__LINE__+`). This data is used to ensure that any errors raised
+      # within the evaluated code will be given the correct identification
+      # in a backtrace.
+      #
+      # The cop also checks that the line number given relative to `+__LINE__+` is
+      # correct.
+      #
+      # This cop will autocorrect incorrect or missing filename and line number
+      # values. However, if `eval` is called without a binding argument, the cop
+      # will not attempt to automatically add a binding, or add filename and
+      # line values.
+      #
+      # NOTE: This cop works only when a string literal is given as a code string.
+      # No offense is reported if a string variable is given as below:
+      #
+      # [source,ruby]
+      # ----
+      # code = <<-RUBY
+      #   def do_something
+      #   end
+      # RUBY
+      # eval code # not checked.
+      # ----
+      #
+      # @example
+      #   # bad
+      #   eval <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # bad
+      #   C.class_eval <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # good
+      #   eval <<-RUBY, binding, __FILE__, __LINE__ + 1
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # good
+      #   C.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      class EvalWithLocation < Base
+        extend AutoCorrector
+
+        MSG = 'Pass `__FILE__` and `__LINE__` to `%<method_name>s`.'
+        MSG_EVAL = 'Pass a binding, `__FILE__`, and `__LINE__` to `eval`.'
+        MSG_INCORRECT_FILE = 'Incorrect file for `%<method_name>s`; ' \
+                             'use `%<expected>s` instead of `%<actual>s`.'
+        MSG_INCORRECT_LINE = 'Incorrect line number for `%<method_name>s`; ' \
+                             'use `%<expected>s` instead of `%<actual>s`.'
+
+        RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
+
+        # @!method valid_eval_receiver?(node)
+        def_node_matcher :valid_eval_receiver?, <<~PATTERN
+          { nil? (const {nil? cbase} :Kernel) }
+        PATTERN
+
+        # @!method line_with_offset?(node, sign, num)
+        def_node_matcher :line_with_offset?, <<~PATTERN
+          {
+            (send #special_line_keyword? %1 (int %2))
+            (send (int %2) %1 #special_line_keyword?)
+          }
+        PATTERN
+
+        def on_send(node)
+          # Classes should not redefine eval, but in case one does, it shouldn't
+          # register an offense. Only `eval` without a receiver and `Kernel.eval`
+          # are considered.
+          return if node.method?(:eval) && !valid_eval_receiver?(node.receiver)
+
+          code = node.first_argument
+          return unless code&.type?(:str, :dstr)
+
+          check_location(node, code)
+        end
+
+        private
+
+        def check_location(node, code)
+          file, line = file_and_line(node)
+
+          if line
+            check_file(node, file)
+            check_line(node, code)
+          elsif file
+            check_file(node, file)
+            add_offense_for_missing_line(node, code)
+          else
+            add_offense_for_missing_location(node, code)
+          end
+        end
+
+        def register_offense(node, &block)
+          msg = node.method?(:eval) ? MSG_EVAL : format(MSG, method_name: node.method_name)
+          add_offense(node, message: msg, &block)
+        end
+
+        def special_file_keyword?(node)
+          node.str_type? && node.source == '__FILE__'
+        end
+
+        def special_line_keyword?(node)
+          node.int_type? && node.source == '__LINE__'
+        end
+
+        def file_and_line(node)
+          base = node.method?(:eval) ? 2 : 1
+          [node.arguments[base], node.arguments[base + 1]]
+        end
+
+        def with_binding?(node)
+          node.method?(:eval) ? node.arguments.size >= 2 : true
+        end
+
+        def add_offense_for_incorrect_line(method_name, line_node, sign, line_diff)
+          expected = expected_line(sign, line_diff)
+          message = format(MSG_INCORRECT_LINE,
+                           method_name: method_name,
+                           actual: line_node.source,
+                           expected: expected)
+
+          add_offense(line_node, message: message) do |corrector|
+            corrector.replace(line_node, expected)
+          end
+        end
+
+        def check_file(node, file_node)
+          return if special_file_keyword?(file_node)
+
+          message = format(MSG_INCORRECT_FILE,
+                           method_name: node.method_name,
+                           expected: '__FILE__',
+                           actual: file_node.source)
+
+          add_offense(file_node, message: message) do |corrector|
+            corrector.replace(file_node, '__FILE__')
+          end
+        end
+
+        def check_line(node, code)
+          line_node = node.last_argument
+          return if line_node.variable? || (line_node.send_type? && !line_node.method?(:+))
+
+          line_diff = line_difference(line_node, code)
+          if line_diff.zero?
+            add_offense_for_same_line(node, line_node)
+          else
+            add_offense_for_different_line(node, line_node, line_diff)
+          end
+        end
+
+        def line_difference(line_node, code)
+          string_first_line(code) - line_node.source_range.first_line
+        end
+
+        def string_first_line(str_node)
+          if str_node.heredoc?
+            str_node.loc.heredoc_body.first_line
+          else
+            str_node.source_range.first_line
+          end
+        end
+
+        def add_offense_for_same_line(node, line_node)
+          return if special_line_keyword?(line_node)
+
+          add_offense_for_incorrect_line(node.method_name, line_node, nil, 0)
+        end
+
+        def add_offense_for_different_line(node, line_node, line_diff)
+          sign = line_diff.positive? ? :+ : :-
+          return if line_with_offset?(line_node, sign, line_diff.abs)
+
+          add_offense_for_incorrect_line(node.method_name, line_node, sign, line_diff.abs)
+        end
+
+        def expected_line(sign, line_diff)
+          if line_diff.zero?
+            '__LINE__'
+          else
+            "__LINE__ #{sign} #{line_diff.abs}"
+          end
+        end
+
+        def add_offense_for_missing_line(node, code)
+          register_offense(node) do |corrector|
+            line_str = missing_line(node, code)
+            corrector.insert_after(node.last_argument.source_range.end, ", #{line_str}")
+          end
+        end
+
+        def add_offense_for_missing_location(node, code)
+          if node.method?(:eval) && !with_binding?(node)
+            register_offense(node)
+            return
+          end
+
+          register_offense(node) do |corrector|
+            line_str = missing_line(node, code)
+            corrector.insert_after(node.last_argument.source_range.end, ", __FILE__, #{line_str}")
+          end
+        end
+
+        def missing_line(node, code)
+          line_diff = line_difference(node.last_argument, code)
+          sign = line_diff.positive? ? :+ : :-
+          expected_line(sign, line_diff)
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/style/even_odd.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where `Integer#even?` or `Integer#odd?`
+      # can be used.
+      #
+      # @example
+      #
+      #   # bad
+      #   if x % 2 == 0
+      #   end
+      #
+      #   # good
+      #   if x.even?
+      #   end
+      class EvenOdd < Base
+        extend AutoCorrector
+
+        MSG = 'Replace with `Integer#%<method>s?`.'
+        RESTRICT_ON_SEND = %i[== !=].freeze
+
+        # @!method even_odd_candidate?(node)
+        def_node_matcher :even_odd_candidate?, <<~PATTERN
+          (send
+            {(send $_ :% (int 2))
+             (begin (send $_ :% (int 2)))}
+            ${:== :!=}
+            (int ${0 1}))
+        PATTERN
+
+        def on_send(node)
+          even_odd_candidate?(node) do |base_number, method, arg|
+            replacement_method = replacement_method(arg, method)
+            add_offense(node, message: format(MSG, method: replacement_method)) do |corrector|
+              correction = "#{receiver_source(base_number)}.#{replacement_method}?"
+              corrector.replace(node, correction)
+            end
+          end
+        end
+
+        private
+
+        def receiver_source(node)
+          # A binary or unary operator receiver (e.g. `a * b`, `-a`) binds looser
+          # than the appended method call, so it must be wrapped in parentheses.
+          if node.send_type? && node.operator_method? && !node.method?(:[])
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
+
+        def replacement_method(arg, method)
+          case arg
+          when 0
+            method == :== ? :even : :odd
+          when 1
+            method == :== ? :odd : :even
+          end
+        end
+      end
+    end
+  end
+end