toys-core 0.3.6 → 0.3.7

data/lib/toys/errors.rb

@@ -79,7 +79,7 @@ module Toys
           e = ContextualError.new(e, banner, opts)
         end
         raise e
-      rescue ::StandardError => e
+      rescue ::ScriptError, ::StandardError => e
         e = ContextualError.new(e, banner)
         add_fields_if_missing(e, opts)
         add_config_path_if_missing(e, path)
@@ -92,7 +92,7 @@ module Toys
       rescue ContextualError => e
         add_fields_if_missing(e, opts)
         raise e
-      rescue ::StandardError => e
+      rescue ::ScriptError, ::StandardError => e
         raise ContextualError.new(e, banner, opts)
       end
 

data/lib/toys/helpers.rb

@@ -45,10 +45,10 @@ module Toys
     # * `:spinner` : Displays a spinner on the terminal.
     #
     # @param [String,Symbol] name Name of the helper module to return
-    # @return [Module,nil] The module, or `nil` if not found
+    # @return [Module,nil] The module.
     #
-    def self.lookup(name)
-      Utils::ModuleLookup.lookup(:helpers, name)
+    def self.lookup!(name)
+      Utils::ModuleLookup.lookup!(:helpers, name)
     end
   end
 end

data/lib/toys/helpers/exec.rb

@@ -37,24 +37,15 @@ module Toys
     # in a string. Also provides an interface for controlling a spawned
     # process's streams.
     #
+    # You may make these methods available to your tool by including the
+    # following directive in your tool configuration:
+    #
+    #     include :exec
+    #
     # This is a frontend for {Toys::Utils::Exec}. More information is
     # available in that class's documentation.
     #
     module Exec
-      ## @private
-      def self.extended(context)
-        context[Exec] = Utils::Exec.new do |k|
-          case k
-          when :logger
-            context[Context::LOGGER]
-          when :nonzero_status_handler
-            if context[Context::EXIT_ON_NONZERO_STATUS]
-              proc { |s| context.exit(s.exitstatus) }
-            end
-          end
-        end
-      end
-
       ##
       # Set default configuration keys.
       #
@@ -62,7 +53,7 @@ module Toys
       #     configuration options in the {Toys::Utils::Exec} docs.
       #
       def configure_exec(opts = {})
-        self[Exec].configure_defaults(opts)
+        Exec._exec(self).configure_defaults(Exec._setup_exec_opts(opts, self))
       end
 
       ##
@@ -82,7 +73,7 @@ module Toys
       #     code and any captured output.
       #
       def exec(cmd, opts = {}, &block)
-        self[Exec].exec(cmd, Exec._setup_exec_opts(opts, self), &block)
+        Exec._exec(self).exec(cmd, Exec._setup_exec_opts(opts, self), &block)
       end
 
       ##
@@ -101,7 +92,7 @@ module Toys
       #     code and any captured output.
       #
       def ruby(args, opts = {}, &block)
-        self[Exec].ruby(args, Exec._setup_exec_opts(opts, self), &block)
+        Exec._exec(self).ruby(args, Exec._setup_exec_opts(opts, self), &block)
       end
 
       ##
@@ -110,13 +101,11 @@ module Toys
       # @param [String] cmd The shell command to execute.
       # @param [Hash] opts The command options. See the section on
       #     configuration options in the {Toys::Utils::Exec} module docs.
-      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller for
-      #     the subprocess streams.
       #
       # @return [Integer] The exit code
       #
       def sh(cmd, opts = {})
-        self[Exec].sh(cmd, Exec._setup_exec_opts(opts, self))
+        Exec._exec(self).sh(cmd, Exec._setup_exec_opts(opts, self))
       end
 
       ##
@@ -128,21 +117,38 @@ module Toys
       # @param [String,Array<String>] cmd The command to execute.
       # @param [Hash] opts The command options. See the section on
       #     configuration options in the {Toys::Utils::Exec} module docs.
-      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller for
-      #     the subprocess streams.
       #
       # @return [String] What was written to standard out.
       #
       def capture(cmd, opts = {})
