toys 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ddcf431eae87a4ef5781ee240d99dca2bf39b9ec3d4f2343158c4f1a3e593078
+  data.tar.gz: b7b0fb7173d9e58c42814def124141af2383024c982a30096773dc835718f57c
+SHA512:
+  metadata.gz: 5dc3a473a1a2288cfc58f928629d491c4227d73a9765aae48b4384fee391999d4e096fd1fc46a1eb3290a982877a46028c5279c6ed3d863e95b11d6f6a916249
+  data.tar.gz: 378aa6465225148659697d6c4c4b75720c6f182c7539b7ef922da601fac94d5ad950a50265452d4439e9c178744b3d4906ec22d9319d444fd4c8163ac97396a0

data/bin/toys

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.absolute_path(File.join(File.dirname(__dir__), "lib")))
+require "toys"
+
+Toys::Cli.create_standard.run(ARGV)

data/lib/toys.rb

@@ -0,0 +1,10 @@
+module Toys
+end
+
+require "toys/cli"
+require "toys/context"
+require "toys/errors"
+require "toys/lookup"
+require "toys/parser"
+require "toys/tool"
+require "toys/version"

data/lib/toys/builtins/system.rb

@@ -0,0 +1,9 @@
+short_desc "A collection of system commands for toys"
+long_desc "A collection of system commands for toys"
+
+name "version" do
+  short_desc "Print current toys version"
+  execute do
+    puts Toys::VERSION
+  end
+end

data/lib/toys/cli.rb

@@ -0,0 +1,90 @@
+module Toys
+  class Cli
+    BUILTINS_PATH = File.join(__dir__, "builtins")
+    DEFAULT_DIR_NAME = ".toys"
+    DEFAULT_FILE_NAME = ".toys.rb"
+    DEFAULT_BINARY_NAME = "toys"
+    ETC_PATH = "/etc"
+
+    def initialize(
+      binary_name: nil,
+      logger: nil,
+      config_dir_name: nil,
+      config_file_name: nil,
+      index_file_name: nil
+    )
+      @lookup = Toys::Lookup.new(
+        config_dir_name: config_dir_name,
+        config_file_name: config_file_name,
+        index_file_name: index_file_name)
+      @context = Context.new(
+        @lookup,
+        logger: logger || self.class.default_logger,
+        binary_name: binary_name)
+    end
+
+    def add_paths(paths)
+      @lookup.add_paths(paths)
+      self
+    end
+
+    def add_config_paths(paths)
+      @lookup.add_config_paths(paths)
+      self
+    end
+
+    def add_config_path_hierarchy(path=nil, base="/")
+      path ||= Dir.pwd
+      paths = []
+      loop do
+        paths << path
+        break if !base || path == base
+        next_path = File.dirname(path)
+        break if next_path == path
+        path = next_path
+      end
+      @lookup.add_config_paths(paths)
+      self
+    end
+
+    def run(*args)
+      @context.run(*args)
+    end
+
+    class << self
+      def create_standard
+        cli = new(
+          binary_name: DEFAULT_BINARY_NAME,
+          config_dir_name: DEFAULT_DIR_NAME,
+          config_file_name: DEFAULT_FILE_NAME,
+          index_file_name: DEFAULT_FILE_NAME
+        )
+        cli.add_config_path_hierarchy
+        if !File.directory?(ETC_PATH) || !File.readable?(ETC_PATH)
+          cli.add_config_paths(ETC_PATH)
+        end
+        cli.add_paths(BUILTINS_PATH)
+        cli
+      end
+
+      def default_logger
+        logger = Logger.new(STDERR)
+        logger.formatter = ->(severity, time, progname, msg) {
+          msg_str =
+            case msg
+            when String
+              msg
+            when Exception
+              "#{msg.message} (#{msg.class})\n" << (msg.backtrace || []).join("\n")
+            else
+              msg.inspect
+            end
+          timestr = time.strftime("%Y-%m-%d %H:%M:%S")
+          "[%s %5s]  %s\n" % [timestr, severity, msg_str]
+        }
+        logger.level = Logger::WARN
+        logger
+      end
+    end
+  end
+end

