toys-core 0.9.4 → 0.10.4

data/lib/toys/utils/gems.rb

@@ -1,30 +1,12 @@
 # frozen_string_literal: true
 
-# Copyright 2019 Daniel Azuma
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-;
+require "monitor"
+require "rubygems"
 
 module Toys
   module Utils
     ##
-    # A helper module that activates and installs gems.
+    # A helper class that activates and installs gems and sets up bundler.
     #
     # This class is not loaded by default. Before using it directly, you should
     # `require "toys/utils/gems"`
@@ -58,6 +40,30 @@ module Toys
         end
       end
 
+      ##
+      # Failed to run Bundler
+      #
+      class BundlerFailedError < ::StandardError
+      end
+
+      ##
+      # Could not find a Gemfile
+      #
+      class GemfileNotFoundError < BundlerFailedError
+      end
+
+      ##
+      # The bundle is not and could not be installed
+      #
+      class BundleNotInstalledError < BundlerFailedError
+      end
+
+      ##
+      # Bundler has already been run; cannot do so again
+      #
+      class AlreadyBundledError < BundlerFailedError
+      end
+
       ##
       # Activate the given gem. If it is not present, attempt to install it (or
       # inform the user to update the bundle).
@@ -73,24 +79,48 @@ module Toys
       ##
       # Create a new gem activator.
       #
-      # @param input [IO] Input IO
-      # @param output [IO] Output IO
-      # @param suppress_confirm [Boolean] Suppress the confirmation prompt and
-      #     just use the given `default_confirm` value. Default is false,
-      #     indicating the confirmation prompt appears by default.
-      # @param default_confirm [Boolean] Default response for the confirmation
-      #     prompt. Default is true.
-      #
-      def initialize(input: $stdin,
-                     output: $stderr,
-                     suppress_confirm: false,
-                     default_confirm: true)
-        require "toys/utils/terminal"
-        require "toys/utils/exec"
-        @terminal = Utils::Terminal.new(input: input, output: output)
-        @exec = Utils::Exec.new
-        @suppress_confirm = suppress_confirm ? true : false
-        @default_confirm = default_confirm ? true : false
+      # @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)
+      # @param suppress_confirm [Boolean] Deprecated. Use `on_missing` instead.
+      # @param default_confirm [Boolean] Deprecated. Use `on_missing` instead.
+      #
+      def initialize(on_missing: nil,
+                     on_conflict: nil,
+                     terminal: nil,
+                     input: nil,
+                     output: nil,
+                     suppress_confirm: nil,
+                     default_confirm: nil)
+        @default_confirm = default_confirm || default_confirm.nil? ? true : false
+        @on_missing = on_missing ||
+                      if suppress_confirm
+                        @default_confirm ? :install : :error
+                      else
+                        :confirm
+                      end
+        @on_conflict = on_conflict || :error
+        @terminal = terminal
+        @input = input || ::STDIN
+        @output = output || ::STDOUT
       end
 
       ##
@@ -102,13 +132,57 @@ module Toys
       # @return [void]
       #
       def activate(name, *requirements)
-        gem(name, *requirements)
-      rescue ::Gem::LoadError => e
-        handle_activation_error(e, name, requirements)
+        Gems.synchronize do
+          begin
+            gem(name, *requirements)
+          rescue ::Gem::LoadError => e
+            handle_activation_error(e, name, requirements)
+          end
+        end
+      end
+
+      ##
+      # Set up the bundle.
+      #
+      # @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)
+        Gems.synchronize do
+          gemfile_path = find_gemfile(Array(search_dirs))
+          if configure_gemfile(gemfile_path)
+            activate("bundler", "~> 2.1")
+            require "bundler"
+            setup_bundle(gemfile_path, groups || [])
+          end
+        end
+      end
+
+      @global_mutex = ::Monitor.new
+
+      ## @private
+      def self.synchronize(&block)
+        @global_mutex.synchronize(&block)
       end
 
       private
 
+      def terminal
+        @terminal ||= begin
+          require "toys/utils/terminal"
+          Utils::Terminal.new(input: @input, output: @output)
+        end
+      end
+
+      def exec_util
+        @exec_util ||= begin
+          require "toys/utils/exec"
+          Utils::Exec.new
+        end
+      end
+
       def handle_activation_error(error, name, requirements)
         is_missing_spec =
           if defined?(::Gem::MissingSpecError)
@@ -116,15 +190,15 @@ module Toys
           else
             error.message.include?("Could not find")
           end
