appraisal2 3.1.4 → 3.2.1

data/lib/appraisal/cli.rb

@@ -2,17 +2,27 @@
 
 require "thor"
 require "fileutils"
+require "thread"
 
 module Appraisal
   class CLI < Thor
+    MINIMUM_PARALLEL_BUNDLER_VERSION = Gem::Version.new("2.1.0")
+
     default_task :install
     map ["-v", "--version"] => "version"
+    map "generate-install" => "generate_install"
+    map "generate-update" => "generate_update"
 
     class_option "gem-manager",
       :aliases => "-g",
       :type => :string,
       :default => "bundler",
       :desc => "Gem manager to use for install/update (bundler or ore)"
+    class_option "appraisal-jobs",
+      :aliases => "-n",
+      :type => :numeric,
+      :banner => "SIZE",
+      :desc => "Process appraisals in parallel using the given number of workers."
 
     class << self
       # Override help command to print out usage
@@ -27,7 +37,8 @@ module Appraisal
             appraisal, otherwise it runs the EXTERNAL_COMMAND against all appraisals.
         HELP
 
-        if File.exist?("Appraisals")
+        appraisals_file = ENV["APPRAISAL_FILE"] || "Appraisals"
+        if File.exist?(appraisals_file)
           shell.say
           shell.say("Available Appraisal(s):")
 
@@ -59,7 +70,7 @@ module Appraisal
       :type => :numeric,
       :default => 1,
       :banner => "SIZE",
-      :desc => "Install gems in parallel using the given number of workers."
+      :desc => "Pass the given parallel job count to the selected gem manager."
     method_option "retry",
       :type => :numeric,
       :default => 1,
@@ -78,11 +89,7 @@ module Appraisal
         "Bundler will remember this option."
 
     def install
-      install_options = options.to_h
-      AppraisalFile.each do |appraisal|
-        appraisal.install(install_options)
-        appraisal.relativize
-      end
+      install_appraisals(appraisals, install_options, appraisal_jobs(options))
     end
 
     desc "generate-install", "Generate gemfiles, then resolve and install dependencies for each appraisal"
@@ -91,7 +98,7 @@ module Appraisal
       :type => :numeric,
       :default => 1,
       :banner => "SIZE",
-      :desc => "Install gems in parallel using the given number of workers."
+      :desc => "Pass the given parallel job count to the selected gem manager."
     method_option "retry",
       :type => :numeric,
       :default => 1,
@@ -109,15 +116,14 @@ module Appraisal
       :desc => "Install gems in the specified directory. " \
         "Bundler will remember this option."
     def generate_install
-      invoke(:generate, [], {})
-      invoke(:install, [], options.to_h)
+      appraisal_list = appraisals
+      generate_appraisals(appraisal_list, appraisal_jobs(options))
+      install_appraisals(appraisal_list, install_options, appraisal_jobs(options))
     end
 
     desc "generate", "Generate a gemfile for each appraisal"
     def generate
-      AppraisalFile.each do |appraisal|
-        appraisal.write_gemfile
-      end
+      generate_appraisals(appraisals, appraisal_jobs(options))
     end
 
     desc "clean", "Remove all generated gemfiles and lockfiles from gemfiles folder"
@@ -127,17 +133,14 @@ module Appraisal
 
     desc "update [LIST_OF_GEMS]", "Update dependencies for each generated appraisal gemfile"
     def update(*gems)
-      gem_manager = options["gem-manager"] || options[:gem_manager]
-      update_options = gem_manager ? {:gem_manager => gem_manager} : {}
-      AppraisalFile.each do |appraisal|
-        appraisal.update(gems, update_options)
-      end
+      update_appraisals(appraisals, gems, update_options, appraisal_jobs(options))
     end
 
     desc "generate-update [LIST_OF_GEMS]", "Generate gemfiles, then update dependencies for each appraisal"
     def generate_update(*gems)
-      invoke(:generate, [], {})
-      update(*gems)
+      appraisal_list = appraisals
+      generate_appraisals(appraisal_list, appraisal_jobs(options))
+      update_appraisals(appraisal_list, gems, update_options, appraisal_jobs(options))
     end
 
     desc "list", "List the names of the defined appraisals"
