mux_ruby 5.1.0 → 5.2.0

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.92.2/lib/rubocop/unified_diff.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Renders a unified diff between two versions of a file's source.
+  #
+  # RuboCop has no diffing dependency and this output is meant to be read by
+  # people (and occasionally piped into `git apply`), so the goal is a diff
+  # that is correct and readable, not one that matches `diff -u` byte for byte.
+  #
+  # @api private
+  class UnifiedDiff
+    CONTEXT_LINES = 3
+    NO_NEWLINE_MARKER = "\\n"
+
+    # Finding a minimal diff costs time and memory proportional to the square
+    # of the number of edits. Past this many edits the file was rewritten
+    # rather than corrected, so the changed region is reported as a single
+    # replacement instead.
+    MAX_EDIT_DISTANCE = 400
+
+    def initialize(path, old_source, new_source)
+      @path = path
+      @old_lines = old_source.lines
+      @new_lines = new_source.lines
+    end
+
+    # @return [String] the diff, or an empty string when the sources are identical
+    def to_s
+      return '' if @old_lines == @new_lines
+
+      hunks = hunks_for(edit_script)
+      return '' if hunks.empty?
+
+      ["--- a/#{@path}\n", "+++ b/#{@path}\n", *hunks].join
+    end
+
+    private
+
+    def edit_script
+      prefix = common_prefix_length
+      suffix = common_suffix_length(prefix)
+      old_last = @old_lines.length - suffix
+      new_last = @new_lines.length - suffix
+
+      [
+        *@old_lines[0...prefix].map { |line| [:equal, line] },
+        *middle_script(@old_lines[prefix...old_last], @new_lines[prefix...new_last]),
+        *@old_lines[old_last..].map { |line| [:equal, line] }
+      ]
+    end
+
+    def common_prefix_length
+      length = 0
+      length += 1 while length < @old_lines.length && @old_lines[length] == @new_lines[length]
+      length
+    end
+
+    def common_suffix_length(prefix)
+      length = 0
+      max = [@old_lines.length, @new_lines.length].min - prefix
+      while length < max &&
+            @old_lines[@old_lines.length - 1 - length] == @new_lines[@new_lines.length - 1 - length]
+        length += 1
+      end
+      length
+    end
+
+    def middle_script(old_lines, new_lines)
+      # The region that actually differs is diffed on its own, so the rest of
+      # the algorithm works on these two slices rather than the whole file.
+      @from_lines = old_lines
+      @to_lines = new_lines
+
+      myers_script ||
+        [*old_lines.map { |line| [:delete, line] }, *new_lines.map { |line| [:insert, line] }]
+    end
+
+    # Myers' diff algorithm. Each round `d` extends the furthest reaching path
+    # for every diagonal `k`; the first path to reach the end of both sources
+    # is a shortest edit script, which is then reconstructed from the saved
+    # rounds. Returns `nil` when the sources are too different to bother.
+    def myers_script
+      trace = []
+      furthest = Hash.new(0)
+      max_distance = [@from_lines.length + @to_lines.length, MAX_EDIT_DISTANCE].min
+
+      0.upto(max_distance) do |distance|
+        trace << furthest.dup
+
+        (-distance).step(distance, 2) do |diagonal|
+          furthest[diagonal] = advance(furthest, diagonal, distance)
+
+          return backtrack(trace) if reached_end?(furthest[diagonal], diagonal)
+        end
+      end
+
+      nil
+    end
+
+    def reached_end?(old_index, diagonal)
+      old_index >= @from_lines.length && old_index - diagonal >= @to_lines.length
+    end
+
+    # Picks the better of the two paths reaching this diagonal, then follows
+    # the diagonal as far as the lines match.
+    def advance(furthest, diagonal, distance)
+      old_index = start_of_path(furthest, diagonal, distance)
+
+      follow_diagonal(old_index, old_index - diagonal)
+    end
+
+    # A path arrives at this diagonal either from the one above it (having
+    # inserted a line) or the one below it (having deleted one); whichever
+    # reached further wins.
+    def previous_diagonal(furthest, diagonal, distance)
+      if diagonal == -distance ||
+         (diagonal != distance && furthest[diagonal - 1] < furthest[diagonal + 1])
+        diagonal + 1
+      else
+        diagonal - 1
+      end
+    end
+
+    def start_of_path(furthest, diagonal, distance)
+      previous = previous_diagonal(furthest, diagonal, distance)
+
+      previous > diagonal ? furthest[previous] : furthest[previous] + 1
+    end
+
+    # Matching lines cost nothing, so the path slides along them for free.
+    def follow_diagonal(old_index, new_index)
+      while old_index < @from_lines.length && new_index < @to_lines.length &&
+            @from_lines[old_index] == @to_lines[new_index]
+        old_index += 1
+        new_index += 1
+      end
+
+      old_index
+    end
+
+    def backtrack(trace)
+      script = []
+      position = [@from_lines.length, @to_lines.length]
+
+      trace.each_with_index.reverse_each do |furthest, distance|
+        previous = previous_position(furthest, distance, *position)
+        position = walk_diagonal(script, position, previous)
+        next if distance.zero?
+
+        position = record_edit(script, position, previous)
+      end
+
+      script
+    end
+
+    # Both sides step back together for as long as their lines match.
+    def walk_diagonal(script, position, previous)
+      old_index, new_index = position
+
+      while old_index > previous[0] && new_index > previous[1]
+        old_index -= 1
+        new_index -= 1
+        script.unshift([:equal, @from_lines[old_index]])
+      end
+
+      [old_index, new_index]
+    end
+
+    def record_edit(script, position, previous)
+      old_index, new_index = position
+
+      if old_index == previous[0]
+        new_index -= 1
+        script.unshift([:insert, @to_lines[new_index]])
+      else
+        old_index -= 1
+        script.unshift([:delete, @from_lines[old_index]])
+      end
+
+      [old_index, new_index]
+    end
+
+    def previous_position(furthest, distance, old_index, new_index)
+      previous = previous_diagonal(furthest, old_index - new_index, distance)
+      previous_old = furthest[previous]
+
+      [previous_old, previous_old - previous]
+    end
+
+    def hunks_for(script)
+      changed = script.each_index.reject { |index| script[index].first == :equal }
+      return [] if changed.empty?
+
+      ranges_for(changed, script.length).map { |range| hunk(script, range) }
+    end
+
+    # Every change is shown with a few lines of context around it, and changes
+    # whose context would overlap are shown as a single hunk.
+    def ranges_for(changed, script_length)
+      ranges = []
+
+      changed.each do |index|
+        first = [index - CONTEXT_LINES, 0].max
+        last = [index + CONTEXT_LINES, script_length - 1].min
+
+        if ranges.last && first <= ranges.last.last + 1
+          ranges[-1] = (ranges.last.first..last)
+        else
+          ranges << (first..last)
+        end
+      end
+
+      ranges
+    end
+
+    def hunk(script, range)
+      old_start, new_start = start_positions(script, range.first)
+      old_count = script[range].count { |kind, _| kind != :insert }
+      new_count = script[range].count { |kind, _| kind != :delete }
+      body = script[range].map { |kind, line| formatted_line(kind, line) }
+
+      [
+        "@@ -#{position(old_start, old_count)} +#{position(new_start, new_count)} @@\n",
+        *body
+      ].join
+    end
+
+    def start_positions(script, index)
+      old_line = 1
+      new_line = 1
+
+      script[0...index].each do |entry|
+        old_line += 1 unless entry.first == :insert
+        new_line += 1 unless entry.first == :delete
+      end
+
+      [old_line, new_line]
+    end
+
+    # An empty side is anchored to the line it follows, which is how `diff`
+    # reports a pure insertion or deletion, and a single line drops the count.
+    def position(start, count)
+      case count
+      when 0 then "#{start - 1},0"
+      when 1 then start.to_s
+      else "#{start},#{count}"
+      end
+    end
+
+    def formatted_line(kind, line)
+      marker = { equal: ' ', delete: '-', insert: '+' }.fetch(kind)
+      return "#{marker}#{line}" if line.end_with?("\n")
+
+      "#{marker}#{line}\n#{NO_NEWLINE_MARKER}"
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.92.2/lib/rubocop/util.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This module contains a collection of useful utility methods.
+  module Util
+    def self.silence_warnings
+      # Replaces Kernel::silence_warnings since it hides any warnings,
+      # including the RuboCop ones
+      old_verbose = $VERBOSE
+      $VERBOSE = nil
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+
+    # The source as it reads back after `File.write`, which in text mode turns
+    # each LF into CRLF on Windows. Cops like `Layout/EndOfLine` have to see
+    # corrected code that way between correction passes, and so does anything
+    # that compares it with what a write leaves on disk. The final `File.write`
+    # still performs the conversion for the file itself.
+    def self.emulate_write_read_cycle(source)
+      return source unless Platform.windows?
+
+      source.encode(source.encoding, crlf_newline: true)
+    end
+
+    # Replaces the contents of `path` without a window in which the file is truncated
+    # but not yet rewritten, so that an interrupted run or a full disk cannot lose
+    # the original: the new contents are written next to the file and renamed over it,
+    # like `ResultCache#save`. `File.write` is used for the temporary file so text-mode
+    # semantics (the CRLF conversion on Windows) stay identical to a direct write.
+    # Where the temporary file cannot be created or renamed for lack of permission,
+    # a direct write is used as before.
+    def self.replace_file_contents(path, contents)
+      # Write through symlinks so that the rename replaces the real file and
+      # the symlink survives.
+      path = File.realpath(path)
+
+      # Opening a read-only file fails without truncating it, keeping the behavior
+      # a direct write always had.
+      return File.write(path, contents) unless File.writable?(path)
+
+      temp_path = "#{path}.#{Process.pid}.#{rand(1_000_000_000)}.rubocop.tmp"
+      begin
+        replace_via_temporary_file(path, temp_path, contents)
+      ensure
+        FileUtils.rm_f(temp_path)
+      end
+    rescue Errno::ENOENT
+      # The file vanished mid-run or is a dangling symlink: recreate it the way
+      # a direct write always has.
+      File.write(path, contents)
+    end
+
+    def self.replace_via_temporary_file(path, temp_path, contents)
+      # The directory refuses new files even though the file itself is writable,
+      # so a direct write is the only option left.
+      return File.write(path, contents) unless write_temporary_file(temp_path, contents)
+
+      begin
+        # A fresh file would get umask-default permissions on rename;
+        # keep the original's.
+        File.chmod(File.stat(path).mode, temp_path)
+        File.rename(temp_path, path)
+      rescue SystemCallError
+        # The replacement was refused, e.g. the file is open in another process on Windows.
+        # The contents already fit on disk, so a direct write is safe once the temporary copy
+        # no longer takes up that space.
+        FileUtils.rm_f(temp_path)
+        File.write(path, contents)
+      end
+    end
+    private_class_method :replace_via_temporary_file
+
+    # Space errors such as `ENOSPC` must propagate: a direct write would then
+    # truncate the file and fail, which is exactly the loss being avoided.
+    def self.write_temporary_file(temp_path, contents)
+      File.write(temp_path, contents)
+      true
+    rescue Errno::EACCES, Errno::EPERM
+      false
+    end
+    private_class_method :write_temporary_file
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.92.2/lib/rubocop/version.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This module holds the RuboCop version information.
+  module Version
+    STRING = '1.92.2'
+
+    MSG = '%<version>s (using %<parser_version>s, ' \
+          'rubocop-ast %<rubocop_ast_version>s, ' \
+          'analyzing as Ruby %<target_ruby_version>s, ' \
+          'running on %<ruby_engine>s %<ruby_version>s)' \
+          '%<rubydex_indicator>s%<server_mode>s [%<ruby_platform>s]'
+
+    MINIMUM_PARSABLE_PRISM_VERSION = 3.3
+
+    CANONICAL_FEATURE_NAMES = {
+      'Rspec' => 'RSpec', 'Graphql' => 'GraphQL', 'Md' => 'Markdown', 'Factory_bot' => 'FactoryBot',
+      'Thread_safety' => 'ThreadSafety', 'Rspec_rails' => 'RSpecRails'
+    }.freeze
+    EXTENSION_PATH_NAMES = {
+      'rubocop-md' => 'markdown', 'rubocop-factory_bot' => 'factory_bot'
+    }.freeze
+
+    # NOTE: Marked as private but used by gems like standard.
+    # @api private
+    # rubocop:disable-next Metrics/MethodLength
+    def self.version(debug: false, env: nil)
+      if debug
+        target_ruby_version = target_ruby_version(env)
+        verbose_version = format(MSG, version: STRING,
+                                      parser_version: parser_version(target_ruby_version),
+                                      rubocop_ast_version: RuboCop::AST::Version::STRING,
+                                      target_ruby_version: target_ruby_version,
+                                      ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
+                                      rubydex_indicator: rubydex_indicator(env),
+                                      server_mode: server_mode,
+                                      ruby_platform: RUBY_PLATFORM)
+        return verbose_version unless env
+
+        extension_versions = extension_versions(env)
+        return verbose_version if extension_versions.empty?
+
+        <<~VERSIONS
+          #{verbose_version}
+          #{extension_versions.join("\n")}
+        VERSIONS
+      else
+        STRING
+      end
+    end
+
+    # @api private
+    def self.verbose(env: nil)
+      version(debug: true, env: env)
+    end
+
+    # @api private
+    def self.parser_version(target_ruby_version)
+      config_path = ConfigFinder.find_config_path(PathUtil.pwd)
+      yaml = Util.silence_warnings do
+        ConfigLoader.load_yaml_configuration(config_path)
+      end
+      parser_engine = yaml.dig('AllCops', 'ParserEngine')
+      parser_engine_text = ", #{parser_engine}" if parser_engine
+
+      if target_ruby_version >= MINIMUM_PARSABLE_PRISM_VERSION
+        "Parser #{Parser::VERSION}, Prism #{Prism::VERSION}#{parser_engine_text}"
+      else
+        "Parser #{Parser::VERSION}"
+      end
+    end
+
+    # @api private
+    # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def self.extension_versions(env)
+      plugins = config_for_pwd(env).loaded_plugins
+      plugin_versions = plugins.filter_map do |plugin|
+        next if Plugin::BUILTIN_INTERNAL_PLUGINS.key?(plugin.about.name)
+        next unless (plugin_name = plugin.about.name)
+
+        "  - #{plugin_name} #{plugin.about.version}"
+      end
+
+      # TODO: It needs to be maintained for a while to ensure compatibility with extensions that
+      # don't support plugins. It should be removed in future once the old style becomes obsolete.
+      features = config_for_pwd(env).loaded_features.sort
+      features -= plugins.map { |plugin| plugin.about.name }
+      feature_versions = features.filter_map do |loaded_feature|
+        next unless (match = loaded_feature.match(/rubocop-(?<feature>.*)/))
+
+        # Get the expected name of the folder containing the extension code.
+        # Usually it would be the same as the extension name. but sometimes authors
+        # can choose slightly different name for their gems, e.g. rubocop-md instead of
+        # rubocop-markdown.
+        feature = EXTENSION_PATH_NAMES.fetch(loaded_feature, match[:feature])
+
+        begin
+          require "rubocop/#{feature}/version"
+        rescue LoadError
+          # Not worth mentioning libs that are not installed
+        end
+
+        next unless (feature_version = feature_version(feature))
+
+        "  - #{loaded_feature} #{feature_version}"
+      end
+
+      plugin_versions + feature_versions
+    end
+
+    # @api private
+    def self.target_ruby_version(env)
+      if env
+        config_for_pwd(env).target_ruby_version
+      else
+        TargetRuby.new(Config.new).version
+      end
+    end
+
+    # @api private
+    def self.config_for_pwd(env)
+      Util.silence_warnings do
+        # Suppress any config issues when loading the config (ie. deprecations,
+        # pending cops, etc.).
+        env.config_store.unvalidated.for_pwd
+      end
+    end
+
+    # Returns feature version in one of two ways:
+    #
+    # * Find by RuboCop core version style (e.g. rubocop-performance, rubocop-rspec)
+    # * Find by `bundle gem` version style (e.g. rubocop-rake)
+    #
+    # @api private
+    def self.feature_version(feature)
+      capitalized_feature = feature.capitalize
+      extension_name = CANONICAL_FEATURE_NAMES.fetch(capitalized_feature, capitalized_feature)
+
+      # Find by RuboCop core version style (e.g. rubocop-performance, rubocop-rspec)
+      RuboCop.const_get(extension_name)::Version::STRING
+    rescue NameError
+      begin
+        # Find by `bundle gem` version style (e.g. rubocop-rake, rubocop-packaging)
+        RuboCop.const_get(extension_name)::VERSION
+      rescue NameError
+        # noop
+      end
+    end
+
+    # @api private
+    def self.document_version
+      STRING.match('\d+\.\d+').to_s
+    end
+
+    # @api private
+    def self.rubydex_indicator(env)
+      env && rubydex_enabled?(env) && ProjectIndexLoader.available? ? ' +Rubydex' : ''
+    end
+
+    # @api private
+    def self.rubydex_enabled?(env)
+      config_for_pwd(env).for_all_cops['UseProjectIndex']
+    rescue StandardError
+      # Keep `rubocop -V` usable when the config cannot be loaded (broken YAML,
+      # missing `inherit_from` target, etc). It is the first command users run to
+      # diagnose a broken setup, so the indicator just hides rather than letting
+      # the version banner crash.
+      false
+    end
+
+    # @api private
+    def self.server_mode
+      RuboCop.const_defined?(:Server) && Server.running? ? ' +server' : ''
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.92.2/lib/rubocop/yaml_duplication_checker.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Find duplicated keys from YAML.
+  # @api private
+  module YAMLDuplicationChecker
+    def self.check(yaml_string, filename, &on_duplicated)
+      handler = DuplicationCheckHandler.new(&on_duplicated)
+      parser = Psych::Parser.new(handler)
+      parser.parse(yaml_string, filename)
+      parser.handler.root.children[0]
+    end
+
+    class DuplicationCheckHandler < Psych::TreeBuilder # :nodoc:
+      def initialize(&block)
+        super()
+        @block = block
+      end
+
+      def end_mapping
+        mapping_node = super
+        # OPTIMIZE: Use a hash for faster lookup since there can
+        # be quite a few keys at the top-level.
+        keys = {}
+        mapping_node.children.each_slice(2) do |key, _value|
+          duplicate = keys[key.value]
+          @block.call(duplicate, key) if duplicate
+          keys[key.value] = key
+        end
+        mapping_node
+      end
+    end
+  end
+end