super-pro-sys 0.0.1

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

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks whether some constant value isn't a
+      # mutable literal (e.g. array or hash).
+      #
+      # When the `Recursive` option is enabled, mutable literals nested inside
+      # arrays and hashes are also frozen, so an offense on the outermost
+      # unfrozen literal will autocorrect every nested mutable literal as well.
+      # When the outer literal already has `.freeze` appended, the cop descends
+      # into it and reports each outermost unfrozen literal underneath. The
+      # option is disabled by default to preserve existing behavior; opt in to
+      # get strict nested freezing.
+      #
+      # Strict mode can be used to freeze all constants, rather than
+      # just literals.
+      # Strict mode is considered an experimental feature. It has not been
+      # updated with an exhaustive list of all methods that will produce
+      # frozen objects so there is a decent chance of getting some false
+      # positives. Luckily, there is no harm in freezing an already
+      # frozen object.
+      #
+      # From Ruby 3.0, this cop honours the magic comment
+      # 'shareable_constant_value'. When this magic comment is set to any
+      # acceptable value other than none, it will suppress the offenses
+      # raised by this cop. It enforces frozen state.
+      #
+      # NOTE: `Regexp` and `Range` literals are frozen objects since Ruby 3.0.
+      #
+      # NOTE: From Ruby 3.0, interpolated strings are not frozen when
+      # `# frozen-string-literal: true` is used, so this cop enforces explicit
+      # freezing for such strings.
+      #
+      # NOTE: From Ruby 3.0, this cop allows explicit freezing of constants when
+      # the `shareable_constant_value` directive is used.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe since any mutations on objects that
+      #   are made frozen will change from being accepted to raising `FrozenError`,
+      #   and will need to be manually refactored.
+      #
+      # @example EnforcedStyle: literals (default)
+      #   # bad
+      #   CONST = [1, 2, 3]
+      #
+      #   # good
+      #   CONST = [1, 2, 3].freeze
+      #
+      #   # good
+      #   CONST = <<~TESTING.freeze
+      #     This is a heredoc
+      #   TESTING
+      #
+      #   # good
+      #   CONST = Something.new
+      #
+      #
+      # @example Recursive: false (default)
+      #   # good - only the outer container needs to be frozen
+      #   CONST = [{ a: [], b: 'foo' }].freeze
+      #
+      # @example Recursive: true
+      #   # bad - nested mutable literals must be frozen too
+      #   CONST = [{ a: [], b: 'foo' }].freeze
+      #
+      #   # good
+      #   CONST = [{ a: [].freeze, b: 'foo'.freeze }.freeze].freeze
+      #
+      # @example EnforcedStyle: strict
+      #   # bad
+      #   CONST = Something.new
+      #
+      #   # bad
+      #   CONST = Struct.new do
+      #     def foo
+      #       puts 1
+      #     end
+      #   end
+      #
+      #   # good
+      #   CONST = Something.new.freeze
+      #
+      #   # good
+      #   CONST = Struct.new do
+      #     def foo
+      #       puts 1
+      #     end
+      #   end.freeze
+      #
+      # @example
+      #   # Magic comment - shareable_constant_value: literal
+      #
+      #   # bad
+      #   CONST = [1, 2, 3]
+      #
+      #   # good
+      #   # shareable_constant_value: literal
+      #   CONST = [1, 2, 3]
+      #
+      class MutableConstant < Base
+        # Handles magic comment shareable_constant_value with O(n ^ 2) complexity
+        # n - number of lines in the source
+        # Iterates over all lines before a CONSTANT
+        # until it reaches shareable_constant_value
+        module ShareableConstantValue
+          module_function
+
+          def recent_shareable_value?(node)
+            shareable_constant_comment = magic_comment_in_scope node
+            return false if shareable_constant_comment.nil?
+
+            shareable_constant_value = MagicComment.parse(shareable_constant_comment)
+                                                   .shareable_constant_value
+            shareable_constant_value_enabled? shareable_constant_value
+          end
+
+          # Identifies the most recent magic comment with valid shareable constant values
+          # that's in scope for this node
+          def magic_comment_in_scope(node)
+            processed_source_till_node(node).reverse_each.find do |line|
+              MagicComment.parse(line).valid_shareable_constant_value?
+            end
+          end
+
+          private
+
+          def processed_source_till_node(node)
+            processed_source.lines[0..(node.last_line - 1)]
+          end
+
+          def shareable_constant_value_enabled?(value)
+            %w[literal experimental_everything experimental_copy].include? value
+          end
+        end
+        private_constant :ShareableConstantValue
+
+        include ShareableConstantValue
+        include FrozenStringLiteral
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = 'Freeze mutable objects assigned to constants.'
+
+        def on_casgn(node)
+          if node.expression.nil? # This is only the case for `CONST += ...` or similar
+            parent = node.parent
+            return unless parent.or_asgn_type? # We only care about `CONST ||= ...`
+
+            on_assignment(parent.children.last)
+          else
+            on_assignment(node.expression)
+          end
+        end
+
+        private
+
+        def on_assignment(value)
+          nodes = mutable_nodes(value) do |node|
+            if style == :strict
+              strict_check(node)
+            else
+              literal_check(node)
+            end
+          end
+
+          nodes.each do |node|
+            add_offense(node) { |corrector| autocorrect(corrector, node) }
+          end
+        end
+
+        def mutable_nodes(value, &block)
+          if recursive? && explicitly_frozen_literal?(value)
+            literal_children(value.receiver).flat_map { |c| mutable_nodes(c, &block) }
+          else
+            node_offending = yield(value)
+
+            if node_offending
+              [value]
+            else
+              []
+            end
+          end
+        end
+
+        def strict_check(value)
+          return if immutable_literal?(value)
+          return if operation_produces_immutable_object?(value)
+          return if frozen_string_literal?(value)
+          return if shareable_constant_value?(value)
+
+          true
+        end
+
+        def literal_check(value)
+          return unless mutable_or_unfrozen_range?(value)
+          return if frozen_string_literal?(value)
+          return if shareable_constant_value?(value)
+
+          true
+        end
+
+        def mutable_or_unfrozen_range?(value)
+          mutable_literal?(value) ||
+            (target_ruby_version <= 2.7 && range_enclosed_in_parentheses?(value))
+        end
+
+        def autocorrect(corrector, node)
+          expr = node.source_range
+
+          splat_value = splat_value(node)
+          if splat_value
+            correct_splat_expansion(corrector, expr, splat_value)
+            corrector.insert_after(expr, '.freeze')
+            return
+          end
+
+          if node.array_type? && !node.bracketed?
+            corrector.wrap(expr, '[', ']')
+          elsif requires_parentheses?(node)
+            corrector.wrap(expr, '(', ')')
+          end
+
+          corrector.insert_after(expr, '.freeze')
+
+          freeze_nested_literals(corrector, node) if recursive?
+        end
+
+        # Recursively freezes every nested mutable literal inside an array or
+        # hash literal. Already-frozen subtrees are not re-frozen, but their
+        # children are still inspected for unfrozen literals deeper down.
+        def freeze_nested_literals(corrector, node)
+          literal_children(node).each do |child|
+            if explicitly_frozen_literal?(child)
+              freeze_nested_literals(corrector, child.receiver)
+            elsif freezable_nested_literal?(child)
+              autocorrect(corrector, child)
+            end
+          end
+        end
+
+        def freezable_nested_literal?(node)
+          return false if frozen_string_literal?(node)
+          return false if shareable_constant_value?(node)
+
+          mutable_literal?(node)
+        end
+
+        # Returns the child literals of an array or hash node that may
+        # themselves need freezing. For hashes, both keys and values are
+        # included. Percent-literal arrays (e.g. `%w(a b)`) are skipped because
+        # `.freeze` cannot be appended to their contents.
+        def literal_children(node)
+          case node.type
+          when :array
+            return [] if node.percent_literal?
+
+            node.children
+          when :hash
+            node.children.flat_map { |child| child.pair_type? ? child.children : [] }
+          else
+            []
+          end
+        end
+
+        def explicitly_frozen_literal?(node)
+          return false unless node.send_type? && node.method?(:freeze)
+
+          node.receiver && mutable_literal?(node.receiver)
+        end
+
+        def recursive?
+          cop_config.fetch('Recursive', false)
+        end
+
+        def mutable_literal?(value)
+          return false if frozen_regexp_or_range_literals?(value)
+
+          value.mutable_literal?
+        end
+
+        def immutable_literal?(node)
+          frozen_regexp_or_range_literals?(node) || node.immutable_literal?
+        end
+
+        def shareable_constant_value?(node)
+          return false if target_ruby_version < 3.0
+
+          recent_shareable_value? node
+        end
+
+        def frozen_regexp_or_range_literals?(node)
+          target_ruby_version >= 3.0 && node.type?(:regexp, :range)
+        end
+
+        def requires_parentheses?(node)
+          node.range_type? || (node.send_type? && node.loc.dot.nil?)
+        end
+
+        def correct_splat_expansion(corrector, expr, splat_value)
+          if range_enclosed_in_parentheses?(splat_value)
+            corrector.replace(expr, "#{splat_value.source}.to_a")
+          else
+            corrector.replace(expr, "(#{splat_value.source}).to_a")
+          end
+        end
+
+        # @!method splat_value(node)
+        def_node_matcher :splat_value, <<~PATTERN
+          (array (splat $_))
+        PATTERN
+
+        # Some of these patterns may not actually return an immutable object,
+        # but we want to consider them immutable for this cop.
+        # @!method operation_produces_immutable_object?(node)
+        def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
+          {
+            (const _ _)
+            (send (const {nil? cbase} :Struct) :new ...)
+            (block (send (const {nil? cbase} :Struct) :new ...) ...)
+            (send _ :freeze)
+            (send {float int} {:+ :- :* :** :/ :% :<<} _)
+            (send _ {:+ :- :* :** :/ :%} {float int})
+            (send _ {:== :=== :!= :<= :>= :< :>} _)
+            (send (const {nil? cbase} :ENV) :[] _)
+            (or (send (const {nil? cbase} :ENV) :[] _) _)
+            (send _ {:count :length :size} ...)
+            (block (send _ {:count :length :size} ...) ...)
+          }
+        PATTERN
+
+        # @!method range_enclosed_in_parentheses?(node)
+        def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
+          (begin (range _ _))
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of if with a negated condition. Only ifs
+      # without else are considered. There are three different styles:
+      #
+      # * both
+      # * prefix
+      # * postfix
+      #
+      # @example EnforcedStyle: both (default)
+      #   # enforces `unless` for `prefix` and `postfix` conditionals
+      #
+      #   # bad
+      #
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #
+      #   bar if !foo
+      #
+      #   # good
+      #
+      #   bar unless foo
+      #
+      # @example EnforcedStyle: prefix
+      #   # enforces `unless` for just `prefix` conditionals
+      #
+      #   # bad
+      #
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   bar if !foo
+      #
+      # @example EnforcedStyle: postfix
+      #   # enforces `unless` for just `postfix` conditionals
+      #
+      #   # bad
+      #
+      #   bar if !foo
+      #
+      #   # good
+      #
+      #   bar unless foo
+      #
+      #   # good
+      #
+      #   if !foo
+      #     bar
+      #   end
+      class NegatedIf < Base
+        include ConfigurableEnforcedStyle
+        include NegativeConditional
+        extend AutoCorrector
+
+        def on_if(node)
+          return if node.unless? || node.elsif? || node.ternary?
+          return if correct_style?(node)
+
+          message = message(node)
+          check_negative_conditional(node, message: message) do |corrector|
+            ConditionCorrector.correct_negative_condition(corrector, node)
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
+        end
+
+        def correct_style?(node)
+          (style == :prefix && node.modifier_form?) || (style == :postfix && !node.modifier_form?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of `if-else` and ternary operators with a negated condition
+      # which can be simplified by inverting condition and swapping branches.
+      #
+      # @example
+      #   # bad
+      #   if !x
+      #     do_something
+      #   else
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   if x
+      #     do_something_else
+      #   else
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   !x ? do_something : do_something_else
+      #
+      #   # good
+      #   x ? do_something_else : do_something
+      #
+      class NegatedIfElseCondition < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Invert the negated condition and swap the %<type>s branches.'
+
+        NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
+
+        # @!method double_negation?(node)
+        def_node_matcher :double_negation?, '(send (send _ :!) :!)'
+
+        def self.autocorrect_incompatible_with
+          [Style::InverseMethods, Style::Not]
+        end
+
+        def on_new_investigation
+          @corrected_nodes = nil
+        end
+
+        # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+        def on_if(node)
+          return unless if_else?(node)
+          return unless (condition = unwrap_begin_nodes(node.condition))
+          return if double_negation?(condition) || !negated_condition?(condition)
+          return unless condition.arguments.size < 2
+
+          message = message(node)
+          add_offense(node, message: message) do |corrector|
+            unless corrected_ancestor?(node)
+              correct_negated_condition(corrector, condition)
+              swap_branches(corrector, node)
+
+              @corrected_nodes ||= Set.new.compare_by_identity
+              @corrected_nodes.add(node)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity
+
+        private
+
+        def if_else?(node)
+          else_branch = node.else_branch
+          !node.elsif? && else_branch && (!else_branch.if_type? || !else_branch.elsif?)
+        end
+
+        def unwrap_begin_nodes(node)
+          node = node.children.first while node&.type?(:begin, :kwbegin)
+
+          node
+        end
+
+        def negated_condition?(node)
+          node.send_type? &&
+            (node.negation_method? || NEGATED_EQUALITY_METHODS.include?(node.method_name))
+        end
+
+        def message(node)
+          type = node.ternary? ? 'ternary' : 'if-else'
+
+          format(MSG, type: type)
+        end
+
+        def corrected_ancestor?(node)
+          node.each_ancestor(:if).any? { |ancestor| @corrected_nodes&.include?(ancestor) }
+        end
+
+        def correct_negated_condition(corrector, node)
+          replacement =
+            if node.negation_method?
+              node.receiver.source
+            else
+              inverted_method = node.method_name.to_s.sub('!', '=')
+              "#{node.receiver.source} #{inverted_method} #{node.first_argument.source}"
+            end
+
+          corrector.replace(node, replacement)
+        end
+
+        def swap_branches(corrector, node)
+          if node.if_branch.nil?
+            corrector.remove(range_by_whole_lines(node.loc.else, include_final_newline: true))
+          else
+            corrector.swap(if_range(node), else_range(node))
+          end
+        end
+
+        # Collect the entire if branch, including whitespace and comments
+        def if_range(node)
+          if node.ternary?
+            node.if_branch
+          else
+            range_between(node.condition.source_range.end_pos, node.loc.else.begin_pos)
+          end
+        end
+
+        # Collect the entire else branch, including whitespace and comments
+        def else_range(node)
+          if node.ternary?
+            node.else_branch
+          else
+            range_between(node.loc.else.end_pos, node.loc.end.begin_pos)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of unless with a negated condition. Only unless
+      # without else are considered. There are three different styles:
+      #
+      # * both
+      # * prefix
+      # * postfix
+      #
+      # @example EnforcedStyle: both (default)
+      #   # enforces `if` for `prefix` and `postfix` conditionals
+      #
+      #   # bad
+      #   unless !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   if foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #   bar unless !foo
+      #
+      #   # good
+      #   bar if foo
+      #
+      # @example EnforcedStyle: prefix
+      #   # enforces `if` for just `prefix` conditionals
+      #
+      #   # bad
+      #   unless !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   if foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   bar unless !foo
+      #
+      # @example EnforcedStyle: postfix
+      #   # enforces `if` for just `postfix` conditionals
+      #
+      #   # bad
+      #   bar unless !foo
+      #
+      #   # good
+      #   bar if foo
+      #
+      #   # good
+      #   unless !foo
+      #     bar
+      #   end
+      class NegatedUnless < Base
+        include ConfigurableEnforcedStyle
+        include NegativeConditional
+        extend AutoCorrector
+
+        def on_if(node)
+          return if node.if? || node.elsif? || node.ternary?
+          return if correct_style?(node)
+
+          message = message(node)
+          check_negative_conditional(node, message: message) do |corrector|
+            ConditionCorrector.correct_negative_condition(corrector, node)
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
+        end
+
+        def correct_style?(node)
+          (style == :prefix && node.modifier_form?) || (style == :postfix && !node.modifier_form?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of while with a negated condition.
+      #
+      # @example
+      #   # bad
+      #   while !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   until foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #   bar until !foo
+      #
+      #   # good
+      #   bar while foo
+      #   bar while !foo && baz
+      class NegatedWhile < Base
+        include NegativeConditional
+        extend AutoCorrector
+
+        def on_while(node)
+          message = format(MSG, inverse: node.inverse_keyword, current: node.keyword)
+
+          check_negative_conditional(node, message: message) do |corrector|
+            ConditionCorrector.correct_negative_condition(corrector, node)
+          end
+        end
+        alias on_until on_while
+      end
+    end
+  end
+end