data/lib/toys/context.rb

@@ -0,0 +1,39 @@
+module Toys
+  class Context
+    def initialize(lookup, logger: nil, binary_name: nil, tool_name: nil, args: nil, options: nil)
+      @_lookup = lookup
+      @logger = logger || Logger.new(STDERR)
+      @binary_name = binary_name
+      @tool_name = tool_name
+      @args = args
+      @options = options
+    end
+
+    attr_reader :logger
+    attr_reader :binary_name
+    attr_reader :tool_name
+    attr_reader :args
+    attr_reader :options
+
+    def [](key)
+      @options[key]
+    end
+
+    def run(*args)
+      args = args.flatten
+      tool = @_lookup.lookup(args)
+      tool.execute(self, args.slice(tool.full_name.length..-1))
+    end
+
+    def exit_with_code(code)
+      throw :result, code
+    end
+
+    attr_reader :_lookup
+
+    def _create_child(tool_name, args, options)
+      Context.new(@_lookup, logger: @logger, binary_name: @binary_name,
+        tool_name: tool_name, args: args, options: options)
+    end
+  end
+end

data/lib/toys/errors.rb

@@ -0,0 +1,7 @@
+module Toys
+  class ToolDefinitionError < StandardError
+  end
+
+  class LookupError < StandardError
+  end
+end

data/lib/toys/helpers/exec.rb

@@ -0,0 +1,50 @@
+module Toys
+  module Helpers
+    module Exec
+      def config_exec(opts={})
+        @exec_config ||= {}
+        @exec_config.merge!(opts)
+      end
+
+      def sh(cmd, opts={})
+        utils = Utils.new(self, opts, @exec_config)
+        utils.log(cmd)
+        system(cmd)
+        utils.handle_status($?.exitstatus)
+      end
+
+      def capture(cmd, opts={})
+        utils = Utils.new(self, opts, @exec_config)
+        utils.log(cmd)
+        result = ""
+        begin
+          result = `#{cmd}`
+          utils.handle_status($?.exitstatus)
+        rescue StandardError
+          utils.handle_status(-1)
+        end
+        result
+      end
+
+      class Utils
+        def initialize(context, opts, config)
+          @context = context
+          @config = config ? config.merge(opts) : opts
+        end
+
+        def log(cmd)
+          unless @config[:log_level] == false
+            @context.logger.add(@config[:log_level] || Logger::INFO, cmd)
+          end
+        end
+
+        def handle_status(status)
+          if status != 0 && @config[:report_subprocess_errors]
+            @context.exit_with_code(status)
+          end
+          status
+        end
+      end
+    end
+  end
+end

data/lib/toys/lookup.rb

