super-pro-sys 0.0.1

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer `Enumerable` predicate methods over expressions with `count`.
+      #
+      # The cop checks calls to `count` without arguments, or with a
+      # block. It doesn't register offenses for `count` with a positional
+      # argument because its behavior differs from predicate methods (`count`
+      # matches the argument using `==`, while `any?`, `none?` and `one?` use
+      # `===`).
+      #
+      # NOTE: This cop doesn't check `length` and `size` methods because they
+      # would yield false positives. For example, `String` implements `length`
+      # and `size`, but it doesn't include `Enumerable`.
+      #
+      # @safety
+      #   The cop is unsafe because receiver might not include `Enumerable`, or
+      #   it has nonstandard implementation of `count` or any replacement
+      #   methods.
+      #
+      #   It's also unsafe because for collections with falsey values, expressions
+      #   with `count` without a block return a different result than methods `any?`,
+      #   `none?` and `one?`:
+      #
+      #   [source,ruby]
+      #   ----
+      #   [nil, false].count.positive?
+      #   [nil].count == 1
+      #   # => true
+      #
+      #   [nil, false].any?
+      #   [nil].one?
+      #   # => false
+      #
+      #   [nil].count == 0
+      #   # => false
+      #
+      #   [nil].none?
+      #   # => true
+      #   ----
+      #
+      #   Autocorrection is unsafe when replacement methods don't iterate over
+      #   every element in collection and the given block runs side effects:
+      #
+      #   [source,ruby]
+      #   ----
+      #   x.count(&:method_with_side_effects).positive?
+      #   # calls `method_with_side_effects` on every element
+      #
+      #   x.any?(&:method_with_side_effects)
+      #   # calls `method_with_side_effects` until first element returns a truthy value
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   x.count.positive?
+      #   x.count > 0
+      #   x.count != 0
+      #
+      #   x.count(&:foo?).positive?
+      #   x.count { |item| item.foo? }.positive?
+      #
+      #   # good
+      #   x.any?
+      #
+      #   x.any?(&:foo?)
+      #   x.any? { |item| item.foo? }
+      #
+      #   # bad
+      #   x.count.zero?
+      #   x.count == 0
+      #
+      #   # good
+      #   x.none?
+      #
+      #   # bad
+      #   x.count == 1
+      #   x.one?
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #
+      #   # good
+      #   x.count > 1
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #
+      #   # bad
+      #   x.count > 1
+      #
+      #   # good
+      #   x.many?
+      #
+      class CollectionQuerying < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead.'
+
+        RESTRICT_ON_SEND = %i[positive? > != zero? ==].freeze
+
+        REPLACEMENTS = {
+          [:positive?, nil] => :any?,
+          [:>, 0] => :any?,
+          [:!=, 0] => :any?,
+          [:zero?, nil] => :none?,
+          [:==, 0] => :none?,
+          [:==, 1] => :one?,
+          [:>, 1] => :many?
+        }.freeze
+
+        # @!method count_predicate(node)
+        def_node_matcher :count_predicate, <<~PATTERN
+          (send
+            {
+              (any_block $(call !nil? :count) _ _)
+              $(call !nil? :count (block-pass _)?)
+            }
+            {
+              :positive? |
+              :> (int 0) |
+              :!= (int 0) |
+              :zero? |
+              :== (int 0) |
+              :== (int 1) |
+              :> (int 1)
+            })
+        PATTERN
+
+        def on_send(node)
+          return unless (count_node = count_predicate(node))
+
+          replacement_method = replacement_method(node)
+
+          return unless replacement_supported?(replacement_method)
+
+          offense_range = count_node.loc.selector.join(node.source_range.end)
+          add_offense(offense_range,
+                      message: format(MSG, prefer: replacement_method)) do |corrector|
+            corrector.replace(count_node.loc.selector, replacement_method)
+            corrector.remove(removal_range(node))
+          end
+        end
+
+        private
+
+        def replacement_method(node)
+          REPLACEMENTS.fetch([node.method_name, node.first_argument&.value])
+        end
+
+        def replacement_supported?(method_name)
+          return true if active_support_extensions_enabled?
+
+          method_name != :many?
+        end
+
+        def removal_range(node)
+          range = (node.loc.dot || node.loc.selector).join(node.source_range.end)
+
+          range_with_surrounding_space(range, side: :left)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for methods invoked via the `::` operator instead
+      # of the `.` operator (like `FileUtils::rmdir` instead of
+      # `FileUtils.rmdir`). The `::` operator is conventionally used to
+      # reference constants, so using it for method calls can be misleading.
+      #
+      # @example
+      #   # bad
+      #   Timeout::timeout(500) { do_something }
+      #   FileUtils::rmdir(dir)
+      #   Marshal::dump(obj)
+      #
+      #   # good
+      #   Timeout.timeout(500) { do_something }
+      #   FileUtils.rmdir(dir)
+      #   Marshal.dump(obj)
+      #
+      class ColonMethodCall < Base
+        extend AutoCorrector
+
+        MSG = 'Do not use `::` for method calls.'
+
+        # @!method java_root?(node)
+        def_node_matcher :java_root?, <<~PATTERN
+          (const nil? :Java)
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [RedundantSelf]
+        end
+
+        def on_send(node)
+          return unless node.receiver && node.double_colon?
+          return if node.camel_case_method?
+          # ignore Java interop code like `Java::int` or `Java::com::method`
+          return if java_interop?(node)
+
+          add_offense(node.loc.dot) { |corrector| corrector.replace(node.loc.dot, '.') }
+        end
+
+        private
+
+        def java_interop?(node)
+          receiver = node.receiver
+          receiver = receiver.receiver while receiver.respond_to?(:receiver) && receiver.receiver
+          java_root?(receiver)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for class methods that are defined using the `::`
+      # operator instead of the `.` operator.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     def self::bar
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def self.bar
+      #     end
+      #   end
+      #
+      class ColonMethodDefinition < Base
+        extend AutoCorrector
+
+        MSG = 'Do not use `::` for defining class methods.'
+
+        def on_defs(node)
+          return unless node.loc.operator.source == '::'
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '.')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for multiple `defined?` calls joined by `&&` that can be combined
+      # into a single `defined?`.
+      #
+      # When checking that a nested constant or chained method is defined, it is
+      # not necessary to check each ancestor or component of the chain.
+      #
+      # @example
+      #   # bad
+      #   defined?(Foo) && defined?(Foo::Bar) && defined?(Foo::Bar::Baz)
+      #
+      #   # good
+      #   defined?(Foo::Bar::Baz)
+      #
+      #   # bad
+      #   defined?(foo) && defined?(foo.bar) && defined?(foo.bar.baz)
+      #
+      #   # good
+      #   defined?(foo.bar.baz)
+      class CombinableDefined < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Combine nested `defined?` calls.'
+        OPERATORS = %w[&& and].freeze
+
+        def on_and(node)
+          # Only register an offense if all `&&` terms are `defined?` calls
+          return unless (terms = terms(node)).all?(&:defined_type?)
+
+          calls = defined_calls(terms)
+          namespaces = namespaces(calls)
+
+          calls.each do |call|
+            next unless namespaces.any?(call)
+
+            add_offense(node) do |corrector|
+              remove_term(corrector, call)
+            end
+          end
+        end
+
+        private
+
+        def terms(node)
+          node.each_descendant.select do |descendant|
+            descendant.parent.and_type? && !descendant.and_type?
+          end
+        end
+
+        def defined_calls(nodes)
+          nodes.filter_map do |defined_node|
+            subject = defined_node.first_argument
+            subject if subject.type?(:const, :call)
+          end
+        end
+
+        def namespaces(nodes)
+          nodes.filter_map do |node|
+            if node.respond_to?(:namespace)
+              node.namespace
+            elsif node.respond_to?(:receiver)
+              node.receiver
+            end
+          end
+        end
+
+        def remove_term(corrector, term)
+          term = term.parent until term.parent.and_type?
+          range = if term == term.parent.children.last
+                    rhs_range_to_remove(term)
+                  else
+                    lhs_range_to_remove(term)
+                  end
+
+          corrector.remove(range)
+        end
+
+        # If the redundant `defined?` node is the LHS of an `and` node,
+        # the term as well as the subsequent `&&`/`and` operator will be removed.
+        def lhs_range_to_remove(term)
+          source = @processed_source.buffer.source
+
+          pos = term.source_range.end_pos
+          pos += 1 until source[..pos].end_with?(*OPERATORS)
+
+          range_with_surrounding_space(
+            range: term.source_range.with(end_pos: pos + 1),
+            side: :right,
+            newlines: false
+          )
+        end
+
+        # If the redundant `defined?` node is the RHS of an `and` node,
+        # the term as well as the preceding `&&`/`and` operator will be removed.
+        def rhs_range_to_remove(term)
+          source = @processed_source.buffer.source
+
+          pos = term.source_range.begin_pos
+          pos -= 1 until source[pos, 3].start_with?(*OPERATORS)
+
+          range_with_surrounding_space(
+            range: term.source_range.with(begin_pos: pos - 1),
+            side: :right,
+            newlines: false
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where multiple consecutive loops over the same data
+      # can be combined into a single loop. It is very likely that combining them
+      # will make the code more efficient and more concise.
+      #
+      # NOTE: Autocorrection is not applied when the block variable names differ in separate loops,
+      # as it is impossible to determine which variable name should be prioritized.
+      #
+      # @safety
+      #   The cop is unsafe, because the first loop might modify state that the
+      #   second loop depends on; these two aren't combinable.
+      #
+      # @example
+      #   # bad
+      #   def method
+      #     items.each do |item|
+      #       do_something(item)
+      #     end
+      #
+      #     items.each do |item|
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     items.each do |item|
+      #       do_something(item)
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def method
+      #     for item in items do
+      #       do_something(item)
+      #     end
+      #
+      #     for item in items do
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     for item in items do
+      #       do_something(item)
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     each_slice(2) { |slice| do_something(slice) }
+      #     each_slice(3) { |slice| do_something(slice) }
+      #   end
+      #
+      class CombinableLoops < Base
+        extend AutoCorrector
+
+        MSG = 'Combine this loop with the previous loop.'
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def on_block(node)
+          return unless node.parent&.begin_type?
+          return unless collection_looping_method?(node)
+          return unless same_collection_looping_block?(node, node.left_sibling)
+          return unless node.body && node.left_sibling.body
+
+          add_offense(node) do |corrector|
+            next unless node.arguments == node.left_sibling.arguments
+
+            combine_with_left_sibling(corrector, node)
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_for(node)
+          return unless node.parent&.begin_type?
+          return unless same_collection_looping_for?(node, node.left_sibling)
+          return unless node.body && node.left_sibling.body
+
+          add_offense(node) do |corrector|
+            # Combining loops with different iteration variables would leave the second
+            # body referencing an undefined variable, so only autocorrect when they match.
+            next unless node.variable == node.left_sibling.variable
+
+            combine_with_left_sibling(corrector, node)
+          end
+        end
+
+        private
+
+        def collection_looping_method?(node)
+          method_name = node.method_name
+          method_name.start_with?('each') || method_name.end_with?('_each')
+        end
+
+        def same_collection_looping_block?(node, sibling)
+          return false if sibling.nil? || !sibling.any_block_type?
+
+          sibling.method?(node.method_name) &&
+            sibling.receiver == node.receiver &&
+            sibling.send_node.arguments == node.send_node.arguments
+        end
+
+        def same_collection_looping_for?(node, sibling)
+          sibling&.for_type? && node.collection == sibling.collection
+        end
+
+        def combine_with_left_sibling(corrector, node)
+          corrector.remove(node.left_sibling.body.source_range.end.join(node.left_sibling.loc.end))
+          corrector.remove(node.source_range.begin.join(node.body.source_range.begin))
+
+          correct_end_of_block(corrector, node)
+        end
+
+        def correct_end_of_block(corrector, node)
+          return unless node.left_sibling.respond_to?(:braces?)
+          return if node.right_sibling&.any_block_type?
+
+          end_of_block = node.left_sibling.braces? ? '}' : ' end'
+          corrector.remove(node.loc.end)
+          corrector.insert_before(node.source_range.end, end_of_block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces using `` or %x around command literals.
+      #
+      # @example EnforcedStyle: backticks (default)
+      #   # bad
+      #   folders = %x(find . -type d).split
+      #
+      #   # bad
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      #   # good
+      #   folders = `find . -type d`.split
+      #
+      #   # good
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
+      #   folders = %x(find . -type d).split
+      #
+      #   # bad
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # good
+      #   folders = `find . -type d`.split
+      #
+      #   # good
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      # @example EnforcedStyle: percent_x
+      #   # bad
+      #   folders = `find . -type d`.split
+      #
+      #   # bad
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # good
+      #   folders = %x(find . -type d).split
+      #
+      #   # good
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      # @example AllowInnerBackticks: false (default)
+      #   # If `false`, the cop will always recommend using `%x` if one or more
+      #   # backticks are found in the command string.
+      #
+      #   # bad
+      #   `echo \`ls\``
+      #
+      #   # good
+      #   %x(echo `ls`)
+      #
+      # @example AllowInnerBackticks: true
+      #   # good
+      #   `echo \`ls\``
+      class CommandLiteral < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG_USE_BACKTICKS = 'Use backticks around command string.'
+        MSG_USE_PERCENT_X = 'Use `%x` around command string.'
+
+        def on_xstr(node)
+          return if node.heredoc?
+
+          if backtick_literal?(node)
+            check_backtick_literal(node, MSG_USE_PERCENT_X)
+          else
+            check_percent_x_literal(node, MSG_USE_BACKTICKS)
+          end
+        end
+
+        private
+
+        def check_backtick_literal(node, message)
+          return if allowed_backtick_literal?(node)
+
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+
+        def check_percent_x_literal(node, message)
+          return if allowed_percent_x_literal?(node)
+
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+
+        def autocorrect(corrector, node)
+          return if contains_backtick?(node)
+
+          replacement = if backtick_literal?(node)
+                          ['%x', ''].zip(preferred_delimiter).map(&:join)
+                        else
+                          %w[` `]
+                        end
+
+          corrector.replace(node.loc.begin, replacement.first)
+          corrector.replace(node.loc.end, replacement.last)
+        end
+
+        def allowed_backtick_literal?(node)
+          case style
+          when :backticks
+            !contains_disallowed_backtick?(node)
+          when :mixed
+            node.single_line? && !contains_disallowed_backtick?(node)
+          end
+        end
+
+        def allowed_percent_x_literal?(node)
+          case style
+          when :backticks
+            contains_disallowed_backtick?(node)
+          when :mixed
+            node.multiline? || contains_disallowed_backtick?(node)
+          when :percent_x
+            true
+          end
+        end
+
+        def contains_disallowed_backtick?(node)
+          !allow_inner_backticks? && contains_backtick?(node)
+        end
+
+        def allow_inner_backticks?
+          cop_config['AllowInnerBackticks']
+        end
+
+        def contains_backtick?(node)
+          node_body(node).include?('`')
+        end
+
+        def node_body(node)
+          loc = node.loc
+          loc.expression.source[loc.begin.length...-loc.end.length]
+        end
+
+        def backtick_literal?(node)
+          node.loc.begin.source == '`'
+        end
+
+        def preferred_delimiter
+          (command_delimiter || default_delimiter).chars
+        end
+
+        def command_delimiter
+          preferred_delimiters_config['%x']
+        end
+
+        def default_delimiter
+          preferred_delimiters_config['default']
+        end
+
+        def preferred_delimiters_config
+          config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
+        end
+      end
+    end
+  end
+end