toys-core 0.10.2 → 0.11.1

data/lib/toys/utils/gems.rb

@@ -64,6 +64,19 @@ module Toys
       class AlreadyBundledError < BundlerFailedError
       end
 
+      ##
+      # The bundle contained a toys or toys-core dependency that is
+      # incompatible with the currently running version.
+      #
+      class IncompatibleToysError < BundlerFailedError
+      end
+
+      ##
+      # The gemfile names that are searched by default.
+      # @return [Array<String>]
+      #
+      DEFAULT_GEMFILE_NAMES = [".gems.rb", "gems.rb", "Gemfile"].freeze
+
       ##
       # Activate the given gem. If it is not present, attempt to install it (or
       # inform the user to update the bundle).
@@ -81,16 +94,22 @@ module Toys
       #
       # @param on_missing [:confirm,:error,:install] What to do if a needed gem
       #     is not installed. Possible values:
+      #
       #      *  `:confirm` - prompt the user on whether to install
       #      *  `:error` - raise an exception
       #      *  `:install` - just install the gem
+      #
       #     The default is `:confirm`.
+      #
       # @param on_conflict [:error,:warn,:ignore] What to do if bundler has
       #     already been run with a different Gemfile. Possible values:
+      #
       #      *  `:error` - raise an exception
       #      *  `:ignore` - just silently proceed without bundling again
       #      *  `:warn` - print a warning and proceed without bundling again
+      #
       #     The default is `:error`.
+      #
       # @param terminal [Toys::Utils::Terminal] Terminal to use (optional)
       # @param input [IO] Input IO (optional, defaults to STDIN)
       # @param output [IO] Output IO (optional, defaults to STDOUT)
@@ -136,26 +155,54 @@ module Toys
       end
 
       ##
-      # Set up the bundle.
+      # Search for an appropriate Gemfile, and set up the bundle.
+      #
+      # @param groups [Array<String>] The groups to include in setup.
+      #
+      # @param gemfile_path [String] The path to the Gemfile to use. If `nil`
+      #     or not given, the `:search_dirs` will be searched for a Gemfile.
+      #
+      # @param search_dirs [String,Array<String>] Directories in which to
+      #     search for a Gemfile, if gemfile_path is not given. You can provide
+      #     a single directory or an array of directories.
+      #
+      # @param gemfile_names [String,Array<String>] File names that are
+      #     recognized as Gemfiles, when searching because gemfile_path is not
+      #     given. Defaults to {DEFAULT_GEMFILE_NAMES}.
       #
-      # @param groups [Array<String>] The groups to include in setup
-      # @param search_dirs [Array<String>] Directories to search for a Gemfile
       # @return [void]
       #
       def bundle(groups: nil,
-                 search_dirs: nil)
+                 gemfile_path: nil,
+                 search_dirs: nil,
+                 gemfile_names: nil)
+        Array(search_dirs).each do |dir|
+          break if gemfile_path
+          gemfile_path = Gems.find_gemfile(dir, gemfile_names: gemfile_names)
+        end
+        raise GemfileNotFoundError, "Gemfile not found" unless gemfile_path
         Gems.synchronize do
-          gemfile_path = find_gemfile(Array(search_dirs))
-          activate("bundler", "~> 2.1")
           if configure_gemfile(gemfile_path)
+            activate("bundler", "~> 2.1")
+            require "bundler"
             setup_bundle(gemfile_path, groups || [])
           end
         end
       end
 
+      # @private
+      def self.find_gemfile(search_dir, gemfile_names: nil)
+        gemfile_names ||= DEFAULT_GEMFILE_NAMES
+        Array(gemfile_names).each do |file|
+          gemfile_path = ::File.join(search_dir, file)
+          return gemfile_path if ::File.readable?(gemfile_path)
+        end
+        nil
+      end
+
       @global_mutex = ::Monitor.new
 
-      ## @private
+      # @private
       def self.synchronize(&block)
         @global_mutex.synchronize(&block)
       end
@@ -184,14 +231,14 @@ module Toys
             error.message.include?("Could not find")
           end
         if !is_missing_spec || @on_missing == :error
-          report_error(name, requirements, error)
+          report_activation_error(name, requirements, error)
           return
         end
         confirm_and_install_gem(name, requirements)
         begin
           gem(name, *requirements)
         rescue ::Gem::LoadError => e
-          report_error(name, requirements, e)
+          report_activation_error(name, requirements, e)
         end
       end
 
@@ -215,7 +262,7 @@ module Toys
         ::Gem::Specification.reset
       end
 
