super-pro-sys 0.0.1

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

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for operators, variables, literals, lambda, proc and nonmutating
+      # methods used in void context.
+      #
+      # `each` blocks are allowed to prevent false positives.
+      # For example, the expression inside the `each` block below.
+      # It's not void, especially when the receiver is an `Enumerator`:
+      #
+      # [source,ruby]
+      # ----
+      # enumerator = [1, 2, 3].filter
+      # enumerator.each { |item| item >= 2 } #=> [2, 3]
+      # ----
+      #
+      # NOTE: Return values in assignment method definitions such as `def foo=(arg)` are
+      # detected because they are in a void context. However, autocorrection does not remove
+      # the return value, as that would change behavior. In such cases, whether to remove
+      # the return value or rename the method to something more appropriate should be left to
+      # the user.
+      #
+      # @example CheckForMethodsWithNoSideEffects: false (default)
+      #   # bad
+      #   def some_method
+      #     some_num * 10
+      #     do_something
+      #   end
+      #
+      #   def some_method(some_var)
+      #     some_var
+      #     do_something
+      #   end
+      #
+      # @example CheckForMethodsWithNoSideEffects: true
+      #   # bad
+      #   def some_method(some_array)
+      #     some_array.sort
+      #     do_something(some_array)
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #     some_num * 10
+      #   end
+      #
+      #   def some_method(some_var)
+      #     do_something
+      #     some_var
+      #   end
+      #
+      #   def some_method(some_array)
+      #     some_array.sort!
+      #     do_something(some_array)
+      #   end
+      class Void < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
+        OP_MSG = 'Operator `%<op>s` used in void context.'
+        VAR_MSG = 'Variable `%<var>s` used in void context.'
+        CONST_MSG = 'Constant `%<var>s` used in void context.'
+        LIT_MSG = 'Literal `%<lit>s` used in void context.'
+        SELF_MSG = '`self` used in void context.'
+        EXPRESSION_MSG = '`%<expression>s` used in void context.'
+        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. Did you mean `#%<suggest>s`?'
+
+        BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
+        UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
+        OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
+        NONMUTATING_METHODS_WITH_BANG_VERSION = %i[capitalize chomp chop compact
+                                                   delete_prefix delete_suffix downcase
+                                                   encode flatten gsub lstrip merge next
+                                                   reject reverse rotate rstrip scrub select
+                                                   shuffle slice sort sort_by squeeze strip sub
+                                                   succ swapcase tr tr_s transform_values
+                                                   unicode_normalize uniq upcase].freeze
+        METHODS_REPLACEABLE_BY_EACH = %i[collect map].freeze
+
+        NONMUTATING_METHODS = (NONMUTATING_METHODS_WITH_BANG_VERSION +
+                               METHODS_REPLACEABLE_BY_EACH).freeze
+
+        def on_block(node)
+          return unless node.body && !node.body.begin_type?
+          return unless in_void_context?(node.body)
+          return if node.method?(:each)
+
+          check_void_op(node.body)
+          check_expression(node.body)
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_begin(node)
+          check_begin(node)
+        end
+        alias on_kwbegin on_begin
+
+        def on_ensure(node)
+          check_ensure(node)
+        end
+
+        private
+
+        def check_begin(node)
+          expressions = *node
+          inside_each_block = node.each_ancestor(:any_block).first&.method?(:each)
+          expressions.pop if !in_void_context?(node) || inside_each_block
+          expressions.each do |expr|
+            check_void_op(expr) { inside_each_block }
+            check_expression(expr)
+          end
+        end
+
+        def check_expression(expr)
+          return check_if_expression(expr) if expr.if_type?
+          return check_case_expression(expr) if expr.case_type?
+          return check_case_match_expression(expr) if expr.case_match_type?
+
+          check_void_expression_nodes(expr)
+        end
+
+        def check_void_expression_nodes(expr)
+          check_literal(expr)
+          check_var(expr)
+          check_self(expr)
+          check_void_expression(expr)
+          return unless cop_config['CheckForMethodsWithNoSideEffects']
+
+          check_nonmutating(expr)
+        end
+
+        def check_if_expression(if_node)
+          check_void_expression_nodes(if_node.body) if if_node.body
+        end
+
+        def check_case_expression(case_node)
+          case_node.each_when { |when_node| check_expression(when_node.body) if when_node.body }
+          check_expression(case_node.else_branch) if case_node.else_branch
+        end
+
+        def check_case_match_expression(case_node)
+          case_node.each_in_pattern do |in_pattern_node|
+            check_expression(in_pattern_node.body) if in_pattern_node.body
+          end
+          check_expression(case_node.else_branch) if case_node.else_branch
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def check_void_op(node, &block)
+          node = node.children.first while node&.begin_type?
+          return unless node&.call_type? && OPERATORS.include?(node.method_name)
+          if !UNARY_OPERATORS.include?(node.method_name) && node.loc.dot && node.arguments.none?
+            return
+          end
+
+          return if block && yield(node)
+
+          add_offense(node.loc.selector,
+                      message: format(OP_MSG, op: node.method_name)) do |corrector|
+            autocorrect_void_op(corrector, node)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def check_var(node)
+          return unless node.variable? || node.const_type?
+
+          if node.const_type?
+            template = node.special_keyword? ? VAR_MSG : CONST_MSG
+
+            offense_range = node
+            message = format(template, var: node.source)
+          else
+            offense_range = node.loc.name
+            message = format(VAR_MSG, var: node.loc.name.source)
+          end
+
+          add_offense(offense_range, message: message) do |corrector|
+            autocorrect_void_expression(corrector, node)
+          end
+        end
+
+        def check_literal(node)
+          if !entirely_literal?(node) || node.xstr_type? || node.range_type? || node.nil_type?
+            return
+          end
+
+          add_offense(node, message: format(LIT_MSG, lit: node.source)) do |corrector|
+            autocorrect_void_expression(corrector, node)
+          end
+        end
+
+        def check_self(node)
+          return unless node.self_type?
+
+          add_offense(node, message: SELF_MSG) do |corrector|
+            autocorrect_void_expression(corrector, node)
+          end
+        end
+
+        def check_void_expression(node)
+          return unless node.defined_type? || node.lambda_or_proc?
+
+          add_offense(node, message: format(EXPRESSION_MSG, expression: node.source)) do |corrector|
+            autocorrect_void_expression(corrector, node)
+          end
+        end
+
+        def check_nonmutating(node)
+          return unless node.type?(:send, :any_block)
+
+          method_name = node.method_name
+          return unless NONMUTATING_METHODS.include?(method_name)
+
+          suggestion = if METHODS_REPLACEABLE_BY_EACH.include?(method_name)
+                         'each'
+                       else
+                         "#{method_name}!"
+                       end
+          add_offense(node,
+                      message: format(NONMUTATING_MSG, method: method_name,
+                                                       suggest: suggestion)) do |corrector|
+            autocorrect_nonmutating_send(corrector, node, suggestion)
+          end
+        end
+
+        def check_ensure(node)
+          return unless (body = node.branch)
+          # NOTE: the `begin` node case is already handled via `on_begin`
+          return if body.begin_type?
+
+          check_expression(body)
+        end
+
+        def in_void_context?(node)
+          parent = node.parent
+          return false unless parent && parent.children.last == node
+
+          parent.respond_to?(:void_context?) && parent.void_context?
+        end
+
+        def autocorrect_void_op(corrector, node)
+          if node.arguments.empty?
+            corrector.replace(node, node.receiver.source)
+          else
+            corrector.remove(node.loc.dot) if node.loc.dot
+            corrector.replace(
+              range_with_surrounding_space(range: node.loc.selector, side: :both,
+                                           newlines: false),
+              "\n"
+            )
+          end
+        end
+
+        def autocorrect_void_expression(corrector, node)
+          return if node.parent.type?(:if, :case, :when, :case_match, :in_pattern)
+          return if (def_node = node.each_ancestor(:any_def).first) && def_node.assignment_method?
+
+          corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
+        end
+
+        def autocorrect_nonmutating_send(corrector, node, suggestion)
+          send_node = if node.send_type?
+                        node
+                      else
+                        node.send_node
+                      end
+          corrector.replace(send_node.loc.selector, suggestion)
+        end
+
+        def entirely_literal?(node)
+          case node.type
+          when :array
+            all_values_entirely_literal?(node)
+          when :hash
+            all_keys_entirely_literal?(node) && all_values_entirely_literal?(node)
+          when :send, :csend
+            node.method?(:freeze) && node.receiver && entirely_literal?(node.receiver)
+          else
+            node.literal?
+          end
+        end
+
+        def all_keys_entirely_literal?(node)
+          node.each_key.all? { |key| entirely_literal?(key) }
+        end
+
+        def all_values_entirely_literal?(node)
+          node.each_value.all? { |value| entirely_literal?(value) }
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/message_annotator.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Message Annotator class annotates a basic offense message
+    # based on params passed into initializer.
+    #
+    # @see #initialize
+    #
+    # @example
+    #   RuboCop::Cop::MessageAnnotator.new(
+    #     config, cop_name, cop_config, @options
+    #   ).annotate('message')
+    #  #=> 'Cop/CopName: message (http://example.org/styleguide)'
+    class MessageAnnotator
+      attr_reader :options, :config, :cop_name, :cop_config
+
+      @style_guide_urls = {}
+
+      class << self
+        attr_reader :style_guide_urls
+      end
+
+      # @param config [RuboCop::Config] Check configs for all cops
+      #   @note Message Annotator specifically checks the
+      #     following config options for_all_cops
+      #     :StyleGuideBaseURL [String] URL for styleguide
+      #     :DisplayStyleGuide [Boolean] Include styleguide and reference URLs
+      #     :ExtraDetails [Boolean] Include cop details
+      #     :DisplayCopNames [Boolean] Include cop name
+      #
+      # @param [String] cop_name for specific cop name
+      # @param [Hash] cop_config configs for specific cop, from config#for_cop
+      # @option cop_config [String] :StyleGuide Extension of base styleguide URL
+      # @option cop_config [String] :References Full reference URLs
+      # @option cop_config [String] :Details
+      #
+      # @param [Hash, nil] options optional
+      # @option options [Boolean] :display_style_guide
+      #   Include style guide and reference URLs
+      # @option options [Boolean] :extra_details
+      #   Include cop specific details
+      # @option options [Boolean] :debug
+      #   Include debug output
+      # @option options [Boolean] :display_cop_names
+      #   Include cop name
+      def initialize(config, cop_name, cop_config, options)
+        @config = config
+        @cop_name = cop_name
+        @cop_config = cop_config || {}
+        @options = options
+      end
+
+      # Returns the annotated message,
+      # based on params passed into initializer
+      #
+      # @return [String] annotated message
+      def annotate(message)
+        message = "#{cop_name}: #{message}" if display_cop_names?
+        message += " #{details}" if extra_details? && details
+        if display_style_guide?
+          links = urls.join(', ')
+          message = "#{message} (#{links})"
+        end
+        message
+      end
+
+      def urls
+        [style_guide_url, *reference_urls].compact
+      end
+
+      private
+
+      def style_guide_url
+        url = cop_config['StyleGuide']
+        return nil if url.nil? || url.empty?
+
+        self.class.style_guide_urls[url] ||= begin
+          base_url = style_guide_base_url
+          if base_url.nil? || base_url.empty?
+            url
+          else
+            URI.join(base_url, url).to_s
+          end
+        end
+      end
+
+      # Returns the base style guide URL from AllCops or the specific department
+      #
+      # @return [String] style guide URL
+      def style_guide_base_url
+        department_name = cop_name.split('/')[0..-2].join('/')
+
+        config.for_department(department_name)['StyleGuideBaseURL'] ||
+          config.for_all_cops['StyleGuideBaseURL']
+      end
+
+      def display_style_guide?
+        (options[:display_style_guide] || config.for_all_cops['DisplayStyleGuide']) && !urls.empty?
+      end
+
+      def reference_urls
+        urls = cop_config
+               .values_at('References', 'Reference') # Support legacy Reference key
+               .flat_map { |url| Array(url) }
+               .reject(&:empty?)
+
+        urls unless urls.empty?
+      end
+
+      def extra_details?
+        options[:extra_details] || config.for_all_cops['ExtraDetails']
+      end
+
+      def debug?
+        options[:debug]
+      end
+
+      def display_cop_names?
+        return true if debug?
+        return false if options[:display_cop_names] == false
+        return true if options[:display_cop_names]
+        return false if options[:format] == 'json'
+
+        config.for_all_cops['DisplayCopNames']
+      end
+
+      def details
+        details = cop_config && cop_config['Details']
+        details.nil? || details.empty? ? nil : details
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/metrics/abc_size.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks that the ABC size of methods is not higher than the
+      # configured maximum. The ABC size is based on assignments, branches
+      # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
+      # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
+      #
+      # Interpreting ABC size:
+      #
+      # * ``<= 17`` satisfactory
+      # * `18..30` unsatisfactory
+      # * `>` 30 dangerous
+      #
+      # You can have repeated "attributes" calls count as a single "branch".
+      # For this purpose, attributes are any method with no argument; no attempt
+      # is meant to distinguish actual `attr_reader` from other methods.
+      #
+      # @example CountRepeatedAttributes: false (default is true)
+      #
+      #    # `model` and `current_user`, referenced 3 times each,
+      #    # are each counted as only 1 branch each if
+      #    # `CountRepeatedAttributes` is set to 'false'
+      #
+      #    def search
+      #      @posts = model.active.visible_by(current_user)
+      #                .search(params[:q])
+      #      @posts = model.some_process(@posts, current_user)
+      #      @posts = model.another_process(@posts, current_user)
+      #
+      #      render 'pages/search/page'
+      #    end
+      #
+      # This cop also takes into account `AllowedMethods` (defaults to `[]`)
+      # And `AllowedPatterns` (defaults to `[]`)
+      #
+      class AbcSize < Base
+        include MethodComplexity
+
+        MSG = 'Assignment Branch Condition size for `%<method>s` is too high. ' \
+              '[%<abc_vector>s %<complexity>.4g/%<max>.4g]'
+
+        private
+
+        def complexity(node)
+          Utils::AbcSizeCalculator.calculate(
+            node,
+            discount_repeated_attributes: !cop_config['CountRepeatedAttributes']
+          )
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/metrics/block_length.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks if the length of a block exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      # The cop can be configured to ignore blocks passed to certain methods.
+      #
+      # You can set constructs you want to fold with `CountAsOne`.
+      #
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+      # Each construct will be counted as one line regardless of its actual size.
+      #
+      # NOTE: This cop does not apply for `Struct` definitions.
+      #
+      # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
+      # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
+      # instead. By default, there are no allowed methods.
+      #
+      # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
+      #
+      #   something do
+      #     array = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     hash = {          # +1
+      #       key: 'value'
+      #     }
+      #
+      #     msg = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 4 points
+      #
+      class BlockLength < Base
+        include CodeLength
+        include AllowedMethods
+        include AllowedPattern
+
+        LABEL = 'Block'
+
+        def on_block(node)
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+          return if method_receiver_excluded?(node)
+          return if node.class_constructor?
+
+          check_code_length(node)
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def method_receiver_excluded?(node)
+          node_receiver = node.receiver&.source&.gsub(/\s+/, '')
+          node_method = String(node.method_name)
+
+          allowed_methods.any? do |config|
+            next unless config.is_a?(String)
+
+            receiver, method = config.split('.')
+
+            unless method
+              method = receiver
+              receiver = node_receiver
+            end
+
+            method == node_method && receiver == node_receiver
+          end
+        end
+
+        def cop_label
+          LABEL
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/metrics/block_nesting.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks for excessive nesting of conditional and looping constructs.
+      # Deeply nested code is harder to read, understand, and maintain.
+      # Extracting nested logic into methods improves clarity.
+      #
+      # You can configure if blocks are considered using the `CountBlocks` and `CountModifierForms`
+      # options. When both are set to `false` (the default) blocks and modifier forms are not
+      # counted towards the nesting level. Set them to `true` to include these in the nesting level
+      # calculation as well.
+      #
+      # The maximum level of nesting allowed is configurable.
+      #
+      # @example Max: 3 (default)
+      #   # bad
+      #   if condition1
+      #     if condition2
+      #       if condition3
+      #         if condition4
+      #           do_something
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   if condition1
+      #     if condition2
+      #       if condition3
+      #         do_something
+      #       end
+      #     end
+      #   end
+      class BlockNesting < Base
+        NESTING_BLOCKS = %i[case case_match if while while_post until until_post for resbody].freeze
+
+        exclude_limit 'Max'
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          max = cop_config['Max']
+          check_nesting_level(processed_source.ast, max, 0)
+        end
+
+        private
+
+        def check_nesting_level(node, max, current_level)
+          if consider_node?(node)
+            current_level += 1 if count_if_block?(node)
+            if current_level > max
+              self.max = current_level
+              unless part_of_ignored_node?(node)
+                add_offense(node, message: message(max)) { ignore_node(node) }
+              end
+            end
+          end
+
+          node.each_child_node do |child_node|
+            check_nesting_level(child_node, max, current_level)
+          end
+        end
+
+        def count_if_block?(node)
+          return true unless node.if_type?
+          return false if node.elsif?
+          return count_modifier_forms? if node.modifier_form?
+
+          true
+        end
+
+        def consider_node?(node)
+          return true if NESTING_BLOCKS.include?(node.type)
+
+          count_blocks? && node.any_block_type?
+        end
+
+        def message(max)
+          "Avoid more than #{max} levels of block nesting."
+        end
+
+        def count_blocks?
+          cop_config.fetch('CountBlocks', false)
+        end
+
+        def count_modifier_forms?
+          cop_config.fetch('CountModifierForms', false)
+        end
+      end
+    end
+  end
+end