super-pro-sys 0.0.1

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of consistent method names
+      # from the `String` class.
+      #
+      # @example
+      #   # bad
+      #   'name'.intern
+      #   'var'.unfavored_method
+      #
+      #   # good
+      #   'name'.to_sym
+      #   'var'.preferred_method
+      class StringMethods < Base
+        include MethodPreference
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+
+        def on_send(node)
+          return unless (preferred_method = preferred_method(node.method_name))
+
+          message = format(MSG, prefer: preferred_method, current: node.method_name)
+
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, preferred_method(node.method_name))
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where `lstrip.rstrip` can be replaced by
+      # `strip`.
+      #
+      # @example
+      #   # bad
+      #   'abc'.lstrip.rstrip
+      #   'abc'.rstrip.lstrip
+      #
+      #   # good
+      #   'abc'.strip
+      class Strip < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `strip` instead of `%<methods>s`.'
+        RESTRICT_ON_SEND = %i[lstrip rstrip].freeze
+
+        # @!method lstrip_rstrip(node)
+        def_node_matcher :lstrip_rstrip, <<~PATTERN
+          {
+            (call $(call _ :rstrip) :lstrip)
+            (call $(call _ :lstrip) :rstrip)
+          }
+        PATTERN
+
+        def on_send(node)
+          lstrip_rstrip(node) do |first_send|
+            range = range_between(first_send.loc.selector.begin_pos, node.source_range.end_pos)
+            message = format(MSG, methods: range.source)
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, 'strip')
+            end
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for inheritance from `Struct.new`. Inheriting from `Struct.new`
+      # adds a superfluous level in inheritance tree.
+      #
+      # @safety
+      #   Autocorrection is unsafe because it will change the inheritance
+      #   tree (e.g. return value of `Module#ancestors`) of the constant.
+      #
+      # @example
+      #   # bad
+      #   class Person < Struct.new(:first_name, :last_name)
+      #     def age
+      #       42
+      #     end
+      #   end
+      #
+      #   Person.ancestors
+      #   # => [Person, #<Class:0x000000010b4e14a0>, Struct, (...)]
+      #
+      #   # good
+      #   Person = Struct.new(:first_name, :last_name) do
+      #     def age
+      #       42
+      #     end
+      #   end
+      #
+      #   Person.ancestors
+      #   # => [Person, Struct, (...)]
+      class StructInheritance < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = "Don't extend an instance initialized by `Struct.new`. " \
+              'Use a block to customize the struct.'
+
+        def on_class(node)
+          return unless struct_constructor?(node.parent_class)
+
+          add_offense(node.parent_class) do |corrector|
+            corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
+            corrector.replace(node.loc.operator, '=')
+
+            correct_parent(node.parent_class, corrector)
+          end
+        end
+
+        # @!method struct_constructor?(node)
+        def_node_matcher :struct_constructor?, <<~PATTERN
+          {(send (const {nil? cbase} :Struct) :new ...)
+           (block (send (const {nil? cbase} :Struct) :new ...) ...)}
+        PATTERN
+
+        private
+
+        def correct_parent(parent, corrector)
+          if parent.block_type?
+            corrector.remove(range_with_surrounding_space(parent.loc.end, newlines: false))
+          elsif (class_node = parent.parent).body.nil?
+            corrector.remove(range_for_empty_class_body(class_node, parent))
+          elsif unparenthesized_struct_new?(parent)
+            wrap_unparenthesized_call_with_do(corrector, parent)
+          else
+            corrector.insert_after(parent, ' do')
+          end
+        end
+
+        def range_for_empty_class_body(class_node, struct_new)
+          if class_node.single_line?
+            range_between(struct_new.source_range.end_pos, class_node.source_range.end_pos)
+          else
+            range_by_whole_lines(class_node.loc.end, include_final_newline: true)
+          end
+        end
+
+        def unparenthesized_struct_new?(parent)
+          parent.send_type? && parent.arguments.any? && !parent.parenthesized?
+        end
+
+        def wrap_unparenthesized_call_with_do(corrector, parent)
+          args_source = parent.arguments.map(&:source).join(', ')
+          range = parent.loc.selector.end.join(parent.source_range.end)
+
+          corrector.replace(range, "(#{args_source}) do")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant argument forwarding when calling super with arguments identical to
+      # the method definition.
+      #
+      # Using zero arity `super` within a `define_method` block results in `RuntimeError`:
+      #
+      # [source,ruby]
+      # ----
+      # def m
+      #   define_method(:foo) { super() } # => OK
+      # end
+      #
+      # def m
+      #   define_method(:foo) { super }   # => RuntimeError
+      # end
+      # ----
+      #
+      # Furthermore, any arguments accompanied by a block may potentially be delegating to
+      # `define_method`, therefore, `super` used within these blocks will be allowed.
+      # This approach might result in false negatives, yet ensuring safe detection takes precedence.
+      #
+      # NOTE: When forwarding the same arguments but replacing the block argument with a new inline
+      # block, it is not necessary to explicitly list the non-block arguments. As such, an offense
+      # will be registered in this case.
+      #
+      # @example
+      #   # bad
+      #   def method(*args, **kwargs)
+      #     super(*args, **kwargs)
+      #   end
+      #
+      #   # good - implicitly passing all arguments
+      #   def method(*args, **kwargs)
+      #     super
+      #   end
+      #
+      #   # good - forwarding a subset of the arguments
+      #   def method(*args, **kwargs)
+      #     super(*args)
+      #   end
+      #
+      #   # good - forwarding no arguments
+      #   def method(*args, **kwargs)
+      #     super()
+      #   end
+      #
+      #   # bad - forwarding with overridden block
+      #   def method(*args, **kwargs, &block)
+      #     super(*args, **kwargs) { do_something }
+      #   end
+      #
+      #   # good - implicitly passing all non-block arguments
+      #   def method(*args, **kwargs, &block)
+      #     super { do_something }
+      #   end
+      #
+      #   # good - assigning to the block variable before calling super
+      #   def method(&block)
+      #     # Assigning to the block variable would pass the old value to super,
+      #     # under this circumstance the block must be referenced explicitly.
+      #     block ||= proc { 'fallback behavior' }
+      #     super(&block)
+      #   end
+      class SuperArguments < Base
+        extend AutoCorrector
+
+        ASSIGN_TYPES = %i[or_asgn lvasgn].freeze
+
+        MSG = 'Call `super` without arguments and parentheses when the signature is identical.'
+        MSG_INLINE_BLOCK = 'Call `super` without arguments and parentheses when all positional ' \
+                           'and keyword arguments are forwarded.'
+
+        def on_super(super_node)
+          return unless (def_node = find_def_node(super_node))
+
+          def_node_args = def_node.arguments.argument_list
+          super_args = preprocess_super_args(super_node.arguments)
+
+          return unless arguments_identical?(def_node, super_node, def_node_args, super_args)
+
+          # If the number of arguments to the def node and super node are different here,
+          # it's because the block argument is not forwarded.
+          message = def_node_args.size == super_args.size ? MSG : MSG_INLINE_BLOCK
+          add_offense(super_node, message: message) do |corrector|
+            corrector.replace(super_node, 'super')
+          end
+        end
+
+        private
+
+        def find_def_node(super_node)
+          super_node.ancestors.find do |node|
+            # When defining dynamic methods, implicitly calling `super` is not possible.
+            # Since there is a possibility of delegation to `define_method`,
+            # `super` used within the block is always allowed.
+            break if node.any_block_type? && !block_sends_to_super?(super_node, node)
+
+            break node if node.any_def_type?
+          end
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def arguments_identical?(def_node, super_node, def_args, super_args)
+          return false if argument_list_size_differs?(def_args, super_args, super_node)
+
+          def_args.zip(super_args).each do |def_arg, super_arg|
+            next if positional_arg_same?(def_arg, super_arg)
+            next if positional_rest_arg_same?(def_arg, super_arg)
+            next if keyword_arg_same?(def_arg, super_arg)
+            next if keyword_rest_arg_same?(def_arg, super_arg)
+            next if block_arg_same?(def_node, super_node, def_arg, super_arg)
+            next if forward_arg_same?(def_arg, super_arg)
+
+            return false
+          end
+
+          true
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def argument_list_size_differs?(def_args, super_args, super_node)
+          # If the def node has a block argument and the super node has an explicit block,
+          # the number of arguments is the same, so ignore the def node block arg.
+          def_args_size = def_args.size
+          def_args_size -= 1 if def_args.any?(&:blockarg_type?) && block_sends_to_super?(super_node)
+
+          def_args_size != super_args.size
+        end
+
+        def block_sends_to_super?(super_node, parent_node = super_node.parent)
+          # Checks if the send node of a block is the given super node,
+          # or a method chain containing it.
+          return false unless parent_node
+          return false unless parent_node.any_block_type?
+
+          parent_node.send_node.each_node(:super).any?(super_node)
+        end
+
+        def positional_arg_same?(def_arg, super_arg)
+          return false unless def_arg.type?(:arg, :optarg)
+          return false unless super_arg.lvar_type?
+
+          def_arg.name == super_arg.children.first
+        end
+
+        def positional_rest_arg_same?(def_arg, super_arg)
+          return false unless def_arg.restarg_type?
+          # anonymous forwarding
+          return true if def_arg.name.nil? && super_arg.forwarded_restarg_type?
+          return false unless super_arg.splat_type?
+          return false unless (lvar_node = super_arg.children.first).lvar_type?
+
+          def_arg.name == lvar_node.children.first
+        end
+
+        def keyword_arg_same?(def_arg, super_arg)
+          return false unless def_arg.type?(:kwarg, :kwoptarg)
+          return false unless (pair_node = super_arg).pair_type?
+          return false unless (sym_node = pair_node.key).sym_type?
+          return false unless (lvar_node = pair_node.value).lvar_type?
+          return false unless sym_node.source == lvar_node.source
+
+          def_arg.name == sym_node.value
+        end
+
+        def keyword_rest_arg_same?(def_arg, super_arg)
+          return false unless def_arg.kwrestarg_type?
+          # anonymous forwarding
+          return true if def_arg.name.nil? && super_arg.forwarded_kwrestarg_type?
+          return false unless super_arg.kwsplat_type?
+          return false unless (lvar_node = super_arg.children.first).lvar_type?
+
+          def_arg.name == lvar_node.children.first
+        end
+
+        def block_arg_same?(def_node, super_node, def_arg, super_arg)
+          return false unless def_arg.blockarg_type?
+          return true if block_sends_to_super?(super_node)
+          return false unless super_arg.block_pass_type?
+
+          # anonymous forwarding
+          return true if (block_pass_child = super_arg.children.first).nil? && def_arg.name.nil?
+
+          block_arg_name = block_pass_child.children.first
+          def_arg.name == block_arg_name && !block_reassigned?(def_node, block_arg_name)
+        end
+
+        # Reassigning the block argument will still pass along the original block to super
+        # https://bugs.ruby-lang.org/issues/20505
+        def block_reassigned?(def_node, block_arg_name)
+          def_node.each_node(*ASSIGN_TYPES).any? do |assign_node|
+            # TODO: Since `Symbol#name` is supported from Ruby 3.0, the inheritance check for
+            # `AST::Node` can be removed when requiring Ruby 3.0+.
+            lhs = assign_node.node_parts[0]
+            next if lhs.is_a?(AST::Node) && !lhs.respond_to?(:name)
+
+            assign_node.name == block_arg_name
+          end
+        end
+
+        def forward_arg_same?(def_arg, super_arg)
+          def_arg.forward_arg_type? && super_arg.forwarded_args_type?
+        end
+
+        def preprocess_super_args(super_args)
+          super_args.flat_map do |node|
+            if node.hash_type? && !node.braces?
+              node.children
+            else
+              node
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the presence of parentheses in `super` containing arguments.
+      #
+      # `super` is a keyword and is provided as a distinct cop from those designed for method call.
+      #
+      # @example
+      #
+      #   # bad
+      #   super name, age
+      #
+      #   # good
+      #   super(name, age)
+      #
+      class SuperWithArgsParentheses < Base
+        extend AutoCorrector
+
+        MSG = 'Use parentheses for `super` with arguments.'
+
+        def on_super(node)
+          return if node.parenthesized?
+
+          add_offense(node) do |corrector|
+            range = node.loc.keyword.end.join(node.first_argument.source_range.begin)
+            corrector.replace(range, '(')
+            corrector.insert_after(node.last_argument, ')')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of shorthand-style swapping of 2 variables.
+      #
+      # @safety
+      #   Autocorrection is unsafe, because the temporary variable used to
+      #   swap variables will be removed, but may be referred to elsewhere.
+      #
+      # @example
+      #   # bad
+      #   tmp = x
+      #   x = y
+      #   y = tmp
+      #
+      #   # good
+      #   x, y = y, x
+      #
+      class SwapValues < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Replace this and assignments at lines %<x_line>d ' \
+              'and %<y_line>d with `%<replacement>s`.'
+
+        SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].to_set.freeze
+
+        def on_asgn(node)
+          return if allowed_assignment?(node)
+
+          tmp_assign = node
+          x_assign, y_assign = *node.right_siblings.take(2)
+          return unless x_assign && y_assign && swapping_values?(tmp_assign, x_assign, y_assign)
+
+          add_offense(node, message: message(x_assign, y_assign)) do |corrector|
+            range = correction_range(tmp_assign, y_assign)
+            corrector.replace(range, replacement(x_assign))
+          end
+        end
+
+        SIMPLE_ASSIGNMENT_TYPES.each { |asgn_type| alias_method :"on_#{asgn_type}", :on_asgn }
+
+        private
+
+        def allowed_assignment?(node)
+          node.parent&.mlhs_type? || node.parent&.shorthand_asgn?
+        end
+
+        def swapping_values?(tmp_assign, x_assign, y_assign)
+          simple_assignment?(tmp_assign) &&
+            simple_assignment?(x_assign) &&
+            simple_assignment?(y_assign) &&
+            lhs(x_assign) == rhs(tmp_assign) &&
+            lhs(y_assign) == rhs(x_assign) &&
+            rhs(y_assign) == lhs(tmp_assign)
+        end
+
+        def simple_assignment?(node)
+          return false unless node.respond_to?(:type)
+
+          SIMPLE_ASSIGNMENT_TYPES.include?(node.type)
+        end
+
+        def message(x_assign, y_assign)
+          format(
+            MSG,
+            x_line: x_assign.first_line,
+            y_line: y_assign.first_line,
+            replacement: replacement(x_assign)
+          )
+        end
+
+        def replacement(x_assign)
+          x = lhs(x_assign)
+          y = rhs(x_assign)
+          "#{x}, #{y} = #{y}, #{x}"
+        end
+
+        def lhs(node)
+          if node.casgn_type?
+            "#{'::' if node.absolute?}#{node.const_name}"
+          else
+            node.name.to_s
+          end
+        end
+
+        def rhs(node)
+          node.expression.source
+        end
+
+        def correction_range(tmp_assign, y_assign)
+          range_by_whole_lines(
+            range_between(tmp_assign.source_range.begin_pos, y_assign.source_range.end_pos)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for array literals made up of symbols that are not
+      # using the %i() syntax.
+      #
+      # Alternatively, it checks for symbol arrays using the %i() syntax on
+      # projects which do not want to use that syntax, perhaps because they
+      # support a version of Ruby lower than 2.0.
+      #
+      # Configuration option: MinSize
+      # If set, arrays with fewer elements than this value will not trigger the
+      # cop. For example, a `MinSize` of `3` will not enforce a style on an
+      # array of 2 or fewer elements.
+      #
+      # @example EnforcedStyle: percent (default)
+      #   # good
+      #   %i[foo bar baz]
+      #
+      #   # bad
+      #   [:foo, :bar, :baz]
+      #
+      #   # bad (contains spaces)
+      #   %i[foo\ bar baz\ quux]
+      #
+      #   # bad (contains [] with spaces)
+      #   %i[foo \[ \]]
+      #
+      #   # bad (contains () with spaces)
+      #   %i(foo \( \))
+      #
+      # @example EnforcedStyle: brackets
+      #   # good
+      #   [:foo, :bar, :baz]
+      #
+      #   # bad
+      #   %i[foo bar baz]
+      class SymbolArray < Base
+        include ArrayMinSize
+        include ArraySyntax
+        include ConfigurableEnforcedStyle
+        include PercentArray
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.0
+
+        PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
+        ARRAY_MSG = 'Use %<prefer>s for an array of symbols.'
+        DELIMITERS = ['[', ']', '(', ')'].freeze
+        SPECIAL_GVARS = %w[
+          $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
+          $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
+        ].freeze
+        REDEFINABLE_OPERATORS = %w(
+          | ^ & <=> == === =~ > >= < <= << >>
+          + - * / % ** ~ +@ -@ [] []= ` ! != !~
+        ).freeze
+
+        class << self
+          attr_accessor :largest_brackets
+        end
+
+        def on_array(node)
+          if bracketed_array_of?(:sym, node)
+            return if complex_content?(node)
+
+            check_bracketed_array(node, 'i')
+          elsif node.percent_literal?(:symbol)
+            check_percent_array(node)
+          end
+        end
+
+        private
+
+        def complex_content?(node)
+          node.children.any? do |sym|
+            return false if DELIMITERS.include?(sym.source)
+
+            content = *sym
+            content = content.map { |c| c.is_a?(AST::Node) ? c.source : c }.join
+            content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s()]*\))/, '')
+
+            content.include?(' ') || DELIMITERS.any? do |delimiter|
+              content_without_delimiter_pairs.include?(delimiter)
+            end
+          end
+        end
+
+        def invalid_percent_array_contents?(node)
+          complex_content?(node)
+        end
+
+        def build_bracketed_array(node)
+          return '[]' if node.children.empty?
+
+          syms = node.children.map do |c|
+            if c.dsym_type?
+              string_literal = to_string_literal(c.source)
+
+              ":#{trim_string_interpolation_escape_character(string_literal)}"
+            else
+              to_symbol_literal(c.value.to_s)
+            end
+          end
+          build_bracketed_array_with_appropriate_whitespace(elements: syms, node: node)
+        end
+
+        def to_symbol_literal(string)
+          if symbol_without_quote?(string)
+            ":#{string}"
+          else
+            ":#{to_string_literal(string)}"
+          end
+        end
+
+        def symbol_without_quote?(string)
+          # method name
+          /\A[a-zA-Z_]\w*[!?]?\z/.match?(string) ||
+            # instance / class variable
+            /\A@@?[a-zA-Z_]\w*\z/.match?(string) ||
+            # global variable
+            /\A\$[1-9]\d*\z/.match?(string) ||
+            /\A\$[a-zA-Z_]\w*\z/.match?(string) ||
+            SPECIAL_GVARS.include?(string) ||
+            REDEFINABLE_OPERATORS.include?(string)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks symbol literal syntax.
+      #
+      # @example
+      #
+      #   # bad
+      #   :"symbol"
+      #
+      #   # good
+      #   :symbol
+      class SymbolLiteral < Base
+        extend AutoCorrector
+
+        MSG = 'Do not use strings for word-like symbol literals.'
+
+        def on_sym(node)
+          return unless /\A:["'][A-Za-z_]\w*["']\z/.match?(node.source)
+
+          add_offense(node) { |corrector| corrector.replace(node, node.source.delete(%q('"))) }
+        end
+      end
+    end
+  end
+end