@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-4

package/lib/ruby/3.4.11/bundler/cli/outdated.rb

@@ -1,297 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Outdated
-    attr_reader :options, :gems, :options_include_groups, :filter_options_patch, :sources, :strict
-    attr_accessor :outdated_gems
-
-    def initialize(options, gems)
-      @options = options
-      @gems = gems
-      @sources = Array(options[:source])
-
-      @filter_options_patch = options.keys & %w[filter-major filter-minor filter-patch]
-
-      @outdated_gems = []
-
-      @options_include_groups = [:group, :groups].any? do |v|
-        options.keys.include?(v.to_s)
-      end
-
-      # the patch level options imply strict is also true. It wouldn't make
-      # sense otherwise.
-      @strict = options["filter-strict"] || Bundler::CLI::Common.patch_level_options(options).any?
-    end
-
-    def run
-      check_for_deployment_mode!
-
-      Bundler.definition.validate_runtime!
-      current_specs = Bundler.ui.silence { Bundler.definition.resolve }
-
-      gems.each do |gem_name|
-        if current_specs[gem_name].empty?
-          raise GemNotFound, "Could not find gem '#{gem_name}'."
-        end
-      end
-
-      current_dependencies = Bundler.ui.silence do
-        Bundler.load.dependencies.map {|dep| [dep.name, dep] }.to_h
-      end
-
-      definition = if gems.empty? && sources.empty?
-        # We're doing a full update
-        Bundler.definition(true)
-      else
-        Bundler.definition(gems: gems, sources: sources)
-      end
-
-      Bundler::CLI::Common.configure_gem_version_promoter(
-        Bundler.definition,
-        options.merge(strict: @strict)
-      )
-
-      definition_resolution = proc do
-        options[:local] ? definition.resolve_with_cache! : definition.resolve_remotely!
-      end
-
-      if options[:parseable]
-        Bundler.ui.progress(&definition_resolution)
-      else
-        definition_resolution.call
-      end
-
-      Bundler.ui.info ""
-
-      # Loop through the current specs
-      gemfile_specs, dependency_specs = current_specs.partition do |spec|
-        current_dependencies.key? spec.name
-      end
-
-      specs = if options["only-explicit"]
-        gemfile_specs
-      else
-        gemfile_specs + dependency_specs
-      end
-
-      specs.sort_by(&:name).uniq(&:name).each do |current_spec|
-        next unless gems.empty? || gems.include?(current_spec.name)
-
-        active_spec = retrieve_active_spec(definition, current_spec)
-        next unless active_spec
-
-        next unless filter_options_patch.empty? || update_present_via_semver_portions(current_spec, active_spec, options)
-
-        gem_outdated = Gem::Version.new(active_spec.version) > Gem::Version.new(current_spec.version)
-        next unless gem_outdated || (current_spec.git_version != active_spec.git_version)
-
-        dependency = current_dependencies[current_spec.name]
-        groups = ""
-        if dependency && !options[:parseable]
-          groups = dependency.groups.join(", ")
-        end
-
-        outdated_gems << {
-          active_spec: active_spec,
-          current_spec: current_spec,
-          dependency: dependency,
-          groups: groups,
-        }
-      end
-
-      relevant_outdated_gems = if options_include_groups
-        outdated_gems.group_by {|g| g[:groups] }.sort.flat_map do |groups, gems|
-          contains_group = groups.split(", ").include?(options[:group])
-          next unless options[:groups] || contains_group
-
-          gems
-        end.compact
-      else
-        outdated_gems
-      end
-
-      if relevant_outdated_gems.empty?
-        unless options[:parseable]
-          Bundler.ui.info(nothing_outdated_message)
-        end
-      else
-        if options[:parseable]
-          print_gems(relevant_outdated_gems)
-        else
-          print_gems_table(relevant_outdated_gems)
-        end
-
-        exit 1
-      end
-    end
-
-    private
-
-    def loaded_from_for(spec)
-      return unless spec.respond_to?(:loaded_from)
-
-      spec.loaded_from
-    end
-
-    def groups_text(group_text, groups)
-      "#{group_text}#{groups.split(",").size > 1 ? "s" : ""} \"#{groups}\""
-    end
-
-    def nothing_outdated_message
-      if filter_options_patch.any?
-        display = filter_options_patch.map do |o|
-          o.sub("filter-", "")
-        end.join(" or ")
-
-        "No #{display} updates to display.\n"
-      else
-        "Bundle up to date!\n"
-      end
-    end
-
-    def retrieve_active_spec(definition, current_spec)
-      active_spec = definition.resolve.find_by_name_and_platform(current_spec.name, current_spec.platform)
-      return unless active_spec
-
-      return active_spec if strict
-
-      active_specs = active_spec.source.specs.search(current_spec.name).select {|spec| spec.match_platform(current_spec.platform) }.sort_by(&:version)
-      if !current_spec.version.prerelease? && !options[:pre] && active_specs.size > 1
-        active_specs.delete_if {|b| b.respond_to?(:version) && b.version.prerelease? }
-      end
-      active_specs.last
-    end
-
-    def print_gems(gems_list)
-      gems_list.each do |gem|
-        print_gem(
-          gem[:current_spec],
-          gem[:active_spec],
-          gem[:dependency],
-          gem[:groups],
-        )
-      end
-    end
-
-    def print_gems_table(gems_list)
-      data = gems_list.map do |gem|
-        gem_column_for(
-          gem[:current_spec],
-          gem[:active_spec],
-          gem[:dependency],
-          gem[:groups],
-        )
-      end
-
-      print_indented([table_header] + data)
-    end
-
-    def print_gem(current_spec, active_spec, dependency, groups)
-      spec_version = "#{active_spec.version}#{active_spec.git_version}"
-      if Bundler.ui.debug?
-        loaded_from = loaded_from_for(active_spec)
-        spec_version += " (from #{loaded_from})" if loaded_from
-      end
-      current_version = "#{current_spec.version}#{current_spec.git_version}"
-
-      if dependency&.specific?
-        dependency_version = %(, requested #{dependency.requirement})
-      end
-
-      spec_outdated_info = "#{active_spec.name} (newest #{spec_version}, " \
-        "installed #{current_version}#{dependency_version})"
-
-      output_message = if options[:parseable]
-        spec_outdated_info.to_s
-      elsif options_include_groups || groups.empty?
-        "  * #{spec_outdated_info}"
-      else
-        "  * #{spec_outdated_info} in #{groups_text("group", groups)}"
-      end
-
-      Bundler.ui.info output_message.rstrip
-    end
-
-    def gem_column_for(current_spec, active_spec, dependency, groups)
-      current_version = "#{current_spec.version}#{current_spec.git_version}"
-      spec_version = "#{active_spec.version}#{active_spec.git_version}"
-      dependency = dependency.requirement if dependency
-
-      ret_val = [active_spec.name, current_version, spec_version, dependency.to_s, groups.to_s]
-      ret_val << loaded_from_for(active_spec).to_s if Bundler.ui.debug?
-      ret_val
-    end
-
-    def check_for_deployment_mode!
-      return unless Bundler.frozen_bundle?
-      suggested_command = if Bundler.settings.locations("frozen").keys.&([:global, :local]).any?
-        "bundle config unset frozen"
-      elsif Bundler.settings.locations("deployment").keys.&([:global, :local]).any?
-        "bundle config unset deployment"
-      end
-      raise ProductionError, "You are trying to check outdated gems in " \
-        "deployment mode. Run `bundle outdated` elsewhere.\n" \
-        "\nIf this is a development machine, remove the " \
-        "#{Bundler.default_gemfile} freeze" \
-        "\nby running `#{suggested_command}`."
-    end
-
-    def update_present_via_semver_portions(current_spec, active_spec, options)
-      current_major = current_spec.version.segments.first
-      active_major = active_spec.version.segments.first
-
-      update_present = false
-      update_present = active_major > current_major if options["filter-major"]
-
-      if !update_present && (options["filter-minor"] || options["filter-patch"]) && current_major == active_major
-        current_minor = get_version_semver_portion_value(current_spec, 1)
-        active_minor = get_version_semver_portion_value(active_spec, 1)
-
-        update_present = active_minor > current_minor if options["filter-minor"]
-
-        if !update_present && options["filter-patch"] && current_minor == active_minor
-          current_patch = get_version_semver_portion_value(current_spec, 2)
-          active_patch = get_version_semver_portion_value(active_spec, 2)
-
-          update_present = active_patch > current_patch
-        end
-      end
-
-      update_present
-    end
-
-    def get_version_semver_portion_value(spec, version_portion_index)
-      version_section = spec.version.segments[version_portion_index, 1]
-      version_section.to_a[0].to_i
-    end
-
-    def print_indented(matrix)
-      header = matrix[0]
-      data = matrix[1..-1]
-
-      column_sizes = Array.new(header.size) do |index|
-        matrix.max_by {|row| row[index].length }[index].length
-      end
-
-      Bundler.ui.info justify(header, column_sizes)
-
-      data.sort_by! {|row| row[0] }
-
-      data.each do |row|
-        Bundler.ui.info justify(row, column_sizes)
-      end
-    end
-
-    def table_header
-      header = ["Gem", "Current", "Latest", "Requested", "Groups"]
-      header << "Path" if Bundler.ui.debug?
-      header
-    end
-
-    def justify(row, sizes)
-      row.each_with_index.map do |element, index|
-        element.ljust(sizes[index])
-      end.join("  ").strip + "\n"
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/platform.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Platform
-    attr_reader :options
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      ruby_version = if Bundler.locked_gems
-        Bundler.locked_gems.ruby_version&.gsub(/p\d+\Z/, "")
-      else
-        Bundler.definition.ruby_version&.single_version_string
-      end
-
-      output = []
-
-      if options[:ruby]
-        if ruby_version
-          output << ruby_version
-        else
-          output << "No ruby version specified"
-        end
-      else
-        platforms = Bundler.definition.platforms.map {|p| "* #{p}" }
-
-        output << "Your platform is: #{Gem::Platform.local}"
-        output << "Your app has gems that work on these platforms:\n#{platforms.join("\n")}"
-
-        if ruby_version
-          output << "Your Gemfile specifies a Ruby version requirement:\n* #{ruby_version}"
-
-          begin
-            Bundler.definition.validate_runtime!
-            output << "Your current platform satisfies the Ruby version requirement."
-          rescue RubyVersionMismatch => e
-            output << e.message
-          end
-        else
-          output << "Your Gemfile does not specify a Ruby version requirement."
-        end
-      end
-
-      Bundler.ui.info output.join("\n\n")
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/plugin.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../vendored_thor"
-module Bundler
-  class CLI::Plugin < Thor
-    desc "install PLUGINS", "Install the plugin from the source"
-    long_desc <<-D
-      Install plugins either from the rubygems source provided (with --source option), from a git source provided with --git, or a local path provided with --path. If no sources are provided, it uses Gem.sources
-   D
-    method_option "source", type: :string, default: nil, banner: "URL of the RubyGems source to fetch the plugin from"
-    method_option "version", type: :string, default: nil, banner: "The version of the plugin to fetch"
-    method_option "git", type: :string, default: nil, banner: "URL of the git repo to fetch from"
-    method_option "local_git", type: :string, default: nil, banner: "Path of the local git repo to fetch from (deprecated)"
-    method_option "branch", type: :string, default: nil, banner: "The git branch to checkout"
-    method_option "ref", type: :string, default: nil, banner: "The git revision to check out"
-    method_option "path", type: :string, default: nil, banner: "Path of a local gem to directly use"
-    def install(*plugins)
-      Bundler::Plugin.install(plugins, options)
-    end
-
-    desc "uninstall PLUGINS", "Uninstall the plugins"
-    long_desc <<-D
-      Uninstall given list of plugins. To uninstall all the plugins, use -all option.
-    D
-    method_option "all", type: :boolean, default: nil, banner: "Uninstall all the installed plugins. If no plugin is installed, then it does nothing."
-    def uninstall(*plugins)
-      Bundler::Plugin.uninstall(plugins, options)
-    end
-
-    desc "list", "List the installed plugins and available commands"
-    def list
-      Bundler::Plugin.list
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/pristine.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Pristine
-    def initialize(gems)
-      @gems = gems
-    end
-
-    def run
-      CLI::Common.ensure_all_gems_in_lockfile!(@gems)
-      definition = Bundler.definition
-      definition.validate_runtime!
-      installer = Bundler::Installer.new(Bundler.root, definition)
-
-      ProcessLock.lock do
-        installed_specs = definition.specs.reject do |spec|
-          next if spec.name == "bundler" # Source::Rubygems doesn't install bundler
-          next if !@gems.empty? && !@gems.include?(spec.name)
-
-          gem_name = "#{spec.name} (#{spec.version}#{spec.git_version})"
-          gem_name += " (#{spec.platform})" if !spec.platform.nil? && spec.platform != Gem::Platform::RUBY
-
-          case source = spec.source
-          when Source::Rubygems
-            cached_gem = spec.cache_file
-            unless File.exist?(cached_gem)
-              Bundler.ui.error("Failed to pristine #{gem_name}. Cached gem #{cached_gem} does not exist.")
-              next
-            end
-
-            FileUtils.rm_rf spec.full_gem_path
-          when Source::Git
-            if source.local?
-              Bundler.ui.warn("Cannot pristine #{gem_name}. Gem is locally overridden.")
-              next
-            end
-
-            source.remote!
-            if extension_cache_path = source.extension_cache_path(spec)
-              FileUtils.rm_rf extension_cache_path
-            end
-            FileUtils.rm_rf spec.extension_dir
-            FileUtils.rm_rf spec.full_gem_path
-          else
-            Bundler.ui.warn("Cannot pristine #{gem_name}. Gem is sourced from local path.")
-            next
-          end
-
-          true
-        end.map(&:name)
-
-        jobs = installer.send(:installation_parallelization)
-        pristine_count = definition.specs.count - installed_specs.count
-        # allow a pristining a single gem to skip the parallel worker
-        jobs = [jobs, pristine_count].min
-        ParallelInstaller.call(installer, definition.specs, jobs, false, true, skip: installed_specs)
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/remove.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Remove
-    def initialize(gems, options)
-      @gems = gems
-      @options = options
-    end
-
-    def run
-      raise InvalidOption, "Please specify gems to remove." if @gems.empty?
-
-      Injector.remove(@gems, {})
-      Installer.install(Bundler.root, Bundler.definition)
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/show.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Show
-    attr_reader :options, :gem_name, :latest_specs
-    def initialize(options, gem_name)
-      @options = options
-      @gem_name = gem_name
-      @verbose = options[:verbose] || options[:outdated]
-      @latest_specs = fetch_latest_specs if @verbose
-    end
-
-    def run
-      Bundler.ui.silence do
-        Bundler.definition.validate_runtime!
-        Bundler.load.lock
-      end
-
-      if gem_name
-        if gem_name == "bundler"
-          path = File.expand_path("../../..", __dir__)
-        else
-          spec = Bundler::CLI::Common.select_spec(gem_name, :regex_match)
-          return unless spec
-          path = spec.full_gem_path
-          unless File.directory?(path)
-            return Bundler.ui.warn "The gem #{gem_name} is missing. It should be installed at #{path}, but was not found"
-          end
-        end
-        return Bundler.ui.info(path)
-      end
-
-      if options[:paths]
-        Bundler.load.specs.sort_by(&:name).map do |s|
-          Bundler.ui.info s.full_gem_path
-        end
-      else
-        Bundler.ui.info "Gems included by the bundle:"
-        Bundler.load.specs.sort_by(&:name).each do |s|
-          desc = "  * #{s.name} (#{s.version}#{s.git_version})"
-          if @verbose
-            latest = latest_specs.find {|l| l.name == s.name }
-            Bundler.ui.info <<~END
-              #{desc.lstrip}
-              \tSummary:  #{s.summary || "No description available."}
-              \tHomepage: #{s.homepage || "No website available."}
-              \tStatus:   #{outdated?(s, latest) ? "Outdated - #{s.version} < #{latest.version}" : "Up to date"}
-            END
-          else
-            Bundler.ui.info desc
-          end
-        end
-      end
-    end
-
-    private
-
-    def fetch_latest_specs
-      definition = Bundler.definition(true)
-      if options[:outdated]
-        Bundler.ui.info "Fetching remote specs for outdated check...\n\n"
-        Bundler.ui.silence { definition.remotely! }
-      else
-        definition.with_cache!
-      end
-      Bundler.reset!
-      definition.specs
-    end
-
-    def outdated?(current, latest)
-      return false unless latest
-      Gem::Version.new(current.version) < Gem::Version.new(latest.version)
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/update.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Update
-    attr_reader :options, :gems
-    def initialize(options, gems)
-      @options = options
-      @gems = gems
-    end
-
-    def run
-      Bundler.ui.level = "warn" if options[:quiet]
-
-      update_bundler = options[:bundler]
-
-      Bundler.self_manager.update_bundler_and_restart_with_it_if_needed(update_bundler) if update_bundler
-
-      Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.feature_flag.plugins?
-
-      sources = Array(options[:source])
-      groups  = Array(options[:group]).map(&:to_sym)
-
-      full_update = gems.empty? && sources.empty? && groups.empty? && !options[:ruby] && !update_bundler
-
-      if full_update && !options[:all]
-        if Bundler.feature_flag.update_requires_all_flag?
-          raise InvalidOption, "To update everything, pass the `--all` flag."
-        end
-        SharedHelpers.major_deprecation 3, "Pass --all to `bundle update` to update everything"
-      elsif !full_update && options[:all]
-        raise InvalidOption, "Cannot specify --all along with specific options."
-      end
-
-      conservative = options[:conservative]
-
-      if full_update
-        if conservative
-          Bundler.definition(conservative: conservative)
-        else
-          Bundler.definition(true)
-        end
-      else
-        unless Bundler.default_lockfile.exist?
-          raise GemfileLockNotFound, "This Bundle hasn't been installed yet. " \
-            "Run `bundle install` to update and install the bundled gems."
-        end
-        Bundler::CLI::Common.ensure_all_gems_in_lockfile!(gems)
-
-        if groups.any?
-          deps = Bundler.definition.dependencies.select {|d| (d.groups & groups).any? }
-          gems.concat(deps.map(&:name))
-        end
-
-        Bundler.definition(gems: gems, sources: sources, ruby: options[:ruby],
-                           conservative: conservative,
-                           bundler: update_bundler)
-      end
-
-      Bundler::CLI::Common.configure_gem_version_promoter(Bundler.definition, options)
-
-      Bundler::Fetcher.disable_endpoint = options["full-index"]
-
-      opts = options.dup
-      opts["update"] = true
-      opts["local"] = options[:local]
-      opts["force"] = options[:redownload]
-
-      Bundler.settings.set_command_option_if_given :jobs, opts["jobs"]
-
-      Bundler.definition.validate_runtime!
-
-      if locked_gems = Bundler.definition.locked_gems
-        previous_locked_info = locked_gems.specs.reduce({}) do |h, s|
-          h[s.name] = { spec: s, version: s.version, source: s.source.identifier }
-          h
-        end
-      end
-
-      installer = Installer.install Bundler.root, Bundler.definition, opts
-      Bundler.load.cache if Bundler.app_cache.exist?
-
-      if CLI::Common.clean_after_install?
-        require_relative "clean"
-        Bundler::CLI::Clean.new(options).run
-      end
-
-      if locked_gems
-        gems.each do |name|
-          locked_info = previous_locked_info[name]
-          next unless locked_info
-
-          locked_spec = locked_info[:spec]
-          new_spec = Bundler.definition.specs[name].first
-          unless new_spec
-            unless locked_spec.match_platform(Bundler.local_platform)
-              Bundler.ui.warn "Bundler attempted to update #{name} but it was not considered because it is for a different platform from the current one"
-            end
-
-            next
-          end
-
-          locked_source = locked_info[:source]
-          new_source = new_spec.source.identifier
-          next if locked_source != new_source
-
-          new_version = new_spec.version
-          locked_version = locked_info[:version]
-          if new_version < locked_version
-            Bundler.ui.warn "Note: #{name} version regressed from #{locked_version} to #{new_version}"
-          elsif new_version == locked_version
-            Bundler.ui.warn "Bundler attempted to update #{name} but its version stayed the same"
-          end
-        end
-      end
-
-      Bundler.ui.confirm "Bundle updated!"
-      Bundler::CLI::Common.output_without_groups_message(:update)
-      Bundler::CLI::Common.output_post_install_messages installer.post_install_messages
-
-      Bundler::CLI::Common.output_fund_metadata_summary
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/viz.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Viz
-    attr_reader :options, :gem_name
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      # make sure we get the right `graphviz`. There is also a `graphviz`
-      # gem we're not built to support
-      gem "ruby-graphviz"
-      require "graphviz"
-
-      options[:without] = options[:without].join(":").tr(" ", ":").split(":")
-      output_file = File.expand_path(options[:file])
-
-      graph = Graph.new(Bundler.load, output_file, options[:version], options[:requirements], options[:format], options[:without])
-      graph.viz
-    rescue LoadError => e
-      Bundler.ui.error e.inspect
-      Bundler.ui.warn "Make sure you have the graphviz ruby gem. You can install it with:"
-      Bundler.ui.warn "`gem install ruby-graphviz`"
-    rescue StandardError => e
-      raise unless e.message.to_s.include?("GraphViz not installed or dot not in PATH")
-      Bundler.ui.error e.message
-      Bundler.ui.warn "Please install GraphViz. On a Mac with Homebrew, you can run `brew install graphviz`."
-    end
-  end
-end