@@ -152,7 +155,99 @@ module Appraisal
 
     private
 
+    def appraisals
+      AppraisalFile.new.appraisals
+    end
+
+    def generate_appraisals(appraisal_list, jobs)
+      each_appraisal(appraisal_list, jobs) do |appraisal|
+        appraisal.write_gemfile
+      end
+    end
+
+    def install_appraisals(appraisal_list, install_options, jobs)
+      each_appraisal(appraisal_list, jobs) do |appraisal|
+        appraisal.install(install_options.dup)
+        appraisal.relativize
+      end
+    end
+
+    def update_appraisals(appraisal_list, gems, update_options, jobs)
+      each_appraisal(appraisal_list, jobs) do |appraisal|
+        appraisal.update(gems, update_options.dup)
+      end
+    end
+
+    def each_appraisal(appraisal_list, jobs)
+      jobs = worker_count(jobs, appraisal_list.length)
+      return appraisal_list.each { |appraisal| yield(appraisal) } if jobs <= 1
+
+      queue = Queue.new
+      errors = []
+      mutex = Mutex.new
+
+      appraisal_list.each { |appraisal| queue << appraisal }
+      jobs.times { queue << nil }
+
+      # rubocop:disable ThreadSafety/NewThread
+      threads = Array.new(jobs) do
+        Thread.new do
+          while (appraisal = queue.pop)
+            begin
+              yield(appraisal)
+            rescue Exception => error # rubocop:disable Lint/RescueException
+              mutex.synchronize { errors << error }
+            end
+          end
+        end
+      end
+      # rubocop:enable ThreadSafety/NewThread
+      threads.each(&:join)
+
+      raise errors.first unless errors.empty?
+    end
+
+    def worker_count(jobs, item_count)
+      jobs = jobs.to_i
+      jobs = 1 if jobs < 1
+      jobs = 1 unless parallel_appraisals_supported?
+      return jobs if item_count.zero?
+
+      [jobs, item_count].min
+    end
+
+    def parallel_appraisals_supported?
+      # Parallel install/update workers depend on Appraisal::Command being able
+      # to build independent Bundler subprocess environments. Bundler 2.1 is the
+      # floor for the modern original_env/unbundled_env API split that replaced
+      # clean_env, so older Bundler versions keep the historical serial path.
+      bundler_version = Gem::Specification.find_all_by_name("bundler").map(&:version).max
+      return false unless bundler_version
+
+      bundler_version >= MINIMUM_PARALLEL_BUNDLER_VERSION
+    end
+
+    def appraisal_jobs(command_options)
+      command_options["appraisal-jobs"] || command_options[:appraisal_jobs] || ENV["APPRAISAL_JOBS"] || 2
+    end
+
+    def install_options
+      options.to_h.reject { |key, _value| key.to_s == "appraisal-jobs" }
+    end
+
+    def update_options
+      gem_manager = options["gem-manager"] || options[:gem_manager]
+      gem_manager ? {:gem_manager => gem_manager} : {}
+    end
+
     def method_missing(name, *args)
+      case name.to_s
+      when "generate-install"
+        return generate_install
+      when "generate-update"
+        return generate_update(*args)
+      end
+
       matching_appraisal = AppraisalFile.new.appraisals.detect do |appraisal|
         appraisal.name == name.to_s
       end
@@ -213,7 +308,7 @@ module Appraisal
           Command.new(actual_args, :gemfile => matching_appraisal.gemfile_path).run
         end
       else
-        AppraisalFile.each do |appraisal|
+        each_appraisal(AppraisalFile.new.appraisals, appraisal_jobs(options)) do |appraisal|
           Command.new(ARGV, :gemfile => appraisal.gemfile_path).run
         end
       end
@@ -240,6 +335,17 @@ module Appraisal
           options[:jobs] = Regexp.last_match(1).to_i
         when /^-j(\d+)$/
           options[:jobs] = Regexp.last_match(1).to_i