-        self[Exec].capture(cmd, Exec._setup_exec_opts(opts, self))
+        Exec._exec(self).capture(cmd, Exec._setup_exec_opts(opts, self))
+      end
+
+      ##
+      # Exit if the given status code is nonzero. Otherwise, returns 0.
+      #
+      # @param [Integer,Process::Status,Toys::Utils::Exec::Result] status
+      #
+      def exit_on_nonzero_status(status)
+        status = status.exit_code if status.respond_to?(:exit_code)
+        status = status.exitstatus if status.respond_to?(:exitstatus)
+        exit(status) unless status.zero?
+        0
+      end
+
+      ## @private
+      def self._exec(tool)
+        tool[Exec] ||= Utils::Exec.new do |k|
+          k == :logger ? tool[Tool::Keys::LOGGER] : nil
+        end
       end
 
       ## @private
-      def self._setup_exec_opts(opts, context)
+      def self._setup_exec_opts(opts, tool)
         return opts unless opts.key?(:exit_on_nonzero_status)
         nonzero_status_handler =
           if opts[:exit_on_nonzero_status]
-            proc { |s| context.exit(s.exitstatus) }
+            proc { |s| tool.exit(s.exitstatus) }
           end
         opts.merge(nonzero_status_handler: nonzero_status_handler)
       end

data/lib/toys/helpers/fileutils.rb

@@ -34,10 +34,16 @@ module Toys
     ##
     # A module that provides all methods in the "fileutils" standard library.
     #
+    # You may make the methods in the `FileUtils` standard library module
+    # available to your tool by including the following directive in your tool
+    # configuration:
+    #
+    #     include :fileutils
+    #
     module Fileutils
       ## @private
-      def self.extend_object(obj)
-        obj.extend(::FileUtils)
+      def self.included(mod)
+        mod.include(::FileUtils)
       end
     end
   end

data/lib/toys/helpers/highline.rb

@@ -27,12 +27,19 @@
 # POSSIBILITY OF SUCH DAMAGE.
 ;
 
+require "toys/utils/gems"
+Toys::Utils::Gems.activate("highline", "~> 1.7")
 require "highline"
 
 module Toys
   module Helpers
     ##
-    # A module that provides access to highline.
+    # A module that provides access to the capabilities of the highline gem.
+    #
+    # You may make these methods available to your tool by including the
+    # following directive in your tool configuration:
+    #
+    #     include :highline
     #
     module Highline
       ##

data/lib/toys/{alias.rb → helpers/terminal.rb}

@@ -27,68 +27,59 @@
 # POSSIBILITY OF SUCH DAMAGE.
 ;
 
+require "toys/utils/terminal"
+
 module Toys
-  ##
-  # An alias is a name that refers to another name.
-  #
-  class Alias
+  module Helpers
     ##
-    # Create a new alias.
+    # A helper that provides a simple terminal. It includes a set of methods
+    # that produce styled output, get user input, and otherwise interact with
+    # the user's terminal.
     #
-    # @param [Array<String>] full_name The name of the alias.
-    # @param [String,Array<String>] target The name of the target. May either
-    #     be a local reference (a single string) or a global reference (an
-    #     array of strings)
+    # You may make these methods available to your tool by including the
+    # following directive in your tool configuration:
     #
-    def initialize(full_name, target)
-      @target_name =
-        if target.is_a?(::String)
-          full_name[0..-2] + [target]
-        else
-          target.dup
-        end
-      @target_name.freeze
-      @full_name = full_name.dup.freeze
-    end
-
-    ##
-    # Return the name of the tool as an array of strings.
-    # This array may not be modified.
-    # @return [Array<String>]
+    #     include :terminal
     #
-    attr_reader :full_name
+    module Terminal
+      ##
+      # Returns a global terminal instance
+      # @return [Toys::Utils::Terminal]
+      #
+      def terminal
+        self[Terminal] ||= Utils::Terminal.new
+      end
 
-    ##
-    # Return the name of the target as an array of strings.
-    # This array may not be modified.
-    # @return [Array<String>]
-    #
-    attr_reader :target_name
+      ##
+      # @see Toys::Utils::Terminal#puts
+      #
+      def puts(str = "", *styles)
+        terminal.puts(str, *styles)
+      end
 