-        unless is_missing_spec
-          report_error(name, requirements, error)
+        if !is_missing_spec || @on_missing == :error
+          report_activation_error(name, requirements, error)
           return
         end
-        install_gem(name, requirements)
+        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
 
@@ -132,41 +206,121 @@ module Toys
         "#{name.inspect}, #{requirements.map(&:inspect).join(', ')}"
       end
 
-      def install_gem(name, requirements)
-        requirements_text = gem_requirements_text(name, requirements)
-        response =
-          if @suppress_confirm
-            @default_confirm
-          else
-            @terminal.confirm("Gem needed: #{requirements_text}. Install? ",
-                              default: @default_confirm)
+      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)
+          unless response
+            raise InstallFailedError, "Canceled installation of needed gem: #{requirements_text}"
           end
-        unless response
-          raise InstallFailedError, "Canceled installation of needed gem: #{requirements_text}"
-        end
-        perform_install(name, requirements)
-      end
-
-      def perform_install(name, requirements)
-        result = @terminal.spinner(leading_text: "Installing gem #{name}... ",
-                                   final_text: "Done.\n") do
-          @exec.exec(["gem", "install", name, "--version", requirements.join(",")],
-                     out: :capture, err: :capture)
         end
-        @terminal.puts(result.captured_out + result.captured_err)
+        result = exec_util.exec(["gem", "install", name, "--version", requirements.join(",")])
         if result.error?
           raise InstallFailedError, "Failed to install gem #{name}"
         end
         ::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"])
         end
         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