+        when /^-j$/
+          options[:jobs] = args[index + 1].to_i
+          skip_next = true
+        when /^--appraisal-jobs=\d+$/
+          nil
+        when /^--appraisal-jobs$/
+          skip_next = true
+        when /^-n\d+$/
+          nil
+        when /^-n$/
+          skip_next = true
         when /^--retry=(\d+)$/
           options[:retry] = Regexp.last_match(1).to_i
         when /^--without=(.+)$/
@@ -271,6 +377,10 @@ module Appraisal
           # Next arg should be the value
           options[:gem_manager] = args[index + 1]
           skip_next = true
+        when /^--appraisal-jobs$/
+          skip_next = true
+        when /^-n$/
+          skip_next = true
         when /^-/
           # Other options are not gems, but we don't handle them all here
           # For now, just skip them to be safe if they start with -

data/lib/appraisal/command.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "rbconfig"
 require "shellwords"
 
 module Appraisal
@@ -8,7 +9,9 @@ module Appraisal
     attr_reader :command, :env, :gemfile
 
     # BUNDLE_* environment variables that must be preserved for proper bundler operation
-    # and test isolation. These are preserved when using with_bundler_env to ensure:
+    # and test isolation. These are preserved after starting from Bundler's
+    # unbundled environment so Appraisal can run a fresh Bundler subprocess
+    # without losing the target appraisal and isolation settings:
     # - Bundler version switching works (BUNDLE_GEMFILE)
     # - Test isolation is maintained (BUNDLE_APP_CONFIG, etc.)
     # - User settings are respected (BUNDLE_PATH, BUNDLE_USER_CACHE, etc.)
@@ -30,6 +33,7 @@ module Appraisal
 
     PRESERVED_RUNTIME_VARS = [
       "PATH",
+      "GEM_HOME",
       "GEM_PATH"
     ].freeze
 
@@ -44,101 +48,115 @@ module Appraisal
       run_env = test_environment.merge(env)
 
       if @skip_bundle_exec
-        execute(run_env)
+        execute(ENV.to_h, run_env)
       else
-        # For bundler version switching to work reliably, we need to preserve
-        # the appraisal Gemfile while avoiding the active parent Bundler process.
-        # However, we still need to isolate from the parent's bundler state
-        # to avoid conflicts.
-        #
-        # Solution: Use a selective environment approach instead of with_original_env,
-        # which strips all BUNDLE_* variables and breaks version switching.
-        with_bundler_env do
-          apply_run_env(run_env)
-          ensure_bundler_is_available
-          ensure_locked_bundler_is_available
-          execute(run_env)
-        end
+        clean_env = bundler_env(run_env)
+        ensure_bundler_is_available(clean_env)
+        ensure_locked_bundler_is_available(clean_env)
+        execute(clean_env, run_env)
       end
     end
 
     private
 
-    # Provide a clean environment while preserving Bundler's version switching
-    # inputs and test isolation settings.
+    # Build an Appraisal subprocess environment from Bundler's explicit env APIs.
     #
