toys 0.2.2 → 0.3.0

data/lib/toys/context.rb

@@ -34,31 +34,116 @@ module Toys
   # The object context in effect during the execution of a tool.
   #
   class Context
-    def initialize(context_base, tool_name, args, options)
-      @context_base = context_base
-      @tool_name = tool_name
-      @args = args
-      @options = options
+    ##
+    # Context key for the verbosity value. Verbosity is an integer defaulting
+    # to 0, with higher values meaning more verbose and lower meaning quieter.
+    # @return [Symbol]
+    #
+    VERBOSITY = :__verbosity
+
+    ##
+    # Context key for the `Toys::Tool` object being executed.
+    # @return [Symbol]
+    #
+    TOOL = :__tool
+
+    ##
+    # Context key for the full name of the tool being executed. Value is an
+    # array of strings.
+    # @return [Symbol]
+    #
+    TOOL_NAME = :__tool_name
+
+    ##
+    # Context key for the active `Toys::Loader` object.
+    # @return [Symbol]
+    #
+    LOADER = :__loader
+
+    ##
+    # Context key for the active `Logger` object.
+    # @return [Symbol]
+    #
+    LOGGER = :__logger
+
+    ##
+    # Context key for the name of the toys binary. Value is a string.
+    # @return [Symbol]
+    #
+    BINARY_NAME = :__binary_name
+
+    ##
+    # Context key for the argument list passed to the current tool. Value is
+    # an array of strings.
+    # @return [Symbol]
+    #
+    ARGS = :__args
+
+    ##
+    # Context key for the usage error raised. Value is a string if there was
+    # an error, or nil if there was no error.
+    # @return [Symbol]
+    #
+    USAGE_ERROR = :__usage_error
+
+    def initialize(context_base, data)
+      @_context_base = context_base
+      @_data = data
+      @_data[LOADER] = context_base.loader
+      @_data[BINARY_NAME] = context_base.binary_name
+      @_data[LOGGER] = context_base.logger
     end
 
-    attr_reader :tool_name
-    attr_reader :args
-    attr_reader :options
+    def verbosity
+      @_data[VERBOSITY]
+    end
 
-    def [](key)
-      @options[key]
+    def tool
+      @_data[TOOL]
+    end
+
+    def tool_name
+      @_data[TOOL_NAME]
+    end
+
+    def args
+      @_data[ARGS]
+    end
+
+    def usage_error
+      @_data[USAGE_ERROR]
     end
 
     def logger
-      @context_base.logger
+      @_data[LOGGER]
+    end
+
+    def loader
+      @_data[LOADER]
     end
 
     def binary_name
-      @context_base.binary_name
+      @_data[BINARY_NAME]
+    end
+
+    def [](key)
+      @_data[key]
+    end
+
+    def []=(key, value)
+      @_data[key] = value
+    end
+
+    def options
+      @_data.select do |k, _v|
+        !k.is_a?(::Symbol) || !k.to_s.start_with?("__")
+      end
     end
 
-    def run(*args)
-      @context_base.run(*args)
+    def run(*args, exit_on_nonzero_status: false)
+      code = @_context_base.run(args.flatten, verbosity: @_data[VERBOSITY])
+      exit(code) if exit_on_nonzero_status && !code.zero?
+      code
     end
 
     def exit(code)
@@ -70,21 +155,24 @@ module Toys
     # @private
     #
     class Base
-      def initialize(lookup, binary_name, logger)
-        @lookup = lookup
-        @binary_name = binary_name
+      def initialize(loader, binary_name, logger)
+        @loader = loader
+        @binary_name = binary_name || ::File.basename($PROGRAM_NAME)
         @logger = logger || ::Logger.new(::STDERR)
+        @base_level = @logger.level
       end
 
+      attr_reader :loader
       attr_reader :binary_name
       attr_reader :logger
+      attr_reader :base_level
 
-      def run(*args)
-        @lookup.execute(self, args.flatten)
+      def run(args, verbosity: 0)
+        @loader.execute(self, args, verbosity: verbosity)
       end
 
-      def create_context(tool_name, args, options)
-        Context.new(self, tool_name, args, options)
+      def create_context(data)
+        Context.new(self, data)
       end
     end
   end

data/lib/toys/helpers.rb

