super-pro-sys 0.0.1

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where `max_by { ... }`, `min_by { ... }`, or
+      # `minmax_by { ... }` can be replaced by `max`, `min`, or `minmax`.
+      #
+      # @example
+      #   # bad
+      #   array.max_by { |x| x }
+      #   array.min_by { |x| x }
+      #   array.minmax_by { |x| x }
+      #
+      #   # good
+      #   array.max
+      #   array.min
+      #   array.minmax
+      class RedundantMinMaxBy < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_BLOCK = 'Use `%<replacement>s` instead of `%<original>s { |%<var>s| %<var>s }`.'
+        MSG_NUMBLOCK = 'Use `%<replacement>s` instead of `%<original>s { _1 }`.'
+        MSG_ITBLOCK = 'Use `%<replacement>s` instead of `%<original>s { it }`.'
+
+        REPLACEMENTS = { max_by: 'max', min_by: 'min', minmax_by: 'minmax' }.freeze
+
+        def on_block(node)
+          redundant_minmax_by_block(node) do |send, var_name|
+            register_offense(send, node, message_block(send, var_name))
+          end
+        end
+
+        def on_numblock(node)
+          redundant_minmax_by_numblock(node) do |send|
+            register_offense(send, node, message_numblock(send))
+          end
+        end
+
+        def on_itblock(node)
+          redundant_minmax_by_itblock(node) do |send|
+            register_offense(send, node, message_itblock(send))
+          end
+        end
+
+        private
+
+        # @!method redundant_minmax_by_block(node)
+        def_node_matcher :redundant_minmax_by_block, <<~PATTERN
+          (block $(call _ {:max_by :min_by :minmax_by}) (args (arg $_x)) (lvar _x))
+        PATTERN
+
+        # @!method redundant_minmax_by_numblock(node)
+        def_node_matcher :redundant_minmax_by_numblock, <<~PATTERN
+          (numblock $(call _ {:max_by :min_by :minmax_by}) 1 (lvar :_1))
+        PATTERN
+
+        # @!method redundant_minmax_by_itblock(node)
+        def_node_matcher :redundant_minmax_by_itblock, <<~PATTERN
+          (itblock $(call _ {:max_by :min_by :minmax_by}) _ (lvar :it))
+        PATTERN
+
+        def register_offense(send, node, message)
+          range = offense_range(send, node)
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, REPLACEMENTS[send.method_name])
+          end
+        end
+
+        def offense_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+
+        def message_block(send, var_name)
+          method = send.method_name
+          format(MSG_BLOCK, replacement: REPLACEMENTS[method], original: method, var: var_name)
+        end
+
+        def message_numblock(send)
+          method = send.method_name
+          format(MSG_NUMBLOCK, replacement: REPLACEMENTS[method], original: method)
+        end
+
+        def message_itblock(send)
+          method = send.method_name
+          format(MSG_ITBLOCK, replacement: REPLACEMENTS[method], original: method)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,363 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #   (x) if ((y.z).nil?)
+      #
+      #   # good
+      #   x if y.z.nil?
+      #
+      class RedundantParentheses < Base # rubocop:disable Metrics/ClassLength
+        include Parentheses
+        extend AutoCorrector
+
+        ALLOWED_NODE_TYPES = %i[or send splat kwsplat].freeze
+
+        # @!method square_brackets?(node)
+        def_node_matcher :square_brackets?, <<~PATTERN
+          (send `{(send _recv _msg) str array hash const #variable?} :[] ...)
+        PATTERN
+
+        # @!method rescue?(node)
+        def_node_matcher :rescue?, '{^resbody ^^resbody}'
+
+        # @!method allowed_pin_operator?(node)
+        def_node_matcher :allowed_pin_operator?, '^(pin (begin !{lvar ivar cvar gvar}))'
+
+        def on_begin(node)
+          return if !parentheses?(node) || parens_allowed?(node) || ignore_syntax?(node)
+
+          check(node)
+        end
+
+        private
+
+        def variable?(node)
+          node.respond_to?(:variable?) && node.variable?
+        end
+
+        def parens_allowed?(node)
+          empty_parentheses?(node) ||
+            first_arg_begins_with_hash_literal?(node) ||
+            rescue?(node) ||
+            in_pattern_matching_in_method_argument?(node) ||
+            allowed_pin_operator?(node) ||
+            allowed_expression?(node)
+        end
+
+        def ignore_syntax?(node)
+          return false unless (parent = node.parent)
+
+          parent.type?(:while_post, :until_post, :match_with_lvasgn) ||
+            like_method_argument_parentheses?(parent) || multiline_control_flow_statements?(node)
+        end
+
+        def allowed_expression?(node)
+          allowed_ancestor?(node) ||
+            allowed_multiple_expression?(node) ||
+            allowed_ternary?(node) ||
+            node.parent&.range_type?
+        end
+
+        def allowed_ancestor?(node)
+          # Don't flag `break(1)`, etc
+          keyword_ancestor?(node) && parens_required?(node)
+        end
+
+        def allowed_multiple_expression?(node)
+          return false if node.children.one?
+
+          ancestor = node.ancestors.first
+          return false unless ancestor
+
+          !ancestor.type?(:begin, :any_def, :any_block)
+        end
+
+        def allowed_ternary?(node)
+          return false unless node&.parent&.if_type?
+
+          node.parent.ternary? && ternary_parentheses_required?
+        end
+
+        def ternary_parentheses_required?
+          config = @config.for_cop('Style/TernaryParentheses')
+          allowed_styles = %w[require_parentheses require_parentheses_when_complex]
+
+          config.fetch('Enabled') && allowed_styles.include?(config['EnforcedStyle'])
+        end
+
+        def like_method_argument_parentheses?(node)
+          return false unless node.type?(:send, :super, :yield)
+
+          node.arguments.one? && !node.parenthesized? &&
+            !node.operator_method? && node.first_argument.begin_type?
+        end
+
+        def multiline_control_flow_statements?(node)
+          return false unless (parent = node.parent)
+          return false if parent.single_line?
+
+          parent.type?(:return, :next, :break)
+        end
+
+        def empty_parentheses?(node)
+          # Don't flag `()`
+          node.children.empty?
+        end
+
+        def first_arg_begins_with_hash_literal?(node)
+          # Don't flag `method ({key: value})` or `method ({key: value}.method)`
+          hash_literal = method_chain_begins_with_hash_literal(node.children.first)
+          if (root_method = node.each_ancestor(:call).to_a.last)
+            parenthesized = root_method.parenthesized_call?
+          end
+          hash_literal && first_argument?(node) && !parentheses?(hash_literal) && !parenthesized
+        end
+
+        def in_pattern_matching_in_method_argument?(begin_node)
+          return false unless begin_node.parent&.call_type?
+          return false unless (node = begin_node.children.first)
+
+          target_ruby_version <= 2.7 ? node.match_pattern_type? : node.match_pattern_p_type?
+        end
+
+        def method_chain_begins_with_hash_literal(node)
+          return if node.nil?
+          return node if node.hash_type?
+          return unless node.send_type?
+
+          method_chain_begins_with_hash_literal(node.children.first)
+        end
+
+        def check(begin_node)
+          node = begin_node.children.first
+
+          if (message = find_offense_message(begin_node, node))
+            return offense(begin_node, message) if message == 'block body'
+
+            if node.range_type? && !argument_of_parenthesized_method_call?(begin_node, node)
+              begin_node = begin_node.parent
+            end
+
+            return offense(begin_node, message)
+          end
+
+          check_send(begin_node, node) if call_node?(node)
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def find_offense_message(begin_node, node)
+          return 'a keyword' if keyword_with_redundant_parentheses?(node)
+          return 'a literal' if node.literal? && disallowed_literal?(begin_node, node)
+          return 'a variable' if node.variable?
+          return 'a constant' if node.const_type?
+          return 'block body' if begin_node.parent&.any_block_type? || body_range?(begin_node, node)
+
+          if node.assignment? && (begin_node.parent.nil? || begin_node.parent.begin_type?)
+            return 'an assignment'
+          end
+          if node.lambda_or_proc? && (node.braces? || node.send_node.lambda_literal?)
+            return 'an expression'
+          end
+          if disallowed_one_line_pattern_matching?(begin_node, node)
+            return 'a one-line pattern matching'
+          end
+          return 'an interpolated expression' if interpolation?(begin_node)
+          return 'a method argument' if argument_of_parenthesized_method_call?(begin_node, node)
+          return 'a one-line rescue' if oneline_rescue_parentheses_required?(begin_node, node)
+
+          return if begin_node.chained?
+
+          if node.operator_keyword?
+            return if node.semantic_operator? && begin_node.parent
+            return if node.multiline? && allow_in_multiline_conditions?
+            return if ALLOWED_NODE_TYPES.include?(begin_node.parent&.type)
+            return if !node.and_type? && begin_node.parent&.and_type?
+            return if begin_node.parent&.if_type? && begin_node.parent.ternary?
+
+            'a logical expression'
+          elsif node.respond_to?(:comparison_method?) && node.comparison_method?
+            return unless begin_node.parent.nil?
+
+            'a comparison expression'
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        # @!method interpolation?(node)
+        def_node_matcher :interpolation?, '[^begin ^^dstr]'
+
+        def argument_of_parenthesized_method_call?(begin_node, node)
+          if node.basic_conditional? || node.rescue_type? || method_call_parentheses_required?(node)
+            return false
+          end
+          return false unless (parent = begin_node.parent)
+
+          parent.call_type? && parent.parenthesized? && parent.receiver != begin_node
+        end
+
+        def oneline_rescue_parentheses_required?(begin_node, node)
+          return false unless node.rescue_type?
+          return false unless (parent = begin_node.parent)
+          return false if parent.if_type? && parent.ternary?
+          return false if parent.conditional? && parent.condition == begin_node
+
+          !parent.type?(:call, :array, :pair)
+        end
+
+        def method_call_parentheses_required?(node)
+          return false unless node.call_type?
+
+          (node.receiver.nil? || node.loc.dot) && node.arguments.any?
+        end
+
+        def allow_in_multiline_conditions?
+          !!config.for_enabled_cop('Style/ParenthesesAroundCondition')['AllowInMultilineConditions']
+        end
+
+        def call_node?(node)
+          node.call_type? || (node.any_block_type? && node.braces? && !node.lambda_or_proc?)
+        end
+
+        def check_send(begin_node, node)
+          node = node.send_node if node.any_block_type?
+
+          return check_unary(begin_node, node) if node.unary_operation?
+
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
+          return if call_chain_starts_with_int?(begin_node, node) ||
+                    do_end_block_in_method_chain?(begin_node, node)
+
+          offense(begin_node, 'a method call')
+        end
+
+        def check_unary(begin_node, node)
+          return if begin_node.chained?
+
+          node = node.children.first while suspect_unary?(node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
+
+          offense(begin_node, 'a unary operation')
+        end
+
+        def offense(node, msg)
+          add_offense(node, message: "Don't use parentheses around #{msg}.") do |corrector|
+            ParenthesesCorrector.correct(corrector, node)
+          end
+        end
+
+        def suspect_unary?(node)
+          node.send_type? && node.unary_operation? && !node.prefix_not?
+        end
+
+        def keyword_ancestor?(node)
+          node.parent&.keyword?
+        end
+
+        def disallowed_literal?(begin_node, node)
+          if node.range_type?
+            return false unless (parent = begin_node.parent)
+
+            parent.begin_type? && parent.children.one?
+          else
+            !raised_to_power_negative_numeric?(begin_node, node)
+          end
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def body_range?(begin_node, node)
+          return false if begin_node.chained?
+          return false unless node.range_type?
+          return false unless (parent = begin_node.parent)
+          return false unless parent.begin_type?
+
+          (node.begin.nil? && begin_node == parent.children.first) ||
+            (node.end.nil? && begin_node == parent.children.last)
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def disallowed_one_line_pattern_matching?(begin_node, node)
+          if (parent = begin_node.parent)
+            return false if parent.any_def_type? && parent.endless?
+            return false if parent.assignment?
+          end
+
+          node.any_match_pattern_type? && node.each_ancestor.none?(&:operator_keyword?)
+        end
+
+        def raised_to_power_negative_numeric?(begin_node, node)
+          return false unless node.numeric_type?
+
+          next_sibling = begin_node.right_sibling
+          return false unless next_sibling
+
+          base_value = node.children.first
+
+          base_value.negative? && next_sibling == :**
+        end
+
+        def keyword_with_redundant_parentheses?(node)
+          return false unless node.keyword?
+          return true if node.special_keyword?
+
+          args = *node
+
+          if only_begin_arg?(args)
+            parentheses?(args.first)
+          else
+            args.empty? || parentheses?(node)
+          end
+        end
+
+        def method_call_with_redundant_parentheses?(begin_node, node)
+          return false unless node.type?(:call, :super, :yield, :defined?)
+          return false if node.prefix_not?
+          return true if singular_parenthesized_parent?(begin_node)
+
+          node.arguments.empty? || parentheses?(node) || square_brackets?(node)
+        end
+
+        def singular_parenthesized_parent?(begin_node)
+          return true unless (parent = begin_node.parent)
+          return false if parent.type?(:splat, :kwsplat)
+
+          parent.children.one?
+        end
+
+        def only_begin_arg?(args)
+          args.one? && args.first&.begin_type?
+        end
+
+        def first_argument?(node)
+          return true if first_call_argument?(node)
+
+          node.each_ancestor.any? { |ancestor| first_argument?(ancestor) }
+        end
+
+        # @!method first_call_argument?(node)
+        def_node_matcher :first_call_argument?, <<~PATTERN
+          {^(call _ _ equal?(%0) ...)
+           ^({super yield} equal?(%0) ...)}
+        PATTERN
+
+        def call_chain_starts_with_int?(begin_node, send_node)
+          recv = first_part_of_call_chain(send_node)
+          recv&.int_type? && (parent = begin_node.parent) &&
+            parent.send_type? && (parent.method?(:-@) || parent.method?(:+@))
+        end
+
+        def do_end_block_in_method_chain?(begin_node, node)
+          return false unless (block = node.each_descendant(:any_block).first)
+
+          block.keywords? && begin_node.each_ancestor(:call).any?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usage of the %q/%Q syntax when '' or "" would do.
+      #
+      # @example
+      #
+      #   # bad
+      #   name = %q(Bruce Wayne)
+      #   time = %q(8 o'clock)
+      #   question = %q("What did you say?")
+      #
+      #   # good
+      #   name = 'Bruce Wayne'
+      #   time = "8 o'clock"
+      #   question = '"What did you say?"'
+      #
+      class RedundantPercentQ < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<q_type>s` only for strings that contain both ' \
+              'single quotes and double quotes%<extra>s.'
+        DYNAMIC_MSG = ', or for dynamic strings that contain double quotes'
+        SINGLE_QUOTE = "'"
+        QUOTE = '"'
+        EMPTY = ''
+        PERCENT_Q = '%q'
+        PERCENT_CAPITAL_Q = '%Q'
+        STRING_INTERPOLATION_REGEXP = /#\{.+\}/.freeze
+        ESCAPED_NON_BACKSLASH = /\\[^\\]/.freeze
+
+        def on_dstr(node)
+          return unless string_literal?(node)
+
+          check(node)
+        end
+
+        def on_str(node)
+          # Interpolated strings that contain more than just interpolation
+          # will call `on_dstr` for the entire string and `on_str` for the
+          # non interpolated portion of the string
+          return unless string_literal?(node)
+
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return unless start_with_percent_q_variant?(node)
+          return if interpolated_quotes?(node) || allowed_percent_q?(node)
+
+          add_offense(node) do |corrector|
+            delimiter = /\A%Q[^"]+\z|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
+
+            corrector.replace(node.loc.begin, delimiter)
+            corrector.replace(node.loc.end, delimiter)
+          end
+        end
+
+        def interpolated_quotes?(node)
+          node.source.include?(SINGLE_QUOTE) && node.source.include?(QUOTE)
+        end
+
+        def allowed_percent_q?(node)
+          (node.source.start_with?(PERCENT_Q) && acceptable_q?(node)) ||
+            (node.source.start_with?(PERCENT_CAPITAL_Q) && acceptable_capital_q?(node))
+        end
+
+        def message(node)
+          src = node.source
+          extra = if src.start_with?(PERCENT_CAPITAL_Q)
+                    DYNAMIC_MSG
+                  else
+                    EMPTY
+                  end
+          format(MSG, q_type: src[0, 2], extra: extra)
+        end
+
+        def string_literal?(node)
+          node.loc?(:begin) && node.loc?(:end)
+        end
+
+        def start_with_percent_q_variant?(string)
+          string.source.start_with?(PERCENT_Q, PERCENT_CAPITAL_Q)
+        end
+
+        def acceptable_q?(node)
+          src = node.source
+
+          # If the string contains interpolation-like syntax and would be
+          # converted to a double-quoted string (because it contains single
+          # quotes), the replacement would activate interpolation.
+          return true if STRING_INTERPOLATION_REGEXP.match?(src) && src.include?(SINGLE_QUOTE)
+
+          src.scan(/\\./).any?(ESCAPED_NON_BACKSLASH)
+        end
+
+        def acceptable_capital_q?(node)
+          src = node.source
+          src.include?(QUOTE) &&
+            (STRING_INTERPOLATION_REGEXP.match?(src) ||
+            (node.str_type? && double_quotes_required?(src)))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where argument can be replaced from
+      # a deterministic regexp to a string.
+      #
+      # @example
+      #   # bad
+      #   'foo'.byteindex(/f/)
+      #   'foo'.byterindex(/f/)
+      #   'foo'.gsub(/f/, 'x')
+      #   'foo'.gsub!(/f/, 'x')
+      #   'foo'.partition(/f/)
+      #   'foo'.rpartition(/f/)
+      #   'foo'.scan(/f/)
+      #   'foo'.split(/f/)
+      #   'foo'.start_with?(/f/)
+      #   'foo'.sub(/f/, 'x')
+      #   'foo'.sub!(/f/, 'x')
+      #
+      #   # good
+      #   'foo'.byteindex('f')
+      #   'foo'.byterindex('f')
+      #   'foo'.gsub('f', 'x')
+      #   'foo'.gsub!('f', 'x')
+      #   'foo'.partition('f')
+      #   'foo'.rpartition('f')
+      #   'foo'.scan('f')
+      #   'foo'.split('f')
+      #   'foo'.start_with?('f')
+      #   'foo'.sub('f', 'x')
+      #   'foo'.sub!('f', 'x')
+      class RedundantRegexpArgument < Base
+        include StringLiteralsHelp
+        extend AutoCorrector
+
+        MSG = 'Use string `%<prefer>s` as argument instead of regexp `%<current>s`.'
+        RESTRICT_ON_SEND = %i[
+          byteindex byterindex gsub gsub! partition rpartition scan split start_with? sub sub!
+        ].freeze
+        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
+        STR_SPECIAL_CHARS = %w[
+          \a \c \C \e \f \M \n \" \' \\\\ \t \b \f \r \u \v \x \0 \1 \2 \3 \4 \5 \6 \7
+        ].freeze
+
+        def on_send(node)
+          return unless (regexp_node = node.first_argument)
+          return unless regexp_node.regexp_type?
+          return if !regexp_node.regopt.children.empty? || regexp_node.content == ' '
+          return unless determinist_regexp?(regexp_node)
+
+          prefer = preferred_argument(regexp_node)
+          message = format(MSG, prefer: prefer, current: regexp_node.source)
+
+          add_offense(regexp_node, message: message) do |corrector|
+            corrector.replace(regexp_node, prefer)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def determinist_regexp?(regexp_node)
+          DETERMINISTIC_REGEX.match?(regexp_node.source)
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def preferred_argument(regexp_node)
+          new_argument = replacement(regexp_node)
+
+          if new_argument.include?('"')
+            new_argument.gsub!("'", "\\\\'")
+            new_argument.gsub!('\"', '"')
+            quote = "'"
+          elsif new_argument.include?("\\'")
+            # Add a backslash before single quotes preceded by an even number of backslashes.
+            # An even number (including zero) of backslashes before a quote means the quote itself
+            # is not escaped.
+            # Otherwise an odd number means the quote is already escaped so this doesn't touch it.
+            new_argument.gsub!(/(?<!\\)((?:\\\\)*)'/) { "#{::Regexp.last_match(1)}\\'" }
+            quote = "'"
+          elsif new_argument.include?('\'')
+            new_argument.gsub!("'", "\\\\'")
+            quote = "'"
+          elsif new_argument.include?('\\')
+            quote = '"'
+          else
+            quote = enforce_double_quotes? ? '"' : "'"
+          end
+
+          "#{quote}#{new_argument}#{quote}"
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def replacement(regexp_node)
+          regexp_content = regexp_node.content
+          stack = []
+          chars = regexp_content.chars.each_with_object([]) do |char, strings|
+            if stack.empty? && char == '\\'
+              stack.push(char)
+            else
+              strings << "#{stack.pop}#{char}"
+            end
+          end
+          chars.map do |char|
+            char = char.dup
+            char.delete!('\\') unless STR_SPECIAL_CHARS.include?(char)
+            char
+          end.join
+        end
+      end
+    end
+  end
+end