-    # The current Ruby process has bundler activated, which adds bundler/setup to RUBYOPT.
-    # When we run a subprocess, we need to remove that activation so the subprocess bundler
-    # can start fresh. However, we keep all test isolation variables intact.
-    def with_bundler_env
-      backup_env = ENV.to_h
-
-      begin
-        clean_env = if Bundler.respond_to?(:original_env)
-          Bundler.original_env.to_h
-        else
-          backup_env.to_h
-        end
-
-        # Avoid leaking a global BUNDLE_LOCKFILE into subprocesses.
-        clean_env.delete("BUNDLE_LOCKFILE")
-
-        preserved_vars = PRESERVED_BUNDLE_VARS + PRESERVED_RUNTIME_VARS
-
-        preserved_vars.each do |var|
-          clean_env[var] = backup_env[var] if backup_env[var]
-        end
-
-        # Remove bundler/setup from RUBYOPT so subprocess doesn't auto-load bundler
-        if backup_env["RUBYOPT"]
-          rubyopt = backup_env["RUBYOPT"].split(" ")
-          rubyopt.reject! { |opt| opt == "-rbundler/setup" || opt.include?("bundler/setup") }
-          clean_env["RUBYOPT"] = rubyopt.join(" ") unless rubyopt.empty?
-        end
-
-        # Remove Bundler activation markers from the subprocess environment.
-        # BUNDLE_BIN_PATH pins the already-active Bundler executable, so keeping
-        # it would bypass the BUNDLED WITH version selected below.
-        clean_env.delete("BUNDLE_BIN_PATH")
-        clean_env.delete("BUNDLER_SETUP")
-        clean_env.delete("BUNDLER_VERSION")
-
-        ENV.replace(clean_env)
-
-        yield
-      ensure
-        ENV.replace(backup_env)
+    # Bundler.clean_env / Bundler.with_clean_env are removed. Bundler now exposes
+    # three related but distinct choices:
+    #
+    # - Bundler.original_env: the environment before the current Bundler activated.
+    #   This is too broad for Appraisal because unrelated original BUNDLE_* values
+    #   can leak into the appraisal subprocess.
+    # - Bundler.unbundled_env: original_env with Bundler activation removed. This
+    #   is the right base because it removes parent Bundler state, RUBYOPT
+    #   bundler/setup activation, and arbitrary BUNDLE_* values.
+    # - Bundler.with_unbundled_env: the block form of unbundled_env. Appraisal
+    #   needs a Hash to pass to Kernel.system and must re-add selected variables,
+    #   so the block helper is the wrong shape even though its semantics are close.
+    #
+    # Starting from unbundled_env would normally remove BUNDLE_GEMFILE,
+    # BUNDLE_APP_CONFIG, and related isolation knobs. Appraisal intentionally
+    # reintroduces only the variables it owns or must preserve, then sets
+    # BUNDLE_GEMFILE and the selected Bundler version for the target subprocess.
+    def bundler_env(run_env)
+      current_env = ENV.to_h
+      clean_env = if defined?(Bundler) && Bundler.respond_to?(:unbundled_env)
+        Bundler.unbundled_env.to_h
+      elsif defined?(Bundler) && Bundler.respond_to?(:original_env)
+        Bundler.original_env.to_h
+      else
+        current_env.to_h
       end
-    end
 
-    def execute(run_env)
-      announce
+      # Avoid leaking a global BUNDLE_LOCKFILE into subprocesses.
+      clean_env["BUNDLE_LOCKFILE"] = nil
+
+      preserved_vars = PRESERVED_BUNDLE_VARS + PRESERVED_RUNTIME_VARS
+
+      preserved_vars.each do |var|
+        clean_env[var] = current_env[var] if current_env[var]
+      end
+
+      clean_env["RUBYOPT"] = current_env["RUBYOPT"] if current_env["RUBYOPT"]
 
-      ENV["BUNDLE_GEMFILE"] = gemfile
-      if (bundler_version = locked_bundler_version)
-        ENV["BUNDLER_VERSION"] = bundler_version
+      # Remove bundler/setup from RUBYOPT so subprocess doesn't auto-load bundler.
+      # Bundler.original_env can also contain RUBYOPT, so strip from the final
+      # command environment rather than only from the active process env.
+      if clean_env["RUBYOPT"]
+        rubyopt = clean_env["RUBYOPT"].split(" ")
+        rubyopt.reject! { |opt| opt == "-rbundler/setup" || opt.include?("bundler/setup") }
+        clean_env["RUBYOPT"] = rubyopt.join(" ")
+        clean_env["RUBYOPT"] = nil if clean_env["RUBYOPT"].empty?
       end
-      ENV["APPRAISAL_INITIALIZED"] = "1"
+
+      # Remove Bundler activation markers from the subprocess environment.
+      # BUNDLE_BIN_PATH pins the already-active Bundler executable, so keeping
+      # it would bypass the BUNDLED WITH version selected below.
+      clean_env["BUNDLE_BIN_PATH"] = nil
+      clean_env["BUNDLE_VERSION"] = nil
+      clean_env["BUNDLER_SETUP"] = nil
+      clean_env["BUNDLER_VERSION"] = nil
+
       run_env.each_pair do |key, value|
