super-pro-sys 0.0.1

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantCopDisableDirective
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that there is an `# rubocop:enable ...` statement
+      # after a `# rubocop:disable ...` statement. This will prevent leaving
+      # cop disables on wide ranges of code, that later contributors to
+      # a file wouldn't be aware of.
+      #
+      # You can set `MaxRangeSize` to define the maximum number of
+      # consecutive lines a cop can be disabled for.
+      #
+      # - `.inf` any size (default)
+      # - `0` allows only single-line disables
+      # - `1` means the maximum allowed is as follows:
+      #
+      # [source,ruby]
+      # ----
+      # # rubocop:disable SomeCop
+      # a = 1
+      # # rubocop:enable SomeCop
+      # ----
+      #
+      # @example MaxRangeSize: .inf (default)
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #   # y = 1
+      #   # EOF
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # EOF
+      #
+      # @example MaxRangeSize: 2
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # With the previous, there are 2 lines on which cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   x += 1
+      #   # Including this, that's 3 lines on which the cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      class MissingCopEnableDirective < Base
+        include RangeHelp
+
+        MSG = 'Re-enable %<cop>s %<type>s with `# rubocop:enable` after disabling it.'
+        MSG_BOUND = 'Re-enable %<cop>s %<type>s within %<max_range>s lines after disabling it.'
+
+        def on_new_investigation
+          each_missing_enable do |cop, line_range|
+            next if acceptable_range?(cop, line_range)
+
+            comment = processed_source.comment_at_line(line_range.begin)
+
+            add_offense(comment, message: message(cop, comment))
+          end
+        end
+
+        private
+
+        def each_missing_enable
+          processed_source.disabled_line_ranges.each do |cop, line_ranges|
+            line_ranges.each { |line_range| yield cop, line_range }
+          end
+        end
+
+        def acceptable_range?(cop, line_range)
+          # This has to remain a strict inequality to handle
+          # the case when max_range is Float::INFINITY
+          return true if line_range.max - line_range.min < max_range + 2
+          # This cop is disabled in the config, it is not expected to be re-enabled
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          if cop_class &&
+             !processed_source.registry.enabled?(cop_class, config) &&
+             line_range.max == Float::INFINITY
+            return true
+          end
+
+          false
+        end
+
+        def max_range
+          @max_range ||= cop_config['MaxRangeSize']
+        end
+
+        def message(cop, comment, type = 'cop')
+          if department_enabled?(cop, comment)
+            type = 'department'
+            cop = cop.split('/').first
+          end
+
+          if max_range == Float::INFINITY
+            format(MSG, cop: cop, type: type)
+          else
+            format(MSG_BOUND, cop: cop, type: type, max_range: max_range)
+          end
+        end
+
+        def department_enabled?(cop, comment)
+          DirectiveComment.new(comment).in_directive_department?(cop)
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Lint/RedundantCopDisableDirective

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the presence of constructors and lifecycle callbacks
+      # without calls to `super`.
+      #
+      # This cop does not consider `method_missing` (and `respond_to_missing?`)
+      # because in some cases it makes sense to overtake what is considered a
+      # missing method. In other cases, the theoretical ideal handling could be
+      # challenging or verbose for no actual gain.
+      #
+      # Autocorrection is not supported because the position of `super` cannot be
+      # determined automatically.
+      #
+      # `Object` and `BasicObject` are allowed by this cop because of their
+      # stateless nature. However, sometimes you might want to allow other parent
+      # classes from this cop, for example in the case of an abstract class that is
+      # not meant to be called with `super`. In those cases, you can use the
+      # `AllowedParentClasses` option to specify which classes should be allowed
+      # *in addition to* `Object` and `BasicObject`.
+      #
+      # @example
+      #   # bad
+      #   class Employee < Person
+      #     def initialize(name, salary)
+      #       @salary = salary
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Employee < Person
+      #     def initialize(name, salary)
+      #       super(name)
+      #       @salary = salary
+      #     end
+      #   end
+      #
+      #   # bad
+      #   Employee = Class.new(Person) do
+      #     def initialize(name, salary)
+      #       @salary = salary
+      #     end
+      #   end
+      #
+      #   # good
+      #   Employee = Class.new(Person) do
+      #     def initialize(name, salary)
+      #       super(name)
+      #       @salary = salary
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Parent
+      #     def self.inherited(base)
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Parent
+      #     def self.inherited(base)
+      #       super
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   class ClassWithNoParent
+      #     def initialize
+      #       do_something
+      #     end
+      #   end
+      #
+      # @example AllowedParentClasses: [MyAbstractClass]
+      #   # good
+      #   class MyConcreteClass < MyAbstractClass
+      #     def initialize
+      #       do_something
+      #     end
+      #   end
+      #
+      class MissingSuper < Base
+        CONSTRUCTOR_MSG = 'Call `super` to initialize state of the parent class.'
+        CALLBACK_MSG    = 'Call `super` to invoke callback defined in the parent class.'
+
+        STATELESS_CLASSES = %w[BasicObject Object].freeze
+
+        CLASS_LIFECYCLE_CALLBACKS   = %i[inherited].freeze
+        METHOD_LIFECYCLE_CALLBACKS  = %i[method_added method_removed method_undefined
+                                         singleton_method_added singleton_method_removed
+                                         singleton_method_undefined].freeze
+
+        CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS + METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
+
+        # @!method class_new_block(node)
+        def_node_matcher :class_new_block, <<~RUBY
+          (any_block
+            (send
+              (const {nil? cbase} :Class) :new $_) ...)
+        RUBY
+
+        def on_def(node)
+          return unless offender?(node)
+
+          if node.method?(:initialize) && inside_class_with_stateful_parent?(node)
+            add_offense(node, message: CONSTRUCTOR_MSG)
+          elsif callback_method_def?(node)
+            add_offense(node, message: CALLBACK_MSG)
+          end
+        end
+
+        def on_defs(node)
+          return if !callback_method_def?(node) || contains_super?(node)
+
+          add_offense(node, message: CALLBACK_MSG)
+        end
+
+        private
+
+        def offender?(node)
+          (node.method?(:initialize) || callback_method_def?(node)) && !contains_super?(node)
+        end
+
+        def callback_method_def?(node)
+          return false unless CALLBACKS.include?(node.method_name)
+
+          node.each_ancestor(:class, :sclass, :module).first
+        end
+
+        def contains_super?(node)
+          node.each_descendant(:super, :zsuper).any?
+        end
+
+        def inside_class_with_stateful_parent?(node)
+          if (block_node = node.each_ancestor(:any_block).first)
+            return false unless (super_class = class_new_block(block_node))
+
+            !allowed_class?(super_class)
+          elsif (class_node = node.each_ancestor(:class).first)
+            class_node.parent_class && !allowed_class?(class_node.parent_class)
+          else
+            false
+          end
+        end
+
+        def allowed_class?(node)
+          allowed_classes.include?(node.const_name)
+        end
+
+        def allowed_classes
+          @allowed_classes ||= STATELESS_CLASSES + cop_config.fetch('AllowedParentClasses', [])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for mixed-case character ranges since they include likely unintended characters.
+      #
+      # Offenses are registered for regexp character classes like `/[A-z]/`
+      # as well as range objects like `('A'..'z')`.
+      #
+      # NOTE: `Range` objects cannot be autocorrected.
+      #
+      # @safety
+      #   The cop autocorrects regexp character classes
+      #   by replacing one character range with two: `A-z` becomes `A-Za-z`.
+      #   In most cases this is probably what was originally intended
+      #   but it changes the regexp to no longer match symbols it used to include.
+      #   For this reason, this cop's autocorrect is unsafe (it will
+      #   change the behavior of the code).
+      #
+      # @example
+      #
+      #   # bad
+      #   r = /[A-z]/
+      #
+      #   # good
+      #   r = /[A-Za-z]/
+      class MixedCaseRange < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Ranges from upper to lower case ASCII letters may include unintended ' \
+              'characters. Instead of `A-z` (which also includes several symbols) ' \
+              'specify each range individually: `A-Za-z` and individually specify any symbols.'
+        RANGES = [('a'..'z').freeze, ('A'..'Z').freeze].freeze
+
+        def on_irange(node)
+          return unless node.children.compact.all?(&:str_type?)
+          return if node.begin.nil? || node.end.nil?
+
+          add_offense(node) if unsafe_range?(node.begin.value, node.end.value)
+        end
+        alias on_erange on_irange
+
+        def on_regexp(node)
+          each_unsafe_regexp_range(node) do |loc|
+            next unless (replacement = regexp_range(loc.source))
+
+            add_offense(loc) do |corrector|
+              corrector.replace(loc, replacement)
+            end
+          end
+        end
+
+        def each_unsafe_regexp_range(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if skip_expression?(expr)
+
+            range_pairs(expr).reject do |range_start, range_end|
+              next if skip_range?(range_start, range_end)
+
+              next unless unsafe_range?(range_start.text, range_end.text)
+
+              yield(build_source_range(range_start, range_end))
+            end
+          end
+        end
+
+        private
+
+        def build_source_range(range_start, range_end)
+          range_between(range_start.expression.begin_pos, range_end.expression.end_pos)
+        end
+
+        def range_for(char)
+          RANGES.detect do |range|
+            range.include?(char)
+          end
+        end
+
+        def range_pairs(expr)
+          expr.expressions.filter_map { |e| [e.expressions[0], e.expressions[1]] if e.type == :set }
+        end
+
+        def unsafe_range?(range_start, range_end)
+          return false if range_start.length != 1 || range_end.length != 1
+
+          range_for(range_start) != range_for(range_end)
+        end
+
+        def skip_expression?(expr)
+          !(expr.type == :set && expr.token == :character)
+        end
+
+        def skip_range?(range_start, range_end)
+          [range_start, range_end].any? do |bound|
+            bound&.type != :literal
+          end
+        end
+
+        def regexp_range(source)
+          open, close = source.split('-')
+          return unless (open_range = range_for(open))
+          return unless (close_range = range_for(close))
+
+          first = [open, open_range.end]
+          second = [close_range.begin, close]
+          "#{first.uniq.join('-')}#{second.uniq.join('-')}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Do not mix named captures and numbered captures in a `Regexp` literal
+      # because numbered capture is ignored if they're mixed.
+      # Replace numbered captures with non-capturing groupings or
+      # named captures.
+      #
+      # @example
+      #   # bad
+      #   /(?<foo>FOO)(BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?<bar>BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?:BAR)/
+      #
+      #   # good
+      #   /(FOO)(BAR)/
+      #
+      class MixedRegexpCaptureTypes < Base
+        MSG = 'Do not mix named captures and numbered captures in a Regexp literal.'
+
+        def on_regexp(node)
+          return if node.interpolation?
+          return if node.each_capture(named: false).none?
+          return if node.each_capture(named: true).none?
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # In math and Python, we can use `x < y < z` style comparison to compare
+      # multiple values. However, we can't use the comparison in Ruby. However,
+      # the comparison is not a syntax error. This cop checks the bad usage of
+      # comparison operators.
+      #
+      # @example
+      #
+      #   # bad
+      #   x < y < z
+      #   10 <= x <= 20
+      #
+      #   # good
+      #   x < y && y < z
+      #   10 <= x && x <= 20
+      class MultipleComparison < Base
+        extend AutoCorrector
+
+        MSG = 'Use the `&&` operator to compare multiple values.'
+        COMPARISON_METHODS = %i[< > <= >=].freeze
+        SET_OPERATION_OPERATORS = %i[& | ^].freeze
+        RESTRICT_ON_SEND = COMPARISON_METHODS
+
+        # @!method multiple_compare?(node)
+        def_node_matcher :multiple_compare?, <<~PATTERN
+          (send (send _ {:< :> :<= :>=} $_) {:#{COMPARISON_METHODS.join(' :')}} _)
+        PATTERN
+
+        def on_send(node)
+          return unless (center = multiple_compare?(node))
+          # It allows multiple comparison using `&`, `|`, and `^` set operation operators.
+          # e.g. `x >= y & y < z`
+          return if center.send_type? && SET_OPERATION_OPERATORS.include?(center.method_name)
+
+          add_offense(node) do |corrector|
+            new_center = "#{center.source} && #{center.source}"
+
+            corrector.replace(center, new_center)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for nested method definitions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # `bar` definition actually produces methods in the same scope
+      #   # as the outer `foo` method. Furthermore, the `bar` method
+      #   # will be redefined every time `foo` is invoked.
+      #   def foo
+      #     def bar
+      #     end
+      #   end
+      #
+      #   # good
+      #
+      #   def foo
+      #     bar = -> { puts 'hello' }
+      #     bar.call
+      #   end
+      #
+      #   # good
+      #
+      #   # `class_eval`, `instance_eval`, `module_eval`, `class_exec`, `instance_exec`, and
+      #   # `module_exec` blocks are allowed by default.
+      #
+      #   def foo
+      #     self.class.class_eval do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      #   def foo
+      #     self.class.module_exec do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #
+      #   def foo
+      #     class << self
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedMethods: [] (default)
+      #   # bad
+      #   def do_something
+      #     has_many :articles do
+      #       def find_or_create_by_name(name)
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedMethods: ['has_many']
+      #   # bad
+      #   def do_something
+      #     has_many :articles do
+      #       def find_or_create_by_name(name)
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # bad
+      #   def foo(obj)
+      #     obj.do_baz do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: ['baz']
+      #   # good
+      #   def foo(obj)
+      #     obj.do_baz do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      class NestedMethodDefinition < Base
+        include AllowedMethods
+        include AllowedPattern
+
+        MSG = 'Method definitions must not be nested. Use `lambda` instead.'
+
+        def on_def(node)
+          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          return if node.defs_type? && allowed_subject_type?(subject)
+
+          def_ancestor = node.each_ancestor(:any_def).first
+          return unless def_ancestor
+
+          within_scoping_def =
+            node.each_ancestor(:any_block, :sclass).any? do |ancestor|
+              scoping_method_call?(ancestor)
+            end
+
+          add_offense(node) if def_ancestor && !within_scoping_def
+        end
+        alias on_defs on_def
+
+        private
+
+        def scoping_method_call?(child)
+          child.sclass_type? || eval_call?(child) || exec_call?(child) ||
+            child.class_constructor? || allowed_method_name?(child)
+        end
+
+        def allowed_subject_type?(subject)
+          subject.variable? || subject.const_type? || subject.call_type?
+        end
+
+        def allowed_method_name?(node)
+          name = node.method_name
+
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
+        # @!method eval_call?(node)
+        def_node_matcher :eval_call?, <<~PATTERN
+          (any_block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+        PATTERN
+
+        # @!method exec_call?(node)
+        def_node_matcher :exec_call?, <<~PATTERN
+          (any_block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for nested percent literals.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # The percent literal for nested_attributes is parsed as four tokens,
+      #   # yielding the array [:name, :content, :"%i[incorrectly", :"nested]"].
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: %i[name content %i[incorrectly nested]]
+      #   }
+      #
+      #   # good
+      #
+      #   # Neither is incompatible with the bad case, but probably the intended code.
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: [:name, :content, %i[incorrectly nested]]
+      #   }
+      #
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: [:name, :content, [:incorrectly, :nested]]
+      #   }
+      #
+      class NestedPercentLiteral < Base
+        include PercentLiteral
+
+        MSG = 'Within percent literals, nested percent literals do not ' \
+              'function and may be unwanted in the result.'
+
+        # The array of regular expressions representing percent literals that,
+        # if found within a percent literal expression, will cause a
+        # NestedPercentLiteral violation to be emitted.
+        PERCENT_LITERAL_TYPES = PreferredDelimiters::PERCENT_LITERAL_TYPES
+        REGEXES = PERCENT_LITERAL_TYPES.map { |percent_literal| /\A#{percent_literal}\W/ }.freeze
+
+        def on_array(node)
+          process(node, *PERCENT_LITERAL_TYPES)
+        end
+
+        def on_percent_literal(node)
+          add_offense(node) if contains_percent_literals?(node)
+        end
+
+        private
+
+        def contains_percent_literals?(node)
+          node.each_child_node.any? do |child|
+            literal = child.children.first.to_s.scrub
+            REGEXES.any? { |regex| literal.match?(regex) }
+          end
+        end
+      end
+    end
+  end
+end