@@ -0,0 +1,41 @@
+# Copyright 2018 Daniel Azuma
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+;
+
+require "toys/utils/module_lookup"
+
+module Toys
+  ##
+  # Namespace for common helper modules
+  #
+  module Helpers
+    def self.lookup(name)
+      Utils::ModuleLookup.lookup(:helpers, name)
+    end
+  end
+end

data/lib/toys/helpers/exec.rb

@@ -29,250 +29,260 @@
 
 require "logger"
 
-module Toys::Helpers
-  ##
-  # A set of helper methods for invoking subcommands
-  #
-  module Exec
-    def configure_exec(opts = {})
-      @exec_config ||= {}
-      @exec_config.merge!(opts)
-    end
-
-    def exec(cmd, opts = {}, &block)
-      exec_opts = ExecOpts.new(self)
-      exec_opts.add(@exec_config) if defined? @exec_config
-      exec_opts.add(opts)
-      executor = Executor.new(exec_opts, cmd)
-      executor.execute(&block)
-    end
-
-    def ruby(args, opts = {}, &block)
-      cmd =
-        if args.is_a?(Array)
-          [[Exec.ruby_binary, "ruby"]] + args
-        else
-          "#{Exec.ruby_binary} #{args}"
-        end
-      exec(cmd, opts, &block)
-    end
-
-    def sh(cmd, opts = {})
-      exec(cmd, opts).exit_code
-    end
-
-    def capture(cmd, opts = {})
-      exec(cmd, opts.merge(out_to: :capture)).captured_out
-    end
-
-    def self.ruby_binary
-      ::File.join(::RbConfig::CONFIG["bindir"], ::RbConfig::CONFIG["ruby_install_name"])
-    end
-
+module Toys
+  module Helpers
     ##
-    # The object passed to a subcommand control block
+    # A set of helper methods for invoking subcommands
     #
-    class Controller
-      def initialize(ins, out, err, out_err, pid)
-        @in = ins
-        @out = out
-        @err = err
-        @out_err = out_err
-        @pid = pid
+    module Exec
+      def configure_exec(opts = {})
+        @exec_config ||= {}
+        @exec_config.merge!(opts)
       end
 
-      attr_reader :in
-      attr_reader :out
-      attr_reader :err
-      attr_reader :out_err
-      attr_reader :pid
+      def exec(cmd, opts = {}, &block)
+        exec_opts = ExecOpts.new(self)
+        exec_opts.add(@exec_config) if defined? @exec_config
+        exec_opts.add(opts)
+        executor = Executor.new(exec_opts, cmd)
+        executor.execute(&block)
+      end
 
-      def kill(signal)
-        ::Process.kill(signal, pid)
+      def ruby(args, opts = {}, &block)
+        cmd =
+          if args.is_a?(Array)
+            [[Exec.ruby_binary, "ruby"]] + args
+          else
+            "#{Exec.ruby_binary} #{args}"
+          end
+        exec(cmd, opts, &block)
       end
-    end
 
-    ##
-    # The return result from a subcommand
-    #
-    class Result
-      def initialize(out, err, out_err, status)
-        @captured_out = out
-        @captured_err = err
-        @captured_out_err = out_err
-        @status = status
+      def sh(cmd, opts = {})
+        exec(cmd, opts).exit_code
       end
 
-      attr_reader :captured_out
-      attr_reader :captured_err
-      attr_reader :captured_out_err
-      attr_reader :status
+      def capture(cmd, opts = {})
+        exec(cmd, opts.merge(out_to: :capture)).captured_out
+      end
 
-      def exit_code
-        status.exitstatus
+      def self.ruby_binary
+        ::File.join(::RbConfig::CONFIG["bindir"], ::RbConfig::CONFIG["ruby_install_name"])
       end
-    end
 
-    ##
-    # An internal helper class storing the configuration of a subcommand invocation
-    # @private
-    #
-    class ExecOpts
       ##
-      # Option keys that belong to exec configuration rather than spawn
-      # @private
+      # The object passed to a subcommand control block
       #
-      CONFIG_KEYS = %i[
-        exit_on_nonzero_status
-        env
-        log_level
-        in_from
-        out_to
-        err_to
-        out_err_to
-      ].freeze
+      class Controller
+        def initialize(ins, out, err, out_err, pid)
+          @in = ins
+          @out = out
+          @err = err
+          @out_err = out_err
+          @pid = pid
+        end
 
