super-pro-sys 0.0.1

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for unnecessary single-element `Regexp` character classes.
+      #
+      # @example
+      #
+      #   # bad
+      #   r = /[x]/
+      #
+      #   # good
+      #   r = /x/
+      #
+      #   # bad
+      #   r = /[\s]/
+      #
+      #   # good
+      #   r = /\s/
+      #
+      #   # bad
+      #   r = %r{/[b]}
+      #
+      #   # good
+      #   r = %r{/b}
+      #
+      #   # good
+      #   r = /[ab]/
+      class RedundantRegexpCharacterClass < Base
+        extend AutoCorrector
+
+        REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS = '.*+?{}()|$'.chars.freeze
+        MSG_REDUNDANT_CHARACTER_CLASS = 'Redundant single-element character class, ' \
+                                        '`%<char_class>s` can be replaced with `%<element>s`.'
+
+        def on_regexp(node)
+          each_redundant_character_class(node) do |loc|
+            add_offense(
+              loc, message: format(
+                MSG_REDUNDANT_CHARACTER_CLASS,
+                char_class: loc.source,
+                element: without_character_class(loc)
+              )
+            ) do |corrector|
+              corrector.replace(loc, without_character_class(loc))
+            end
+          end
+        end
+
+        private
+
+        def each_redundant_character_class(node)
+          each_single_element_character_class(node) do |char_class|
+            next unless redundant_single_element_character_class?(node, char_class)
+
+            yield char_class.loc.body
+          end
+        end
+
+        def each_single_element_character_class(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if expr.type != :set || expr.expressions.size != 1
+            next if expr.negative?
+            next if %i[set posixclass nonposixclass].include?(expr.expressions.first.type)
+            next if multiple_codepoints?(expr.expressions.first)
+
+            yield expr
+          end
+        end
+
+        def redundant_single_element_character_class?(node, char_class)
+          class_elem = char_class.expressions.first.text
+
+          non_redundant =
+            whitespace_in_free_space_mode?(node, class_elem) ||
+            backslash_b?(class_elem) || octal_requiring_char_class?(class_elem) ||
+            requires_escape_outside_char_class?(class_elem)
+
+          !non_redundant
+        end
+
+        def multiple_codepoints?(expression)
+          expression.respond_to?(:codepoints) && expression.codepoints.count >= 2
+        end
+
+        def without_character_class(loc)
+          without_character_class = loc.source[1..-2]
+
+          # Adds `\` to prevent autocorrection that changes to an interpolated string when `[#]`.
+          # e.g. From `/[#]{0}/` to `/#{0}/`
+          loc.source == '[#]' ? "\\#{without_character_class}" : without_character_class
+        end
+
+        def whitespace_in_free_space_mode?(node, elem)
+          return false unless node.extended?
+
+          /\s/.match?(elem)
+        end
+
+        def backslash_b?(elem)
+          # \b's behavior is different inside and outside of a character class, matching word
+          # boundaries outside but backspace (0x08) when inside.
+          elem == '\b'
+        end
+
+        def octal_requiring_char_class?(elem)
+          # The octal escapes \1 to \7 only work inside a character class
+          # because they would be a backreference outside it.
+          elem.match?(/\A\\[1-7]\z/)
+        end
+
+        def requires_escape_outside_char_class?(elem)
+          REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS.include?(elem)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the instantiation of a regexp using a redundant `Regexp.new` or `Regexp.compile`.
+      # Autocorrect replaces it with a regexp literal which is the simplest and fastest.
+      #
+      # @example
+      #
+      #   # bad
+      #   Regexp.new(/regexp/)
+      #   Regexp.compile(/regexp/)
+      #
+      #   # good
+      #   /regexp/
+      #   Regexp.new('regexp')
+      #   Regexp.compile('regexp')
+      #
+      class RedundantRegexpConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `Regexp.%<method>s`.'
+        RESTRICT_ON_SEND = %i[new compile].freeze
+
+        # @!method redundant_regexp_constructor(node)
+        def_node_matcher :redundant_regexp_constructor, <<~PATTERN
+          (send
+            (const {nil? cbase} :Regexp) {:new :compile}
+            (regexp $... (regopt $...)))
+        PATTERN
+
+        def on_send(node)
+          return unless (regexp, regopt = redundant_regexp_constructor(node))
+
+          add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
+            pattern = regexp.map(&:source).join
+            regopt = regopt.join
+
+            corrector.replace(node, "/#{pattern}/#{regopt}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant escapes inside `Regexp` literals.
+      #
+      # @example
+      #   # bad
+      #   %r{foo\/bar}
+      #
+      #   # good
+      #   %r{foo/bar}
+      #
+      #   # good
+      #   /foo\/bar/
+      #
+      #   # good
+      #   %r/foo\/bar/
+      #
+      #   # good
+      #   %r!foo\!bar!
+      #
+      #   # bad
+      #   /a\-b/
+      #
+      #   # good
+      #   /a-b/
+      #
+      #   # bad
+      #   /[\+\-]\d/
+      #
+      #   # good
+      #   /[+\-]\d/
+      class RedundantRegexpEscape < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_REDUNDANT_ESCAPE = 'Redundant escape inside regexp literal'
+
+        ALLOWED_ALWAYS_ESCAPES = " \n[]^\\#".chars.freeze
+        ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = '-'.chars.freeze
+        ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = '.*+?{}()|$'.chars.freeze
+        INTERPOLATION_SIGILS = %w[@ $].freeze
+
+        def on_regexp(node)
+          each_escape(node) do |char, index, within_character_class|
+            next if char.valid_encoding? && allowed_escape?(node, char, index,
+                                                            within_character_class)
+
+            location = escape_range_at_index(node, index)
+
+            add_offense(location, message: MSG_REDUNDANT_ESCAPE) do |corrector|
+              corrector.remove_leading(escape_range_at_index(node, index), 1)
+            end
+          end
+        end
+
+        private
+
+        def allowed_escape?(node, char, index, within_character_class)
+          # Strictly speaking a few single-letter metachars are currently
+          # unnecessary to "escape", e.g. i, E, F, but enumerating them is
+          # rather difficult, and their behavior could change over time with
+          # different versions of Ruby so that e.g. /\i/ != /i/
+          return true if /[[:alnum:]]/.match?(char)
+          return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
+          return true if requires_escape_to_avoid_interpolation?(node, index, char)
+
+          if within_character_class
+            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
+              !char_class_begins_or_ends_with_escaped_hyphen?(node, index)
+          else
+            ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+          end
+        end
+
+        def char_class_begins_or_ends_with_escaped_hyphen?(node, index)
+          # The hyphen character is allowed to be escaped within a character class
+          # but it's not necessary to escape hyphen if it's the first or last character
+          # within the character class. This method checks if that's the case.
+          # e.g. "[0-9\\-]" or "[\\-0-9]" would return true
+          content = contents_range(node).source
+
+          if content[index + 2] == ']'
+            true
+          elsif content[index - 1] == '['
+            index < 2 || content[index - 2] != '\\'
+          else
+            false
+          end
+        end
+
+        def delimiter?(node, char)
+          delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
+
+          delimiters.include?(char)
+        end
+
+        def requires_escape_to_avoid_interpolation?(node, index, escaped_char)
+          # Preserve escapes after '#' that would otherwise trigger interpolation:
+          # '#@ivar', '#@@cvar', and '#$gvar'. `index` is relative to the regexp
+          # contents, so index into those rather than `node.source` (which also
+          # includes the opening delimiter, e.g. `%r{`).
+          return false unless index.positive? && INTERPOLATION_SIGILS.include?(escaped_char)
+
+          contents_range(node).source[index - 1] == '#'
+        end
+
+        def each_escape(node)
+          node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
+            yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape
+
+            if expr.type == :set
+              char_class_depth + (event == :enter ? 1 : -1)
+            else
+              char_class_depth
+            end
+          end
+        end
+
+        def escape_range_at_index(node, index)
+          regexp_begin = node.loc.begin.end_pos
+
+          start = regexp_begin + index
+
+          range_between(start, start + 2)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant `return` expressions. Ruby methods
+      # implicitly return the value of the last evaluated expression,
+      # so an explicit `return` at the end of a method body is unnecessary.
+      #
+      # @example
+      #   # These bad cases should be extended to handle methods whose body is
+      #   # if/else or a case expression with a default branch.
+      #
+      #   # bad
+      #   def test
+      #     return something
+      #   end
+      #
+      #   # bad
+      #   def test
+      #     one
+      #     two
+      #     three
+      #     return something
+      #   end
+      #
+      #   # bad
+      #   def test
+      #     return something if something_else
+      #   end
+      #
+      #   # good
+      #   def test
+      #     something if something_else
+      #   end
+      #
+      #   # good
+      #   def test
+      #     if x
+      #     elsif y
+      #     else
+      #     end
+      #   end
+      #
+      # @example AllowMultipleReturnValues: false (default)
+      #   # bad
+      #   def test
+      #     return x, y
+      #   end
+      #
+      # @example AllowMultipleReturnValues: true
+      #   # good
+      #   def test
+      #     return x, y
+      #   end
+      #
+      class RedundantReturn < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant `return` detected.'
+        MULTI_RETURN_MSG = 'To return multiple values, use an array.'
+        RESTRICT_ON_SEND = %i[define_method define_singleton_method lambda].freeze
+
+        def on_send(node)
+          return unless node.block_literal?
+
+          check_branch(node.parent.body)
+        end
+
+        def on_def(node)
+          check_branch(node.body)
+        end
+        alias on_defs on_def
+
+        private
+
+        def correct_without_arguments(return_node, corrector)
+          corrector.replace(return_node, 'nil')
+        end
+
+        def correct_with_arguments(return_node, corrector)
+          if return_node.children.size > 1
+            add_brackets(corrector, return_node)
+          elsif hash_without_braces?(return_node.first_argument)
+            add_braces(corrector, return_node.first_argument)
+          end
+          if return_node.splat_argument?
+            first_argument = return_node.first_argument
+            corrector.replace(first_argument, first_argument.source.delete_prefix('*'))
+          end
+
+          keyword = range_with_surrounding_space(return_node.loc.keyword, side: :right)
+          corrector.remove(keyword)
+        end
+
+        def hash_without_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+
+        def add_brackets(corrector, node)
+          corrector.insert_before(node.children.first, '[')
+          corrector.insert_after(node.children.last, ']')
+        end
+
+        def add_braces(corrector, node)
+          corrector.insert_before(node.children.first, '{')
+          corrector.insert_after(node.children.last, '}')
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def check_branch(node)
+          return unless node
+
+          case node.type
+          when :return then check_return_node(node)
+          when :case   then check_case_node(node)
+          when :case_match then check_case_match_node(node)
+          when :if     then check_if_node(node)
+          when :rescue then check_rescue_node(node)
+          when :resbody then check_resbody_node(node)
+          when :ensure then check_ensure_node(node)
+          when :begin, :kwbegin
+            check_begin_node(node)
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def check_return_node(node)
+          return if cop_config['AllowMultipleReturnValues'] && node.children.size > 1
+
+          add_offense(node.loc.keyword, message: message(node)) do |corrector|
+            if node.arguments?
+              correct_with_arguments(node, corrector)
+            else
+              correct_without_arguments(node, corrector)
+            end
+          end
+        end
+
+        def check_case_node(node)
+          node.when_branches.each { |when_node| check_branch(when_node.body) }
+          check_branch(node.else_branch)
+        end
+
+        def check_case_match_node(node)
+          node.in_pattern_branches.each { |in_pattern_node| check_branch(in_pattern_node.body) }
+          check_branch(node.else_branch)
+        end
+
+        def check_if_node(node)
+          return if node.ternary?
+
+          check_branch(node.if_branch)
+          check_branch(node.else_branch)
+        end
+
+        def check_rescue_node(node)
+          node.branches.each { |branch| check_branch(branch) }
+          check_branch(node.body) unless node.else?
+        end
+
+        def check_resbody_node(node)
+          check_branch(node.body)
+        end
+
+        def check_ensure_node(node)
+          rescue_node = node.node_parts[0]
+          check_branch(rescue_node)
+        end
+
+        def check_begin_node(node)
+          last_expr = node.children.last
+          check_branch(last_expr)
+        end
+
+        def allow_multiple_return_values?
+          cop_config['AllowMultipleReturnValues'] || false
+        end
+
+        def message(node)
+          if !allow_multiple_return_values? && node.children.size > 1
+            "#{MSG} #{MULTI_RETURN_MSG}"
+          else
+            MSG
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant uses of `self`.
+      #
+      # The usage of `self` is only needed when:
+      #
+      # * Sending a message to same object with zero arguments in
+      #   presence of a method name clash with an argument or a local
+      #   variable.
+      #
+      # * Calling an attribute writer to prevent a local variable assignment.
+      #
+      # Note, with using explicit self you can only send messages with public or
+      # protected scope, you cannot send private messages this way.
+      #
+      # Note we allow uses of `self` with operators because it would be awkward
+      # otherwise. Also allows the use of `self.it` without arguments in blocks,
+      # as in `0.times { self.it }`, following `Lint/ItWithoutArgumentsInBlock` cop.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo(bar)
+      #     self.baz
+      #   end
+      #
+      #   # good
+      #   def foo(bar)
+      #     self.bar  # Resolves name clash with the argument.
+      #   end
+      #
+      #   def foo
+      #     bar = 1
+      #     self.bar  # Resolves name clash with the local variable.
+      #   end
+      #
+      #   def foo
+      #     %w[x y z].select do |bar|
+      #       self.bar == bar  # Resolves name clash with argument of the block.
+      #     end
+      #   end
+      class RedundantSelf < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant `self` detected.'
+        KERNEL_METHODS = Kernel.methods(false)
+        KEYWORDS = %i[alias and begin break case class def defined? do
+                      else elsif end ensure false for if in module
+                      next nil not or redo rescue retry return self
+                      super then true undef unless until when while
+                      yield __FILE__ __LINE__ __ENCODING__].freeze
+
+        def self.autocorrect_incompatible_with
+          [ColonMethodCall, Layout::DotPosition]
+        end
+
+        def initialize(config = nil, options = nil)
+          super
+          @allowed_send_nodes = Set.new.compare_by_identity
+          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }.compare_by_identity
+        end
+
+        # Assignment of self.x
+
+        def on_or_asgn(node)
+          allow_self(node.lhs)
+
+          lhs_name = node.lhs.lvasgn_type? ? node.lhs.name : node.lhs
+          add_lhs_to_local_variables_scopes(node.rhs, lhs_name)
+        end
+        alias on_and_asgn on_or_asgn
+
+        def on_op_asgn(node)
+          allow_self(node.lhs)
+        end
+
+        # Using self.x to distinguish from local variable x
+
+        def on_def(node)
+          add_scope(node)
+        end
+        alias on_defs on_def
+
+        def on_args(node)
+          node.children.each { |arg| on_argument(arg) }
+        end
+
+        def on_blockarg(node)
+          on_argument(node)
+        end
+
+        def on_masgn(node)
+          add_masgn_lhs_variables(node.rhs, node.lhs)
+        end
+
+        def on_lvasgn(node)
+          add_lhs_to_local_variables_scopes(node.rhs, node.lhs)
+        end
+
+        # Register the exception variable of `rescue => e` so that `self.e` in the
+        # body is not treated as redundant (it disambiguates the local variable).
+        def on_resbody(node)
+          exception_variable = node.exception_variable
+          return unless exception_variable&.lvasgn_type?
+
+          @local_variables_scopes[node] << exception_variable.name
+        end
+
+        def on_in_pattern(node)
+          add_match_var_scopes(node)
+        end
+
+        def on_send(node)
+          return unless node.self_receiver? && regular_method_call?(node)
+          return if node.parent&.mlhs_type?
+          return if allowed_send_node?(node)
+          return if it_method_in_block?(node)
+
+          add_offense(node.receiver) do |corrector|
+            corrector.remove(node.receiver)
+            corrector.remove(node.loc.dot)
+          end
+        end
+
+        def on_block(node)
+          add_scope(node, @local_variables_scopes[node])
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_if(node)
+          # Allow conditional nodes to use `self` in the condition if that variable
+          # name is used in an `lvasgn` or `masgn` within the `if`.
+          node.each_descendant(:lvasgn, :masgn) do |descendant_node|
+            if descendant_node.lvasgn_type?
+              add_lhs_to_local_variables_scopes(node.condition, descendant_node.lhs)
+            else
+              add_masgn_lhs_variables(node.condition, descendant_node.lhs)
+            end
+          end
+        end
+        alias on_while on_if
+        alias on_until on_if
+
+        private
+
+        def add_scope(node, local_variables = [])
+          node.each_descendant do |child_node|
+            @local_variables_scopes[child_node] = local_variables
+          end
+        end
+
+        def allowed_send_node?(node)
+          @allowed_send_nodes.include?(node) ||
+            @local_variables_scopes[node].include?(node.method_name) ||
+            node.each_ancestor.any? do |ancestor|
+              @local_variables_scopes[ancestor].include?(node.method_name)
+            end ||
+            KERNEL_METHODS.include?(node.method_name)
+        end
+
+        # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning:
+        #
+        # $ ruby -e '0.times { begin; it; end }'
+        # -e:1: warning: `it` calls without arguments will refer to the first block param in
+        # Ruby 3.4; use it() or self.it
+        #
+        def it_method_in_block?(node)
+          return false unless node.method?(:it)
+          return false unless (block_node = node.each_ancestor(:block).first)
+          return false unless block_node.arguments.empty_and_without_delimiters?
+
+          node.arguments.empty? && !node.block_literal?
+        end
+
+        def regular_method_call?(node)
+          !(node.operator_method? ||
+            KEYWORDS.include?(node.method_name) ||
+            node.camel_case_method? ||
+            node.setter_method? ||
+            node.implicit_call?)
+        end
+
+        def on_argument(node)
+          if node.mlhs_type?
+            on_args(node)
+          elsif node.respond_to?(:name)
+            @local_variables_scopes[node] << node.name
+          end
+        end
+
+        def allow_self(node)
+          return unless node.send_type? && node.self_receiver?
+
+          @allowed_send_nodes.add(node)
+        end
+
+        def add_lhs_to_local_variables_scopes(rhs, lhs)
+          if rhs&.send_type? && !rhs.arguments.empty?
+            rhs.arguments.each { |argument| @local_variables_scopes[argument] << lhs }
+          else
+            @local_variables_scopes[rhs] << lhs
+          end
+        end
+
+        def add_masgn_lhs_variables(rhs, lhs)
+          lhs.children.each do |child|
+            add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
+          end
+        end
+
+        def add_match_var_scopes(in_pattern_node)
+          in_pattern_node.each_descendant(:match_var) do |match_var_node|
+            @local_variables_scopes[in_pattern_node] << match_var_node.children.first
+          end
+        end
+      end
+    end
+  end
+end