-    ##
-    # Returns the local name of this tool.
-    # @return [String]
-    #
-    def simple_name
-      full_name.last
-    end
+      ##
+      # @see Toys::Utils::Terminal#write
+      #
+      def write(str = "", *styles)
+        terminal.write(str, *styles)
+      end
 
-    ##
-    # Returns a displayable name of this tool, generally the full name
-    # delimited by spaces.
-    # @return [String]
-    #
-    def display_name
-      full_name.join(" ")
-    end
+      ##
+      # @see Toys::Utils::Terminal#confirm
+      #
+      def confirm(prompt = "Proceed?")
+        terminal.confirm(prompt)
+      end
 
-    ##
-    # Returns a displayable name of the target, generally the full name
-    # delimited by spaces.
-    # @return [String]
-    #
-    def display_target
-      target_name.join(" ")
+      ##
+      # @see Toys::Utils::Terminal#spinner
+      #
+      def spinner(leading_text: "", final_text: "",
+                  frame_length: nil, frames: nil, style: nil, &block)
+        terminal.spinner(leading_text: leading_text, final_text: final_text,
+                         frame_length: frame_length, frames: frames, style: style,
+                         &block)
+      end
     end
   end
 end

data/lib/toys/input_file.rb

@@ -0,0 +1,61 @@
+# 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.
+;
+
+##
+# Internal modules providing constant namespaces for config files.
+#
+module Toys::InputFile # rubocop:disable Style/ClassAndModuleChildren
+  ## @private
+  def self.__binding
+    binding
+  end
+
+  ## @private
+  def self.evaluate(tool_class, remaining_words, path)
+    namespace = ::Module.new
+    namespace.module_eval do
+      include ::Toys::Tool::Keys
+      @tool_class = tool_class
+    end
+    name = "M#{namespace.object_id}"
+    const_set(name, namespace)
+    str = <<-STR
+      module #{name}; @tool_class.class_eval do
+      #{::IO.read(path)}
+      end end
+    STR
+    ::Toys::DSL::Tool.prepare(tool_class, remaining_words, path) do
+      ::Toys::ContextualError.capture_path("Error while loading Toys config!", path) do
+        # rubocop:disable Security/Eval
+        eval(str, __binding, path, 0)
+        # rubocop:enable Security/Eval
+      end
+    end
+  end
+end

data/lib/toys/loader.rb

@@ -33,6 +33,17 @@ module Toys
   # appropriate tool given a set of command line arguments.
   #
   class Loader
+    ## @private
+    ToolData = ::Struct.new(:definitions, :top_priority, :active_priority) do
+      def top_definition
+        top_priority ? definitions[top_priority] : nil
+      end
+
+      def active_definition
+        active_priority ? definitions[active_priority] : nil
+      end
+    end
+
     ##
     # Create a Loader
     #
@@ -60,7 +71,7 @@ module Toys
       @preload_file_name = preload_file_name
       @middleware_stack = middleware_stack
       @load_worklist = []
-      @tools = {}
+      @tool_data = {}
       @max_priority = @min_priority = 0
     end
 
@@ -93,27 +104,26 @@ module Toys
     # that are not part of the tool name and should be passed as tool args.
     #
     # @param [String] args Command line arguments
-    # @return [Array(Toys::Tool,Array<String>)]
+    # @return [Array(Toys::Definition::Tool,Array<String>)]
     #
     def lookup(args)
       orig_prefix = args.take_while { |arg| !arg.start_with?("-") }
-      cur_prefix = orig_prefix.dup
+      cur_prefix = orig_prefix
       loop do
         load_for_prefix(cur_prefix)
-        p = orig_prefix.dup
-        while p.length >= cur_prefix.length
-          tool = get_tool(p, [])
-          if tool
-            finish_definitions_in_tree(tool.full_name)
-            return [tool, args.slice(p.length..-1)]
+        p = orig_prefix
+        loop do
+          tool_definition = get_active_tool(p, [])
+          if tool_definition
+            finish_definitions_in_tree(tool_definition.full_name)
+            return [tool_definition, args.slice(p.length..-1)]
           end