-      def initialize(context)
-        @context = context
-        @config = {}
-        @spawn_opts = {}
-      end
+        attr_reader :in
+        attr_reader :out
+        attr_reader :err
+        attr_reader :out_err
+        attr_reader :pid
 
-      def add(config)
-        config.each do |k, v|
-          if CONFIG_KEYS.include?(k)
-            @config[k] = v
-          else
-            @spawn_opts[k] = v
-          end
+        def kill(signal)
+          ::Process.kill(signal, pid)
         end
       end
 
-      attr_reader :config
-      attr_reader :spawn_opts
-      attr_reader :context
-    end
+      ##
+      # The return result from a subcommand
+      #
+      class Result
+        def initialize(out, err, out_err, status)
+          @captured_out = out
+          @captured_err = err
+          @captured_out_err = out_err
+          @status = status
+        end
 
-    ##
-    # An object that manages the execution of a subcommand
-    # @private
-    #
-    class Executor
-      def initialize(exec_opts, cmd)
-        @cmd = Array(cmd)
-        @config = exec_opts.config
-        @context = exec_opts.context
-        @spawn_opts = exec_opts.spawn_opts.dup
-        @captures = {}
-        @controller_streams = {}
-        @join_threads = []
-        @child_streams = []
-      end
+        attr_reader :captured_out
+        attr_reader :captured_err
+        attr_reader :captured_out_err
+        attr_reader :status
 
-      def execute(&block)
-        setup_in_stream
-        setup_out_stream(:out, :out_to, :out)
-        setup_out_stream(:err, :err_to, :err)
-        setup_out_stream(:out_err, :out_err_to, [:out, :err])
-        log_command
-        wait_thread = start_process
-        status = control_process(wait_thread, &block)
-        create_result(status)
-      end
+        def exit_code
+          status.exitstatus
+        end
 
-      private
+        def success?
+          exit_code.zero?
+        end
 
-      def log_command
-        unless @config[:log_level] == false
-          cmd_str = @cmd.size == 1 ? @cmd.first : @cmd.inspect
-          @context.logger.add(@config[:log_level] || ::Logger::INFO, cmd_str)
+        def error?
+          !exit_code.zero?
         end
       end
 
-      def start_process
-        args = []
-        args << @config[:env] if @config[:env]
-        args.concat(@cmd)
-        pid = ::Process.spawn(*args, @spawn_opts)
-        @child_streams.each(&:close)
-        ::Process.detach(pid)
-      end
+      ##
+      # An internal helper class storing the configuration of a subcommand invocation
+      # @private
+      #
+      class ExecOpts
+        ##
+        # Option keys that belong to exec configuration rather than spawn
+        # @private
+        #
+        CONFIG_KEYS = %i[
+          exit_on_nonzero_status
+          env
+          log_level
+          in_from
+          out_to
+          err_to
+          out_err_to
+        ].freeze
+
+        def initialize(context)
+          @context = context
+          @config = {}
+          @spawn_opts = {}
+        end
 
-      def control_process(wait_thread)
-        begin
-          if block_given?
-            controller = Controller.new(
-              @controller_streams[:in], @controller_streams[:out], @controller_streams[:err],
-              @controller_streams[:out_err], wait_thread.pid
-            )
-            yield controller
+        def add(config)
+          config.each do |k, v|
+            if CONFIG_KEYS.include?(k)
+              @config[k] = v
+            else
+              @spawn_opts[k] = v
+            end
           end
-        ensure
-          @controller_streams.each_value(&:close)
         end
-        @join_threads.each(&:join)
-        wait_thread.value
+
+        attr_reader :config
+        attr_reader :spawn_opts
+        attr_reader :context
       end
 
-      def create_result(status)
-        if @config[:exit_on_nonzero_status]
-          exit_status = status.exitstatus
-          @context.exit(exit_status) if exit_status != 0
+      ##
+      # An object that manages the execution of a subcommand
+      # @private
+      #
+      class Executor
+        def initialize(exec_opts, cmd)
+          @cmd = Array(cmd)
+          @config = exec_opts.config
+          @context = exec_opts.context
+          @spawn_opts = exec_opts.spawn_opts.dup
+          @captures = {}
+          @controller_streams = {}
+          @join_threads = []
+          @child_streams = []
         end
