super-pro-sys 0.0.1

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

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for literals used as the conditions or as
+      # operands in and/or expressions serving as the conditions of
+      # if/while/until/case-when/case-in.
+      #
+      # NOTE: Literals in `case-in` condition where the match variable is used in
+      # `in` are accepted as a pattern matching.
+      #
+      # @example
+      #
+      #   # bad
+      #   if 20
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   # We're only interested in the left hand side being a truthy literal,
+      #   # because it affects the evaluation of the &&, whereas the right hand
+      #   # side will be conditionally executed/called and can be a literal.
+      #   if true && some_var
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if some_var
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   # When using a boolean value for an infinite loop.
+      #   while true
+      #     break if condition
+      #   end
+      class LiteralAsCondition < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Literal `%<literal>s` appeared as a condition.'
+        RESTRICT_ON_SEND = [:!].freeze
+
+        def on_and(node)
+          return unless node.lhs.truthy_literal?
+
+          add_offense(node.lhs) do |corrector|
+            # Don't autocorrect `'foo' && return` because having `return` as
+            # the leftmost node can lead to a void value expression syntax error.
+            next if node.rhs.type?(:return, :break, :next)
+
+            corrector.replace(node, node.rhs.source)
+          end
+        end
+
+        def on_or(node)
+          return unless node.lhs.falsey_literal?
+
+          add_offense(node.lhs) do |corrector|
+            # Don't autocorrect `'foo' && return` because having `return` as
+            # the leftmost node can lead to a void value expression syntax error.
+            next if node.rhs.type?(:return, :break, :next)
+
+            corrector.replace(node, node.rhs.source)
+          end
+        end
+
+        def on_if(node)
+          cond = condition(node)
+
+          return unless cond.falsey_literal? || cond.truthy_literal?
+
+          correct_if_node(node, cond)
+        end
+
+        def on_while(node)
+          return if node.condition.source == 'true'
+
+          if node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node.condition, 'true')
+            end
+          elsif node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.remove(node)
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def on_while_post(node)
+          return if node.condition.source == 'true'
+
+          if node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.source.sub(node.condition.source, 'true'))
+            end
+          elsif node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def on_until(node)
+          return if node.condition.source == 'false'
+
+          if node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node.condition, 'false')
+            end
+          elsif node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.remove(node)
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def on_until_post(node)
+          return if node.condition.source == 'false'
+
+          if node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.source.sub(node.condition.source, 'false'))
+            end
+          elsif node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def on_case(case_node)
+          if (cond = case_node.condition)
+            return if !cond.falsey_literal? && !cond.truthy_literal?
+
+            check_case(case_node)
+          else
+            case_node.when_branches.each do |when_node|
+              next unless when_node.conditions.all?(&:literal?)
+
+              range = when_conditions_range(when_node)
+              message = message(range)
+
+              add_offense(range, message: message)
+            end
+          end
+        end
+
+        def on_case_match(case_match_node)
+          if case_match_node.condition
+            return if case_match_node.descendants.any?(&:match_var_type?)
+
+            check_case(case_match_node)
+          else
+            case_match_node.in_pattern_branches.each do |in_pattern_node|
+              next unless in_pattern_node.condition.literal?
+
+              add_offense(in_pattern_node)
+            end
+          end
+        end
+
+        def on_send(node)
+          return unless node.negation_method?
+
+          check_for_literal(node)
+        end
+
+        def message(node)
+          format(MSG, literal: node.source)
+        end
+
+        private
+
+        def check_for_literal(node)
+          cond = condition(node)
+          if cond.literal?
+            add_offense(cond)
+          else
+            check_node(cond)
+          end
+        end
+
+        def basic_literal?(node)
+          if node.array_type?
+            primitive_array?(node)
+          else
+            node.basic_literal?
+          end
+        end
+
+        def primitive_array?(node)
+          node.children.all? { |n| basic_literal?(n) }
+        end
+
+        def check_node(node)
+          if node.send_type? && node.prefix_bang?
+            handle_node(node.receiver)
+          elsif node.operator_keyword?
+            node.each_child_node { |op| handle_node(op) }
+          elsif node.begin_type? && node.children.one?
+            handle_node(node.children.first)
+          end
+        end
+
+        def handle_node(node)
+          if node.literal?
+            return if node.parent.and_type?
+
+            add_offense(node)
+          elsif %i[send and or begin].include?(node.type)
+            check_node(node)
+          end
+        end
+
+        def check_case(case_node)
+          condition = case_node.condition
+
+          return if condition.array_type? && !primitive_array?(condition)
+          return if condition.dstr_type?
+
+          handle_node(condition)
+        end
+
+        def condition(node)
+          if node.send_type?
+            node.receiver
+          else
+            node.condition
+          end
+        end
+
+        def when_conditions_range(when_node)
+          range_between(
+            when_node.conditions.first.source_range.begin_pos,
+            when_node.conditions.last.source_range.end_pos
+          )
+        end
+
+        def condition_evaluation?(node, cond)
+          if node.unless?
+            cond.falsey_literal?
+          else
+            cond.truthy_literal?
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def correct_if_node(node, cond)
+          result = condition_evaluation?(node, cond)
+
+          new_node = if node.elsif? && result
+                       "else\n  #{range_with_comments(node.if_branch).source}"
+                     elsif node.elsif? && !result
+                       "else\n  #{node.else_branch.source}"
+                     elsif node.if_branch && result
+                       node.if_branch.source
+                     elsif node.elsif_conditional?
+                       "#{node.else_branch.source.sub('elsif', 'if')}\nend"
+                     elsif node.else? || node.ternary?
+                       node.else_branch.source
+                     else
+                       '' # Equivalent to removing the node
+                     end
+
+          add_offense(cond) do |corrector|
+            next if part_of_ignored_node?(node)
+
+            corrector.replace(node, new_node)
+
+            ignore_node(node)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for literal assignments in the conditions of `if`, `while`, and `until`.
+      # It emulates the following Ruby warning:
+      #
+      # [source,console]
+      # ----
+      # $ ruby -we 'if x = true; end'
+      # -e:1: warning: found `= literal' in conditional, should be ==
+      # ----
+      #
+      # As a lint cop, it cannot be determined if `==` is appropriate as intended,
+      # therefore this cop does not provide autocorrection.
+      #
+      # @example
+      #
+      #   # bad
+      #   if x = 42
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if x == 42
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if x = y
+      #     do_something
+      #   end
+      #
+      class LiteralAssignmentInCondition < Base
+        MSG = "Don't use literal assignment `= %<literal>s` in conditional, " \
+              'should be `==` or non-literal operand.'
+
+        def on_if(node)
+          traverse_node(node.condition) do |asgn_node|
+            next unless asgn_node.loc.operator
+
+            rhs = asgn_node.rhs
+            next if !all_literals?(rhs) || parallel_assignment_with_splat_operator?(rhs)
+
+            range = offense_range(asgn_node, rhs)
+
+            add_offense(range, message: format(MSG, literal: rhs.source))
+          end
+        end
+        alias on_while on_if
+        alias on_until on_if
+
+        private
+
+        def traverse_node(node, &block)
+          yield node if node.equals_asgn?
+
+          node.each_child_node do |child|
+            next if scope_body?(node, child)
+
+            traverse_node(child, &block)
+          end
+        end
+
+        # An assignment inside a block or method body within the condition belongs to
+        # that inner scope rather than the condition itself, so it is not inspected.
+        def scope_body?(node, child)
+          node.type?(:any_block, :any_def) && child == node.body
+        end
+
+        def all_literals?(node)
+          case node.type
+          when :dstr, :xstr
+            false
+          when :array
+            node.values.all? { |value| all_literals?(value) }
+          when :hash
+            (node.values + node.keys).all? { |item| all_literals?(item) }
+          else
+            node.respond_to?(:literal?) && node.literal?
+          end
+        end
+
+        def parallel_assignment_with_splat_operator?(node)
+          node.array_type? && node.values.first&.splat_type?
+        end
+
+        def offense_range(asgn_node, rhs)
+          asgn_node.loc.operator.join(rhs.source_range.end)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for interpolated literals.
+      #
+      # NOTE: Array literals interpolated in regexps are not handled by this cop, but
+      # by `Lint/ArrayLiteralInRegexp` instead.
+      #
+      # @example
+      #
+      #   # bad
+      #   "result is #{10}"
+      #
+      #   # good
+      #   "result is 10"
+      class LiteralInInterpolation < Base
+        include Interpolation
+        include RangeHelp
+        include PercentLiteral
+        extend AutoCorrector
+
+        MSG = 'Literal interpolation detected.'
+        COMPOSITE = %i[array hash pair irange erange].freeze
+
+        # rubocop:disable Metrics/AbcSize
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
+          return unless offending?(final_node)
+
+          # %W and %I split the content into words before expansion
+          # treating each interpolation as a word component, so
+          # interpolation should not be removed if the expanded value
+          # contains a space character.
+          expanded_value = autocorrected_value(final_node)
+          expanded_value = handle_special_regexp_chars(begin_node, expanded_value)
+
+          return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(expanded_value)
+
+          add_offense(final_node) do |corrector|
+            next if final_node.dstr_type? # nested, fixed in next iteration
+
+            replacement = if final_node.str_type? && !final_node.value.valid_encoding?
+                            final_node.source.delete_prefix('"').delete_suffix('"')
+                          else
+                            expanded_value
+                          end
+
+            corrector.replace(final_node.parent, replacement)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def offending?(node)
+          node &&
+            !special_keyword?(node) &&
+            prints_as_self?(node) &&
+            # Special case for `Layout/TrailingWhitespace`
+            !(space_literal?(node) && ends_heredoc_line?(node)) &&
+            # Handled by `Lint/ArrayLiteralInRegexp`
+            !array_in_regexp?(node)
+        end
+
+        def special_keyword?(node)
+          # handle strings like __FILE__
+          (node.str_type? && !node.loc?(:begin)) || node.source_range.is?('__LINE__')
+        end
+
+        def array_in_regexp?(node)
+          grandparent = node.parent.parent
+          node.array_type? && grandparent.regexp_type?
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+        def autocorrected_value(node)
+          case node.type
+          when :int
+            node.children.last.to_i.to_s
+          when :float
+            node.children.last.to_f.to_s
+          when :str
+            autocorrected_value_for_string(node)
+          when :sym
+            autocorrected_value_for_symbol(node)
+          when :array
+            autocorrected_value_for_array(node)
+          when :hash
+            autocorrected_value_for_hash(node)
+          when :nil
+            ''
+          else
+            node.source.gsub('"', '\"')
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
+
+        def handle_special_regexp_chars(begin_node, value)
+          parent_node = begin_node.parent
+
+          return value unless parent_node.regexp_type? && parent_node.slash_literal? && value['/']
+
+          # When a literal string containing a forward slash preceded by backslashes
+          # is interpolated inside a regexp, the number of resultant backslashes in the
+          # compiled Regexp is `(2(n+1) / 4)+1`, where `n` is the number of backslashes
+          # inside the interpolation.
+          # ie. 0-2 backslashes is compiled to 1, 3-6 is compiled to 3, etc.
+          # This maintains that same behavior in order to ensure the Regexp behavior
+          # does not change upon removing the interpolation.
+          value.gsub(%r{(\\*)/}) do
+            backslashes = Regexp.last_match[1]
+            backslash_count = backslashes.length
+            needed_backslashes = (2 * ((backslash_count + 1) / 4)) + 1
+
+            "#{'\\' * needed_backslashes}/"
+          end
+        end
+
+        def autocorrected_value_for_string(node)
+          return node.source.delete_prefix('"').delete_suffix('"') unless node.value.valid_encoding?
+
+          escape_string_content(node.children.last)
+        end
+
+        def escape_string_content(string)
+          string.gsub(/[\\"]|#(?=[@{$])/, '\\\\\&')
+        end
+
+        def autocorrected_value_for_symbol(node)
+          end_pos =
+            node.loc.end ? node.loc.end.begin_pos : node.source_range.end_pos
+
+          range_between(node.loc.begin.end_pos, end_pos).source.gsub('"', '\"')
+        end
+
+        def autocorrected_value_in_hash_for_symbol(node)
+          escape_string_content(node.value.inspect)
+        end
+
+        def autocorrected_value_for_array(node)
+          return node.source.gsub('"', '\"') unless node.percent_literal?
+
+          contents_range(node).source.split.to_s.gsub('"', '\"')
+        end
+
+        def autocorrected_value_for_hash(node)
+          hash_string = node.children.map do |child|
+            key = autocorrected_value_in_hash(child.key)
+            value = autocorrected_value_in_hash(child.value)
+            "#{key}=>#{value}"
+          end.join(', ')
+
+          "{#{hash_string}}"
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def autocorrected_value_in_hash(node)
+          case node.type
+          when :int
+            node.children.last.to_i.to_s
+          when :float
+            node.children.last.to_f.to_s
+          when :str
+            "\\\"#{node.value.to_s.gsub('"') { '\\\\\"' }}\\\""
+          when :sym
+            autocorrected_value_in_hash_for_symbol(node)
+          when :array
+            autocorrected_value_for_array(node)
+          when :hash
+            autocorrected_value_for_hash(node)
+          else
+            node.source.gsub('"', '\"')
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        # Does node print its own source when converted to a string?
+        def prints_as_self?(node)
+          node.basic_literal? ||
+            (COMPOSITE.include?(node.type) && node.children.all? { |child| prints_as_self?(child) })
+        end
+
+        def space_literal?(node)
+          node.str_type? && node.value.valid_encoding? && node.value.blank?
+        end
+
+        def ends_heredoc_line?(node)
+          grandparent = node.parent.parent
+          return false unless grandparent&.dstr_type? && grandparent.heredoc?
+
+          line = processed_source.lines[node.last_line - 1]
+          line.size == node.loc.last_column + 1
+        end
+
+        def in_array_percent_literal?(node)
+          parent = node.parent
+          return false unless parent.type?(:dstr, :dsym)
+
+          grandparent = parent.parent
+          grandparent&.array_type? && grandparent.percent_literal?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for uses of `begin...end while/until something`.
+      #
+      # @safety
+      #   The cop is unsafe because behavior can change in some cases, including
+      #   if a local variable inside the loop body is accessed outside of it, or if the
+      #   loop body raises a `StopIteration` exception (which `Kernel#loop` rescues).
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # using while
+      #   begin
+      #     do_something
+      #   end while some_condition
+      #
+      #   # good
+      #
+      #   # while replacement
+      #   loop do
+      #     do_something
+      #     break unless some_condition
+      #   end
+      #
+      #   # bad
+      #
+      #   # using until
+      #   begin
+      #     do_something
+      #   end until some_condition
+      #
+      #   # good
+      #
+      #   # until replacement
+      #   loop do
+      #     do_something
+      #     break if some_condition
+      #   end
+      class Loop < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Kernel#loop` with `break` rather than `begin/end/until`(or `while`).'
+
+        def on_while_post(node)
+          register_offense(node)
+        end
+
+        def on_until_post(node)
+          register_offense(node)
+        end
+
+        private
+
+        def register_offense(node)
+          body = node.body
+
+          add_offense(node.loc.keyword) do |corrector|
+            corrector.replace(body.loc.begin, 'loop do')
+            corrector.remove(keyword_and_condition_range(node))
+            corrector.insert_before(body.loc.end, build_break_line(node))
+          end
+        end
+
+        def keyword_and_condition_range(node)
+          node.body.loc.end.end.join(node.source_range.end)
+        end
+
+        def build_break_line(node)
+          conditional_keyword = node.while_post_type? ? 'unless' : 'if'
+          "break #{conditional_keyword} #{node.condition.source}\n#{indent(node)}"
+        end
+      end
+    end
+  end
+end