super-pro-sys 0.0.1

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where classes with only class methods can be
+      # replaced with a module. Classes should be used only when it makes sense to create
+      # instances out of them.
+      #
+      # @safety
+      #   This cop is unsafe, because it is possible that this class is a parent
+      #   for some other subclass, monkey-patched with instance methods or
+      #   a dummy instance is instantiated from it somewhere.
+      #
+      # @example
+      #   # bad
+      #   class SomeClass
+      #     def self.some_method
+      #       # body omitted
+      #     end
+      #
+      #     def self.some_other_method
+      #       # body omitted
+      #     end
+      #   end
+      #
+      #   # good
+      #   module SomeModule
+      #     module_function
+      #
+      #     def some_method
+      #       # body omitted
+      #     end
+      #
+      #     def some_other_method
+      #       # body omitted
+      #     end
+      #   end
+      #
+      #   # good - has instance method
+      #   class SomeClass
+      #     def instance_method; end
+      #     def self.class_method; end
+      #   end
+      #
+      class StaticClass < Base
+        include RangeHelp
+        include VisibilityHelp
+        extend AutoCorrector
+
+        MSG = 'Prefer modules to classes with only class methods.'
+
+        def on_class(class_node)
+          return if class_node.parent_class
+          return unless class_convertible_to_module?(class_node)
+
+          add_offense(class_node) do |corrector|
+            autocorrect(corrector, class_node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, class_node)
+          corrector.replace(class_node.loc.keyword, 'module')
+          corrector.insert_after(class_node.loc.name, "\nmodule_function\n")
+
+          class_elements(class_node).each do |node|
+            if node.defs_type?
+              autocorrect_def(corrector, node)
+            elsif node.sclass_type?
+              autocorrect_sclass(corrector, node)
+            end
+          end
+        end
+
+        def autocorrect_def(corrector, node)
+          corrector.remove(
+            range_between(node.receiver.source_range.begin_pos, node.loc.name.begin_pos)
+          )
+        end
+
+        def autocorrect_sclass(corrector, node)
+          corrector.remove(
+            range_between(node.loc.keyword.begin_pos, node.identifier.source_range.end_pos)
+          )
+          corrector.remove(node.loc.end)
+        end
+
+        def class_convertible_to_module?(class_node)
+          nodes = class_elements(class_node)
+          return false if nodes.empty?
+
+          nodes.all? do |node|
+            (node_visibility(node) == :public && node.defs_type?) ||
+              sclass_convertible_to_module?(node) ||
+              node.equals_asgn? ||
+              extend_call?(node)
+          end
+        end
+
+        def extend_call?(node)
+          node.send_type? && node.method?(:extend)
+        end
+
+        def sclass_convertible_to_module?(node)
+          return false unless node.sclass_type?
+
+          class_elements(node).all? do |child|
+            node_visibility(child) == :public && (child.def_type? || child.equals_asgn?)
+          end
+        end
+
+        def class_elements(class_node)
+          class_def = class_node.body
+
+          if !class_def
+            []
+          elsif class_def.begin_type?
+            class_def.children
+          else
+            [class_def]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where `$stderr.puts` can be replaced by
+      # `warn`. The latter has the advantage of easily being disabled by,
+      # the `-W0` interpreter flag or setting `$VERBOSE` to `nil`.
+      #
+      # @example
+      #   # bad
+      #   $stderr.puts('hello')
+      #
+      #   # good
+      #   warn('hello')
+      #
+      class StderrPuts < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
+        RESTRICT_ON_SEND = %i[puts].freeze
+
+        # @!method stderr_puts?(node)
+        def_node_matcher :stderr_puts?, <<~PATTERN
+          (send
+            {(gvar #stderr_gvar?) (const {nil? cbase} :STDERR)}
+            :puts $_
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return unless stderr_puts?(node)
+
+          message = message(node)
+          add_offense(stderr_puts_range(node), message: message) do |corrector|
+            corrector.replace(stderr_puts_range(node), 'warn')
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, bad: "#{node.receiver.source}.#{node.method_name}")
+        end
+
+        def stderr_gvar?(sym)
+          sym == :$stderr
+        end
+
+        def stderr_puts_range(send)
+          range_between(send.source_range.begin_pos, send.loc.selector.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of `String#split` with empty string or regexp literal argument.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is actually a string. If another class has a `split` method with
+      #   different behavior, it would be registered as a false positive.
+      #
+      # @example
+      #   # bad
+      #   string.split(//)
+      #   string.split('')
+      #
+      #   # good
+      #   string.chars
+      #
+      class StringChars < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `chars` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[split].freeze
+        BAD_ARGUMENTS = %w[// '' ""].freeze
+
+        def on_send(node)
+          return unless node.arguments.one? && BAD_ARGUMENTS.include?(node.first_argument.source)
+
+          range = range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+
+          add_offense(range, message: format(MSG, current: range.source)) do |corrector|
+            corrector.replace(range, 'chars')
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where string concatenation
+      # can be replaced with string interpolation.
+      #
+      # The cop can autocorrect simple cases but will skip autocorrecting
+      # more complex cases where the resulting code would be harder to read.
+      # In those cases, it might be useful to extract statements to local
+      # variables or methods which you can then interpolate in a string.
+      #
+      # NOTE: When concatenation between two strings is broken over multiple
+      # lines, this cop does not register an offense; instead,
+      # `Style/LineEndConcatenation` will pick up the offense if enabled.
+      #
+      # Two modes are supported:
+      # 1. `aggressive` style checks and corrects all occurrences of `+` where
+      # either the left or right side of `+` is a string literal.
+      # 2. `conservative` style on the other hand, checks and corrects only if
+      # left side (receiver of `+` method call) is a string literal.
+      # This is useful when the receiver is some expression that returns string like `Pathname`
+      # instead of a string literal.
+      #
+      # @safety
+      #   This cop is unsafe in `aggressive` mode, as it cannot be guaranteed that
+      #   the receiver is actually a string, which can result in a false positive.
+      #
+      # @example Mode: aggressive (default)
+      #   # bad
+      #   email_with_name = user.name + ' <' + user.email + '>'
+      #   Pathname.new('/') + 'test'
+      #
+      #   # good
+      #   email_with_name = "#{user.name} <#{user.email}>"
+      #   email_with_name = format('%s <%s>', user.name, user.email)
+      #   "#{Pathname.new('/')}test"
+      #
+      #   # accepted, line-end concatenation
+      #   name = 'First' +
+      #     'Last'
+      #
+      # @example Mode: conservative
+      #   # bad
+      #   'Hello' + user.name
+      #
+      #   # good
+      #   "Hello #{user.name}"
+      #   user.name + '!!'
+      #   Pathname.new('/') + 'test'
+      #
+      class StringConcatenation < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer string interpolation to string concatenation.'
+        RESTRICT_ON_SEND = %i[+].freeze
+
+        # @!method string_concatenation?(node)
+        def_node_matcher :string_concatenation?, <<~PATTERN
+          {
+            (send str_type? :+ _)
+            (send _ :+ str_type?)
+          }
+        PATTERN
+
+        def on_new_investigation
+          @corrected_nodes = nil
+        end
+
+        def on_send(node)
+          return unless string_concatenation?(node)
+          return if line_end_concatenation?(node)
+
+          topmost_plus_node = find_topmost_plus_node(node)
+          parts = collect_parts(topmost_plus_node)
+          return if mode == :conservative && !parts.first.str_type?
+
+          register_offense(topmost_plus_node, parts)
+        end
+
+        private
+
+        def register_offense(topmost_plus_node, parts)
+          add_offense(topmost_plus_node) do |corrector|
+            correctable_parts = parts.none? { |part| uncorrectable?(part) }
+            if correctable_parts && !corrected_ancestor?(topmost_plus_node)
+              corrector.replace(topmost_plus_node, replacement(parts))
+
+              @corrected_nodes ||= Set.new.compare_by_identity
+              @corrected_nodes.add(topmost_plus_node)
+            end
+          end
+        end
+
+        def line_end_concatenation?(node)
+          # If the concatenation happens at the end of the line,
+          # and both the receiver and argument are strings, allow
+          # `Style/LineEndConcatenation` to handle it instead.
+          node.receiver.str_type? &&
+            node.first_argument.str_type? &&
+            node.multiline? &&
+            node.source.match?(/\+\s*\n/)
+        end
+
+        def find_topmost_plus_node(node)
+          current = node
+          while (parent = current.parent) && plus_node?(parent)
+            current = parent
+          end
+          current
+        end
+
+        def collect_parts(node, parts = [])
+          return unless node
+
+          if plus_node?(node)
+            collect_parts(node.receiver, parts)
+            collect_parts(node.first_argument, parts)
+          else
+            parts << node
+          end
+        end
+
+        def plus_node?(node)
+          node.send_type? && node.method?(:+)
+        end
+
+        def uncorrectable?(part)
+          part.multiline? || heredoc?(part) || part.each_descendant(:any_block).any?
+        end
+
+        def heredoc?(node)
+          return false unless node.type?(:str, :dstr)
+
+          node.heredoc?
+        end
+
+        def corrected_ancestor?(node)
+          node.each_ancestor(:send).any? { |ancestor| @corrected_nodes&.include?(ancestor) }
+        end
+
+        def replacement(parts)
+          interpolated_parts = parts.map { |part| adjust_str(part) }
+
+          "\"#{handle_quotes(interpolated_parts).join}\""
+        end
+
+        def adjust_str(part)
+          case part.type
+          when :str
+            if single_quoted?(part)
+              part.value.gsub(/(\\|"|#\{|#@|#\$)/, '\\\\\&')
+            else
+              part.value.inspect[1..-2]
+            end
+          when :dstr, :begin
+            part.children.map do |child|
+              adjust_str(child)
+            end.join
+          else
+            "\#{#{part.source}}"
+          end
+        end
+
+        def handle_quotes(parts)
+          parts.map do |part|
+            part == '"' ? '\"' : part
+          end
+        end
+
+        def single_quoted?(str_node)
+          str_node.source.start_with?("'")
+        end
+
+        def mode
+          cop_config['Mode'].to_sym
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the use of strings as keys in hashes. The use of
+      # symbols is preferred instead.
+      #
+      # @safety
+      #   This cop is unsafe because while symbols are preferred for hash keys,
+      #   there are instances when string keys are required.
+      #
+      # @example
+      #   # bad
+      #   { 'one' => 1, 'two' => 2, 'three' => 3 }
+      #
+      #   # good
+      #   { one: 1, two: 2, three: 3 }
+      class StringHashKeys < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer symbols instead of strings as hash keys.'
+
+        # @!method string_hash_key?(node)
+        def_node_matcher :string_hash_key?, <<~PATTERN
+          (pair (str _) _)
+        PATTERN
+
+        # @!method receive_environments_method?(node)
+        def_node_matcher :receive_environments_method?, <<~PATTERN
+          {
+            ^^(send (const {nil? cbase} :IO) :popen ...)
+            ^^(send (const {nil? cbase} :Open3)
+                {:capture2 :capture2e :capture3 :popen2 :popen2e :popen3} ...)
+            ^^^(send (const {nil? cbase} :Open3)
+                {:pipeline :pipeline_r :pipeline_rw :pipeline_start :pipeline_w} ...)
+            ^^(send {nil? (const {nil? cbase} :Kernel)} {:spawn :system} ...)
+            ^^(send _ {:gsub :gsub!} ...)
+          }
+        PATTERN
+
+        def on_pair(node)
+          return unless string_hash_key?(node)
+          return if node.key.heredoc?
+
+          key_content = node.key.str_content
+          return unless key_content.valid_encoding?
+          return if receive_environments_method?(node)
+
+          add_offense(node.key) do |corrector|
+            symbol_content = key_content.to_sym.inspect
+
+            corrector.replace(node.key, symbol_content)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks if uses of quotes match the configured preference.
+      #
+      # @example EnforcedStyle: single_quotes (default)
+      #   # bad
+      #   "No special symbols"
+      #   "No string interpolation"
+      #   "Just text"
+      #
+      #   # good
+      #   'No special symbols'
+      #   'No string interpolation'
+      #   'Just text'
+      #   "Wait! What's #{this}!"
+      #
+      # @example EnforcedStyle: double_quotes
+      #   # bad
+      #   'Just some text'
+      #   'No special chars or interpolation'
+      #
+      #   # good
+      #   "Just some text"
+      #   "No special chars or interpolation"
+      #   "Every string in #{project} uses double_quotes"
+      class StringLiterals < Base
+        include ConfigurableEnforcedStyle
+        include StringLiteralsHelp
+        include StringHelp
+        extend AutoCorrector
+
+        MSG_INCONSISTENT = 'Inconsistent quote style.'
+
+        def on_dstr(node)
+          # Strings which are continued across multiple lines using \
+          # are parsed as a `dstr` node with `str` children
+          # If one part of that continued string contains interpolations,
+          # then it will be parsed as a nested `dstr` node
+          return unless consistent_multiline?
+          return if node.heredoc?
+
+          children = node.children
+          return unless all_string_literals?(children)
+
+          quote_styles = detect_quote_styles(node)
+
+          if quote_styles.size > 1
+            register_offense(node, message: MSG_INCONSISTENT)
+          else
+            check_multiline_quote_style(node, quote_styles[0])
+          end
+
+          ignore_node(node)
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          StringLiteralCorrector.correct(corrector, node, style)
+        end
+
+        def register_offense(node, message: nil)
+          add_offense(node, message: message || message(node)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def all_string_literals?(nodes)
+          nodes.all? { |n| n.type?(:str, :dstr) }
+        end
+
+        def detect_quote_styles(node)
+          styles = node.children.map { |c| c.loc.begin }
+
+          # For multi-line strings that only have quote marks
+          # at the beginning of the first line and the end of
+          # the last, the begin and end region of each child
+          # is nil. The quote marks are in the parent node.
+          return [node.loc.begin.source] if styles.all?(&:nil?)
+
+          styles.map(&:source).uniq
+        end
+
+        def message(_node)
+          if style == :single_quotes
+            "Prefer single-quoted strings when you don't need string " \
+              'interpolation or special symbols.'
+          else
+            'Prefer double-quoted strings unless you need single quotes to ' \
+              'avoid extra backslashes for escaping.'
+          end
+        end
+
+        def offense?(node)
+          wrong_quotes?(node) && !inside_interpolation?(node)
+        end
+
+        def consistent_multiline?
+          cop_config['ConsistentQuotesInMultiline']
+        end
+
+        def check_multiline_quote_style(node, quote)
+          children = node.children
+          if unexpected_single_quotes?(quote)
+            all_children_with_quotes = children.all? { |c| wrong_quotes?(c) }
+            register_offense(node) if all_children_with_quotes
+          elsif unexpected_double_quotes?(quote) && !accept_child_double_quotes?(children)
+            register_offense(node)
+          end
+        end
+
+        def unexpected_single_quotes?(quote)
+          quote == "'" && style == :double_quotes
+        end
+
+        def unexpected_double_quotes?(quote)
+          quote == '"' && style == :single_quotes
+        end
+
+        def accept_child_double_quotes?(nodes)
+          nodes.any? { |n| n.dstr_type? || double_quotes_required?(n.source) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks that quotes inside string, symbol, and regexp interpolations
+      # match the configured preference.
+      #
+      # @example EnforcedStyle: single_quotes (default)
+      #   # bad
+      #   string = "Tests #{success ? "PASS" : "FAIL"}"
+      #   symbol = :"Tests #{success ? "PASS" : "FAIL"}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? "PASS" : "FAIL"}
+      #   TEXT
+      #   regexp = /Tests #{success ? "PASS" : "FAIL"}/
+      #
+      #   # good
+      #   string = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   symbol = :"Tests #{success ? 'PASS' : 'FAIL'}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? 'PASS' : 'FAIL'}
+      #   TEXT
+      #   regexp = /Tests #{success ? 'PASS' : 'FAIL'}/
+      #
+      # @example EnforcedStyle: double_quotes
+      #   # bad
+      #   string = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   symbol = :"Tests #{success ? 'PASS' : 'FAIL'}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? 'PASS' : 'FAIL'}
+      #   TEXT
+      #   regexp = /Tests #{success ? 'PASS' : 'FAIL'}/
+      #
+      #   # good
+      #   string = "Tests #{success ? "PASS" : "FAIL"}"
+      #   symbol = :"Tests #{success ? "PASS" : "FAIL"}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? "PASS" : "FAIL"}
+      #   TEXT
+      #   regexp = /Tests #{success ? "PASS" : "FAIL"}/
+      class StringLiteralsInInterpolation < Base
+        include ConfigurableEnforcedStyle
+        include StringLiteralsHelp
+        include StringHelp
+        extend AutoCorrector
+
+        def autocorrect(corrector, node)
+          StringLiteralCorrector.correct(corrector, node, style)
+        end
+
+        # Cop classes that include the StringHelp module usually ignore regexp
+        # nodes. Not so for this cop, which is why we override the on_regexp
+        # definition with an empty one.
+        def on_regexp(node); end
+
+        private
+
+        def message(_node)
+          # single_quotes -> single-quoted
+          kind = style.to_s.sub(/_(.*)s/, '-\1d')
+
+          "Prefer #{kind} strings inside interpolations."
+        end
+
+        def offense?(node)
+          # If it's not a string within an interpolation, then it's not an
+          # offense for this cop.
+          return false unless inside_interpolation?(node)
+
+          wrong_quotes?(node)
+        end
+      end
+    end
+  end
+end