super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/cop/offense.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # An offense represents a style violation detected by RuboCop.
+    class Offense
+      include Comparable
+
+      # @api private
+      COMPARISON_ATTRIBUTES = %i[line column cop_name message severity].freeze
+
+      # @api public
+      #
+      # @!attribute [r] severity
+      #
+      # @return [RuboCop::Cop::Severity]
+      attr_reader :severity
+
+      # @api public
+      #
+      # @!attribute [r] location
+      #
+      # @return [Parser::Source::Range]
+      #   the location where the violation is detected.
+      #
+      # @see https://www.rubydoc.info/gems/parser/Parser/Source/Range
+      #   Parser::Source::Range
+      attr_reader :location
+
+      # @api public
+      #
+      # @!attribute [r] message
+      #
+      # @return [String]
+      #   human-readable message
+      #
+      # @example
+      #   'Line is too long. [90/80]'
+      attr_reader :message
+
+      # @api public
+      #
+      # @!attribute [r] cop_name
+      #
+      # @return [String]
+      #   the cop name as a String for which this offense is for.
+      #
+      # @example
+      #   'Layout/LineLength'
+      attr_reader :cop_name
+
+      # @api private
+      attr_reader :status
+
+      # @api public
+      #
+      # @!attribute [r] corrector
+      #
+      # @return [Corrector | nil]
+      #   the autocorrection for this offense, or `nil` when not available
+      attr_reader :corrector
+
+      PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
+                                     :end_pos) do
+        alias_method :first_line, :line
+        alias_method :last_line, :line
+        alias_method :last_column, :column
+
+        attr_reader :source_buffer
+
+        def initialize(line, column, source_line, begin_pos, end_pos)
+          super
+          @source_buffer = Parser::Source::Buffer.new('(pseudo)', source: source_line)
+        end
+
+        def column_range
+          column...last_column
+        end
+
+        def size
+          end_pos - begin_pos
+        end
+        alias_method :length, :size
+      end
+      private_constant :PseudoSourceRange
+
+      NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 0).freeze
+
+      # @api private
+      def initialize(severity, location, message, cop_name, # rubocop:disable Metrics/ParameterLists
+                     status = :uncorrected, corrector = nil)
+        @severity = RuboCop::Cop::Severity.new(severity)
+        @location = location
+        @message = message.freeze
+        @cop_name = cop_name.freeze
+        @status = status
+        @corrector = corrector
+        freeze
+      end
+
+      def marshal_dump
+        [@severity, @location, @message, @cop_name, @status]
+      end
+
+      def marshal_load(array)
+        @severity, @location, @message, @cop_name, @status = array
+      end
+
+      # @api public
+      #
+      # @!attribute [r] correctable?
+      #
+      # @return [Boolean]
+      #   whether this offense can be automatically corrected via autocorrect.
+      #   This includes todo comments, for example when requested with `--disable-uncorrectable`.
+      def correctable?
+        @status != :unsupported
+      end
+
+      # @api public
+      #
+      # @!attribute [r] corrected?
+      #
+      # @return [Boolean]
+      #   whether this offense is automatically corrected via
+      #   autocorrect or a todo.
+      def corrected?
+        @status == :corrected || @status == :corrected_with_todo
+      end
+
+      # @api public
+      #
+      # @!attribute [r] corrected_with_todo?
+      #
+      # @return [Boolean]
+      #   whether this offense is automatically disabled via a todo.
+      def corrected_with_todo?
+        @status == :corrected_with_todo
+      end
+
+      # @api public
+      #
+      # @!attribute [r] disabled?
+      #
+      # @return [Boolean]
+      #   whether this offense was locally disabled with a
+      #   disable or todo where it occurred.
+      def disabled?
+        @status == :disabled || @status == :todo
+      end
+
+      # @api public
+      #
+      # @return [Parser::Source::Range]
+      #   the range of the code that is highlighted
+      def highlighted_area
+        source_buffer = Parser::Source::Buffer.new(location.source_buffer.name, source: source_line)
+        Parser::Source::Range.new(source_buffer, column, column + column_length)
+      end
+
+      # @api private
+      # This is just for debugging purpose.
+      def to_s
+        format('%<severity>s:%3<line>d:%3<column>d: %<message>s',
+               severity: severity.code, line: line,
+               column: real_column, message: message)
+      end
+
+      # @api private
+      def line
+        location.line
+      end
+
+      # @api private
+      def column
+        location.column
+      end
+
+      # @api private
+      def source_line
+        location.source_line
+      end
+
+      # @api private
+      def column_length
+        if first_line == last_line
+          column_range.count
+        else
+          source_line.length - column
+        end
+      end
+
+      # @api private
+      def first_line
+        location.first_line
+      end
+
+      # @api private
+      def last_line
+        location.last_line
+      end
+
+      # @api private
+      def last_column
+        location.last_column
+      end
+
+      # @api private
+      def column_range
+        location.column_range
+      end
+
+      # @api private
+      #
+      # Internally we use column number that start at 0, but when
+      # outputting column numbers, we want them to start at 1. One
+      # reason is that editors, such as Emacs, expect this.
+      def real_column
+        column + 1
+      end
+
+      # @api public
+      #
+      # @return [Boolean]
+      #   returns `true` if two offenses contain same attributes
+      def ==(other)
+        COMPARISON_ATTRIBUTES.all? do |attribute|
+          public_send(attribute) == other.public_send(attribute)
+        end
+      end
+
+      alias eql? ==
+
+      def hash
+        COMPARISON_ATTRIBUTES.map { |attribute| public_send(attribute) }.hash
+      end
+
+      # @api public
+      #
+      # Returns `-1`, `0`, or `+1`
+      # if this offense is less than, equal to, or greater than `other`.
+      #
+      # @return [Integer]
+      #   comparison result
+      def <=>(other)
+        COMPARISON_ATTRIBUTES.each do |attribute|
+          result = public_send(attribute) <=> other.public_send(attribute)
+          return result unless result.zero?
+        end
+        0
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/registry.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Error raised when an unqualified cop name is used that could
+    # refer to two or more cops under different departments
+    class AmbiguousCopName < RuboCop::Error
+      MSG = 'Ambiguous cop name `%<name>s` used in %<origin>s needs ' \
+            'department qualifier. Did you mean %<options>s?'
+
+      def initialize(name, origin, badges)
+        super(
+          format(MSG, name: name, origin: origin, options: badges.to_a.join(' or '))
+        )
+      end
+    end
+
+    # Registry that tracks all cops by their badge and department.
+    class Registry # rubocop:disable Metrics/ClassLength
+      include Enumerable
+
+      def self.all
+        global.without_department(:Test).cops
+      end
+
+      def self.qualified_cop_name(name, origin, warn: true)
+        global.qualified_cop_name(name, origin, warn: warn)
+      end
+
+      # Changes momentarily the global registry
+      # Intended for testing purposes
+      def self.with_temporary_global(temp_global = global.dup)
+        previous = @global
+        @global = temp_global
+        yield
+      ensure
+        @global = previous
+      end
+
+      def self.reset!
+        @global = new
+      end
+
+      def self.qualified_cop?(name)
+        badge = Badge.parse(name)
+        global.qualify_badge(badge).first == badge
+      end
+
+      attr_reader :options, :warnings
+
+      def initialize(cops = [], options = {})
+        @departments = Set.new
+        @cops_by_badge = {}
+        @lazy_loaded_cops_by_badge = {}
+
+        @enrollment_queue = cops
+        @options = options
+
+        @enabled_cache = {}.compare_by_identity
+        @disabled_cache = {}.compare_by_identity
+        @warnings = {}
+      end
+
+      def lazy_load(cop_name, constant_name)
+        badge = Badge.parse(cop_name)
+        @departments << badge.department
+        @lazy_loaded_cops_by_badge[badge] = constant_name
+      end
+
+      def enlist(cop)
+        @enrollment_queue << cop
+      end
+
+      def dismiss(cop)
+        raise "Cop #{cop} could not be dismissed" unless @enrollment_queue.delete(cop)
+      end
+
+      # @return [Array<Symbol>] list of departments for current cops.
+      def departments
+        clear_enrollment_queue
+        @departments.to_a
+      end
+
+      # @return [Registry] Cops for that specific department.
+      def with_department(department)
+        with(cops.select { |cop| cop.department == department })
+      end
+
+      # @return [Registry] Cops not for a specific department.
+      def without_department(department)
+        with(cops.reject { |cop| cop.department == department })
+      end
+
+      # @return [Boolean] Checks if given name is department
+      def department?(name)
+        departments.include?(name.to_sym)
+      end
+
+      def contains_cop_matching?(names)
+        cops.any? { |cop| cop.match?(names) }
+      end
+
+      # Convert a user provided cop name into a properly namespaced name
+      #
+      # @example gives back a correctly qualified cop name
+      #
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('Layout/EndOfLine', '') # => 'Layout/EndOfLine'
+      #
+      # @example fixes incorrect namespaces
+      #
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('Lint/EndOfLine', '') # => 'Layout/EndOfLine'
+      #
+      # @example namespaces bare cop identifiers
+      #
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('EndOfLine', '') # => 'Layout/EndOfLine'
+      #
+      # @example passes back unrecognized cop names
+      #
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('NotACop', '') # => 'NotACop'
+      #
+      # @param name [String] Cop name extracted from config
+      # @param path [String, nil] Path of file that `name` was extracted from
+      # @param warn [Boolean] Print a warning if no department given for `name`
+      #
+      # @raise [AmbiguousCopName]
+      #   if a bare identifier with two possible namespaces is provided
+      #
+      # @note Emits a warning if the provided name has an incorrect namespace
+      #
+      # @return [String] Qualified cop name
+      def qualified_cop_name(name, path, warn: true)
+        badge = Badge.parse(name)
+        print_department_missing_warning(name, path) if warn && department_missing?(badge, name)
+        return name if registered?(badge)
+
+        potential_badges = qualify_badge(badge)
+
+        case potential_badges.size
+        when 0 then name # No namespace found. Deal with it later in caller.
+        when 1 then resolve_badge(badge, potential_badges.first, path, warn: warn)
+        else raise AmbiguousCopName.new(badge, path, potential_badges)
+        end
+      end
+
+      def department_missing?(badge, name)
+        !badge.qualified? && unqualified_cop_names.include?(name)
+      end
+
+      def print_department_missing_warning(name, path)
+        message = "no department given for #{name}."
+        if path.end_with?('.rb')
+          message += ' Run `rubocop -a --only Migration/DepartmentName` to fix.'
+        end
+        emit_warning(path, message)
+      end
+
+      def unqualified_cop_names
+        clear_enrollment_queue
+        @unqualified_cop_names ||=
+          (@cops_by_badge.keys | @lazy_loaded_cops_by_badge.keys)
+          .to_set { |badge| File.basename(badge.to_s) } << 'RedundantCopDisableDirective'
+      end
+
+      def qualify_badge(badge)
+        clear_enrollment_queue
+        @departments
+          .map { |department| badge.with_department(department) }
+          .select { |potential_badge| registered?(potential_badge) }
+      end
+
+      # @return [Hash{String => Array<Class>}]
+      def to_h
+        clear_enrollment_queue
+        load_all_lazy_cops
+        @cops_by_badge.to_h { |_badge, cop| [cop.cop_name, [cop]] }
+      end
+
+      def cops
+        clear_enrollment_queue
+        load_all_lazy_cops
+        @cops_by_badge.values
+      end
+
+      def length
+        clear_enrollment_queue
+        @cops_by_badge.size + @lazy_loaded_cops_by_badge.size
+      end
+
+      def enabled(config)
+        @enabled_cache[config] ||= select { |cop| enabled?(cop, config) }
+      end
+
+      def disabled(config)
+        @disabled_cache[config] ||= reject { |cop| enabled?(cop, config) }
+      end
+
+      def enabled?(cop, config)
+        return true if options[:only]&.include?(cop.cop_name)
+
+        # We need to use `cop_name` in this case, because `for_cop` uses caching
+        # which expects cop names or cop classes as keys.
+        cfg = config.for_cop(cop.cop_name)
+
+        cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config)
+
+        if options.fetch(:safe, false)
+          cop_enabled && cfg.fetch('Safe', true)
+        else
+          cop_enabled
+        end
+      end
+
+      def enabled_pending_cop?(cop_cfg, config)
+        return false if @options[:disable_pending_cops]
+
+        cop_cfg.fetch('Enabled') == 'pending' &&
+          (@options[:enable_pending_cops] || config.enabled_new_cops?)
+      end
+
+      def names
+        clear_enrollment_queue
+        @cops_by_badge.keys.map(&:to_s) | @lazy_loaded_cops_by_badge.keys.map(&:to_s)
+      end
+
+      def cops_for_department(department)
+        cops.select { |cop| cop.department == department.to_sym }
+      end
+
+      def names_for_department(department)
+        cops_for_department(department).map(&:cop_name)
+      end
+
+      def ==(other)
+        cops == other.cops
+      end
+
+      def sort!
+        clear_enrollment_queue
+        load_all_lazy_cops
+        @cops_by_badge = @cops_by_badge.sort_by { |badge, _cop| badge.cop_name }.to_h
+
+        self
+      end
+
+      def select(&block)
+        cops.select(&block)
+      end
+
+      def each(&block)
+        cops.each(&block)
+      end
+
+      # @param [String] cop_name
+      # @return [Class, nil]
+      def find_by_cop_name(cop_name)
+        clear_enrollment_queue
+        badge = Badge.parse(cop_name)
+        @cops_by_badge[badge] || load_lazy_cop(badge)
+      end
+
+      # When a cop name is given returns a single-element array with the cop class.
+      # When a department name is given returns an array with all the cop classes
+      # for that department.
+      def find_cops_by_directive(directive)
+        cop = find_by_cop_name(directive)
+        cop ? [cop] : cops_for_department(directive)
+      end
+
+      def freeze
+        clear_enrollment_queue
+        load_all_lazy_cops
+        unqualified_cop_names # build cache
+        super
+      end
+
+      @global = new
+
+      class << self
+        attr_reader :global
+      end
+
+      def warnings?(path)
+        @warnings[path]
+      end
+
+      private
+
+      def initialize_copy(reg)
+        initialize(reg.cops, reg.options)
+      end
+
+      def clear_enrollment_queue
+        return if @enrollment_queue.empty?
+
+        @enrollment_queue.each do |cop|
+          @cops_by_badge[cop.badge] = cop
+          @departments << cop.department
+        end
+        @enrollment_queue = []
+      end
+
+      def load_all_lazy_cops
+        @lazy_loaded_cops_by_badge.each_key { |badge| load_lazy_cop(badge) }
+      end
+
+      def load_lazy_cop(badge)
+        constant_name = @lazy_loaded_cops_by_badge.delete(badge)
+        return unless constant_name
+
+        @cops_by_badge[badge] = Kernel.const_get(constant_name)
+      end
+
+      def with(cops)
+        self.class.new(cops)
+      end
+
+      def resolve_badge(given_badge, real_badge, source_path, warn: true)
+        if warn && !given_badge.match?(real_badge)
+          emit_warning(source_path,
+                       "#{given_badge} has the wrong namespace - " \
+                       "replace it with #{given_badge.with_department(real_badge.department)}")
+        end
+
+        real_badge.to_s
+      end
+
+      def emit_warning(path, message)
+        Registry.global.warnings[path] = true
+        warn "#{PathUtil.smart_path(path)}: Warning: #{message}"
+      end
+
+      def registered?(badge)
+        clear_enrollment_queue
+        @cops_by_badge.key?(badge) || @lazy_loaded_cops_by_badge.key?(badge)
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/security/compound_hash.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # Checks for implementations of the `hash` method which combine
+      # values using custom logic instead of delegating to `Array#hash`.
+      #
+      # Manually combining hashes is error prone and hard to follow, especially
+      # when there are many values. Poor implementations may also introduce
+      # performance or security concerns if they are prone to collisions.
+      # Delegating to `Array#hash` is clearer and safer, although it might be slower
+      # depending on the use case.
+      #
+      # @safety
+      #   This cop may be unsafe if the application logic depends on the hash
+      #   value, however this is inadvisable anyway.
+      #
+      # @example
+      #
+      #   # bad
+      #   def hash
+      #     @foo ^ @bar
+      #   end
+      #
+      #   # good
+      #   def hash
+      #     [@foo, @bar].hash
+      #   end
+      class CompoundHash < Base
+        COMBINATOR_IN_HASH_MSG = 'Use `[...].hash` instead of combining hash values manually.'
+        MONUPLE_HASH_MSG =
+          'Delegate hash directly without wrapping in an array when only using a single value.'
+        REDUNDANT_HASH_MSG = 'Calling .hash on elements of a hashed array is redundant.'
+        RESTRICT_ON_SEND = %i[hash ^ + * |].freeze
+
+        # @!method hash_method_definition?(node)
+        def_node_matcher :hash_method_definition?, <<~PATTERN
+          {#static_hash_method_definition? | #dynamic_hash_method_definition?}
+        PATTERN
+
+        # @!method dynamic_hash_method_definition?(node)
+        def_node_matcher :dynamic_hash_method_definition?, <<~PATTERN
+          (block
+            (send _ {:define_method | :define_singleton_method}
+              (sym :hash))
+            (args)
+            _)
+        PATTERN
+
+        # @!method static_hash_method_definition?(node)
+        def_node_matcher :static_hash_method_definition?, <<~PATTERN
+          ({def | defs _} :hash
+            (args)
+            _)
+        PATTERN
+
+        # @!method bad_hash_combinator?(node)
+        def_node_matcher :bad_hash_combinator?, <<~PATTERN
+          ({send | op-asgn} _ {:^ | :+ | :* | :|} _)
+        PATTERN
+
+        # @!method monuple_hash?(node)
+        def_node_matcher :monuple_hash?, <<~PATTERN
+          (send (array _) :hash)
+        PATTERN
+
+        # @!method redundant_hash?(node)
+        def_node_matcher :redundant_hash?, <<~PATTERN
+          (
+            ^^(send array ... :hash)
+            _ :hash
+          )
+        PATTERN
+
+        def contained_in_hash_method?(node, &block)
+          node.each_ancestor.any? do |ancestor|
+            hash_method_definition?(ancestor, &block)
+          end
+        end
+
+        def outer_bad_hash_combinator?(node)
+          bad_hash_combinator?(node) do
+            yield true if node.each_ancestor.none? { |ancestor| bad_hash_combinator?(ancestor) }
+          end
+        end
+
+        def on_send(node)
+          outer_bad_hash_combinator?(node) do
+            contained_in_hash_method?(node) do
+              add_offense(node, message: COMBINATOR_IN_HASH_MSG)
+            end
+          end
+
+          monuple_hash?(node) do
+            add_offense(node, message: MONUPLE_HASH_MSG)
+          end
+
+          redundant_hash?(node) do
+            add_offense(node, message: REDUNDANT_HASH_MSG)
+          end
+        end
+        alias on_csend on_send
+        alias on_op_asgn on_send
+      end
+    end
+  end
+end