@@ -0,0 +1,187 @@
+module Toys
+  class Lookup
+    def initialize(config_dir_name: nil, config_file_name: nil, index_file_name: nil)
+      @config_dir_name = config_dir_name
+      if @config_dir_name && File.extname(@config_dir_name) == ".rb"
+        raise LookupError, "Illegal config dir name #{@config_dir_name.inspect}"
+      end
+      @config_file_name = config_file_name
+      if @config_file_name && File.extname(@config_file_name) != ".rb"
+        raise LookupError, "Illegal config file name #{@config_file_name.inspect}"
+      end
+      @index_file_name = index_file_name
+      if @index_file_name && File.extname(@index_file_name) != ".rb"
+        raise LookupError, "Illegal index file name #{@index_file_name.inspect}"
+      end
+      @load_worklist = []
+      @tools = {[] => [Tool.new(nil, nil), nil]}
+      @max_priority = @min_priority = 0
+    end
+
+    def add_paths(paths, high_priority: false)
+      paths = Array(paths)
+      paths = paths.reverse if high_priority
+      paths.each do |path|
+        path = check_path(path)
+        priority = high_priority ? (@max_priority += 1) : (@min_priority -= 1)
+        @load_worklist << [path, [], priority]
+      end
+      self
+    end
+
+    def add_config_paths(paths, high_priority: false)
+      paths = Array(paths)
+      paths = paths.reverse if high_priority
+      paths.each do |path|
+        if !File.directory?(path) || !File.readable?(path)
+          raise LookupError, "Cannot read config directory #{path}"
+        end
+        priority = high_priority ? (@max_priority += 1) : (@min_priority -= 1)
+        if @config_file_name
+          p = File.join(path, @config_file_name)
+          if !File.directory?(p) && File.readable?(p)
+            @load_worklist << [p, [], priority]
+          end
+        end
+        if @config_dir_name
+          p = File.join(path, @config_dir_name)
+          if File.directory?(p) && File.readable?(p)
+            @load_worklist << [p, [], priority]
+          end
+        end
+      end
+      self
+    end
+
+    def lookup(args)
+      orig_prefix = args.take_while{ |arg| !arg.start_with?("-") }
+      cur_prefix = orig_prefix.dup
+      loop do
+        load_for_prefix(cur_prefix)
+        p = orig_prefix.dup
+        while p.length >= cur_prefix.length
+          return @tools[p].first if @tools.key?(p)
+          p.pop
+        end
+        raise "Bug: No tools found" unless cur_prefix.pop
+      end
+    end
+
+    def get_tool(words, priority)
+      if @tools.key?(words)
+        tool, tool_priority = @tools[words]
+        return tool if tool_priority.nil? || tool_priority == priority
+        return nil if tool_priority > priority
+      end
+      parent = get_tool(words[0..-2], priority)
+      return nil if parent.nil?
+      tool = Tool.new(parent, words.last)
+      @tools[words] = [tool, priority]
+      tool
+    end
+
+    def tool_defined?(words)
+      @tools.key?(words)
+    end
+
+    def list_subtools(words, recursive)
+      found_tools = []
+      len = words.length
+      @tools.each do |n, tp|
+        if n.length > 0
+          if !recursive && n.slice(0..-2) == words ||
+              recursive && n.length > len && n.slice(0, len) == words
+            found_tools << tp.first
+          end
+        end
+      end
+      found_tools.sort do |a, b|
+        a = a.full_name
+        b = b.full_name
+        while !a.empty? && !b.empty? && a.first == b.first
+          a = a.slice(1..-1)
+          b = b.slice(1..-1)
+        end
+        a.first.to_s <=> b.first.to_s
+      end
+    end
+
+    def include_path(path, words, remaining_words, priority)
+      handle_path(check_path(path), words, remaining_words, priority)
+    end
+
+    private
+
+    def load_for_prefix(prefix)
+      cur_worklist = @load_worklist
+      @load_worklist = []
+      cur_worklist.each do |path, words, priority|
+        handle_path(path, words, calc_remaining_words(prefix, words), priority)
+      end
+    end
+
+    def handle_path(path, words, remaining_words, priority)
+      if remaining_words
+        load_path(path, words, remaining_words, priority)
+      else
+        @load_worklist << [path, words, priority]
+      end
+    end
+
+    def load_path(path, words, remaining_words, priority)
+      if File.extname(path) == ".rb"
+        tool = get_tool(words, priority)
+        if tool
+          Parser.parse(path, tool, remaining_words, priority, self, IO.read(path))
+        end
+      else
+        children = Dir.entries(path) - [".", ".."]
+        children.each do |child|
+          child_path = File.join(path, child)
+          if child == @index_file_name
+            load_path(check_path(child_path), words, remaining_words, priority)
+          else
+            next unless check_path(child_path, strict: false)
+            child_word = File.basename(child, ".rb")
+            next_words = words + [child_word]
+            next_remaining_words =
+              if remaining_words.empty?
+                remaining_words
+              elsif child_word == remaining_words.first
+                remaining_words.slice(1..-1)
+              else
+                nil
+              end
+            handle_path(child_path, next_words, next_remaining_words, priority)
+          end
+        end
+      end
+    end
+
+    def check_path(path, strict: true)
+      if File.extname(path) == ".rb"
+        if File.directory?(path) || !File.readable?(path)
+          raise LookupError, "Cannot read file #{path}"
+        end
+      else
+        if !File.directory?(path) || !File.readable?(path)
+          if strict
+            raise LookupError, "Cannot read directory #{path}"
+          else
+            return nil
+          end
+        end
+      end
+      path
+    end
+
+    def calc_remaining_words(words1, words2)
+      index = 0
+      loop do
+        return words1.slice(index..-1) if index == words1.length || index == words2.length
+        return nil if words1[index] != words2[index]
+        index += 1
+      end
+    end
+  end
+end