-      def report_error(name, requirements, err)
+      def report_activation_error(name, requirements, err)
         if ::ENV["BUNDLE_GEMFILE"]
           raise GemfileUpdateNeededError.new(gem_requirements_text(name, requirements),
                                              ::ENV["BUNDLE_GEMFILE"])
@@ -223,22 +270,16 @@ module Toys
         raise ActivationFailedError, err.message
       end
 
-      def find_gemfile(search_dirs)
-        search_dirs.each do |dir|
-          gemfile_path = ::File.join(dir, "Gemfile")
-          return gemfile_path if ::File.readable?(gemfile_path)
-        end
-        raise GemfileNotFoundError, "Gemfile not found"
-      end
-
       def configure_gemfile(gemfile_path)
         old_path = ::ENV["BUNDLE_GEMFILE"]
-        if old_path && gemfile_path != old_path
-          case @on_conflict
-          when :warn
-            terminal.puts("Warning: could not set up bundler because it is already set up.", :red)
-          when :error
-            raise AlreadyBundledError, "Could not set up bundler because it is already set up"
+        if old_path
+          if gemfile_path != old_path
+            case @on_conflict
+            when :warn
+              terminal.puts("Warning: could not set up bundler because it is already set up.", :red)
+            when :error
+              raise AlreadyBundledError, "Could not set up bundler because it is already set up"
+            end
           end
           return false
         end
@@ -247,21 +288,61 @@ module Toys
       end
 
       def setup_bundle(gemfile_path, groups)
-        require "bundler"
         begin
-          ::Bundler.setup(*groups)
-        rescue ::Bundler::GemNotFound
+          modify_bundle_definition(gemfile_path)
+          ::Bundler.ui.silence { ::Bundler.setup(*groups) }
+        rescue ::Bundler::GemNotFound, ::Bundler::VersionConflict
           restore_toys_libs
           install_bundle(gemfile_path)
           ::Bundler.reset!
-          ::Bundler.setup(*groups)
+          modify_bundle_definition(gemfile_path)
+          ::Bundler.ui.silence { ::Bundler.setup(*groups) }
         end
         restore_toys_libs
       end
 
+      def modify_bundle_definition(gemfile_path)
+        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(gemfile_path + ".lock", { gems: toys_gems })
+        ::Bundler.instance_variable_set(:@definition, definition)
+      end
+
+      def remove_gem_from_definition(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))
+          raise IncompatibleToysError,
+                "The bundle lists #{name} #{existing_dep.requirement} as a dependency, which is" \
+                " incompatible with the current 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)
+        end
+        command = "gem #{name.inspect}, #{::Toys::Core::VERSION.inspect}, path: #{path.inspect}\n"
+        builder.eval_gemfile("current #{name}", command)
+      end
+
       def restore_toys_libs
+        $LOAD_PATH.delete(::Toys::CORE_LIB_PATH)
         $LOAD_PATH.unshift(::Toys::CORE_LIB_PATH)
-        $LOAD_PATH.unshift(::Toys::LIB_PATH) if ::Toys.const_defined?(:LIB_PATH)
+        if ::Toys.const_defined?(:LIB_PATH)
+          $LOAD_PATH.delete(::Toys::LIB_PATH)
+          $LOAD_PATH.unshift(::Toys::LIB_PATH)
+        end
       end
 
       def permission_to_bundle?
@@ -271,7 +352,8 @@ module Toys
         when :error
           false
         else
-          terminal.confirm("Your bundle is not complete. Install? ", default: @default_confirm)
+          terminal.confirm("Your bundle requires additional gems. Install? ",
+                           default: @default_confirm)
         end
       end
 
@@ -283,7 +365,12 @@ module Toys
                   " `cd #{gemfile_dir} && bundle install`"
         end
         require "bundler/cli"
-        ::Bundler::CLI.start(["install"])
+        begin
+          ::Bundler::CLI.start(["install"])
+        rescue ::Bundler::GemNotFound, ::Bundler::InstallError
+          terminal.puts("Failed to install. Trying update...")
+          ::Bundler::CLI.start(["update"])
+        end
       end
     end
   end

data/lib/toys/utils/help_text.rb

@@ -32,14 +32,13 @@ module Toys
       # @return [Toys::Utils::HelpText]
       #
       def self.from_context(context)
-        orig_context = context
-        while (from = context[Context::Key::DELEGATED_FROM])
-          context = from
+        delegates = []
+        cur = context
+        while (cur = cur[Context::Key::DELEGATED_FROM])
+          delegates << cur[Context::Key::TOOL]
         end
-        delegate_target = orig_context == context ? nil : orig_context[Context::Key::TOOL_NAME]
         cli = context[Context::Key::CLI]
