toys-core 0.12.2 → 0.13.0

data/lib/toys/utils/exec.rb

@@ -280,7 +280,7 @@ module Toys
       #
       def exec_ruby(args, **opts, &block)
         cmd = args.is_a?(::Array) ? [::RbConfig.ruby] + args : "#{::RbConfig.ruby} #{args}"
-        log_cmd = args.is_a?(::Array) ? ["ruby"] + args : "ruby #{args}"
+        log_cmd = "exec ruby: #{args.inspect}"
         opts = {argv0: "ruby", log_cmd: log_cmd}.merge(opts)
         exec(cmd, **opts, &block)
       end
@@ -396,92 +396,6 @@ module Toys
         exec(cmd, **opts, &block).exit_code
       end
 
-      ##
-      # An internal helper class storing the configuration of a subprocess invocation
-      # @private
-      #
-      class Opts
-        ##
-        # Option keys that belong to exec configuration
-        # @private
-        #
-        CONFIG_KEYS = [
-          :argv0,
-          :background,
-          :cli,
-          :env,
-          :err,
-          :in,
-          :logger,
-          :log_cmd,
-          :log_level,
-          :name,
-          :out,
-          :result_callback,
-        ].freeze
-
-        ##
-        # Option keys that belong to spawn configuration
-        # @private
-        #
-        SPAWN_KEYS = [
-          :chdir,
-          :close_others,
-          :new_pgroup,
-          :pgroup,
-          :umask,
-          :unsetenv_others,
-        ].freeze
-
-        ## @private
-        def initialize(parent = nil)
-          if parent
-            @config_opts = ::Hash.new { |_h, k| parent.config_opts[k] }
-            @spawn_opts = ::Hash.new { |_h, k| parent.spawn_opts[k] }
-          elsif block_given?
-            @config_opts = ::Hash.new { |_h, k| yield k }
-            @spawn_opts = ::Hash.new { |_h, k| yield k }
-          else
-            @config_opts = {}
-            @spawn_opts = {}
-          end
-        end
-
-        ## @private
-        def add(config)
-          config.each do |k, v|
-            if CONFIG_KEYS.include?(k)
-              @config_opts[k] = v
-            elsif SPAWN_KEYS.include?(k) || k.to_s.start_with?("rlimit_")
-              @spawn_opts[k] = v
-            else
-              raise ::ArgumentError, "Unknown key: #{k.inspect}"
-            end
-          end
-          self
-        end
-
-        ## @private
-        def delete(*keys)
-          keys.each do |k|
-            if CONFIG_KEYS.include?(k)
-              @config_opts.delete(k)
-            elsif SPAWN_KEYS.include?(k) || k.to_s.start_with?("rlimit_")
-              @spawn_opts.delete(k)
-            else
-              raise ::ArgumentError, "Unknown key: #{k.inspect}"
-            end
-          end
-          self
-        end
-
-        ## @private
-        attr_reader :config_opts
-
-        ## @private
-        attr_reader :spawn_opts
-      end
-
       ##
       # An object that controls a subprocess. This object is returned from an
       # execution running in the background, or is yielded to a control block
@@ -490,28 +404,6 @@ module Toys
       # send signals to the process, and get its result.
       #
       class Controller
-        ## @private
-        def initialize(name, controller_streams, captures, pid, join_threads,
-                       result_callback, mutex)
-          @name = name
-          @in = controller_streams[:in]
-          @out = controller_streams[:out]
-          @err = controller_streams[:err]
-          @captures = captures
-          @pid = @exception = @wait_thread = nil
-          case pid
-          when ::Integer
-            @pid = pid
-            @wait_thread = ::Process.detach(pid)
-          when ::Exception
-            @exception = pid
-          end
-          @join_threads = join_threads
-          @result_callback = result_callback
-          @mutex = mutex
-          @result = nil
-        end
-
         ##
         # The subcommand's name.
         # @return [Object]
@@ -746,8 +638,33 @@ module Toys
           end
         end
 
