super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/cop/lint/ambiguous_assignment.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for mistyped shorthand assignments.
+      #
+      # @example
+      #   # bad
+      #   x =- y
+      #   x =+ y
+      #   x =* y
+      #   x =! y
+      #
+      #   # good
+      #   x -= y # or x = -y
+      #   x += y # or x = +y
+      #   x *= y # or x = *y
+      #   x != y # or x = !y
+      #
+      class AmbiguousAssignment < Base
+        include RangeHelp
+
+        MSG = 'Suspicious assignment detected. Did you mean `%<op>s`?'
+
+        SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
+
+        MISTAKES = { '=-' => '-=', '=+' => '+=', '=*' => '*=', '=!' => '!=' }.freeze
+
+        def on_asgn(node)
+          return unless (rhs = node.expression)
+
+          range = range_between(node.loc.operator.end_pos - 1, rhs.source_range.begin_pos + 1)
+          source = range.source
+          return unless MISTAKES.key?(source)
+
+          add_offense(range, message: format(MSG, op: MISTAKES[source]))
+        end
+
+        SIMPLE_ASSIGNMENT_TYPES.each { |asgn_type| alias_method :"on_#{asgn_type}", :on_asgn }
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/lint/ambiguous_block_association.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for ambiguous block association with method
+      # when param passed without parentheses.
+      #
+      # This cop can customize allowed methods with `AllowedMethods`.
+      # By default, there are no allowed methods.
+      #
+      # @example
+      #
+      #   # bad
+      #   some_method a { |val| puts val }
+      #
+      #   # good
+      #   # With parentheses, there's no ambiguity.
+      #   some_method(a { |val| puts val })
+      #   # or (different meaning)
+      #   some_method(a) { |val| puts val }
+      #
+      #   # good
+      #   # Operator methods require no disambiguation
+      #   foo == bar { |b| b.baz }
+      #
+      #   # good
+      #   # Lambda arguments require no disambiguation
+      #   foo = ->(bar) { bar.baz }
+      #
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   expect { do_something }.to change { object.attribute }
+      #
+      # @example AllowedMethods: [change]
+      #
+      #   # good
+      #   expect { do_something }.to change { object.attribute }
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   expect { do_something }.to change { object.attribute }
+      #
+      # @example AllowedPatterns: ['change']
+      #
+      #   # good
+      #   expect { do_something }.to change { object.attribute }
+      #   expect { do_something }.to not_change { object.attribute }
+      #
+      class AmbiguousBlockAssociation < Base
+        extend AutoCorrector
+
+        include AllowedMethods
+        include AllowedPattern
+
+        MSG = 'Parenthesize the param `%<param>s` to make sure that the ' \
+              'block will be associated with the `%<method>s` method ' \
+              'call.'
+
+        def on_send(node)
+          return unless node.arguments?
+
+          return unless ambiguous_block_association?(node)
+          return if node.parenthesized? || node.last_argument.lambda_or_proc? ||
+                    allowed_method_pattern?(node)
+
+          message = message(node)
+
+          add_offense(node, message: message) do |corrector|
+            wrap_in_parentheses(corrector, node)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def ambiguous_block_association?(send_node)
+          send_node.last_argument.any_block_type? && !send_node.last_argument.send_node.arguments?
+        end
+
+        def allowed_method_pattern?(node)
+          node.assignment? || node.operator_method? || node.method?(:[]) ||
+            allowed_method?(node.last_argument.method_name) ||
+            matches_allowed_pattern?(node.last_argument.send_node.source)
+        end
+
+        def message(send_node)
+          block_param = send_node.last_argument
+
+          format(MSG, param: block_param.source, method: block_param.send_node.source)
+        end
+
+        def wrap_in_parentheses(corrector, node)
+          range = node.loc.selector.end.join(node.first_argument.source_range.begin)
+
+          corrector.remove(range)
+          corrector.insert_before(range, '(')
+          corrector.insert_after(node.last_argument, ')')
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/lint/ambiguous_operator.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for ambiguous operators in the first argument of a
+      # method invocation without parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # The `*` is interpreted as a splat operator but it could possibly be
+      #   # a `*` method invocation (i.e. `do_something.*(some_array)`).
+      #   do_something *some_array
+      #
+      #   # good
+      #
+      #   # With parentheses, there's no ambiguity.
+      #   do_something(*some_array)
+      class AmbiguousOperator < Base
+        extend AutoCorrector
+
+        AMBIGUITIES = {
+          '+'  => { actual: 'positive number', possible: 'an addition' },
+          '-'  => { actual: 'negative number', possible: 'a subtraction' },
+          '*'  => { actual: 'splat',           possible: 'a multiplication' },
+          '&'  => { actual: 'block',           possible: 'a binary AND' },
+          '**' => { actual: 'keyword splat',   possible: 'an exponent' }
+        }.each do |key, hash|
+          hash[:operator] = key
+        end
+
+        MSG_FORMAT = 'Ambiguous %<actual>s operator. Parenthesize the method ' \
+                     "arguments if it's surely a %<actual>s operator, or add " \
+                     'a whitespace to the right of the `%<operator>s` if it ' \
+                     'should be %<possible>s.'
+
+        def self.autocorrect_incompatible_with
+          [Naming::BlockForwarding]
+        end
+
+        def on_new_investigation
+          processed_source.diagnostics.each do |diagnostic|
+            next unless diagnostic.reason == :ambiguous_prefix
+
+            offense_node = find_offense_node_by(diagnostic)
+            next unless offense_node
+
+            message = message(diagnostic)
+
+            add_offense(
+              diagnostic.location, message: message, severity: diagnostic.level
+            ) do |corrector|
+              add_parentheses(offense_node, corrector)
+            end
+          end
+        end
+
+        private
+
+        def find_offense_node_by(diagnostic)
+          ast = processed_source.ast
+          ast.each_node(:splat, :block_pass, :kwsplat) do |node|
+            next unless offense_position?(node, diagnostic)
+
+            offense_node = offense_node(node)
+            return offense_node if offense_node
+          end
+
+          ast.each_node(:send).find do |send_node|
+            first_argument = send_node.first_argument
+
+            first_argument &&
+              offense_position?(first_argument, diagnostic) &&
+              unary_operator?(first_argument, diagnostic)
+          end
+        end
+
+        def message(diagnostic)
+          operator = diagnostic.location.source
+          hash = AMBIGUITIES[operator]
+          format(MSG_FORMAT, hash)
+        end
+
+        def offense_position?(node, diagnostic)
+          node.source_range.begin_pos == diagnostic.location.begin_pos
+        end
+
+        def offense_node(node)
+          case node.type
+          when :splat, :block_pass
+            node.parent
+          when :kwsplat
+            node.parent.parent
+          end
+        end
+
+        def unary_operator?(node, diagnostic)
+          node.source.start_with?(diagnostic.arguments[:prefix])
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Looks for expressions containing multiple binary operators
+      # where precedence is ambiguous due to lack of parentheses. For example,
+      # in `1 + 2 * 3`, the multiplication will happen before the addition, but
+      # lexically it appears that the addition will happen first.
+      #
+      # The cop does not consider unary operators (ie. `!a` or `-b`) or comparison
+      # operators (ie. `a =~ b`) because those are not ambiguous.
+      #
+      # NOTE: Ranges are handled by `Lint/AmbiguousRange`.
+      #
+      # @example
+      #   # bad
+      #   a + b * c
+      #   a || b && c
+      #   a ** b + c
+      #
+      #   # good (different precedence)
+      #   a + (b * c)
+      #   a || (b && c)
+      #   (a ** b) + c
+      #
+      #   # good (same precedence)
+      #   a + b + c
+      #   a * b / c % d
+      class AmbiguousOperatorPrecedence < Base
+        extend AutoCorrector
+
+        # See https://ruby-doc.org/core-3.0.2/doc/syntax/precedence_rdoc.html
+        PRECEDENCE = [
+          %i[**],
+          %i[* / %],
+          %i[+ -],
+          %i[<< >>],
+          %i[&],
+          %i[| ^],
+          %i[&&],
+          %i[||]
+        ].freeze
+        RESTRICT_ON_SEND = PRECEDENCE.flatten.freeze
+        MSG = 'Wrap expressions with varying precedence with parentheses to avoid ambiguity.'
+
+        def on_and(node)
+          return unless (parent = node.parent)
+
+          return if parent.begin_type? # if the `and` is in a `begin`, it's parenthesized already
+          return unless parent.or_type?
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def on_send(node)
+          return if node.parenthesized?
+
+          return unless (parent = node.parent)
+          return unless operator?(parent)
+          return unless greater_precedence?(node, parent)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def precedence(node)
+          PRECEDENCE.index { |operators| operators.include?(operator_name(node)) }
+        end
+
+        def operator?(node)
+          (node.send_type? && RESTRICT_ON_SEND.include?(node.method_name)) || node.operator_keyword?
+        end
+
+        def greater_precedence?(node1, node2)
+          node1_precedence = precedence(node1)
+          node2_precedence = precedence(node2)
+          return false unless node1_precedence && node2_precedence
+
+          node2_precedence > node1_precedence
+        end
+
+        def operator_name(node)
+          if node.send_type?
+            node.method_name
+          else
+            node.operator.to_sym
+          end
+        end
+
+        def autocorrect(corrector, node)
+          corrector.wrap(node, '(', ')')
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/lint/ambiguous_range.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for ambiguous ranges.
+      #
+      # Ranges have quite low precedence, which leads to unexpected behavior when
+      # using a range with other operators. This cop avoids that by making ranges
+      # explicit by requiring parenthesis around complex range boundaries (anything
+      # that is not a literal: numerics, strings, symbols, etc.).
+      #
+      # This cop can be configured with `RequireParenthesesForMethodChains` in order to
+      # specify whether method chains (including `self.foo`) should be wrapped in parens
+      # by this cop.
+      #
+      # NOTE: Regardless of this configuration, if a method receiver is a basic literal
+      # value, it will be wrapped in order to prevent the ambiguity of `1..2.to_a`.
+      #
+      # @safety
+      #   The cop autocorrects by wrapping the entire boundary in parentheses, which
+      #   makes the outcome more explicit but is possible to not be the intention of the
+      #   programmer. For this reason, this cop's autocorrect is unsafe (it will not
+      #   change the behavior of the code, but will not necessarily match the
+      #   intent of the program).
+      #
+      # @example
+      #   # bad
+      #   x || 1..2
+      #   x - 1..2
+      #   (x || 1..2)
+      #   x || 1..y || 2
+      #   1..2.to_a
+      #
+      #   # good, unambiguous
+      #   1..2
+      #   'a'..'z'
+      #   :bar..:baz
+      #   MyClass::MIN..MyClass::MAX
+      #   @min..@max
+      #   a..b
+      #   -a..b
+      #
+      #   # good, ambiguity removed
+      #   x || (1..2)
+      #   (x - 1)..2
+      #   (x || 1)..2
+      #   (x || 1)..(y || 2)
+      #   (1..2).to_a
+      #
+      # @example RequireParenthesesForMethodChains: false (default)
+      #   # good
+      #   a.foo..b.bar
+      #   (a.foo)..(b.bar)
+      #
+      # @example RequireParenthesesForMethodChains: true
+      #   # bad
+      #   a.foo..b.bar
+      #
+      #   # good
+      #   (a.foo)..(b.bar)
+      class AmbiguousRange < Base
+        include RationalLiteral
+        extend AutoCorrector
+
+        MSG = 'Wrap complex range boundaries with parentheses to avoid ambiguity.'
+
+        def on_irange(node)
+          each_boundary(node) do |boundary|
+            next if acceptable?(boundary)
+
+            add_offense(boundary) do |corrector|
+              corrector.wrap(boundary, '(', ')')
+            end
+          end
+        end
+        alias on_erange on_irange
+
+        private
+
+        def each_boundary(range)
+          yield range.begin if range.begin
+          yield range.end if range.end
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def acceptable?(node)
+          node.begin_type? ||
+            node.literal? || rational_literal?(node) ||
+            node.variable? || node.const_type? || node.self_type? ||
+            (node.call_type? && acceptable_call?(node))
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def acceptable_call?(node)
+          return true if node.unary_operation?
+
+          # Require parentheses when making a method call on a literal
+          # to avoid the ambiguity of `1..2.to_a`.
+          return false if node.receiver&.basic_literal?
+
+          return false if node.operator_method? && !node.method?(:[])
+
+          require_parentheses_for_method_chain? || node.receiver.nil?
+        end
+
+        def require_parentheses_for_method_chain?
+          !cop_config['RequireParenthesesForMethodChains']
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for ambiguous regexp literals in the first argument of
+      # a method invocation without parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # This is interpreted as a method invocation with a regexp literal,
+      #   # but it could possibly be `/` method invocations.
+      #   # (i.e. `do_something./(pattern)./(i)`)
+      #   do_something /pattern/i
+      #
+      #   # good
+      #
+      #   # With parentheses, there's no ambiguity.
+      #   do_something(/pattern/i)
+      class AmbiguousRegexpLiteral < Base
+        extend AutoCorrector
+
+        MSG = 'Ambiguous regexp literal. Parenthesize the method arguments ' \
+              "if it's surely a regexp literal, or add a whitespace to the " \
+              'right of the `/` if it should be a division.'
+
+        def on_new_investigation
+          processed_source.diagnostics.each do |diagnostic|
+            if target_ruby_version >= 3.0
+              next unless diagnostic.reason == :ambiguous_regexp
+            else
+              next unless diagnostic.reason == :ambiguous_literal
+            end
+
+            offense_node = find_offense_node_by(diagnostic)
+
+            add_offense(diagnostic.location, severity: diagnostic.level) do |corrector|
+              add_parentheses(offense_node, corrector)
+            end
+          end
+        end
+
+        private
+
+        def find_offense_node_by(diagnostic)
+          node = processed_source.ast.each_node(:regexp).find do |regexp_node|
+            regexp_node.source_range.begin_pos == diagnostic.location.begin_pos
+          end
+          find_offense_node(node.parent, node)
+        end
+
+        def find_offense_node(node, regexp_receiver)
+          return node if first_argument_is_regexp?(node) || !node.parent
+
+          if (node.parent.send_type? && node.receiver) ||
+             method_chain_to_regexp_receiver?(node, regexp_receiver)
+            node = find_offense_node(node.parent, regexp_receiver)
+          end
+
+          node
+        end
+
+        def first_argument_is_regexp?(node)
+          node.send_type? && node.first_argument&.regexp_type?
+        end
+
+        def method_chain_to_regexp_receiver?(node, regexp_receiver)
+          return false unless (parent = node.parent)
+          return false unless (parent_receiver = parent.receiver)
+
+          parent.parent && parent_receiver.receiver == regexp_receiver
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/lint/array_literal_in_regexp.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for an array literal interpolated inside a regexp.
+      #
+      # When interpolating an array literal, it is converted to a string. This means
+      # that when inside a regexp, it acts as a character class but with additional
+      # quotes, spaces and commas that are likely not intended. For example,
+      # `/#{%w[a b c]}/` parses as `/["a", "b", "c"]/` (or `/["a, bc]/` without
+      # repeated characters).
+      #
+      # The cop can autocorrect to a character class (if all items in the array are a
+      # single character) or alternation (if the array contains longer items).
+      #
+      # NOTE: This only considers interpolated arrays that contain only strings, symbols,
+      # integers, and floats. Any other type is not easily convertible to a character class
+      # or regexp alternation.
+      #
+      # @safety
+      #   Autocorrection is unsafe because it will change the regexp pattern, by
+      #   removing the additional quotes, spaces and commas from the character class.
+      #
+      # @example
+      #   # bad
+      #   /#{%w[a b c]}/
+      #
+      #   # good
+      #   /[abc]/
+      #
+      #   # bad
+      #   /#{%w[foo bar baz]}/
+      #
+      #   # good
+      #   /(?:foo|bar|baz)/
+      #
+      #   # bad - construct a regexp rather than interpolate an array of identifiers
+      #   /#{[foo, bar]}/
+      #
+      class ArrayLiteralInRegexp < Base
+        include Interpolation
+        extend AutoCorrector
+
+        LITERAL_TYPES = %i[str sym int float true false nil].freeze
+        private_constant :LITERAL_TYPES
+
+        MSG_CHARACTER_CLASS = 'Use a character class instead of interpolating an array in a regexp.'
+        MSG_ALTERNATION = 'Use alternation instead of interpolating an array in a regexp.'
+        MSG_UNKNOWN = 'Use alternation or a character class instead of interpolating an array ' \
+                      'in a regexp.'
+
+        def on_interpolation(begin_node)
+          return unless (final_node = begin_node.children.last)
+          return unless final_node.array_type?
+          return unless begin_node.parent.regexp_type?
+
+          if array_of_literal_values?(final_node)
+            register_array_of_literal_values(begin_node, final_node)
+          else
+            register_array_of_nonliteral_values(begin_node)
+          end
+        end
+
+        private
+
+        def array_of_literal_values?(node)
+          node.each_value.all? { |value| value.type?(*LITERAL_TYPES) }
+        end
+
+        def register_array_of_literal_values(begin_node, node)
+          array_values = array_values(node)
+
+          if character_class?(array_values)
+            message = MSG_CHARACTER_CLASS
+            replacement = character_class_for(array_values)
+          else
+            message = MSG_ALTERNATION
+            replacement = alternation_for(array_values)
+          end
+
+          add_offense(begin_node, message: message) do |corrector|
+            corrector.replace(begin_node, replacement)
+          end
+        end
+
+        def register_array_of_nonliteral_values(node)
+          # Add offense but do not correct if the array contains any nonliteral values.
+          add_offense(node, message: MSG_UNKNOWN)
+        end
+
+        def array_values(node)
+          node.each_value.map do |value|
+            value.respond_to?(:value) ? value.value : value.source
+          end
+        end
+
+        def character_class?(values)
+          values.all? { |v| v.to_s.length == 1 }
+        end
+
+        def character_class_for(values)
+          "[#{escape_values(values).join}]"
+        end
+
+        def alternation_for(values)
+          "(?:#{escape_values(values).join('|')})"
+        end
+
+        def escape_values(values)
+          # This may add extraneous escape characters, but they can be cleaned up
+          # by `Style/RedundantRegexpEscape`.
+          values.map { |value| Regexp.escape(value.to_s) }
+        end
+      end
+    end
+  end
+end