-        new(context[Context::Key::TOOL], cli.loader, cli.executable_name,
-            delegate_target: delegate_target)
+        new(context[Context::Key::TOOL], cli.loader, cli.executable_name, delegates: delegates)
       end
 
       ##
@@ -49,16 +48,15 @@ module Toys
       # @param loader [Toys::Loader] A loader that can provide subcommands.
       # @param executable_name [String] The name of the executable.
       #     e.g. `"toys"`.
-      # @param delegate_target [Array<String>,nil] The full name of a tool this
-      #     tool will delegate to. Default is `nil` for no delegation.
+      # @param delegates [Array<Toys::Tool>] The delegation path to the tool.
       #
       # @return [Toys::Utils::HelpText]
       #
-      def initialize(tool, loader, executable_name, delegate_target: nil)
+      def initialize(tool, loader, executable_name, delegates: [])
         @tool = tool
         @loader = loader
         @executable_name = executable_name
-        @delegate_target = delegate_target
+        @delegates = delegates
       end
 
       ##
@@ -88,8 +86,7 @@ module Toys
         indent ||= DEFAULT_INDENT
         subtools = find_subtools(recursive, nil, include_hidden)
         assembler = UsageStringAssembler.new(
-          @tool, @executable_name, @delegate_target, subtools,
-          indent, left_column_width, wrap_width
+          @tool, @executable_name, subtools, indent, left_column_width, wrap_width
         )
         assembler.result
       end
@@ -121,7 +118,7 @@ module Toys
         indent2 ||= DEFAULT_INDENT
         subtools = find_subtools(recursive, search, include_hidden)
         assembler = HelpStringAssembler.new(
-          @tool, @executable_name, @delegate_target, subtools, search, show_source_path,
+          @tool, @executable_name, @delegates, subtools, search, show_source_path,
           indent, indent2, wrap_width, styled
         )
         assembler.result
@@ -155,22 +152,29 @@ module Toys
       private
 
       def find_subtools(recursive, search, include_hidden)
-        subtools = @loader.list_subtools(@tool.full_name,
-                                         recursive: recursive, include_hidden: include_hidden)
-        return subtools if search.nil? || search.empty?
+        subtools_by_name = {}
+        ([@tool] + @delegates).each do |tool|
+          name_len = tool.full_name.length
+          subtools = @loader.list_subtools(tool.full_name,
+                                           recursive: recursive, include_hidden: include_hidden)
+          subtools.each do |subtool|
+            local_name = subtool.full_name.slice(name_len..-1).join(" ")
+            subtools_by_name[local_name] = subtool
+          end
+        end
+        subtool_list = subtools_by_name.sort_by { |(local_name, _tool)| local_name }
+        return subtool_list if search.nil? || search.empty?
         regex = ::Regexp.new(search, ::Regexp::IGNORECASE)
-        subtools.find_all do |tool|
-          regex =~ tool.display_name || regex =~ tool.desc.to_s
+        subtool_list.find_all do |local_name, tool|
+          regex =~ local_name || regex =~ tool.desc.to_s
         end
       end
 
       ## @private
       class UsageStringAssembler
-        def initialize(tool, executable_name, delegate_target, subtools,
-                       indent, left_column_width, wrap_width)
+        def initialize(tool, executable_name, subtools, indent, left_column_width, wrap_width)
           @tool = tool
           @executable_name = executable_name
-          @delegate_target = delegate_target
           @subtools = subtools
           @indent = indent
           @left_column_width = left_column_width
@@ -195,7 +199,7 @@ module Toys
         def add_synopsis_section
           synopses = []
           synopses << namespace_synopsis unless @subtools.empty?
-          synopses << (@delegate_target ? delegate_synopsis : tool_synopsis)
+          synopses << tool_synopsis
           first = true
           synopses.each do |synopsis|
             @lines << (first ? "Usage:  #{synopsis}" : "        #{synopsis}")
@@ -212,11 +216,6 @@ module Toys
           synopsis.join(" ")
         end
 
-        def delegate_synopsis
-          target = @delegate_target.join(" ")
-          "#{@executable_name} #{@tool.display_name} [ARGUMENTS FOR \"#{target}\"...]"
-        end
-
         def namespace_synopsis
           "#{@executable_name} #{@tool.display_name} TOOL [ARGUMENTS...]"
         end
@@ -256,12 +255,10 @@ module Toys
 
         def add_subtool_list_section
           return if @subtools.empty?
-          name_len = @tool.full_name.length
           @lines << ""
           @lines << "Tools:"