+        ##
+        # @private
+        #
+        def initialize(name, controller_streams, captures, pid, join_threads,
+                       result_callback, mutex)
+          @name = name
+          @in = controller_streams[:in]
+          @out = controller_streams[:out]
+          @err = controller_streams[:err]
+          @captures = captures
+          @pid = @exception = @wait_thread = nil
+          case pid
+          when ::Integer
+            @pid = pid
+            @wait_thread = ::Process.detach(pid)
+          when ::Exception
+            @exception = pid
+          end
+          @join_threads = join_threads
+          @result_callback = result_callback
+          @mutex = mutex
+          @result = nil
+        end
+
         ##
         # Close the controller's streams.
+        #
         # @private
         #
         def close_streams(which)
@@ -799,15 +716,6 @@ module Toys
       #     return the numeric signal code.
       #
       class Result
-        ## @private
-        def initialize(name, out, err, status, exception)
-          @name = name
-          @captured_out = out
-          @captured_err = err
-          @status = status
-          @exception = exception
-        end
-
         ##
         # The subcommand's name.
         #
@@ -928,13 +836,129 @@ module Toys
           code = exit_code
           !code.nil? && !code.zero?
         end
+
+        ##
+        # @private
+        #
+        def initialize(name, out, err, status, exception)
+          @name = name
+          @captured_out = out
+          @captured_err = err
+          @status = status
+          @exception = exception
+        end
+      end
+
+      private
+
+      ##
+      # An internal helper class storing the configuration of a subprocess invocation
+      #
+      # @private
+      #
+      class Opts
+        ##
+        # Option keys that belong to exec configuration
+        #
+        # @private
+        #
+        CONFIG_KEYS = [
+          :argv0,
+          :background,
+          :cli,
+          :env,
+          :err,
+          :in,
+          :logger,
+          :log_cmd,
+          :log_level,
+          :name,
+          :out,
+          :result_callback,
+        ].freeze
+
+        ##
+        # Option keys that belong to spawn configuration
+        #
+        # @private
+        #
+        SPAWN_KEYS = [
+          :chdir,
+          :close_others,
+          :new_pgroup,
+          :pgroup,
+          :umask,
+          :unsetenv_others,
+        ].freeze
+
+        ##
+        # @private
+        #
+        def initialize(parent = nil)
+          if parent
+            @config_opts = ::Hash.new { |_h, k| parent.config_opts[k] }
+            @spawn_opts = ::Hash.new { |_h, k| parent.spawn_opts[k] }
+          elsif block_given?
+            @config_opts = ::Hash.new { |_h, k| yield k }
+            @spawn_opts = ::Hash.new { |_h, k| yield k }
+          else
+            @config_opts = {}
+            @spawn_opts = {}
+          end
+        end
+
+        ##
+        # @private
+        #
+        def add(config)
+          config.each do |k, v|
+            if CONFIG_KEYS.include?(k)
+              @config_opts[k] = v
+            elsif SPAWN_KEYS.include?(k) || k.to_s.start_with?("rlimit_")
+              @spawn_opts[k] = v
+            else
+              raise ::ArgumentError, "Unknown key: #{k.inspect}"
+            end
+          end
+          self
+        end
+
+        ##
+        # @private
+        #
+        def delete(*keys)
+          keys.each do |k|
+            if CONFIG_KEYS.include?(k)
+              @config_opts.delete(k)
+            elsif SPAWN_KEYS.include?(k) || k.to_s.start_with?("rlimit_")
+              @spawn_opts.delete(k)
+            else
+              raise ::ArgumentError, "Unknown key: #{k.inspect}"
+            end
+          end
+          self
+        end
+
+        ##
+        # @private
+        #
+        attr_reader :config_opts
+
+        ##
+        # @private
+        #
+        attr_reader :spawn_opts
       end
 
       ##
       # An object that manages the execution of a subcommand
+      #
       # @private
       #
       class Executor
+        ##
+        # @private
+        #
         def initialize(exec_opts, spawn_cmd, block)
           @fork_func = spawn_cmd.respond_to?(:call) ? spawn_cmd : nil
           @spawn_cmd = spawn_cmd.respond_to?(:call) ? nil : spawn_cmd