+          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
+        ::ENV["BUNDLE_GEMFILE"] = gemfile_path
+        true
+      end
+
+      def setup_bundle(gemfile_path, groups)
+        begin
+          modify_bundle_definition(gemfile_path)
+          ::Bundler.setup(*groups)
+        rescue ::Bundler::GemNotFound
+          restore_toys_libs
+          install_bundle(gemfile_path)
+          ::Bundler.reset!
+          modify_bundle_definition(gemfile_path)
+          ::Bundler.setup(*groups)
+        end
+        restore_toys_libs
+      end
+
+      def modify_bundle_definition(gemfile_path)
+        builder = ::Bundler::Dsl.new
+        builder.eval_gemfile(gemfile_path)
+        begin
+          builder.eval_gemfile(::File.join(__dir__, "gems", "gemfile.rb"))
+        rescue ::Bundler::Dsl::DSLError
+          terminal.puts(
+            "WARNING: Unable to integrate your Gemfile into the Toys runtime.\n" \
+            "When using the Toys Bundler integration features, do NOT list\n" \
+            "the toys or toys-core gems directly in your Gemfile. They can be\n" \
+            "dependencies of another gem, but cannot be listed directly.",
+            :red
+          )
+          return
+        end
+        toys_gems = ["toys-core"]
+        toys_gems << "toys" if ::Toys.const_defined?(:VERSION)
+        definition = builder.to_definition(gemfile_path + ".lock", { gems: toys_gems })
+        ::Bundler.instance_variable_set(:@definition, definition)
+      end
+
+      def restore_toys_libs
+        $LOAD_PATH.delete(::Toys::CORE_LIB_PATH)
+        $LOAD_PATH.unshift(::Toys::CORE_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?
+        case @on_missing
+        when :install
+          true
+        when :error
+          false
+        else
+          terminal.confirm("Your bundle requires additional gems. Install? ",
+                           default: @default_confirm)
+        end
+      end
+
+      def install_bundle(gemfile_path)
+        gemfile_dir = ::File.dirname(gemfile_path)
+        unless permission_to_bundle?
+          raise BundleNotInstalledError,
+                "Your bundle is not installed. Consider running" \
+                  " `cd #{gemfile_dir} && bundle install`"
+        end
+        require "bundler/cli"
+        ::Bundler::CLI.start(["install"])
+      end
     end
   end
 end

data/lib/toys/utils/gems/gemfile.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+unless defined?(@__toys_dev_gemspec)
+  gem("toys-core", ::Toys::Core::VERSION)
+  gem("toys", ::Toys::VERSION) if ::Toys.const_defined?(:VERSION)
+end

data/lib/toys/utils/help_text.rb

@@ -1,26 +1,5 @@
 # frozen_string_literal: true
 
-# Copyright 2019 Daniel Azuma
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-;
-
 module Toys
   module Utils
     ##

data/lib/toys/utils/terminal.rb

@@ -1,32 +1,11 @@
 # frozen_string_literal: true
 
-# Copyright 2019 Daniel Azuma
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-;
-
 require "stringio"
 require "monitor"
 
 begin
   require "io/console"
-rescue ::LoadError # rubocop:disable Lint/SuppressedException
+rescue ::LoadError
   # TODO: alternate methods of getting terminal size
 end
 
@@ -146,6 +125,8 @@ module Toys
             styled ? true : false
           end
         @named_styles = BUILTIN_STYLE_NAMES.dup
+        @output_mutex = ::Monitor.new
+        @input_mutex = ::Monitor.new
       end
 
       ##
@@ -164,7 +145,7 @@ module Toys
       # Whether output is styled
       # @return [Boolean]
       #
-      attr_accessor :styled
+      attr_reader :styled
 
       ##
       # Write a partial line without appending a newline.
@@ -175,11 +156,41 @@ module Toys
       # @return [self]
       #
       def write(str = "", *styles)
-        output&.write(apply_styles(str, *styles))
-        output&.flush
+        @output_mutex.synchronize do
+          begin
+            output&.write(apply_styles(str, *styles))
+            output&.flush
+          rescue ::IOError
+            nil
+          end
+        end
         self
       end
 
+      ##
+      # Read a line, blocking until one is available.
+      #
+      # @return [String] the entire string including the temrinating newline
+      # @return [nil] if the input is closed or at eof, or there is no input
+      #
+      def readline
+        @input_mutex.synchronize do
+          begin
+            input&.gets
+          rescue ::IOError
+            nil
+          end
+        end
+      end
+
+      ##
+      # This method is defined so that `::Logger` will recognize a terminal as
+      # a log device target, but it does not actually close anything.
+      #
+      def close
+        nil
+      end
+
       ##
       # Write a line, appending a newline if one is not already present.
       #
@@ -233,7 +244,7 @@ module Toys
           prompt = "#{ptext} #{trailing_text}#{pspaces}"
         end
         write(prompt, *styles)
-        resp = input&.gets.to_s.chomp
+        resp = readline.to_s.chomp
         resp.empty? ? default.to_s : resp
       end
 
@@ -296,13 +307,13 @@ module Toys
         return nil unless block_given?
         frame_length ||= DEFAULT_SPINNER_FRAME_LENGTH
         frames ||= DEFAULT_SPINNER_FRAMES
-        output.write(leading_text) unless leading_text.empty?
+        write(leading_text) unless leading_text.empty?
         spin = SpinDriver.new(self, frames, Array(style), frame_length)
         begin
           yield
         ensure
           spin.stop
-          output.write(final_text) unless final_text.empty?
+          write(final_text) unless final_text.empty?
         end
       end
 
@@ -312,8 +323,8 @@ module Toys
       # @return [Array(Integer,Integer)]
       #
       def size
-        if @output.respond_to?(:tty?) && @output.tty? && @output.respond_to?(:winsize)
-          @output.winsize.reverse
+        if output.respond_to?(:tty?) && output.tty? && output.respond_to?(:winsize)
+          output.winsize.reverse
         else
           [80, 25]
         end
@@ -422,10 +433,8 @@ module Toys
 
       ## @private
       class SpinDriver
-        include ::MonitorMixin
-
         def initialize(terminal, frames, style, frame_length)
-          super()
+          @mutex = ::Monitor.new
           @terminal = terminal
           @frames = frames.map do |f|
             [@terminal.apply_styles(f, *style), Terminal.remove_style_escapes(f).size]
@@ -433,12 +442,12 @@ module Toys
           @frame_length = frame_length
           @cur_frame = 0
           @stopping = false
-          @cond = new_cond
+          @cond = @mutex.new_cond
           @thread = @terminal.output.tty? ? start_thread : nil
         end
 
         def stop
-          synchronize do
+          @mutex.synchronize do
             @stopping = true
             @cond.broadcast
           end
@@ -450,12 +459,12 @@ module Toys
 
         def start_thread
           ::Thread.new do
-            synchronize do
+            @mutex.synchronize do
               until @stopping
-                @terminal.output.write(@frames[@cur_frame][0])
+                @terminal.write(@frames[@cur_frame][0])
                 @cond.wait(@frame_length)
                 size = @frames[@cur_frame][1]
-                @terminal.output.write("\b" * size + " " * size + "\b" * size)
+                @terminal.write("\b" * size + " " * size + "\b" * size)
                 @cur_frame += 1
                 @cur_frame = 0 if @cur_frame >= @frames.size
               end