-        ENV[key] = value
+        clean_env[key] = value
       end
 
-      exit(1) unless Kernel.system(command_as_string)
+      clean_env["RUBYLIB"] = nil
+
+      clean_env
     end
 
-    def apply_run_env(run_env)
-      run_env.each_pair do |key, value|
-        ENV[key] = value
+    def execute(base_env, run_env)
+      process_env = base_env.merge(run_env)
+      process_env["BUNDLE_GEMFILE"] = gemfile if gemfile
+      bundler_version = subprocess_bundler_version(process_env)
+      announce
+      command_text = command_as_string(:bundler_version => bundler_version)
+      if bundler_version
+        process_env["BUNDLE_VERSION"] = bundler_version
+        process_env["BUNDLER_VERSION"] = bundler_version
       end
+      process_env["APPRAISAL_INITIALIZED"] = "1"
+
+      exit(1) unless Kernel.system(process_env, command_text)
     end
 
-    def ensure_bundler_is_available
-      # Check if any version of bundler is available
-      return if system(%(gem list --silent -i bundler))
+    def ensure_bundler_is_available(process_env)
+      rubygems_env = rubygems_command_env(process_env)
+
+      # First ask the actual Bundler executable whether it can boot in the
+      # environment Appraisal is about to use. In CI, especially on alternate
+      # Ruby engines, Bundler may be available through the active app bundle
+      # while a manually scrubbed RubyGems spec lookup cannot see it through the
+      # current GEM_HOME/GEM_PATH.
+      return if system(process_env, "bundle -v > /dev/null 2>&1")
+
+      # Check if any version of bundler is available through RubyGems.
+      return if system(rubygems_env, bundler_available_command)
 
       puts ">> Bundler not found, attempting to install..."
       # If that fails, try to install the latest stable version
-      return if system("gem install bundler")
+      return if system(rubygems_env, "ruby --disable=gems -S gem install bundler")
 
       puts
       puts <<-ERROR.rstrip
@@ -150,14 +168,16 @@ manually.
       exit(1)
     end
 
-    def ensure_locked_bundler_is_available
+    def ensure_locked_bundler_is_available(process_env)
       locked_version = locked_bundler_version
       return unless locked_version
 
-      return if system(%(gem list --silent -i bundler -v "#{locked_version}"))
+      rubygems_env = rubygems_command_env(process_env)
+
+      return if system(rubygems_env, bundler_available_command(locked_version))
 
       puts ">> Bundler #{locked_version} not found, attempting to install..."
-      return if system("gem install bundler -v #{Shellwords.escape(locked_version)} --no-document")
+      return if system(rubygems_env, "ruby --disable=gems -S gem install bundler -v #{Shellwords.escape(locked_version)} --no-document")
 
       puts
       puts <<-ERROR.rstrip
@@ -180,11 +200,42 @@ manually.
       match && match[1]
     end
 