@@ -950,6 +974,9 @@ module Toys
           @mutex = ::Mutex.new
         end
 
+        ##
+        # @private
+        #
         def execute
           setup_in_stream
           setup_out_stream(:out)
@@ -970,17 +997,23 @@ module Toys
         def log_command
           logger = @config_opts[:logger]
           if logger && @config_opts[:log_level] != false
-            cmd_str = @config_opts[:log_cmd] || default_log_str(@spawn_cmd)
+            cmd_str = @config_opts[:log_cmd] || default_log_str
             logger.add(@config_opts[:log_level] || ::Logger::INFO, cmd_str) if cmd_str
           end
         end
 
-        def default_log_str(spawn_cmd)
-          return nil unless spawn_cmd
-          return spawn_cmd.first if spawn_cmd.size == 1 && spawn_cmd.first.is_a?(::String)
-          cmd_binary = spawn_cmd.first
-          cmd_binary = cmd_binary.first if cmd_binary.is_a?(::Array)
-          ([cmd_binary] + spawn_cmd[1..-1]).inspect
+        def default_log_str
+          if @fork_func
+            "exec proc: #{@fork_func.inspect}"
+          elsif @spawn_cmd
+            if @spawn_cmd.size == 1 && @spawn_cmd.first.is_a?(::String)
+              "exec sh: #{@spawn_cmd.first.inspect}"
+            else
+              cmd_binary = @spawn_cmd.first
+              cmd_binary = cmd_binary.first if cmd_binary.is_a?(::Array)
+              "exec: #{([cmd_binary] + @spawn_cmd[1..-1]).inspect}"
+            end
+          end
         end
 
         def start_with_controller
@@ -1311,8 +1344,6 @@ module Toys
         end
       end
 
-      private
-
       def canonical_binary_spec(cmd, exec_opts)
         config_argv0 = exec_opts.config_opts[:argv0]
         return cmd.to_s if !config_argv0 && !cmd.is_a?(::Array)

data/lib/toys/utils/gems.rb

@@ -188,15 +188,16 @@ module Toys
         gemfile_path = ::File.absolute_path(gemfile_path)
         Gems.synchronize do
           if configure_gemfile(gemfile_path)
-            activate("bundler", "~> 2.1")
+            activate("bundler", "~> 2.2")
             require "bundler"
-            lockfile_path = find_lockfile_path(gemfile_path)
-            setup_bundle(gemfile_path, lockfile_path, groups: groups, retries: retries)
+            setup_bundle(gemfile_path, groups: groups, retries: retries)
           end
         end
       end
 
+      ##
       # @private
+      #
       def self.find_gemfile(search_dir, gemfile_names: nil)
         gemfile_names ||= DEFAULT_GEMFILE_NAMES
         Array(gemfile_names).each do |file|
@@ -208,7 +209,9 @@ module Toys
 
       @global_mutex = ::Monitor.new
 
+      ##
       # @private
+      #
       def self.synchronize(&block)
         @global_mutex.synchronize(&block)
       end
@@ -255,8 +258,7 @@ module Toys
       def confirm_and_install_gem(name, requirements)
         if @on_missing == :confirm
           requirements_text = gem_requirements_text(name, requirements)
-          response = terminal.confirm("Gem needed: #{requirements_text}. Install? ",
-                                      default: @default_confirm)
+          response = terminal.confirm("Gem needed: #{requirements_text}. Install? ", default: @default_confirm)
           unless response
             raise InstallFailedError, "Canceled installation of needed gem: #{requirements_text}"
           end
@@ -301,71 +303,92 @@ module Toys
         end
       end
 
-      def setup_bundle(gemfile_path, lockfile_path, groups: nil, retries: nil)
+      def setup_bundle(gemfile_path, groups: nil, retries: nil)
+        check_gemfile_compatibility(gemfile_path)
         groups = Array(groups)
-        old_lockfile_contents = save_old_lockfile(lockfile_path)
+        modified_gemfile_path = create_modified_gemfile(gemfile_path)
         begin