-          @subtools.each do |subtool|
-            tool_name = subtool.full_name.slice(name_len..-1).join(" ")
-            add_right_column_desc(tool_name, wrap_desc(subtool.desc))
+          @subtools.each do |local_name, subtool|
+            add_right_column_desc(local_name, wrap_desc(subtool.desc))
           end
         end
 
@@ -301,12 +298,12 @@ module Toys
 
       ## @private
       class HelpStringAssembler
-        def initialize(tool, executable_name, delegate_target, subtools, search_term,
+        def initialize(tool, executable_name, delegates, subtools, search_term,
                        show_source_path, indent, indent2, wrap_width, styled)
           require "toys/utils/terminal"
           @tool = tool
           @executable_name = executable_name
-          @delegate_target = delegate_target
+          @delegates = delegates
           @subtools = subtools
           @search_term = search_term
           @show_source_path = show_source_path
@@ -356,7 +353,7 @@ module Toys
           @lines << ""
           @lines << bold("SYNOPSIS")
           add_synopsis_clause(namespace_synopsis) unless @subtools.empty?
-          add_synopsis_clause(@delegate_target ? delegate_synopsis : tool_synopsis)
+          add_synopsis_clause(tool_synopsis(@tool))
         end
 
         def add_synopsis_clause(synopsis)
@@ -367,8 +364,8 @@ module Toys
           end
         end
 
-        def tool_synopsis
-          synopsis = [full_executable_name]
+        def tool_synopsis(tool_for_name)
+          synopsis = [full_executable_name(tool_for_name)]
           @tool.flag_groups.each do |flag_group|
             case flag_group
             when FlagGroup::Required
@@ -441,19 +438,14 @@ module Toys
         end
 
         def namespace_synopsis
-          synopsis = [full_executable_name, underline("TOOL"), "[#{underline('ARGUMENTS')}...]"]
+          synopsis = [full_executable_name(@tool),
+                      underline("TOOL"),
+                      "[#{underline('ARGUMENTS')}...]"]
           wrap_indent_indent2(WrappableString.new(synopsis))
         end
 
-        def delegate_synopsis
-          target = @delegate_target.join(" ")
-          args_clause = underline("ARGUMENTS FOR \"#{target}\"")
-          synopsis = [full_executable_name, "[#{args_clause}...]"]
-          wrap_indent_indent2(WrappableString.new(synopsis))
-        end
-
-        def full_executable_name
-          bold(([@executable_name] + @tool.full_name).join(" "))
+        def full_executable_name(tool_for_name)
+          bold(([@executable_name] + tool_for_name.full_name).join(" "))
         end
 
         def add_source_section
@@ -461,15 +453,22 @@ module Toys
           @lines << ""
           @lines << bold("SOURCE")
           @lines << indent_str("Defined in #{@tool.source_info.source_name}")
+          @delegates.each do |delegate|
+            @lines << indent_str("Delegated from \"#{delegate.display_name}\"" \
+                                 " defined in #{delegate.source_info.source_name}")
+          end
         end
 
         def add_description_section
-          desc = @tool.long_desc
-          if @delegate_target
-            delegate_clause =
-              "Passes all arguments to \"#{@delegate_target.join(' ')}\" if invoked directly."
-            desc = desc.empty? ? [delegate_clause] : desc + ["", delegate_clause]
+          desc = @tool.long_desc.dup
+          @delegates.each do |delegate|
+            desc << "" << "Delegated from \"#{delegate.display_name}\""
+            unless delegate.long_desc.empty?
+              desc << ""
+              desc += delegate.long_desc
+            end
           end
+          desc = desc[1..-1] if desc.first == ""
           desc = wrap_indent(desc)
           return if desc.empty?
           @lines << ""
@@ -533,10 +532,8 @@ module Toys
             @lines << indent_str("Showing search results for \"#{@search_term}\"")
             @lines << ""
           end
-          name_len = @tool.full_name.length
-          @subtools.each do |subtool|
-            tool_name = subtool.full_name.slice(name_len..-1).join(" ")
-            add_prefix_with_desc(bold(tool_name), subtool.desc)
+          @subtools.each do |local_name, subtool|
+            add_prefix_with_desc(bold(local_name), subtool.desc)
           end
         end
 
@@ -637,10 +634,8 @@ module Toys
         end
 
         def add_list
-          name_len = @tool.full_name.length
-          @subtools.each do |subtool|
-            tool_name = subtool.full_name.slice(name_len..-1).join(" ")
-            add_prefix_with_desc(bold(tool_name), subtool.desc)
+          @subtools.each do |local_name, subtool|
+            add_prefix_with_desc(bold(local_name), subtool.desc)
           end
         end