data/lib/toys/parser.rb

@@ -0,0 +1,128 @@
+module Toys
+  class Parser
+    def initialize(path, tool, remaining_words, priority, lookup)
+      @path = path
+      @tool = tool
+      @remaining_words = remaining_words
+      @priority = priority
+      @lookup = lookup
+    end
+
+    def name(word, alias_of: nil, &block)
+      word = word.to_s
+      subtool = @lookup.get_tool(@tool.full_name + [word], @priority)
+      return self if subtool.nil?
+      if alias_of
+        if block
+          raise Toys::ToysDefinitionError, "Cannot take a block with alias_of"
+        end
+        target = @tool.full_name + [alias_of.to_s]
+        target_tool = @lookup.lookup(target)
+        unless target_tool.full_name == target
+          raise Toys::ToysDefinitionError, "Alias target #{target.inspect} not found"
+        end
+        subtool.set_alias_target(target)
+        return self
+      end
+      next_remaining = @remaining_words
+      if next_remaining && !next_remaining.empty?
+        if next_remaining.first == word
+          next_remaining = next_remaining.slice(1..-1)
+        else
+          next_remaining = nil
+        end
+      end
+      Parser.parse(@path, subtool, next_remaining, @priority, @lookup, block)
+      self
+    end
+
+    def alias_as(word)
+      unless @tool.root?
+        alias_tool = @lookup.get_tool(@tool.full_name.slice(0..-2) + [word], @priority)
+        alias_tool.set_alias_target(@tool) if alias_tool
+      end
+      self
+    end
+
+    def alias_of(target)
+      target_tool = @lookup.lookup(target)
+      unless target_tool.full_name == target
+        raise Toys::ToysDefinitionError, "Alias target #{target.inspect} not found"
+      end
+      @tool.set_alias_target(target_tool)
+      self
+    end
+
+    def include(path)
+      @tool.yield_definition do
+        @lookup.include_path(path, @tool.full_name, @remaining_words, @priority)
+      end
+      self
+    end
+
+    def long_desc(desc)
+      @tool.long_desc = desc
+      self
+    end
+
+    def short_desc(desc)
+      @tool.short_desc = desc
+      self
+    end
+
+    def switch(key, *switches, accept: nil, default: nil, doc: nil)
+      @tool.add_switch(key, *switches, accept: accept, default: default, doc: doc)
+      self
+    end
+
+    def required_arg(key, accept: nil, doc: nil)
+      @tool.add_required_arg(key, accept: accept, doc: doc)
+      self
+    end
+
+    def optional_arg(key, accept: nil, default: nil, doc: nil)
+      @tool.add_optional_arg(key, accept: accept, default: default, doc: doc)
+      self
+    end
+
+    def remaining_args(key, accept: nil, default: [], doc: nil)
+      @tool.set_remaining_args(key, accept: accept, default: default, doc: doc)
+      self
+    end
+
+    def execute(&block)
+      @tool.executor = block
+      self
+    end
+
+    def helper(name, &block)
+      @tool.add_helper(name, &block)
+      self
+    end
+
+    def helper_module(mod, &block)
+      if block
+        @tool.define_helper_module(mod, &block)
+      else
+        @tool.use_helper_module(mod)
+      end
+      self
+    end
+
+    def _binding
+      binding
+    end
+
+    def self.parse(path, tool, remaining_words, priority, lookup, source)
+      parser = new(path, tool, remaining_words, priority, lookup)
+      tool.defining_from(path) do
+        if String === source
+          eval(source, parser._binding, path, 1)
+        elsif Proc === source
+          parser.instance_eval(&source)
+        end
+      end
+      tool
+    end
+  end
+end