-          modify_bundle_definition(gemfile_path, lockfile_path)
-          ::Bundler.ui.silence { ::Bundler.setup(*groups) }
+          attempt_setup_bundle(modified_gemfile_path, groups)
         rescue ::Bundler::GemNotFound, ::Bundler::VersionConflict
-          restore_toys_libs
-          install_bundle(gemfile_path, retries: retries)
-          old_lockfile_contents = save_old_lockfile(lockfile_path)
           ::Bundler.reset!
-          modify_bundle_definition(gemfile_path, lockfile_path)
-          ::Bundler.ui.silence { ::Bundler.setup(*groups) }
+          restore_toys_libs
+          install_bundle(modified_gemfile_path, retries: retries)
+          attempt_setup_bundle(modified_gemfile_path, groups)
+        ensure
+          delete_modified_gemfile(modified_gemfile_path)
+          ::ENV["BUNDLE_GEMFILE"] = gemfile_path
         end
         restore_toys_libs
-      ensure
-        restore_old_lockfile(lockfile_path, old_lockfile_contents)
       end
 
-      def save_old_lockfile(lockfile_path)
-        return nil unless ::File.readable?(lockfile_path) && ::File.writable?(lockfile_path)
-        ::File.read(lockfile_path)
-      end
-
-      def restore_old_lockfile(lockfile_path, contents)
-        return unless contents
-        ::File.open(lockfile_path, "w") do |file|
-          file.write(contents)
+      def attempt_setup_bundle(modified_gemfile_path, groups)
+        ::ENV["BUNDLE_GEMFILE"] = modified_gemfile_path
+        ::Bundler.configure
+        ::Bundler.settings.temporary({gemfile: modified_gemfile_path}) do
+          ::Bundler.ui.silence do
+            ::Bundler.setup(*groups)
+          end
         end
       end
 
-      def modify_bundle_definition(gemfile_path, lockfile_path)
+      def check_gemfile_compatibility(gemfile_path)
         ::Bundler.configure
         builder = ::Bundler::Dsl.new
         builder.eval_gemfile(gemfile_path)
-        toys_gems = ["toys-core"]
-        remove_gem_from_definition(builder, "toys-core")
-        removed_toys = remove_gem_from_definition(builder, "toys")
-        add_gem_to_definition(builder, "toys-core")
-        if removed_toys || ::Toys.const_defined?(:VERSION)
-          add_gem_to_definition(builder, "toys")
-          toys_gems << "toys"
-        end
-        definition = builder.to_definition(lockfile_path, { gems: toys_gems })
-        ::Bundler.instance_variable_set(:@definition, definition)
+        check_gemfile_gem_compatibility(builder, "toys-core")
+        check_gemfile_gem_compatibility(builder, "toys")
+        ::Bundler.reset!
       end
 
-      def remove_gem_from_definition(builder, name)
+      def check_gemfile_gem_compatibility(builder, name)
         existing_dep = builder.dependencies.find { |dep| dep.name == name }
-        return false unless existing_dep
-        unless existing_dep.requirement.satisfied_by?(::Gem::Version.new(::Toys::Core::VERSION))
+        if existing_dep && !existing_dep.requirement.satisfied_by?(::Gem::Version.new(::Toys::Core::VERSION))
           raise IncompatibleToysError,
                 "The bundle lists #{name} #{existing_dep.requirement} as a dependency, which is" \
-                " incompatible with the current version #{::Toys::Core::VERSION}."
+                " incompatible with the current toys version #{::Toys::Core::VERSION}."
         end
-        builder.dependencies.delete(existing_dep)
-        true
       end
 
-      def add_gem_to_definition(builder, name)
-        if ::ENV["TOYS_DEV"] == "true"
-          path = ::File.join(::File.dirname(::File.dirname(::Toys::CORE_LIB_PATH)), name)
+      def create_modified_gemfile(gemfile_path)
+        dir = ::File.dirname(gemfile_path)
+        modified_gemfile_path = loop do
+          timestamp = ::Time.now.strftime("%Y%m%d%H%M%S")
+          uniquifier = rand(3_656_158_440_062_976).to_s(36) # 10 digits in base 36
+          path = ::File.join(dir, ".toys-tmp-gemfile-#{timestamp}-#{uniquifier}")
+          break path unless ::File.exist?(path)
+        end
+        ::File.open(modified_gemfile_path, "w") do |file|
+          modified_gemfile_content(gemfile_path).each do |line|
+            file.puts(line)
+          end
         end