-          p.pop
+          break if p.empty? || p.length <= cur_prefix.length
+          p = p.slice(0..-2)
         end
-        break unless cur_prefix.pop
+        return nil if cur_prefix.empty?
+        cur_prefix = cur_prefix.slice(0..-2)
       end
-      tool = get_or_create_tool([])
-      finish_definitions_in_tree([])
-      [tool, args]
     end
 
     ##
@@ -123,20 +133,21 @@ module Toys
     # @param [Array<String>] words The name of the parent tool
     # @param [Boolean] recursive If true, return all subtools recursively
     #     rather than just the immediate children (the default)
-    # @return [Array<Toys::Tool,Tool::Alias>]
+    # @return [Array<Toys::Definition::Tool,Tool::Definition::Alias>]
     #
     def list_subtools(words, recursive: false)
       load_for_prefix(words)
       found_tools = []
       len = words.length
-      @tools.each do |n, tp|
+      @tool_data.each do |n, td|
         next if n.empty?
         if recursive
           next if n.length <= len || n.slice(0, len) != words
         else
           next unless n.slice(0..-2) == words
         end
-        found_tools << tp.first
+        tool = td.active_definition || td.top_definition
+        found_tools << tool unless tool.nil?
       end
       sort_tools_by_name(found_tools)
     end
@@ -151,7 +162,7 @@ module Toys
     def has_subtools?(words)
       load_for_prefix(words)
       len = words.length
-      @tools.each do |n, _tp|
+      @tool_data.each_key do |n|
         return true if !n.empty? && n.length > len && n.slice(0, len) == words
       end
       false
@@ -167,9 +178,10 @@ module Toys
     def finish_definitions_in_tree(words)
       load_for_prefix(words)
       len = words.length
-      @tools.each do |n, tp|
+      @tool_data.each do |n, td|
         next if n.length < len || n.slice(0, len) != words
-        tp.first.finish_definition(self) unless tp.first.is_a?(Alias)
+        tool = td.active_definition || td.top_definition
+        tool.finish_definition(self) if tool.is_a?(Definition::Tool)
       end
     end
 
@@ -178,28 +190,18 @@ module Toys
     # Does not do any loading. If the tool is not present, creates it.
     #
     # @param [Array<String>] words The name of the tool.
-    # @param [Integer,nil] priority The priority of the request.
-    # @return [Toys::Tool,Toys::Alias,nil] The tool or alias, or `nil` if the
-    #     given priority is insufficient for modification
+    # @param [Integer] priority The priority of the request.
+    # @return [Toys::Definition::Tool,Toys::Definition::Alias,nil] The tool or
+    #     alias, or `nil` if the given priority is insufficient
     #
     # @private
     #
-    def get_or_create_tool(words, priority: nil)
-      if @tools.key?(words)
-        tool, tool_priority = @tools[words]
-        if !priority || !tool_priority || tool_priority == priority
-          if priority && tool.is_a?(Alias)
-            raise LoaderError, "Cannot modify #{@words.inspect} because it is already an alias"
-          end
-          return tool
-        end
-        return nil if tool_priority > priority
-      end
-      get_or_create_tool(words[0..-2]) unless words.empty?
-      tool = Tool.new(words)
-      tool.middleware_stack.concat(Middleware.resolve_stack(@middleware_stack))
-      @tools[words] = [tool, priority]
-      tool
+    def activate_tool_definition(words, priority)
+      tool_data = get_tool_data(words)
+      return tool_data.active_definition if tool_data.active_priority == priority
+      return nil if tool_data.active_priority && tool_data.active_priority > priority
+      tool_data.active_priority = priority
+      get_tool_definition(words, priority)
     end
 
     ##
@@ -209,39 +211,20 @@ module Toys
     # @param [Array<String>] target The alias target name
     # @param [Integer] priority The priority of the request
     #
-    # @return [Toys::Alias] The alias created
+    # @return [Toys::Definition::Alias] The alias created
     #
     # @private
     #
     def make_alias(words, target, priority)
