super-pro-sys 0.0.1

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for numbered parameters.
+      #
+      # It can either restrict the use of numbered parameters to
+      # single-lined blocks, or disallow completely numbered parameters.
+      #
+      # @example EnforcedStyle: allow_single_line (default)
+      #   # bad
+      #   collection.each do
+      #     puts _1
+      #   end
+      #
+      #   # good
+      #   collection.each { puts _1 }
+      #
+      # @example EnforcedStyle: disallow
+      #   # bad
+      #   collection.each { puts _1 }
+      #
+      #   # good
+      #   collection.each { |item| puts item }
+      #
+      class NumberedParameters < Base
+        include ConfigurableEnforcedStyle
+        extend TargetRubyVersion
+
+        MSG_DISALLOW = 'Avoid using numbered parameters.'
+        MSG_MULTI_LINE = 'Avoid using numbered parameters for multi-line blocks.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_numblock(node)
+          if style == :disallow
+            add_offense(node, message: MSG_DISALLOW)
+          elsif node.multiline?
+            add_offense(node, message: MSG_MULTI_LINE)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Detects use of an excessive amount of numbered parameters in a
+      # single block. Having too many numbered parameters can make code too
+      # cryptic and hard to read.
+      #
+      # The cop defaults to registering an offense if there is more than 1 numbered
+      # parameter but this maximum can be configured by setting `Max`.
+      #
+      # @example Max: 1 (default)
+      #   # bad
+      #   use_multiple_numbered_parameters { _1.call(_2, _3, _4) }
+      #
+      #   # good
+      #   array.each { use_array_element_as_numbered_parameter(_1) }
+      #   hash.each { use_only_hash_value_as_numbered_parameter(_2) }
+      class NumberedParametersLimit < Base
+        extend TargetRubyVersion
+        extend ExcludeLimit
+
+        DEFAULT_MAX_VALUE = 1
+
+        minimum_target_ruby_version 2.7
+        exclude_limit 'Max'
+
+        MSG = 'Avoid using more than %<max>i numbered %<parameter>s; %<count>i detected.'
+        NUMBERED_PARAMETER_PATTERN = /\A_[1-9]\z/.freeze
+
+        def on_numblock(node)
+          param_count = numbered_parameter_nodes(node).uniq.count
+          return if param_count <= max_count
+
+          parameter = max_count > 1 ? 'parameters' : 'parameter'
+          message = format(MSG, max: max_count, parameter: parameter, count: param_count)
+          add_offense(node, message: message) { self.max = param_count }
+        end
+
+        private
+
+        def numbered_parameter_nodes(node)
+          node.each_descendant(:lvar).select do |lvar_node|
+            lvar_node.source.match?(NUMBERED_PARAMETER_PATTERN)
+          end
+        end
+
+        def max_count
+          max = cop_config.fetch('Max', DEFAULT_MAX_VALUE)
+
+          # Ruby does not allow more than 9 numbered parameters
+          [max, 9].min
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for octal, hex, binary, and decimal literals using
+      # uppercase prefixes and corrects them to lowercase prefix
+      # or no prefix (in case of decimals).
+      #
+      # @example EnforcedOctalStyle: zero_with_o (default)
+      #   # bad - missing octal prefix
+      #   num = 01234
+      #
+      #   # bad - uppercase prefix
+      #   num = 0O1234
+      #   num = 0X12AB
+      #   num = 0B10101
+      #
+      #   # bad - redundant decimal prefix
+      #   num = 0D1234
+      #   num = 0d1234
+      #
+      #   # good
+      #   num = 0o1234
+      #   num = 0x12AB
+      #   num = 0b10101
+      #   num = 1234
+      #
+      # @example EnforcedOctalStyle: zero_only
+      #   # bad
+      #   num = 0o1234
+      #   num = 0O1234
+      #
+      #   # good
+      #   num = 01234
+      class NumericLiteralPrefix < Base
+        include IntegerNode
+        extend AutoCorrector
+
+        OCTAL_ZERO_ONLY_REGEX = /^0[Oo][0-7]+$/.freeze
+        OCTAL_REGEX = /^0O?[0-7]+$/.freeze
+        HEX_REGEX = /^0X[0-9A-F]+$/.freeze
+        BINARY_REGEX = /^0B[01]+$/.freeze
+        DECIMAL_REGEX = /^0[dD][0-9]+$/.freeze
+
+        OCTAL_ZERO_ONLY_MSG = 'Use 0 for octal literals.'
+        OCTAL_MSG = 'Use 0o for octal literals.'
+        HEX_MSG = 'Use 0x for hexadecimal literals.'
+        BINARY_MSG = 'Use 0b for binary literals.'
+        DECIMAL_MSG = 'Do not use prefixes for decimal literals.'
+
+        def on_int(node)
+          type = literal_type(node)
+
+          return unless type
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, send(:"format_#{type}", node.source))
+          end
+        end
+
+        private
+
+        def message(node)
+          self.class.const_get(:"#{literal_type(node).upcase}_MSG")
+        end
+
+        def literal_type(node)
+          literal = integer_part(node)
+
+          octal_literal_type(literal) || hex_bin_dec_literal_type(literal)
+        end
+
+        def octal_literal_type(literal)
+          if OCTAL_ZERO_ONLY_REGEX.match?(literal) && octal_zero_only?
+            :octal_zero_only
+          elsif OCTAL_REGEX.match?(literal) && !octal_zero_only?
+            :octal
+          end
+        end
+
+        def hex_bin_dec_literal_type(literal)
+          case literal
+          when HEX_REGEX
+            :hex
+          when BINARY_REGEX
+            :binary
+          when DECIMAL_REGEX
+            :decimal
+          end
+        end
+
+        def octal_zero_only?
+          cop_config['EnforcedOctalStyle'] == 'zero_only'
+        end
+
+        def format_octal(source)
+          source.sub(/^0O?/, '0o')
+        end
+
+        def format_octal_zero_only(source)
+          source.sub(/^0[Oo]?/, '0')
+        end
+
+        def format_hex(source)
+          source.sub(/^0X/, '0x')
+        end
+
+        def format_binary(source)
+          source.sub(/^0B/, '0b')
+        end
+
+        def format_decimal(source)
+          source.sub(/^0[dD]/, '')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for big numeric literals without `_` between groups
+      # of digits in them. Underscores make large numbers easier to
+      # read by visually separating groups of digits.
+      #
+      # Additional allowed patterns can be added by adding regexps to
+      # the `AllowedPatterns` configuration. All regexps are treated
+      # as anchored even if the patterns do not contain anchors (so
+      # `\d{4}_\d{4}` will allow `1234_5678` but not `1234_5678_9012`).
+      #
+      # NOTE: Even if `AllowedPatterns` are given, autocorrection will
+      # only correct to the standard pattern of an `_` every 3 digits.
+      #
+      # @example
+      #
+      #   # bad
+      #   1000000
+      #   1_00_000
+      #   1_0000
+      #
+      #   # good
+      #   1_000_000
+      #   1000
+      #
+      # @example Strict: false (default)
+      #
+      #   # good
+      #   10_000_00 # typical representation of $10,000 in cents
+      #
+      # @example Strict: true
+      #
+      #   # bad
+      #   10_000_00 # typical representation of $10,000 in cents
+      #
+      # @example AllowedNumbers: [3000]
+      #
+      #   # good
+      #   3000 # You can specify allowed numbers. (e.g. port number)
+      #
+      class NumericLiterals < Base
+        include IntegerNode
+        include AllowedPattern
+        extend AutoCorrector
+
+        MSG = 'Use underscores(_) as thousands separator and separate every 3 digits with them.'
+        DELIMITER_REGEXP = /[eE.]/.freeze
+
+        # The parameter is called MinDigits (meaning the minimum number of
+        # digits for which an offense can be registered), but essentially it's
+        # a Max parameter (the maximum number of something that's allowed).
+        exclude_limit 'MinDigits'
+
+        def on_int(node)
+          check(node)
+        end
+
+        def on_float(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          int = integer_part(node)
+          # TODO: handle non-decimal literals as well
+          return if int.start_with?('0')
+          return if allowed_numbers.include?(int)
+          return if matches_allowed_pattern?(int)
+          return unless int.size >= min_digits
+
+          case int
+          when /^\d+$/
+            register_offense(node) { self.min_digits = int.size + 1 }
+          when /\d{4}/, short_group_regex
+            register_offense(node) { self.config_to_allow_offenses = { 'Enabled' => false } }
+          end
+        end
+
+        def register_offense(node, &_block)
+          add_offense(node) do |corrector|
+            yield
+            corrector.replace(node, format_number(node))
+          end
+        end
+
+        def short_group_regex
+          cop_config['Strict'] ? /_\d{1,2}(_|$)/ : /_\d{1,2}_/
+        end
+
+        def format_number(node)
+          source = node.source.gsub(/\s+/, '')
+          int_part, additional_part = source.split(DELIMITER_REGEXP, 2)
+          formatted_int = format_int_part(int_part)
+          delimiter = source[DELIMITER_REGEXP]
+
+          if additional_part
+            formatted_int + delimiter + additional_part
+          else
+            formatted_int
+          end
+        end
+
+        # @param int_part [String]
+        def format_int_part(int_part)
+          int_part = Integer(int_part)
+          formatted_int = int_part.abs.to_s.reverse.gsub(/...(?=.)/, '\&_').reverse
+          formatted_int.insert(0, '-') if int_part.negative?
+          formatted_int
+        end
+
+        def min_digits
+          cop_config['MinDigits']
+        end
+
+        def allowed_numbers
+          @allowed_numbers ||= cop_config.fetch('AllowedNumbers', []).map(&:to_s).freeze
+        end
+
+        def allowed_patterns
+          # Convert the patterns to be anchored
+          super.map { |regexp| /\A#{regexp}\z/ }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usage of comparison operators (`==`,
+      # `>`, `<`) to test numbers as zero, positive, or negative.
+      # These can be replaced by their respective predicate methods.
+      # This cop can also be configured to do the reverse.
+      #
+      # This cop's allowed methods can be customized with `AllowedMethods`.
+      # By default, there are no allowed methods.
+      #
+      # This cop disregards `#nonzero?` as its value is truthy or falsey,
+      # but not `true` and `false`, and thus not always interchangeable with
+      # `!= 0`.
+      #
+      # This cop allows comparisons to global variables, since they are often
+      # populated with objects which can be compared with integers, but are
+      # not themselves `Integer` polymorphic.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   defines the predicates or can be compared to a number, which may lead
+      #   to a false positive for non-standard classes.
+      #
+      # @example EnforcedStyle: predicate (default)
+      #   # bad
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      #   # good
+      #   foo.zero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      # @example EnforcedStyle: comparison
+      #   # bad
+      #   foo.zero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      #   # good
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      # @example AllowedMethods: [] (default) with EnforcedStyle: predicate
+      #   # bad
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      # @example AllowedMethods: [==] with EnforcedStyle: predicate
+      #   # good
+      #   foo == 0
+      #
+      #   # bad
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      # @example AllowedPatterns: [] (default) with EnforcedStyle: comparison
+      #   # bad
+      #   foo.zero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      # @example AllowedPatterns: ['zero'] with EnforcedStyle: predicate
+      #   # good
+      #   # bad
+      #   foo.zero?
+      #
+      #   # bad
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      class NumericPredicate < Base
+        include ConfigurableEnforcedStyle
+        include AllowedMethods
+        include AllowedPattern
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+
+        REPLACEMENTS = { 'zero?' => '==', 'positive?' => '>', 'negative?' => '<' }.freeze
+
+        RESTRICT_ON_SEND = %i[== > < positive? negative? zero?].freeze
+
+        def on_send(node)
+          numeric, replacement = check(node)
+          return unless numeric
+
+          return if allowed_method_name?(node.method_name) ||
+                    node.each_ancestor(:send, :any_block).any? do |ancestor|
+                      allowed_method_name?(ancestor.method_name)
+                    end
+
+          message = format(MSG, prefer: replacement, current: node.source)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
+        def check(node)
+          numeric, operator =
+            if style == :predicate
+              comparison(node) || inverted_comparison(node, &invert)
+            else
+              predicate(node)
+            end
+
+          return unless numeric && operator && replacement_supported?(operator)
+
+          [numeric, replacement(node, numeric, operator)]
+        end
+
+        def replacement(node, numeric, operation)
+          if style == :predicate
+            [parenthesized_source(numeric), REPLACEMENTS.invert[operation.to_s]].join('.')
+          elsif negated?(node)
+            "(#{numeric.source} #{REPLACEMENTS[operation.to_s]} 0)"
+          else
+            [numeric.source, REPLACEMENTS[operation.to_s], 0].join(' ')
+          end
+        end
+
+        def parenthesized_source(node)
+          if require_parentheses?(node)
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
+
+        def require_parentheses?(node)
+          node.send_type? && node.binary_operation? && !node.parenthesized?
+        end
+
+        def replacement_supported?(operator)
+          if %i[> <].include?(operator)
+            target_ruby_version >= 2.3
+          else
+            true
+          end
+        end
+
+        def invert
+          lambda do |comparison, numeric|
+            comparison = { :> => :<, :< => :> }[comparison] || comparison
+
+            [numeric, comparison]
+          end
+        end
+
+        def negated?(node)
+          return false unless (parent = node.parent)
+
+          parent.send_type? && parent.method?(:!)
+        end
+
+        # @!method predicate(node)
+        def_node_matcher :predicate, <<~PATTERN
+          (send $(...) ${:zero? :positive? :negative?})
+        PATTERN
+
+        # @!method comparison(node)
+        def_node_matcher :comparison, <<~PATTERN
+          (send [$(...) !gvar_type?] ${:== :> :<} (int 0))
+        PATTERN
+
+        # @!method inverted_comparison(node)
+        def_node_matcher :inverted_comparison, <<~PATTERN
+          (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of consistent method names
+      # `Object#yield_self` or `Object#then`.
+      #
+      # @example EnforcedStyle: then (default)
+      #
+      #   # bad
+      #   obj.yield_self { |x| x.do_something }
+      #
+      #   # good
+      #   obj.then { |x| x.do_something }
+      #
+      # @example EnforcedStyle: yield_self
+      #
+      #   # bad
+      #   obj.then { |x| x.do_something }
+      #
+      #   # good
+      #   obj.yield_self { |x| x.do_something }
+      #
+      class ObjectThen < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+        RESTRICT_ON_SEND = %i[then yield_self].freeze
+
+        def on_block(node)
+          return unless RESTRICT_ON_SEND.include?(node.method_name)
+
+          check_method_node(node.send_node)
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_send(node)
+          return unless node.arguments.one? && node.first_argument.block_pass_type?
+
+          check_method_node(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_method_node(node)
+          if preferred_method?(node)
+            correct_style_detected
+          else
+            opposite_style_detected
+            message = message(node)
+            add_offense(node.loc.selector, message: message) do |corrector|
+              prefer = style == :then && node.receiver.nil? ? 'self.then' : style
+
+              corrector.replace(node.loc.selector, prefer)
+            end
+          end
+        end
+
+        def preferred_method?(node)
+          node.method?(style)
+        end
+
+        def message(node)
+          format(MSG, prefer: style.to_s, current: node.method_name)
+        end
+      end
+    end
+  end
+end