-        command = "gem #{name.inspect}, #{::Toys::Core::VERSION.inspect}, path: #{path.inspect}\n"
-        builder.eval_gemfile("current #{name}", command)
+        lockfile_path = find_lockfile_path(gemfile_path)
+        modified_lockfile_path = find_lockfile_path(modified_gemfile_path)
+        if ::File.readable?(lockfile_path)
+          lockfile_content = ::File.read(lockfile_path)
+          ::File.open(modified_lockfile_path, "w") { |file| file.write(lockfile_content) }
+        end
+        modified_gemfile_path
+      end
+
+      def modified_gemfile_content(gemfile_path)
+        is_running_toys = ::Toys.const_defined?(:VERSION)
+        content = [::File.read(gemfile_path)]
+        content << "has_toys_dep = dependencies.any? { |dep| dep.name == 'toys' }" unless is_running_toys
+        content << "dependencies.delete_if { |dep| dep.name == 'toys-core' || dep.name == 'toys' }"
+        repo_root = ::File.dirname(::File.dirname(::Toys::CORE_LIB_PATH)) if ::ENV["TOYS_DEV"]
+        path = repo_root ? ::File.join(repo_root, "toys-core") : nil
+        content << "gem 'toys-core', #{::Toys::Core::VERSION.inspect}, path: #{path.inspect}"
+        path = repo_root ? ::File.join(repo_root, "toys") : nil
+        guard = is_running_toys ? "" : " if has_toys_dep"
+        content << "gem 'toys', #{::Toys::Core::VERSION.inspect}, path: #{path.inspect}#{guard}"
+        content
+      end
+
+      def delete_modified_gemfile(modified_gemfile_path)
+        ::File.delete(modified_gemfile_path) if ::File.exist?(modified_gemfile_path)
+        modified_lockfile_path = find_lockfile_path(modified_gemfile_path)
+        ::File.delete(modified_lockfile_path) if ::File.exist?(modified_lockfile_path)
       end
 
       def restore_toys_libs
@@ -384,8 +407,7 @@ module Toys
         when :error
           false
         else
-          terminal.confirm("Your bundle requires additional gems. Install? ",
-                           default: @default_confirm)
+          terminal.confirm("Your bundle requires additional gems. Install? ", default: @default_confirm)
         end
       end
 
@@ -393,17 +415,19 @@ module Toys
         gemfile_dir = ::File.dirname(gemfile_path)
         unless permission_to_bundle?
           raise BundleNotInstalledError,
-                "Your bundle is not installed. Consider running" \
-                  " `cd #{gemfile_dir} && bundle install`"
+                "Your bundle is not installed. Consider running `cd #{gemfile_dir} && bundle install`"
         end
         retries = retries.to_i
-        args = retries.positive? ? ["--retry=#{retries}"] : []
-        require "bundler/cli"
-        begin
-          ::Bundler::CLI.start(["install"] + args)
-        rescue ::Bundler::GemNotFound, ::Bundler::InstallError, ::Bundler::VersionConflict
+        args = ["--gemfile=#{gemfile_path}"]
+        args << "--retry=#{retries}" if retries.positive?
+        bundler_bin = ::Gem.bin_path("bundler", "bundle", ::Bundler::VERSION)
+        result = exec_util.exec_ruby([bundler_bin, "install"] + args)
+        if result.error?
           terminal.puts("Failed to install. Trying update...")
-          ::Bundler::CLI.start(["update"] + args)
+          result = exec_util.exec_ruby([bundler_bin, "update"] + args)
+          unless result.success?
+            raise ::Bundler::InstallError, "Failed to install or update bundle: #{gemfile_path}"
+          end
         end
       end
     end