-    def announce
+    def subprocess_bundler_version(process_env)
+      # Production subprocesses pin Bundler only when the appraisal lockfile
+      # says to. Acceptance specs may provide APPRAISAL_TEST_BUNDLER_VERSION so
+      # the nested subprocesses use the same isolated Bundler selected by the
+      # harness, without changing production behavior.
+      locked_bundler_version || process_env["APPRAISAL_TEST_BUNDLER_VERSION"]
+    end
+
+    def rubygems_command_env(process_env)
+      process_env.dup.tap do |env|
+        env["BUNDLE_APP_CONFIG"] = nil
+        env["BUNDLE_BIN_PATH"] = nil
+        env["BUNDLE_GEMFILE"] = nil
+        env["BUNDLE_LOCKFILE"] = nil
+        env["BUNDLE_VERSION"] = nil
+        env["BUNDLER_SETUP"] = nil
+        env["BUNDLER_VERSION"] = nil
+        env["RUBYOPT"] = nil
+      end
+    end
+
+    def bundler_available_command(version = nil)
+      requirement = version ? ", Gem::Requirement.new(#{version.inspect})" : ""
+      code = <<-RUBY.chomp
+        require "rubygems"
+        specs = Gem::Specification.find_all_by_name("bundler"#{requirement})
+        exit(specs.empty? ? 1 : 0)
+      RUBY
+      "ruby --disable=gems -e #{Shellwords.escape(code)}"
+    end
+
+    def announce(command_text = command_as_string)
       if gemfile
-        puts ">> BUNDLE_GEMFILE=#{gemfile} #{command_as_string}"
+        puts ">> BUNDLE_GEMFILE=#{gemfile} #{command_text}"
       else
-        puts ">> #{command_as_string}"
+        puts ">> #{command_text}"
       end
     end
 
@@ -206,12 +257,20 @@ manually.
       end
     end
 
-    def command_as_string
-      if command.is_a?(Array)
+    def command_as_string(bundler_version: nil)
+      command_text = if command.is_a?(Array)
         Shellwords.join(command)
       else
         command
       end
+      return command_text unless bundler_version
+
+      command_text.gsub(/\bbundle(?=\s)/) { versioned_bundler_command(bundler_version) }
+    end
+
+    def versioned_bundler_command(version)
+      script = %(gem "bundler", #{version.inspect}; load Gem.bin_path("bundler", "bundle"))
+      Shellwords.join([RbConfig.ruby, "-e", script])
     end
 
     def test_environment
@@ -219,7 +278,7 @@ manually.
 
       {
         "GEM_HOME" => ENV["GEM_HOME"],
-        "GEM_PATH" => ""
+        "GEM_PATH" => ENV["APPRAISAL_TEST_SYSTEM_GEM_PATH"].to_s
       }
     end
   end

data/lib/appraisal/gem_manager/bundler_adapter.rb

@@ -2,6 +2,8 @@
 
 require "shellwords"
 
+require "appraisal/utils"
+
 require_relative "base"
 
 module Appraisal
@@ -53,7 +55,16 @@ module Appraisal
       end
 
       def update_command(gems)
-        ["bundle", "update", *gems].compact
+        gems = Array(gems).compact
+        return full_update_command if gems.empty?
+
+        ["bundle", "update", *gems]
+      end
+
+      def full_update_command
+        return ["bundle", "update", "--all"] if Utils.support_bundle_update_all?
+
+        ["bundle", "update"]
       end
 
       def bundle_options(options)
@@ -85,12 +96,14 @@ module Appraisal
       end
 
       def install_environment(options)
-        env = {}
+        env = {"BUNDLE_JOBS" => DEFAULT_INSTALL_OPTIONS.fetch("jobs").to_s}
 
         if options["path"].nil? && Bundler.settings[:path]
           env["BUNDLE_DISABLE_SHARED_GEMS"] = "1"
         end
 
+        env["BUNDLE_JOBS"] = options["jobs"].to_s if options["jobs"].to_i > 1 && Utils.support_parallel_installation?
+
         env
       end
     end

data/lib/appraisal/utils.rb

@@ -12,6 +12,10 @@ module Appraisal
         Gem::Version.create(Bundler::VERSION) > Gem::Version.create("2.4.22")
       end
 
+      def support_bundle_update_all?
+        Gem::Version.create(Bundler::VERSION) >= Gem::Version.create("1.16.5")
+      end
+
       # Appraisal needs to print Gemfiles in the oldest Ruby syntax that is supported by Appraisal.
       # Otherwise, a project would not be able to use Appraisal to test compatibility
       #   with older versions of Ruby, which is a core use case for Appraisal.

data/lib/appraisal/version.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
 module Appraisal
+  # Version namespace for this gem.
   module Version
-    VERSION = "3.1.4"
+    # Current gem version.
+    VERSION = "3.2.1"
   end
-  VERSION = Version::VERSION # Traditional constant location
+  # Current gem version exposed at the traditional constant location.
+  VERSION = Version::VERSION # Traditional Constant Location
 end

data/lib/appraisal.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "appraisal/version"
+
 # simplecov:disable
 require "appraisal2"
 # simplecov:enable

data/lib/appraisal2.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "appraisal2/version"
-
 require "appraisal/version"
 require "appraisal/task"