super-pro-sys 0.0.1

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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for unneeded usages of splat expansion.
+      #
+      # @example
+      #
+      #   # bad
+      #   a = *[1, 2, 3]
+      #   a = *'a'
+      #   a = *1
+      #   ['a', 'b', *%w(c d e), 'f', 'g']
+      #
+      #   # good
+      #   c = [1, 2, 3]
+      #   a = *c
+      #   a, b = *c
+      #   a, *b = *c
+      #   a = *1..10
+      #   a = ['a']
+      #   ['a', 'b', 'c', 'd', 'e', 'f', 'g']
+      #
+      #   # bad
+      #   do_something(*['foo', 'bar', 'baz'])
+      #
+      #   # good
+      #   do_something('foo', 'bar', 'baz')
+      #
+      #   # bad
+      #   begin
+      #     foo
+      #   rescue *[StandardError, ApplicationError]
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue StandardError, ApplicationError
+      #     bar
+      #   end
+      #
+      #   # bad
+      #   case foo
+      #   when *[1, 2, 3]
+      #     bar
+      #   else
+      #     baz
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when 1, 2, 3
+      #     bar
+      #   else
+      #     baz
+      #   end
+      #
+      # @example AllowPercentLiteralArrayArgument: true (default)
+      #
+      #   # good
+      #   do_something(*%w[foo bar baz])
+      #
+      # @example AllowPercentLiteralArrayArgument: false
+      #
+      #   # bad
+      #   do_something(*%w[foo bar baz])
+      #
+      class RedundantSplatExpansion < Base
+        extend AutoCorrector
+
+        MSG = 'Replace splat expansion with comma separated values.'
+        ARRAY_PARAM_MSG = 'Pass array contents as separate arguments.'
+        PERCENT_W = '%w'
+        PERCENT_CAPITAL_W = '%W'
+        PERCENT_I = '%i'
+        PERCENT_CAPITAL_I = '%I'
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
+
+        # @!method array_new?(node)
+        def_node_matcher :array_new?, <<~PATTERN
+          {
+            $(send (const {nil? cbase} :Array) :new ...)
+            $(block (send (const {nil? cbase} :Array) :new ...) ...)
+          }
+        PATTERN
+
+        # @!method literal_expansion(node)
+        def_node_matcher :literal_expansion, <<~PATTERN
+          (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)
+        PATTERN
+
+        def on_splat(node)
+          redundant_splat_expansion(node) do
+            if array_splat?(node) && (method_argument?(node) || part_of_an_array?(node))
+              return if allow_percent_literal_array_argument? &&
+                        use_percent_literal_array_argument?(node)
+
+              add_offense(node, message: ARRAY_PARAM_MSG) do |corrector|
+                autocorrect(corrector, node)
+              end
+            else
+              add_offense(node) { |corrector| autocorrect(corrector, node) }
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          range, content = replacement_range_and_content(node)
+
+          corrector.replace(range, content)
+        end
+
+        def redundant_splat_expansion(node)
+          literal_expansion(node) do |expanded_item|
+            if expanded_item.send_type?
+              return if array_new_inside_array_literal?(expanded_item)
+
+              grandparent = node.parent.parent
+              return if grandparent && !ASSIGNMENT_TYPES.include?(grandparent.type)
+            # An empty array/percent literal (`*[]`, `*%w()`, ...) expands to nothing, so
+            # removing the splat would produce invalid or semantically different code.
+            elsif expanded_item.array_type? && expanded_item.children.empty?
+              return
+            end
+
+            yield
+          end
+        end
+
+        def array_new_inside_array_literal?(array_new_node)
+          return false unless array_new?(array_new_node)
+
+          grandparent = array_new_node.parent.parent
+          grandparent.array_type? && grandparent.children.size > 1
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def replacement_range_and_content(node)
+          variable = node.children.first
+          expression = node.source_range
+
+          if array_new?(variable)
+            expression = node.parent.source_range if node.parent.array_type?
+            [expression, variable.source]
+          elsif !variable.array_type?
+            replacement = variable.source
+            replacement = "[#{replacement}]" if wrap_in_brackets?(node)
+            [expression, replacement]
+          elsif redundant_brackets?(node)
+            [expression, remove_brackets(variable)]
+          else
+            [node.loc.operator, '']
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def array_splat?(node)
+          node.children.first.array_type?
+        end
+
+        def method_argument?(node)
+          node.parent.call_type?
+        end
+
+        def part_of_an_array?(node)
+          # The parent of a splat expansion is an array that does not have
+          # `begin` or `end`
+          parent = node.parent
+          parent.array_type? && parent.loc.begin && parent.loc.end
+        end
+
+        def redundant_brackets?(node)
+          parent = node.parent
+          grandparent = node.parent.parent
+
+          parent.when_type? || method_argument?(node) || part_of_an_array?(node) ||
+            grandparent&.resbody_type?
+        end
+
+        def wrap_in_brackets?(node)
+          node.parent.array_type? && !node.parent.bracketed?
+        end
+
+        def remove_brackets(array)
+          array_start = array.loc.begin.source
+          elements = *array
+          elements = elements.map(&:source)
+
+          if array_start.start_with?(PERCENT_W)
+            "'#{elements.join("', '")}'"
+          elsif array_start.start_with?(PERCENT_CAPITAL_W)
+            %("#{elements.join('", "')}")
+          elsif array_start.start_with?(PERCENT_I)
+            ":#{elements.join(', :')}"
+          elsif array_start.start_with?(PERCENT_CAPITAL_I)
+            %(:"#{elements.join('", :"')}")
+          else
+            elements.join(', ')
+          end
+        end
+
+        def use_percent_literal_array_argument?(node)
+          argument = node.children.first
+
+          method_argument?(node) &&
+            (argument.percent_literal?(:string) || argument.percent_literal?(:symbol))
+        end
+
+        def allow_percent_literal_array_argument?
+          cop_config.fetch('AllowPercentLiteralArrayArgument', true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for string conversion in string interpolation, `print`, `puts`, and `warn` arguments,
+      # which is redundant.
+      #
+      # @example
+      #
+      #   # bad
+      #   "result is #{something.to_s}"
+      #   print something.to_s
+      #   puts something.to_s
+      #   warn something.to_s
+      #
+      #   # good
+      #   "result is #{something}"
+      #   print something
+      #   puts something
+      #   warn something
+      #
+      class RedundantStringCoercion < Base
+        include Interpolation
+        extend AutoCorrector
+
+        MSG_DEFAULT = 'Redundant use of `Object#to_s` in %<context>s.'
+        MSG_SELF = 'Use `self` instead of `Object#to_s` in %<context>s.'
+        RESTRICT_ON_SEND = %i[print puts warn].freeze
+
+        # @!method to_s_without_args?(node)
+        def_node_matcher :to_s_without_args?, '(call _ :to_s)'
+
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
+
+          return unless to_s_without_args?(final_node)
+
+          register_offense(final_node, 'interpolation')
+        end
+
+        def on_send(node)
+          return if node.receiver
+
+          node.each_child_node(:call) do |child|
+            next if !child.method?(:to_s) || child.arguments.any?
+
+            register_offense(child, "`#{node.method_name}`")
+          end
+        end
+
+        private
+
+        def register_offense(node, context)
+          receiver = node.receiver
+          template = receiver ? MSG_DEFAULT : MSG_SELF
+          message = format(template, context: context)
+
+          add_offense(node.loc.selector, message: message) do |corrector|
+            replacement = receiver ? receiver.source : 'self'
+
+            corrector.replace(node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for redundant uses of `to_s`, `to_sym`, `to_i`, `to_f`, `to_d`, `to_r`, `to_c`,
+      # `to_a`, `to_h`, and `to_set`.
+      #
+      # When one of these methods is called on an object of the same type, that object
+      # is returned, making the call unnecessary. The cop detects conversion methods called
+      # on object literals, class constructors, class `[]` methods, and the `Kernel` methods
+      # `String()`, `Integer()`, `Float()`, BigDecimal(), `Rational()`, `Complex()`, and `Array()`.
+      #
+      # Specifically, these cases are detected for each conversion method:
+      #
+      # * `to_s` when called on a string literal, interpolated string, heredoc,
+      #   or with `String.new` or `String()`.
+      # * `to_sym` when called on a symbol literal or interpolated symbol.
+      # * `to_i` when called on an integer literal or with `Integer()`.
+      # * `to_f` when called on a float literal or with `Float()`.
+      # * `to_d` when called with `BigDecimal()`.
+      # * `to_r` when called on a rational literal or with `Rational()`.
+      # * `to_c` when called on a complex literal or with `Complex()`.
+      # * `to_a` when called on an array literal, or with `Array.new`, `Array()` or `Array[]`.
+      # * `to_h` when called on a hash literal, or with `Hash.new`, `Hash()` or `Hash[]`.
+      # * `to_set` when called on `Set.new` or `Set[]`.
+      #
+      # In all cases, chaining one of the same `to_*` conversion methods listed above is redundant.
+      #
+      # The cop can also register an offense for chaining conversion methods on methods that are
+      # expected to return a specific type regardless of receiver (eg. `foo.inspect.to_s` and
+      # `foo.to_json.to_s`).
+      #
+      # @example
+      #   # bad
+      #   "text".to_s
+      #   :sym.to_sym
+      #   42.to_i
+      #   8.5.to_f
+      #   12r.to_r
+      #   1i.to_c
+      #   [].to_a
+      #   {}.to_h
+      #   Set.new.to_set
+      #
+      #   # good
+      #   "text"
+      #   :sym
+      #   42
+      #   8.5
+      #   12r
+      #   1i
+      #   []
+      #   {}
+      #   Set.new
+      #
+      #   # bad
+      #   Integer(var).to_i
+      #
+      #   # good
+      #   Integer(var)
+      #
+      #   # good - chaining to a type constructor with exceptions suppressed
+      #   # in this case, `Integer()` could return `nil`
+      #   Integer(var, exception: false).to_i
+      #
+      #   # bad
+      #   BigDecimal(var).to_d
+      #
+      #   # good
+      #   BigDecimal(var)
+      #
+      #   # bad - chaining the same conversion
+      #   foo.to_s.to_s
+      #
+      #   # good
+      #   foo.to_s
+      #
+      #   # bad - chaining a conversion to a method that is expected to return the same type
+      #   foo.inspect.to_s
+      #   foo.to_json.to_s
+      #
+      #   # good
+      #   foo.inspect
+      #   foo.to_json
+      #
+      class RedundantTypeConversion < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant `%<method>s` detected.'
+
+        # Maps conversion methods to the node types for the literals of that type
+        LITERAL_NODE_TYPES = {
+          to_s: %i[str dstr],
+          to_sym: %i[sym dsym],
+          to_i: %i[int],
+          to_f: %i[float],
+          to_r: %i[rational],
+          to_c: %i[complex],
+          to_a: %i[array],
+          to_h: %i[hash],
+          to_set: [] # sets don't have a literal or node type
+        }.freeze
+
+        # Maps each conversion method to the pattern matcher for that type's constructors
+        # Not every type has a constructor, for instance Symbol.
+        CONSTRUCTOR_MAPPING = {
+          to_s: 'string_constructor?',
+          to_i: 'integer_constructor?',
+          to_f: 'float_constructor?',
+          to_d: 'bigdecimal_constructor?',
+          to_r: 'rational_constructor?',
+          to_c: 'complex_constructor?',
+          to_a: 'array_constructor?',
+          to_h: 'hash_constructor?',
+          to_set: 'set_constructor?'
+        }.freeze
+
+        # Methods that already are expected to return a given type, which makes a further
+        # conversion redundant.
+        TYPED_METHODS = { to_s: %i[inspect to_json] }.freeze
+
+        CONVERSION_METHODS = Set[*LITERAL_NODE_TYPES.keys].freeze
+        RESTRICT_ON_SEND = CONVERSION_METHODS + [:to_d]
+
+        private_constant :LITERAL_NODE_TYPES, :CONSTRUCTOR_MAPPING
+
+        # @!method type_constructor?(node, type_symbol)
+        def_node_matcher :type_constructor?, <<~PATTERN
+          (send {nil? (const {cbase nil?} :Kernel)} %1 ...)
+        PATTERN
+
+        # @!method string_constructor?(node)
+        def_node_matcher :string_constructor?, <<~PATTERN
+          {
+            (send (const {cbase nil?} :String) :new ...)
+            #type_constructor?(:String)
+          }
+        PATTERN
+
+        # @!method integer_constructor?(node)
+        def_node_matcher :integer_constructor?, <<~PATTERN
+          #type_constructor?(:Integer)
+        PATTERN
+
+        # @!method float_constructor?(node)
+        def_node_matcher :float_constructor?, <<~PATTERN
+          #type_constructor?(:Float)
+        PATTERN
+
+        # @!method bigdecimal_constructor?(node)
+        def_node_matcher :bigdecimal_constructor?, <<~PATTERN
+          #type_constructor?(:BigDecimal)
+        PATTERN
+
+        # @!method rational_constructor?(node)
+        def_node_matcher :rational_constructor?, <<~PATTERN
+          #type_constructor?(:Rational)
+        PATTERN
+
+        # @!method complex_constructor?(node)
+        def_node_matcher :complex_constructor?, <<~PATTERN
+          #type_constructor?(:Complex)
+        PATTERN
+
+        # @!method array_constructor?(node)
+        def_node_matcher :array_constructor?, <<~PATTERN
+          {
+            (send (const {cbase nil?} :Array) {:new :[]} ...)
+            #type_constructor?(:Array)
+          }
+        PATTERN
+
+        # @!method hash_constructor?(node)
+        def_node_matcher :hash_constructor?, <<~PATTERN
+          {
+            (block (send (const {cbase nil?} :Hash) :new) ...)
+            (send (const {cbase nil?} :Hash) {:new :[]} ...)
+            (send {nil? (const {cbase nil?} :Kernel)} :Hash ...)
+          }
+        PATTERN
+
+        # @!method set_constructor?(node)
+        def_node_matcher :set_constructor?, <<~PATTERN
+          {
+            (send (const {cbase nil?} :Set) {:new :[]} ...)
+          }
+        PATTERN
+
+        # @!method exception_false_keyword_argument?(node)
+        def_node_matcher :exception_false_keyword_argument?, <<~PATTERN
+          (hash (pair (sym :exception) false))
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def on_send(node)
+          return if node.arguments.any? || hash_or_set_with_block?(node)
+
+          receiver = find_receiver(node)
+          return unless literal_receiver?(node, receiver) ||
+                        constructor?(node, receiver) ||
+                        chained_conversion?(node, receiver) ||
+                        chained_to_typed_method?(node, receiver)
+
+          message = format(MSG, method: node.method_name)
+
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.remove(node.loc.dot.join(node.loc.end || node.loc.selector))
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        alias on_csend on_send
+
+        private
+
+        def hash_or_set_with_block?(node)
+          return false if !node.method?(:to_h) && !node.method?(:to_set)
+
+          node.parent&.any_block_type? || node.last_argument&.block_pass_type?
+        end
+
+        def find_receiver(node)
+          receiver = node.receiver
+          return unless receiver
+
+          while receiver.begin_type?
+            break unless receiver.children.one?
+
+            receiver = receiver.children.first
+          end
+
+          receiver
+        end
+
+        def literal_receiver?(node, receiver)
+          return false unless receiver
+
+          receiver.type?(*LITERAL_NODE_TYPES[node.method_name])
+        end
+
+        def constructor?(node, receiver)
+          matcher = CONSTRUCTOR_MAPPING[node.method_name]
+          return false unless matcher
+
+          public_send(matcher, receiver) && !constructor_suppresses_exceptions?(receiver)
+        end
+
+        def constructor_suppresses_exceptions?(receiver)
+          # If the constructor suppresses exceptions with `exception: false`, it is possible
+          # it could return `nil`, and therefore a chained conversion is not redundant.
+          receiver.arguments.any? { |arg| exception_false_keyword_argument?(arg) }
+        end
+
+        def chained_conversion?(node, receiver)
+          return false unless receiver&.call_type?
+
+          receiver.method?(node.method_name)
+        end
+
+        def chained_to_typed_method?(node, receiver)
+          return false unless receiver&.call_type?
+
+          TYPED_METHODS.fetch(node.method_name, []).include?(receiver.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for redundant `with_index`.
+      #
+      # @example
+      #   # bad
+      #   ary.each_with_index do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      #   # bad
+      #   ary.each.with_index do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      class RedundantWithIndex < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
+        MSG_WITH_INDEX = 'Remove redundant `with_index`.'
+
+        # rubocop:disable Metrics/AbcSize
+        def on_block(node)
+          return unless node.receiver
+          return if node.method?(:with_index) && !node.receiver.receiver
+          return unless (send = redundant_with_index?(node))
+
+          range = with_index_range(send)
+
+          add_offense(range, message: message(send)) do |corrector|
+            if send.method?(:each_with_index)
+              corrector.replace(send.loc.selector, 'each')
+            else
+              corrector.remove(range)
+              corrector.remove(send.loc.dot)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        # @!method redundant_with_index?(node)
+        def_node_matcher :redundant_with_index?, <<~PATTERN
+          {
+            (block
+              $(call _ {:each_with_index :with_index} ...)
+              {(args (arg _)) (args)} ...)
+            (numblock
+              $(call _ {:each_with_index :with_index} ...) 1 ...)
+            (itblock
+              $(call _ {:each_with_index :with_index} ...) _ ...)
+          }
+        PATTERN
+
+        def message(node)
+          if node.method?(:each_with_index)
+            MSG_EACH_WITH_INDEX
+          else
+            MSG_WITH_INDEX
+          end
+        end
+
+        def with_index_range(send)
+          range_between(send.loc.selector.begin_pos, send.source_range.end_pos)
+        end
+      end
+    end
+  end
+end