super-pro-sys 0.0.1

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of methods `Hash#has_key?` and
+      # `Hash#has_value?`, and suggests using `Hash#key?` and `Hash#value?` instead.
+      #
+      # It is configurable to enforce the verbose method names, by using the
+      # `EnforcedStyle: verbose` configuration.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or responds to the replacement methods.
+      #
+      # @example EnforcedStyle: short (default)
+      #   # bad
+      #   Hash#has_key?
+      #   Hash#has_value?
+      #
+      #   # good
+      #   Hash#key?
+      #   Hash#value?
+      #
+      # @example EnforcedStyle: verbose
+      #   # bad
+      #   Hash#key?
+      #   Hash#value?
+      #
+      #   # good
+      #   Hash#has_key?
+      #   Hash#has_value?
+      class PreferredHashMethods < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = 'Use `Hash#%<prefer>s` instead of `Hash#%<current>s`.'
+
+        OFFENDING_SELECTORS = { short: %i[has_key? has_value?], verbose: %i[key? value?] }.freeze
+
+        RESTRICT_ON_SEND = OFFENDING_SELECTORS.values.flatten.freeze
+
+        def on_send(node)
+          return unless node.arguments.one? && offending_selector?(node.method_name)
+
+          message = message(node.method_name)
+
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, proper_method_name(node.loc.selector.source))
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def message(method_name)
+          format(MSG, prefer: proper_method_name(method_name), current: method_name)
+        end
+
+        def proper_method_name(method_name)
+          if style == :verbose
+            "has_#{method_name}"
+          else
+            method_name.to_s.delete_prefix('has_')
+          end
+        end
+
+        def offending_selector?(method_name)
+          OFFENDING_SELECTORS[style].include?(method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of `Proc.new` where `Kernel#proc`
+      # would be more appropriate. `proc` is the shorter and
+      # more idiomatic way to create procs in Ruby.
+      #
+      # @example
+      #   # bad
+      #   p = Proc.new { |n| puts n }
+      #
+      #   # good
+      #   p = proc { |n| puts n }
+      #
+      class Proc < Base
+        extend AutoCorrector
+
+        MSG = 'Use `proc` instead of `Proc.new`.'
+
+        # @!method proc_new?(node)
+        def_node_matcher :proc_new?, '(any_block $(send (const {nil? cbase} :Proc) :new) ...)'
+
+        def on_block(node)
+          proc_new?(node) do |block_method|
+            add_offense(block_method) do |corrector|
+              corrector.replace(block_method, 'proc')
+            end
+          end
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks if the quotes used for quoted symbols match the configured defaults.
+      # By default uses the same configuration as `Style/StringLiterals`; if that
+      # cop is not enabled, the default `EnforcedStyle` is `single_quotes`.
+      #
+      # String interpolation is always kept in double quotes.
+      #
+      # NOTE: `Lint/SymbolConversion` can be used in parallel to ensure that symbols
+      # are not quoted that don't need to be. This cop is for configuring the quoting
+      # style to use for symbols that require quotes.
+      #
+      # @example EnforcedStyle: same_as_string_literals (default) / single_quotes
+      #   # bad
+      #   :"abc-def"
+      #
+      #   # good
+      #   :'abc-def'
+      #   :"#{str}"
+      #   :"a\'b"
+      #
+      # @example EnforcedStyle: double_quotes
+      #   # bad
+      #   :'abc-def'
+      #
+      #   # good
+      #   :"abc-def"
+      #   :"#{str}"
+      #   :"a\'b"
+      class QuotedSymbols < Base
+        include ConfigurableEnforcedStyle
+        include SymbolHelp
+        include StringLiteralsHelp
+        extend AutoCorrector
+
+        MSG_SINGLE = "Prefer single-quoted symbols when you don't need string interpolation " \
+                     'or special symbols.'
+        MSG_DOUBLE = 'Prefer double-quoted symbols unless you need single quotes to ' \
+                     'avoid extra backslashes for escaping.'
+
+        def on_sym(node)
+          return unless quoted?(node)
+
+          message = style == :single_quotes ? MSG_SINGLE : MSG_DOUBLE
+
+          if wrong_quotes?(node) || invalid_double_quotes?(node.source)
+            add_offense(node, message: message) do |corrector|
+              opposite_style_detected
+              autocorrect(corrector, node)
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        private
+
+        def invalid_double_quotes?(source)
+          return false unless style == :double_quotes
+
+          # The string needs single quotes if:
+          # 1. It contains a double quote
+          # 2. It contains text that would become an escape sequence with double quotes
+          # 3. It contains text that would become an interpolation with double quotes
+          !/" | (?<!\\)\\[aAbcdefkMnprsStuUxzZ0-7] | \#[@{$]/x.match?(source)
+        end
+
+        def autocorrect(corrector, node)
+          str = if hash_colon_key?(node)
+                  # strip quotes
+                  correct_quotes(node.source[1..-2])
+                else
+                  # strip leading `:` and quotes
+                  ":#{correct_quotes(node.source[2..-2])}"
+                end
+
+          corrector.replace(node, str)
+        end
+
+        def hash_colon_key?(node)
+          # Is the node a hash key with the colon style?
+          hash_key?(node) && node.parent.colon?
+        end
+
+        def correct_quotes(str)
+          correction = if style == :single_quotes
+                         to_string_literal(str)
+                       else
+                         str.gsub("\\'", "'").inspect
+                       end
+
+          # The conversion process doubles escaped slashes, so they have to be reverted
+          correction.gsub('\\\\', '\\').gsub('\"', '"')
+        end
+
+        def style
+          return super unless super == :same_as_string_literals
+          return :single_quotes unless config.cop_enabled?('Style/StringLiterals')
+
+          string_literals_config['EnforcedStyle'].to_sym
+        end
+
+        def alternative_style
+          (supported_styles - [style, :same_as_string_literals]).first
+        end
+
+        def quoted?(sym_node)
+          sym_node.source.match?(/\A:?(['"]).*?\1\z/m)
+        end
+
+        def wrong_quotes?(node)
+          return super if hash_key?(node)
+
+          super(node.source[1..])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks the args passed to `fail` and `raise`.
+      #
+      # Exploded style (default) enforces passing the exception class and message
+      # arguments separately, rather than constructing an instance of the error.
+      #
+      # Compact style enforces constructing an error instance.
+      #
+      # Both styles allow passing just a message, or an error instance when there is more
+      # than one argument.
+      #
+      # The exploded style has an `AllowedCompactTypes` configuration
+      # option that takes an `Array` of exception name Strings.
+      #
+      # @safety
+      #   This cop is unsafe because `raise Foo` calls `Foo.exception`, not `Foo.new`.
+      #
+      # @example EnforcedStyle: exploded (default)
+      #   # bad
+      #   raise StandardError.new('message')
+      #
+      #   # good
+      #   raise StandardError, 'message'
+      #   fail 'message'
+      #   raise MyCustomError
+      #   raise MyCustomError.new(arg1, arg2, arg3)
+      #   raise MyKwArgError.new(key1: val1, key2: val2)
+      #
+      #   # With `AllowedCompactTypes` set to ['MyWrappedError']
+      #   raise MyWrappedError.new(obj)
+      #   raise MyWrappedError.new(obj), 'message'
+      #
+      # @example EnforcedStyle: compact
+      #   # bad
+      #   raise StandardError, 'message'
+      #   raise RuntimeError, arg1, arg2, arg3
+      #
+      #   # good
+      #   raise StandardError.new('message')
+      #   raise MyCustomError
+      #   raise MyCustomError.new(arg1, arg2, arg3)
+      #   fail 'message'
+      class RaiseArgs < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        EXPLODED_MSG = 'Provide an exception class and message as arguments to `%<method>s`.'
+        COMPACT_MSG = 'Provide an exception object as an argument to `%<method>s`.'
+        ACCEPTABLE_ARG_TYPES = %i[
+          hash forwarded_restarg splat forwarded_kwrestarg forwarded_args
+        ].freeze
+
+        RESTRICT_ON_SEND = %i[raise fail].freeze
+
+        def on_send(node)
+          return unless node.command?(:raise) || node.command?(:fail)
+
+          case style
+          when :compact
+            check_compact(node)
+          when :exploded
+            check_exploded(node)
+          end
+        end
+
+        private
+
+        def correction_compact_to_exploded(node)
+          exception_node, _new, message_node = *node.first_argument
+
+          arguments = [exception_node, message_node].compact.map(&:source).join(', ')
+
+          if node.parent && requires_parens?(node.parent)
+            "#{node.method_name}(#{arguments})"
+          else
+            "#{node.method_name} #{arguments}"
+          end
+        end
+
+        def correction_exploded_to_compact(node)
+          exception_node, *message_nodes = *node.arguments
+          return if message_nodes.size > 1
+
+          argument = message_nodes.first.source
+          exception_class = exception_node.receiver&.source || exception_node.source
+
+          if node.parent && requires_parens?(node.parent)
+            "#{node.method_name}(#{exception_class}.new(#{argument}))"
+          else
+            "#{node.method_name} #{exception_class}.new(#{argument})"
+          end
+        end
+
+        def check_compact(node)
+          if node.arguments.size > 1
+            exception = node.first_argument
+            return if exception.send_type? && exception.first_argument&.hash_type?
+
+            add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
+              replacement = correction_exploded_to_compact(node)
+
+              corrector.replace(node, replacement)
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        def check_exploded(node)
+          return correct_style_detected unless node.arguments.one?
+
+          first_arg = node.first_argument
+
+          return if !use_new_method?(first_arg) || acceptable_exploded_args?(first_arg.arguments)
+
+          return if allowed_non_exploded_type?(first_arg)
+
+          add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
+            replacement = correction_compact_to_exploded(node)
+
+            corrector.replace(node, replacement)
+            opposite_style_detected
+          end
+        end
+
+        def use_new_method?(first_arg)
+          first_arg.send_type? && first_arg.receiver && first_arg.method?(:new)
+        end
+
+        def acceptable_exploded_args?(args)
+          # Allow code like `raise Ex.new(arg1, arg2)`.
+          return true if args.size > 1
+
+          # Disallow zero arguments.
+          return false if args.empty?
+
+          arg = args.first
+
+          # Allow nodes that may forward more than one argument
+          ACCEPTABLE_ARG_TYPES.include?(arg.type)
+        end
+
+        def allowed_non_exploded_type?(arg)
+          type = arg.receiver.const_name
+
+          Array(cop_config['AllowedCompactTypes']).include?(type)
+        end
+
+        def requires_parens?(parent)
+          parent.operator_keyword? || (parent.if_type? && parent.ternary?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the use of randomly generated numbers,
+      # added/subtracted with integer literals, as well as those with
+      # Integer#succ and Integer#pred methods. Prefer using ranges instead,
+      # as it clearly states the intentions.
+      #
+      # @example
+      #   # bad
+      #   rand(6) + 1
+      #   1 + rand(6)
+      #   rand(6) - 1
+      #   1 - rand(6)
+      #   rand(6).succ
+      #   rand(6).pred
+      #   Random.rand(6) + 1
+      #   Kernel.rand(6) + 1
+      #   rand(0..5) + 1
+      #
+      #   # good
+      #   rand(1..6)
+      #   rand(1...7)
+      class RandomWithOffset < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer ranges when generating random numbers instead of integers with offsets.'
+        RESTRICT_ON_SEND = %i[+ - succ pred next].freeze
+
+        # @!method integer_op_rand?(node)
+        def_node_matcher :integer_op_rand?, <<~PATTERN
+          (send
+            int {:+ :-}
+            (send
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
+              :rand
+              {int (range int int)}))
+        PATTERN
+
+        # @!method rand_op_integer?(node)
+        def_node_matcher :rand_op_integer?, <<~PATTERN
+          (send
+            (send
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
+              :rand
+              {int (range int int)})
+            {:+ :-}
+            int)
+        PATTERN
+
+        # @!method rand_modified?(node)
+        def_node_matcher :rand_modified?, <<~PATTERN
+          (send
+            (send
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
+              :rand
+              {int (range int int)})
+            {:succ :pred :next})
+        PATTERN
+
+        def on_send(node)
+          return unless node.receiver
+          return unless integer_op_rand?(node) || rand_op_integer?(node) || rand_modified?(node)
+
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
+        end
+
+        private
+
+        # @!method random_call(node)
+        def_node_matcher :random_call, <<~PATTERN
+          {(send (send $_ _ $_) ...)
+           (send _ _ (send $_ _ $_))}
+        PATTERN
+
+        def autocorrect(corrector, node)
+          if integer_op_rand?(node)
+            corrector.replace(node, corrected_integer_op_rand(node))
+          elsif rand_op_integer?(node)
+            corrector.replace(node, corrected_rand_op_integer(node))
+          elsif rand_modified?(node)
+            corrector.replace(node, corrected_rand_modified(node))
+          end
+        end
+
+        def corrected_integer_op_rand(node)
+          random_call(node) do |prefix_node, random_node|
+            prefix = prefix_from_prefix_node(prefix_node)
+            left_int, right_int = boundaries_from_random_node(random_node)
+
+            offset = to_int(node.receiver)
+
+            if node.method?(:+)
+              "#{prefix}(#{offset + left_int}..#{offset + right_int})"
+            else
+              "#{prefix}(#{offset - right_int}..#{offset - left_int})"
+            end
+          end
+        end
+
+        def corrected_rand_op_integer(node)
+          random_call(node) do |prefix_node, random_node|
+            prefix = prefix_from_prefix_node(prefix_node)
+            left_int, right_int = boundaries_from_random_node(random_node)
+
+            offset = to_int(node.first_argument)
+
+            if node.method?(:+)
+              "#{prefix}(#{left_int + offset}..#{right_int + offset})"
+            else
+              "#{prefix}(#{left_int - offset}..#{right_int - offset})"
+            end
+          end
+        end
+
+        def corrected_rand_modified(node)
+          random_call(node) do |prefix_node, random_node|
+            prefix = prefix_from_prefix_node(prefix_node)
+            left_int, right_int = boundaries_from_random_node(random_node)
+
+            if %i[succ next].include?(node.method_name)
+              "#{prefix}(#{left_int + 1}..#{right_int + 1})"
+            elsif node.method?(:pred)
+              "#{prefix}(#{left_int - 1}..#{right_int - 1})"
+            end
+          end
+        end
+
+        def prefix_from_prefix_node(node)
+          [node&.source, 'rand'].compact.join('.')
+        end
+
+        def boundaries_from_random_node(random_node)
+          case random_node.type
+          when :int
+            [0, to_int(random_node) - 1]
+          when :irange
+            [to_int(random_node.begin), to_int(random_node.end)]
+          when :erange
+            [to_int(random_node.begin), to_int(random_node.end) - 1]
+          end
+        end
+
+        # @!method to_int(node)
+        def_node_matcher :to_int, <<~PATTERN
+          (int $_)
+        PATTERN
+      end
+    end
+  end
+end