-        Result.new(@captures[:out], @captures[:err], @captures[:out_err], status)
-      end
 
-      def setup_in_stream
-        setting = @config[:in_from]
-        if setting
-          r, w = ::IO.pipe
-          @spawn_opts[:in] = r
-          w.sync = true
-          @child_streams << r
-          case setting
-          when :controller
-            @controller_streams[:in] = w
-          when String
-            write_string_thread(w, setting)
-          else
-            raise "Unknown type for in_from"
-          end
+        def execute(&block)
+          setup_in_stream
+          setup_out_stream(:out, :out_to, :out)
+          setup_out_stream(:err, :err_to, :err)
+          setup_out_stream(:out_err, :out_err_to, [:out, :err])
+          log_command
+          wait_thread = start_process
+          status = control_process(wait_thread, &block)
+          create_result(status)
         end
-      end
 
-      def setup_out_stream(stream_name, config_key, spawn_key)
-        setting = @config[config_key]
-        if setting
-          r, w = ::IO.pipe
-          @spawn_opts[spawn_key] = w
-          @child_streams << w
-          case setting
-          when :controller
-            @controller_streams[stream_name] = r
-          when :capture
-            @join_threads << capture_stream_thread(r, stream_name)
-          else
-            raise "Unknown type for #{config_key}"
+        private
+
+        def log_command
+          unless @config[:log_level] == false
+            cmd_str = @cmd.size == 1 ? @cmd.first : @cmd.inspect
+            @context.logger.add(@config[:log_level] || ::Logger::INFO, cmd_str)
           end
         end
-      end
 
-      def write_string_thread(stream, string)
-        ::Thread.new do
+        def start_process
+          args = []
+          args << @config[:env] if @config[:env]
+          args.concat(@cmd)
+          pid = ::Process.spawn(*args, @spawn_opts)
+          @child_streams.each(&:close)
+          ::Process.detach(pid)
+        end
+
+        def control_process(wait_thread)
           begin
-            stream.write string
+            if block_given?
+              controller = Controller.new(
+                @controller_streams[:in], @controller_streams[:out], @controller_streams[:err],
+                @controller_streams[:out_err], wait_thread.pid
+              )
+              yield controller
+            end
           ensure
-            stream.close
+            @controller_streams.each_value(&:close)
           end
+          @join_threads.each(&:join)
+          wait_thread.value
         end
-      end
 
-      def capture_stream_thread(stream, name)
-        ::Thread.new do
-          begin
-            @captures[name] = stream.read
-          ensure
-            stream.close
+        def create_result(status)
+          if @config[:exit_on_nonzero_status]
+            exit_status = status.exitstatus
+            @context.exit(exit_status) if exit_status != 0
+          end
+          Result.new(@captures[:out], @captures[:err], @captures[:out_err], status)
+        end
+
+        def setup_in_stream
+          setting = @config[:in_from]
+          if setting
+            r, w = ::IO.pipe
+            @spawn_opts[:in] = r
+            w.sync = true
+            @child_streams << r
+            case setting
+            when :controller
+              @controller_streams[:in] = w
+            when String
+              write_string_thread(w, setting)
+            else
+              raise "Unknown type for in_from"
+            end
+          end
+        end
+
+        def setup_out_stream(stream_name, config_key, spawn_key)
+          setting = @config[config_key]
+          if setting
+            r, w = ::IO.pipe
+            @spawn_opts[spawn_key] = w
+            @child_streams << w
+            case setting
+            when :controller
+              @controller_streams[stream_name] = r
+            when :capture
+              @join_threads << capture_stream_thread(r, stream_name)
+            else
+              raise "Unknown type for #{config_key}"
+            end
+          end
+        end
+
+        def write_string_thread(stream, string)
+          ::Thread.new do
+            begin
+              stream.write string
+            ensure
+              stream.close
+            end
+          end
+        end
+
+        def capture_stream_thread(stream, name)
+          ::Thread.new do
+            begin
+              @captures[name] = stream.read
+            ensure
+              stream.close
+            end
           end
         end
       end