super-pro-sys 0.0.1

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

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant `begin` blocks. A `begin` block is redundant
+      # when the `rescue`/`ensure` can be handled by the enclosing method
+      # or block definition directly, avoiding unnecessary indentation.
+      #
+      # @example
+      #
+      #   # bad
+      #   def redundant
+      #     begin
+      #       ala
+      #       bala
+      #     rescue StandardError => e
+      #       something
+      #     end
+      #   end
+      #
+      #   # good
+      #   def preferred
+      #     ala
+      #     bala
+      #   rescue StandardError => e
+      #     something
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   do_something
+      #
+      #   # bad
+      #   # When using Ruby 2.5 or later.
+      #   do_something do
+      #     begin
+      #       something
+      #     rescue => ex
+      #       anything
+      #     end
+      #   end
+      #
+      #   # good
+      #   # In Ruby 2.5 or later, you can omit `begin` in `do-end` block.
+      #   do_something do
+      #     something
+      #   rescue => ex
+      #     anything
+      #   end
+      #
+      #   # good
+      #   # Stabby lambdas don't support implicit `begin` in `do-end` blocks.
+      #   -> do
+      #     begin
+      #       foo
+      #     rescue Bar
+      #       baz
+      #     end
+      #   end
+      class RedundantBegin < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant `begin` block detected.'
+
+        def self.autocorrect_incompatible_with
+          [Style::BlockDelimiters]
+        end
+
+        # @!method offensive_kwbegins(node)
+        def_node_search :offensive_kwbegins, <<~PATTERN
+          [(kwbegin ...) !#allowable_kwbegin?]
+        PATTERN
+
+        def on_def(node)
+          return unless node.body&.kwbegin_type?
+          return if node.endless?
+
+          register_offense(node.body)
+        end
+        alias on_defs on_def
+
+        def on_if(node)
+          return if node.modifier_form?
+
+          inspect_branches(node)
+        end
+
+        def on_case(node)
+          inspect_branches(node)
+        end
+        alias on_case_match on_case
+
+        def on_while(node)
+          return if node.modifier_form?
+
+          body = node.body
+
+          return unless body&.kwbegin_type?
+          return if body.rescue_node || body.ensure_node
+
+          register_offense(body)
+        end
+        alias on_until on_while
+
+        def on_block(node)
+          return if target_ruby_version < 2.5
+          return if node.send_node.lambda_literal?
+          return if node.braces?
+          return unless node.body&.kwbegin_type?
+
+          register_offense(node.body)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_kwbegin(node)
+          return unless (target_node = offensive_kwbegins(node).to_a.last)
+
+          register_offense(target_node)
+        end
+
+        private
+
+        def allowable_kwbegin?(node)
+          empty_begin?(node) ||
+            begin_block_has_multiline_statements?(node) ||
+            contain_rescue_or_ensure?(node) ||
+            valid_context_using_only_begin?(node)
+        end
+
+        def register_offense(node)
+          offense_range = node.loc.begin
+
+          add_offense(offense_range) do |corrector|
+            if node.parent&.assignment?
+              replace_begin_with_statement(corrector, offense_range, node)
+            else
+              remove_begin(corrector, offense_range, node)
+            end
+
+            if use_modifier_form_after_multiline_begin_block?(node)
+              correct_modifier_form_after_multiline_begin_block(corrector, node)
+            end
+            corrector.remove(node.loc.end)
+          end
+        end
+
+        def replace_begin_with_statement(corrector, offense_range, node)
+          first_child = node.children.first
+
+          source = first_child.source
+          source = "(#{source})" if first_child.if_type? && first_child.modifier_form?
+
+          corrector.replace(offense_range, source)
+          corrector.remove(range_between(offense_range.end_pos, first_child.source_range.end_pos))
+
+          restore_removed_comments(corrector, offense_range, node, first_child)
+        end
+
+        def remove_begin(corrector, offense_range, node)
+          if node.parent.respond_to?(:endless?) && node.parent.endless?
+            offense_range = range_with_surrounding_space(offense_range, newlines: true)
+          end
+
+          corrector.remove(offense_range)
+        end
+
+        # Restore comments that occur between "begin" and "first_child".
+        # These comments will be moved to above the assignment line.
+        def restore_removed_comments(corrector, offense_range, node, first_child)
+          comments_range = range_between(offense_range.end_pos, first_child.source_range.begin_pos)
+          comments = comments_range.source
+
+          corrector.insert_before(node.parent, comments) unless comments.blank?
+        end
+
+        def use_modifier_form_after_multiline_begin_block?(node)
+          return false unless (parent = node.parent)
+
+          node.multiline? && parent.if_type? && parent.modifier_form?
+        end
+
+        def correct_modifier_form_after_multiline_begin_block(corrector, node)
+          condition_range = condition_range(node.parent)
+
+          corrector.insert_after(node.children.first, " #{condition_range.source}")
+          corrector.remove(range_by_whole_lines(condition_range, include_final_newline: true))
+        end
+
+        def condition_range(node)
+          range_between(node.loc.keyword.begin_pos, node.condition.source_range.end_pos)
+        end
+
+        def empty_begin?(node)
+          node.children.empty?
+        end
+
+        def begin_block_has_multiline_statements?(node)
+          return false unless node.parent
+
+          node.children.count >= 2
+        end
+
+        def contain_rescue_or_ensure?(node)
+          first_child = node.children.first
+
+          first_child.type?(:rescue, :ensure)
+        end
+
+        def valid_context_using_only_begin?(node)
+          parent = node.parent
+
+          valid_begin_assignment?(node) || parent&.post_condition_loop? ||
+            parent&.send_type? || parent&.operator_keyword?
+        end
+
+        def valid_begin_assignment?(node)
+          node.parent&.assignment? && !node.children.one?
+        end
+
+        def inspect_branches(node)
+          node.branches.each do |branch|
+            next unless branch&.kwbegin_type?
+            next if branch.rescue_node || branch.ensure_node
+
+            register_offense(branch)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usage of the %W() syntax when %w() would do.
+      #
+      # @example
+      #   # bad
+      #   %W(cat dog pig)
+      #   %W[door wall floor]
+      #
+      #   # good
+      #   %w/swim run bike/
+      #   %w[shirt pants shoes]
+      #   %W(apple #{fruit} grape)
+      class RedundantCapitalW < Base
+        include PercentLiteral
+        extend AutoCorrector
+
+        MSG = 'Do not use `%W` unless interpolation is needed. If not, use `%w`.'
+
+        def on_array(node)
+          process(node, '%W')
+        end
+
+        private
+
+        def on_percent_literal(node)
+          return if requires_interpolation?(node)
+
+          add_offense(node) do |corrector|
+            src = node.loc.begin.source
+            corrector.replace(node.loc.begin, src.tr('W', 'w'))
+          end
+        end
+
+        def requires_interpolation?(node)
+          node.child_nodes.any? do |string|
+            string.dstr_type? || double_quotes_required?(string.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for unnecessary conditional expressions.
+      #
+      # NOTE: Since the intention of the comment cannot be automatically determined,
+      # autocorrection is not applied when a comment is used, as shown below:
+      #
+      # [source,ruby]
+      # -----
+      # if b
+      #   # Important note.
+      #   b
+      # else
+      #   c
+      # end
+      # -----
+      #
+      # @example
+      #   # bad
+      #   a = b ? b : c
+      #
+      #   # good
+      #   a = b || c
+      #
+      #   # bad
+      #   if b
+      #     b
+      #   else
+      #     c
+      #   end
+      #
+      #   # good
+      #   b || c
+      #
+      #   # good
+      #   if b
+      #     b
+      #   elsif cond
+      #     c
+      #   end
+      #
+      #   # bad
+      #   a.nil? ? true : a
+      #
+      #   # good
+      #   a.nil? || a
+      #
+      #   # bad
+      #   if a.nil?
+      #     true
+      #   else
+      #     a
+      #   end
+      #
+      #   # good
+      #   a.nil? || a
+      #
+      # @example AllowedMethods: ['infinite?', 'nonzero?'] (default)
+      #   # good
+      #   num.infinite? ? true : false
+      #
+      #   # good
+      #   num.nonzero? ? true : false
+      #
+      class RedundantCondition < Base
+        include AllowedMethods
+        include CommentsHelp
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use double pipes `||` instead.'
+        REDUNDANT_CONDITION = 'This condition is not needed.'
+        ARGUMENT_WITH_OPERATOR_TYPES = %i[
+          splat block_pass forwarded_restarg forwarded_kwrestarg forwarded_args
+        ].freeze
+
+        def on_if(node)
+          return if node.modifier_form? || node.elsif_conditional? || !offense?(node)
+
+          message = message(node)
+
+          add_offense(range_of_offense(node), message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def message(node)
+          if redundant_condition?(node)
+            REDUNDANT_CONDITION
+          else
+            MSG
+          end
+        end
+
+        def autocorrect(corrector, node)
+          return if node.each_descendant.any? { |descendant| contains_comments?(descendant) }
+
+          if node.ternary? && !branches_have_method?(node)
+            correct_ternary(corrector, node)
+          elsif redundant_condition?(node)
+            corrector.replace(node, node.if_branch.source)
+          else
+            corrected = make_ternary_form(node)
+
+            corrector.replace(node, corrected)
+          end
+        end
+
+        def range_of_offense(node)
+          return node.source_range unless node.ternary?
+          return node.source_range if node.ternary? && branches_have_method?(node)
+
+          range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
+        end
+
+        def offense?(node)
+          _condition, _if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
+
+          synonymous_condition_and_branch?(node) && !node.elsif? &&
+            (node.ternary? || !else_branch.instance_of?(AST::Node) || else_branch.single_line?)
+        end
+
+        def redundant_condition?(node)
+          node.modifier_form? || !node.else_branch
+        end
+
+        def use_if_branch?(else_branch)
+          else_branch&.if_type?
+        end
+
+        def use_hash_key_assignment?(else_branch)
+          else_branch&.send_type? && else_branch.method?(:[]=)
+        end
+
+        def use_hash_key_access?(node)
+          node.send_type? && node.method?(:[])
+        end
+
+        def synonymous_condition_and_branch?(node)
+          condition, if_branch, _else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          # e.g.
+          #   if var
+          #     var
+          #   else
+          #     'foo'
+          #   end
+          return true if condition == if_branch
+
+          # e.g.
+          #   a.nil? ? true : a
+          # or
+          #   if a.nil?
+          #     true
+          #   else
+          #     a
+          #   end
+          return true if if_branch_is_true_type_and_else_is_not?(node)
+
+          # e.g.
+          #   if foo
+          #     @value = foo
+          #   else
+          #     @value = another_value?
+          #   end
+          return true if branches_have_assignment?(node) && condition == if_branch.expression
+
+          # e.g.
+          #   if foo
+          #     test.value = foo
+          #   else
+          #     test.value = another_value?
+          #   end
+          branches_have_method?(node) && condition == if_branch.first_argument &&
+            !use_hash_key_access?(if_branch)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def if_branch_is_true_type_and_else_is_not?(node)
+          return false unless node.ternary? || node.if?
+
+          cond = node.condition
+          return false unless cond.call_type?
+          return false if !cond.predicate_method? || allowed_method?(cond.method_name)
+
+          node.if_branch&.true_type? && node.else_branch && !node.else_branch.true_type?
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def branches_have_assignment?(node)
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+
+          return false unless if_branch && else_branch
+
+          asgn_type?(if_branch) && (if_branch_variable_name = if_branch.name) &&
+            asgn_type?(else_branch) && (else_branch_variable_name = else_branch.name) &&
+            if_branch_variable_name == else_branch_variable_name
+        end
+
+        def asgn_type?(node)
+          node.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn)
+        end
+
+        def branches_have_method?(node)
+          return false unless node.if_branch && node.else_branch
+
+          single_argument_method?(node.if_branch) && single_argument_method?(node.else_branch) &&
+            same_method?(node.if_branch, node.else_branch)
+        end
+
+        def single_argument_method?(node)
+          return false if !node.send_type? || node.method?(:[]) || !node.arguments.one?
+
+          !argument_with_operator?(node.first_argument)
+        end
+
+        def same_method?(if_branch, else_branch)
+          if_branch.method?(else_branch.method_name) && if_branch.receiver == else_branch.receiver
+        end
+
+        # If the argument is using an operator, it is an invalid syntax.
+        # e.g. `foo || *bar`, `foo || **bar`, and `foo || &bar`.
+        def argument_with_operator?(argument)
+          return true if ARGUMENT_WITH_OPERATOR_TYPES.include?(argument.type)
+          return false unless argument.hash_type?
+          return false unless (node = argument.children.first)
+
+          node.type?(:kwsplat, :forwarded_kwrestarg)
+        end
+
+        def wrap_arguments_with_parens(condition)
+          method = condition.source_range.begin.join(condition.loc.selector.end)
+          arguments = condition.first_argument.source_range.begin.join(condition.source_range.end)
+
+          "#{method.source}(#{arguments.source})"
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def if_source(if_branch, arithmetic_operation)
+          if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
+            if_branch.source.delete_suffix(')')
+          elsif arithmetic_operation
+            argument_source = if_branch.first_argument.source
+
+            "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
+          elsif if_branch.true_type?
+            condition = if_branch.parent.condition
+            return condition.source if condition.arguments.empty? || condition.parenthesized?
+
+            wrap_arguments_with_parens(condition)
+          else
+            if_branch.source
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
+          if arithmetic_operation
+            "#{else_branch.first_argument.source})"
+          elsif branches_have_method?(else_branch.parent)
+            else_source_if_has_method(else_branch)
+          elsif require_parentheses?(else_branch)
+            "(#{else_branch.source})"
+          elsif without_argument_parentheses_method?(else_branch)
+            "#{else_branch.method_name}(#{else_branch.arguments.map(&:source).join(', ')})"
+          elsif branches_have_assignment?(else_branch.parent)
+            else_source_if_has_assignment(else_branch)
+          else
+            else_branch.source
+          end
+        end
+
+        def else_source_if_has_method(else_branch)
+          if require_parentheses?(else_branch.first_argument)
+            "(#{else_branch.first_argument.source})"
+          elsif require_braces?(else_branch.first_argument)
+            "{ #{else_branch.first_argument.source} }"
+          else
+            else_branch.first_argument.source
+          end
+        end
+
+        def else_source_if_has_assignment(else_branch)
+          if require_parentheses?(else_branch.expression)
+            "(#{else_branch.expression.source})"
+          elsif require_braces?(else_branch.expression)
+            "{ #{else_branch.expression.source} }"
+          else
+            else_branch.expression.source
+          end
+        end
+
+        def make_ternary_form(node)
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          arithmetic_operation = use_arithmetic_operation?(if_branch)
+
+          ternary_form = [
+            if_source(if_branch, arithmetic_operation),
+            else_source(else_branch, arithmetic_operation)
+          ].join(' || ')
+          ternary_form += ')' if branches_have_method?(node) && if_branch.parenthesized?
+
+          if node.parent&.send_type?
+            "(#{ternary_form})"
+          else
+            ternary_form
+          end
+        end
+
+        def correct_ternary(corrector, node)
+          corrector.replace(range_of_offense(node), '||')
+
+          return unless node.else_branch.range_type?
+
+          corrector.wrap(node.else_branch, '(', ')')
+        end
+
+        def require_parentheses?(node)
+          (node.basic_conditional? && node.modifier_form?) ||
+            node.range_type? ||
+            node.rescue_type? ||
+            (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
+        end
+
+        def require_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+
+        def use_arithmetic_operation?(node)
+          node.respond_to?(:arithmetic_operation?) && node.arithmetic_operation?
+        end
+
+        def without_argument_parentheses_method?(node)
+          node.send_type? && !node.arguments.empty? &&
+            !node.parenthesized? && !node.operator_method? && !node.assignment_method?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant returning of true/false in conditionals.
+      #
+      # @example
+      #   # bad
+      #   x == y ? true : false
+      #
+      #   # bad
+      #   if x == y
+      #     true
+      #   else
+      #     false
+      #   end
+      #
+      #   # good
+      #   x == y
+      #
+      #   # bad
+      #   x == y ? false : true
+      #
+      #   # good
+      #   x != y
+      class RedundantConditional < Base
+        include Alignment
+        extend AutoCorrector
+
+        operators = RuboCop::AST::Node::COMPARISON_OPERATORS.to_a
+        COMPARISON_OPERATOR_MATCHER = "{:#{operators.join(' :')}}"
+
+        MSG = 'This conditional expression can just be replaced by `%<msg>s`.'
+
+        def on_if(node)
+          return unless offense?(node)
+
+          message = message(node)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement_condition(node))
+          end
+        end
+
+        private
+
+        def message(node)
+          replacement = replacement_condition(node)
+          msg = node.elsif? ? "\n#{replacement}" : replacement
+
+          format(MSG, msg: msg)
+        end
+
+        # @!method redundant_condition?(node)
+        def_node_matcher :redundant_condition?, <<~RUBY
+          (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) true false)
+        RUBY
+
+        # @!method redundant_condition_inverted?(node)
+        def_node_matcher :redundant_condition_inverted?, <<~RUBY
+          (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) false true)
+        RUBY
+
+        def offense?(node)
+          return false if node.modifier_form?
+
+          redundant_condition?(node) || redundant_condition_inverted?(node)
+        end
+
+        def replacement_condition(node)
+          condition = node.condition.source
+          expression = redundant_condition_inverted?(node) ? "!(#{condition})" : condition
+
+          node.elsif? ? indented_else_node(expression, node) : expression
+        end
+
+        def indented_else_node(expression, node)
+          "else\n#{indentation(node)}#{expression}"
+        end
+      end
+    end
+  end
+end