data/lib/toys/tool.rb

@@ -0,0 +1,450 @@
+require "logger"
+require "optparse"
+
+module Toys
+  class Tool
+
+    def initialize(parent, name)
+      @parent = parent
+      @simple_name = name
+      @full_name = name ? [name] : []
+      @full_name = parent.full_name + @full_name if parent
+
+      @definition_path = nil
+      @cur_path = nil
+
+      @alias_target = nil
+
+      @long_desc = nil
+      @short_desc = nil
+
+      @default_data = {}
+      @switches = []
+      @required_args = []
+      @optional_args = []
+      @remaining_args = nil
+      @helpers = {}
+      @modules = []
+      @executor = nil
+
+      @defined_modules = {}
+    end
+
+    attr_reader :simple_name
+    attr_reader :full_name
+
+    def root?
+      @parent.nil?
+    end
+
+    def display_name
+      full_name.join(" ")
+    end
+
+    def effective_short_desc
+      @short_desc || default_desc
+    end
+
+    def effective_long_desc
+      @long_desc || @short_desc || default_desc
+    end
+
+    def has_description?
+      !@long_desc.nil? || !@short_desc.nil?
+    end
+
+    def has_definition?
+      !@default_data.empty? || !@switches.empty? ||
+        !@required_args.empty? || !@optional_args.empty? ||
+        !@remaining_args.nil? || !!@executor ||
+        !@helpers.empty? || !@modules.empty?
+    end
+
+    def only_collection?
+      @executor == false
+    end
+
+    def defining_from(path)
+      raise ToolDefinitionError, "Already being defined" if @cur_path
+      @cur_path = path
+      begin
+        yield
+      ensure
+        @definition_path = @cur_path if has_description? || has_definition?
+        @cur_path = nil
+      end
+    end
+
+    def yield_definition
+      saved_path = @cur_path
+      @cur_path = nil
+      begin
+        yield
+      ensure
+        @cur_path = saved_path
+      end
+    end
+
+    def set_alias_target(target_tool)
+      unless target_tool.is_a?(Toys::Tool)
+        raise ArgumentError, "Illegal target type"
+      end
+      if only_collection?
+        raise ToolDefinitionError, "Tool #{display_name.inspect} is already" \
+          " a collection and cannot be made an alias"
+      end
+      if has_description? || has_definition?
+        raise ToolDefinitionError, "Tool #{display_name.inspect} already has" \
+          " a definition and cannot be made an alias"
+      end
+      if @executor == false
+        raise ToolDefinitionError, "Cannot make tool #{display_name.inspect}" \
+          " an alias because a descendant is already executable"
+      end
+      @parent.ensure_collection_only(full_name) if @parent
+      @alias_target = target_tool
+    end
+
+    def define_helper_module(name, &block)
+      if @alias_target
+        raise ToolDefinitionError, "Tool #{display_name.inspect} is an alias"
+      end
+      unless name.is_a?(String)
+        raise ToolDefinitionError,
+          "Helper module name #{name.inspect} is not a string"
+      end
+      if @defined_modules.key?(name)
+        raise ToolDefinitionError,
+          "Helper module #{name.inspect} is already defined"
+      end
+      mod = Module.new(&block)
+      mod.instance_methods.each do |meth|
+        name_str = meth.to_s
+        unless name_str =~ /^[a-z]\w+$/
+          raise ToolDefinitionError,
+            "Illegal helper method name: #{name_str.inspect}"
+        end
+      end
+      @defined_modules[name] = mod
+    end
+
+    def short_desc=(str)
+      check_definition_state
+      @short_desc = str
+    end
+
+    def long_desc=(str)
+      check_definition_state
+      @long_desc = str
+    end
+
+    def add_helper(name, &block)
+      check_definition_state(true)
+      name_str = name.to_s
+      unless name_str =~ /^[a-z]\w+$/
+        raise ToolDefinitionError, "Illegal helper name: #{name_str.inspect}"
+      end
+      @helpers[name.to_sym] = block
+    end
+
+    def use_helper_module(mod)
+      check_definition_state(true)
+      case mod
+      when Module
+        @modules << mod
+      when Symbol
+        mod = mod.to_s
+        file_name = mod.gsub(/([a-zA-Z])([A-Z])/){ |m| "#{$1}_#{$2.downcase}" }.downcase
+        require "toys/helpers/#{file_name}"
+        const_name = mod.gsub(/_([a-zA-Z0-9])/){ |m| $1.upcase }.capitalize
+        @modules << Toys::Helpers.const_get(const_name)
+      when String
+        @modules << mod
+      else
+        raise ToolDefinitionError, "Illegal helper module name: #{mod.inspect}"
+      end
+    end
+
+    def add_switch(key, *switches, accept: nil, default: nil, doc: nil)
+      check_definition_state(true)
+      @default_data[key] = default
+      switches << "--#{canonical_switch(key)}=VALUE" if switches.empty?
+      switches << accept unless accept.nil?
+      switches += Array(doc)
+      @switches << [key, switches]
+    end
+
+    def add_required_arg(key, accept: nil, doc: nil)
+      check_definition_state(true)
+      @default_data[key] = nil
+      @required_args << [key, accept, Array(doc)]
+    end
+
+    def add_optional_arg(key, accept: nil, default: nil, doc: nil)
+      check_definition_state(true)
+      @default_data[key] = default
+      @optional_args << [key, accept, Array(doc)]
+    end
+
+    def set_remaining_args(key, accept: nil, default: [], doc: nil)
+      check_definition_state(true)
+      @default_data[key] = default
+      @remaining_args = [key, accept, Array(doc)]
+    end
+
+    def executor=(executor)
+      check_definition_state(true)
+      @executor = executor
+    end
+
+    def execute(context, args)
+      return @alias_target.execute(context, args) if @alias_target
+      execution_data = parse_args(args, context.binary_name)
+      context = create_child_context(context, args, execution_data)
+      if execution_data[:usage_error]
+        puts(execution_data[:usage_error])
+        puts("")
+        show_usage(context, execution_data[:optparse])
+        -1
+      elsif execution_data[:show_help]
+        show_usage(context, execution_data[:optparse],
+                   recursive: execution_data[:recursive])
+        0
+      else
+        catch(:result) do
+          context.instance_eval(&@executor)
+          0
+        end
+      end
+    end
+
+    protected
+
+    def find_module_named(name)
+      return @defined_modules[name] if @defined_modules.key?(name)
+      return @parent.find_module_named(name) if @parent
+      nil
+    end
+
+    def ensure_collection_only(source_name)
+      if has_definition?
+        raise ToolDefinitionError, "Cannot create tool #{source_name.inspect}" \
+          " because #{display_name.inspect} is already a tool."
+      end
+      if @executor != false
+        @executor = false
+        @parent.ensure_collection_only(source_name) if @parent
+      end
+    end
+
+    private
+
+    SPECIAL_FLAGS = ["-q", "--quiet", "-v", "--verbose", "-?", "-h", "--help"]
+
+    def default_desc
+      if @alias_target
+        "(Alias of #{@alias_target.display_name.inspect})"
+      elsif @executor
+        "(No description available)"
+      else
+        "(A collection of commands)"
+      end
+    end
+
+    def check_definition_state(execution_field=false)
+      if @alias_target
+        raise ToolDefinitionError, "Tool #{display_name.inspect} is an alias"
+      end
+      if @definition_path
+        in_clause = @cur_path ? "in #{@cur_path} " : ""
+        raise ToolDefinitionError,
+          "Cannot redefine tool #{display_name.inspect} #{in_clause}" \
+          "(already defined in #{@definition_path})"
+      end
+      if execution_field
+        if @executor == false
+          raise ToolDefinitionError,
+            "Cannot make tool #{display_name.inspect} executable because a" \
+            " descendant is already executable"
+        end
+        @parent.ensure_collection_only(full_name) if @parent
+      end
+    end
+
+    def leaf_option_parser(execution_data, binary_name)
+      optparse = OptionParser.new
+      banner = ["Usage:", binary_name] + full_name
+      banner << "[<options...>]" unless @switches.empty?
+      @required_args.each do |key, opts|
+        banner << "<#{canonical_switch(key)}>"
+      end
+      @optional_args.each do |key, opts|
+        banner << "[<#{canonical_switch(key)}>]"
+      end
+      if @remaining_args
+        banner << "[<#{canonical_switch(@remaining_args.first)}...>]"
+      end
+      optparse.banner = banner.join(" ")
+      desc = @long_desc || @short_desc || default_desc
+      unless desc.empty?
+        optparse.separator("")
+        optparse.separator(desc)
+      end
+      optparse.separator("")
+      optparse.separator("Options:")
+      found_special_flags = []
+      @switches.each do |key, opts|
+        found_special_flags |= (opts & SPECIAL_FLAGS)
+        optparse.on(*opts) do |val|
+          execution_data[:options][key] = val
+        end
+      end
+      flags = ["-v", "--verbose"] - found_special_flags
+      unless flags.empty?
+        optparse.on(*(flags + ["Increase verbosity"])) do
+          execution_data[:delta_severity] -= 1
+        end
+      end
+      flags = ["-q", "--quiet"] - found_special_flags
+      unless flags.empty?
+        optparse.on(*(flags + ["Decrease verbosity"])) do
+          execution_data[:delta_severity] += 1
+        end
+      end
+      flags = ["-?", "-h", "--help"] - found_special_flags
+      unless flags.empty?
+        optparse.on(*(flags + ["Show help message"])) do
+          execution_data[:show_help] = true
+        end
+      end
+      optparse
+    end
+
+    def collection_option_parser(execution_data, binary_name)
+      optparse = OptionParser.new
+      optparse.banner = (["Usage:", binary_name] + full_name + ["<command>", "[<options...>]"]).join(" ")
+      desc = @long_desc || @short_desc || default_desc
+      unless desc.empty?
+        optparse.separator("")
+        optparse.separator(desc)
+      end
+      optparse.separator("")
+      optparse.separator("Options:")
+      optparse.on("-?", "--help", "Show help message")
+      optparse.on("-r", "--[no-]recursive", "Show all subcommands recursively") do |val|
+        execution_data[:recursive] = val
+      end
+      execution_data[:show_help] = true
+      optparse
+    end
+
+    def parse_args(args, binary_name)
+      optdata = @default_data.dup
+      execution_data = {
+        show_help: false,
+        usage_error: nil,
+        delta_severity: 0,
+        recursive: false,
+        options: optdata
+      }
+      begin
+        binary_name ||= File.basename($0)
+        option_parser = @executor ?
+          leaf_option_parser(execution_data, binary_name) :
+          collection_option_parser(execution_data, binary_name)
+        execution_data[:optparse] = option_parser
+        remaining = option_parser.parse(args)
+        @required_args.each do |key, accept, doc|
+          if !execution_data[:show_help] && remaining.empty?
+            error = OptionParser::ParseError.new(*args)
+            error.reason = "No value given for required argument named <#{canonical_switch(key)}>"
+            raise error
+          end
+          optdata[key] = process_value(key, remaining.shift, accept)
+        end
+        @optional_args.each do |key, accept, doc|
+          break if remaining.empty?
+          optdata[key] = process_value(key, remaining.shift, accept)
+        end
+        unless remaining.empty?
+          if !@remaining_args
+            if @executor
+              error = OptionParser::ParseError.new(*remaining)
+              error.reason = "Extra arguments provided"
+              raise error
+            else
+              error = OptionParser::ParseError.new(*(full_name + args))
+              error.reason = "Tool not found"
+              raise error
+            end
+          end
+          key = @remaining_args[0]
+          accept = @remaining_args[1]
+          optdata[key] = remaining.map{ |arg| process_value(key, arg, accept) }
+        end
+      rescue OptionParser::ParseError => e
+        execution_data[:usage_error] = e
+      end
+      execution_data
+    end
+
+    def create_child_context(parent_context, args, execution_data)
+      context = parent_context._create_child(
+        full_name, args, execution_data[:options])
+      context.logger.level += execution_data[:delta_severity]
+      @modules.each do |mod|
+        unless Module === mod
+          found = find_module_named(mod)
+          raise StandardError, "Unable to find module #{mod}" unless found
+          mod = found
+        end
+        context.extend(mod)
+      end
+      @helpers.each do |name, block|
+        context.define_singleton_method(name, &block)
+      end
+      context
+    end
+
+    def show_usage(context, optparse, recursive: false)
+      puts(optparse.to_s)
+      if @executor
+        if !@required_args.empty? || !@optional_args.empty? || @remaining_args
+          puts("")
+          puts("Positional arguments:")
+          args_to_display = @required_args + @optional_args
+          args_to_display << @remaining_args if @remaining_args
+          args_to_display.each do |key, accept, doc|
+            puts("    #{canonical_switch(key).ljust(31)}  #{doc.first}")
+            doc[1..-1].each do |d|
+              puts("                                     #{d}")
+            end unless doc.empty?
+          end
+        end
+      else
+        puts("")
+        puts("Commands:")
+        name_len = full_name.length
+        context._lookup.list_subtools(full_name, recursive).each do |tool|
+          desc = tool.effective_short_desc
+          tool_name = tool.full_name.slice(name_len..-1).join(' ').ljust(31)
+          puts("    #{tool_name}  #{desc}")
+        end
+      end
+    end
+
+    def canonical_switch(name)
+      name.to_s.downcase.gsub("_", "-").gsub(/[^a-z0-9-]/, "")
+    end
+
+    def process_value(key, val, accept)
+      return val unless accept
+      n = canonical_switch(key)
+      result = val
+      optparse = OptionParser.new
+      optparse.on("--#{n}=VALUE", accept){ |v| result = v }
+      optparse.parse(["--#{n}", val])
+      result
+    end
+  end
+end

data/lib/toys/version.rb

@@ -0,0 +1,3 @@
+module Toys
+  VERSION = "0.1.0".freeze
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: toys
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel Azuma
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+- !ruby/object:Gem::Dependency
+  name: minitest-focus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: minitest-rg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Command line tool framework
+email:
+- dazuma@gmail.com
+executables:
+- toys
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/toys
+- lib/toys.rb
+- lib/toys/builtins/system.rb
+- lib/toys/cli.rb
+- lib/toys/context.rb
+- lib/toys/errors.rb
+- lib/toys/helpers/exec.rb
+- lib/toys/lookup.rb
+- lib/toys/parser.rb
+- lib/toys/tool.rb
+- lib/toys/version.rb
+homepage: https://github.com/dazuma/toys
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Command line tool framework
+test_files: []