-      if @tools.key?(words)
-        tool_priority = @tools[words].last
-        if tool_priority
-          if tool_priority == priority
-            raise LoaderError, "Cannot make #{words.inspect} an alias because it is already defined"
-          elsif tool_priority > priority
-            return nil
-          end
-        end
+      tool_data = get_tool_data(words)
+      if tool_data.definitions.key?(priority)
+        raise ToolDefinitionError,
+              "Cannot make #{words.inspect} an alias because it is already defined"
       end
-      a = Alias.new(words, target)
-      @tools[words] = [a, priority]
-      a
-    end
-
-    ##
-    # Adds a tool directly to the loader.
-    # This should be used only for testing, as it overrides normal priority
-    # checking.
-    #
-    # @param [Toys::Tool] tool Tool to add.
-    # @param [Integer,nil] priority Priority for the tool.
-    #
-    # @private
-    #
-    def put_tool!(tool, priority = nil)
-      @tools[tool.full_name] = [tool, priority]
-      self
+      alias_def = Definition::Alias.new(self, words, target, priority)
+      tool_data.definitions[priority] = alias_def
+      activate_tool_definition(words, priority)
+      alias_def
     end
 
     ##
@@ -254,7 +237,7 @@ module Toys
     # @private
     #
     def tool_defined?(words)
-      @tools.key?(words)
+      @tool_data.key?(words)
     end
 
     ##
@@ -264,25 +247,47 @@ module Toys
     # @param [Array<Array<String>>] looked_up List of names that have already
     #     been traversed during alias resolution. Used to detect circular
     #     alias references.
-    # @return [Toys::Tool,nil] The tool, or `nil` if not found
+    # @return [Toys::Definition::Tool,nil] The tool, or `nil` if not found
     #
     # @private
     #
-    def get_tool(words, looked_up = [])
-      return nil unless @tools.key?(words)
-      result = @tools[words].first
-      if result.is_a?(Alias)
+    def get_active_tool(words, looked_up = [])
+      tool_data = get_tool_data(words)
+      result = tool_data.active_definition
+      case result
+      when Definition::Alias
         words = result.target_name
         if looked_up.include?(words)
-          raise LoaderError, "Circular alias references: #{looked_up.inspect}"
+          raise ToolDefinitionError, "Circular alias references: #{looked_up.inspect}"
         end
         looked_up << words
-        get_tool(words, looked_up)
-      else
+        get_active_tool(words, looked_up)
+      when Definition::Tool
         result
+      else
+        tool_data.top_definition
       end
     end
 
+    ##
+    # Get the tool definition for the given name and priority.
+    #
+    # @private
+    #
+    def get_tool_definition(words, priority)
+      parent = words.empty? ? nil : get_tool_definition(words.slice(0..-2), priority)
+      if parent.is_a?(Definition::Alias)
+        raise ToolDefinitionError,
+              "Cannot create children of #{parent.display_name.inspect} because it is an alias"
+      end
+      tool_data = get_tool_data(words)
+      if tool_data.top_priority.nil? || tool_data.top_priority < priority
+        tool_data.top_priority = priority
+      end
+      tool_data.definitions[priority] ||=
+        Definition::Tool.new(self, parent, words, priority, @middleware_stack)
+    end
+
     ##
     # Load configuration from the given path.
     #
@@ -309,6 +314,10 @@ module Toys
 
     private
 
+    def get_tool_data(words)
+      @tool_data[words] ||= ToolData.new({}, nil, nil)
+    end
+
     def load_for_prefix(prefix)
       cur_worklist = @load_worklist
       @load_worklist = []
@@ -327,7 +336,8 @@ module Toys
 
     def load_path(path, words, remaining_words, priority)
       if ::File.extname(path) == ".rb"
-        ConfigDSL.evaluate(words, remaining_words, priority, self, path, ::IO.read(path))
+        tool_class = get_tool_definition(words, priority).tool_class
+        Toys::InputFile.evaluate(tool_class, remaining_words, path)
       else
         require_preload_in(path)
         load_index_in(path, words, remaining_words, priority)