mercenary 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ab95f854272a3615464fc0189bb7dd05de87115
-  data.tar.gz: 5cb99b4246ee7194d1c69a142ef2b8ff8f1e3b3a
+  metadata.gz: d9ebb7e735aa1147cbcc69420fa3a934830c0415
+  data.tar.gz: 120e555e1d05e2af4e674b42cd9143195310b92e
 SHA512:
-  metadata.gz: d557c2b7ec5b68148a50aded7101043f5de8f8e2024faa76fd745df535fb8c06ade969c9ebe3caa0f9345d777eedef954645e59777e4ac7767b638d7e924ebec
-  data.tar.gz: 75495874c6ee7cd0c287005f4ef4ce2e4089ff07557014812f516a80805c04d7d84a6b7a021b97f8080721004bc0d7220c3e2376542e90728cb22bdac818524c
+  metadata.gz: becf09d037cb3f6475239595c42deba5c89791ccc13f5d2c622d1a88769d91e89c7da2685f1c238f2e41d0308b81cd81679f7ac7352fffa93d36cf7d989a7975
+  data.tar.gz: 2ca3a69a6039ab31343002957dec0c8753181c17817d3d6b59afaa7dc6186e3d78f501979ffae98e3ecb4ba730bdbd46e4d8d5974f653f25fedf603fc9c75cde

data/.travis.yml

@@ -1,8 +1,8 @@
 language: ruby
 rvm:
-  - 1.8.7
   - 1.9.3
   - 2.0.0
+  - 2.1.0
 script: "./script/cibuild"
 notifications:
   email:

data/History.markdown

@@ -8,6 +8,25 @@
 
 ### Development Fixes
 
+## 0.3.0 / 2014-02-20
+
+### Major Enhancements
+
+* Officially drop 1.8.7 support (#14)
+* Allow Commands to set their own versions (#17)
+* Show subcommands, options and usage in help and attach to all commands (#18)
+* Add `-t, --trace` to allow full exception backtrace to print, otherwise print
+  just the error message (#19)
+
+### Minor Enhancements
+
+* Logging state is maintained throughout process (#12)
+* Tidy up Command#logger output (#21)
+
+### Development Fixes
+
+* Added specs for `Program` (#13)
+
 ## 0.2.1 / 2013-12-25
 
 ### Bug Fixes

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Parker Moore
+Copyright (c) 2013-2014 Parker Moore
 
 MIT License
 

data/README.md

@@ -18,6 +18,8 @@ Or install it yourself as:
 
     $ gem install mercenary
 
+**Note: Mercenary may not work with Ruby < 1.9.3.**
+
 ## Usage
 
 ```ruby

data/examples/help_dialogue.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *%w{ .. lib })
+
+require "mercenary"
+
+# This example sets the logging mode of mercenary to
+# debug. Logging messages from "p.logger.debug" will
+# be output to STDOUT.
+
+Mercenary.program(:help_dialogue) do |p|
+
+  p.version "2.0.1"
+  p.description 'An example of the help dialogue in Mercenary'
+  p.syntax 'help_dialogue <subcommand>'
+
+  p.command(:some_subcommand) do |c|
+    c.version '1.4.2'
+    c.syntax 'some_subcommand <subcommand> [options]'
+    c.description 'Some subcommand to do something'
+    c.option 'an_option', '-o', '--option', 'Some option'
+
+    c.command(:yet_another_sub) do |f|
+      f.syntax 'yet_another_sub [options]'
+      f.description 'Do amazing things'
+      f.option 'blah', '-b', '--blah', 'Trigger blah flag'
+      f.option 'heh', '-H ARG', '--heh ARG', 'Give a heh'
+
+      f.action do |args, options|
+        print "Args: "
+        p args
+        print "Opts: "
+        p options
+      end
+    end
+  end
+
+  p.command(:another_subcommand) do |c|
+    c.syntax 'another_subcommand <subcommand> [options]'
+    c.description 'Another subcommand to do something different.'
+    c.option 'an_option', '-O', '--option', 'Some option'
+    c.option 'another_options', '--pluginzzz', 'Set where the plugins should be found from'
+  end
+
+end

data/examples/logging.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *%w{ .. lib })
+
+require "mercenary"
+
+# This example sets the logging mode of mercenary to
+# debug. Logging messages from "p.logger.debug" will
+# be output to STDOUT.
+
+Mercenary.program(:logger_output) do |p|
+
+  p.version "5.2.6"
+  p.description 'An example of turning on logging for Mercenary.'
+  p.syntax 'logger_output'
+
+
+  p.logger.info "The default log level is INFO. So this will output."
+  p.logger.debug "Since DEBUG is below INFO, this will not output."
+
+  p.logger(Logger::DEBUG)
+  p.logger.debug "Logger level now set to DEBUG. So everything will output."
+  
+  p.logger.debug    "Example of DEBUG level message."
+  p.logger.info     "Example of INFO level message."
+  p.logger.warn     "Example of WARN level message."
+  p.logger.error    "Example of ERROR level message."
+  p.logger.fatal    "Example of FATAL level message."
+  p.logger.unknown  "Example of UNKNOWN level message."
+
+  p.action do |args, options|
+    
+    p.logger(Logger::INFO)
+    p.logger.debug "Logger level back to INFO. This line will not output."
+    p.logger.info "This INFO message will output."
+
+  end
+
+end

data/examples/trace.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *%w{ .. lib })
+
+require "mercenary"
+
+# This example sets the logging mode of mercenary to
+# debug. Logging messages from "p.logger.debug" will
+# be output to STDOUT.
+
+Mercenary.program(:trace) do |p|
+
+  p.version "2.0.1"
+  p.description 'An example of traces in Mercenary'
+  p.syntax 'trace <subcommand>'
+
+  p.action do |_, _|
+    raise ArgumentError.new("YOU DID SOMETHING TERRIBLE YOU BUFFOON")
+  end
+
+end

data/lib/mercenary.rb

@@ -6,8 +6,10 @@ require "optparse"
 require "logger"
 
 module Mercenary
-  autoload :Command, "mercenary/command"
-  autoload :Program, "mercenary/program"
+  autoload :Command,   "mercenary/command"
+  autoload :Option,    "mercenary/option"
+  autoload :Presenter, "mercenary/presenter"
+  autoload :Program,   "mercenary/program"
 
   # Public: Instantiate a new program and execute.
   #

data/lib/mercenary/command.rb

@@ -8,6 +8,7 @@ module Mercenary
     attr_accessor :actions
     attr_reader :map
     attr_accessor :parent
+    attr_reader :trace
 
     # Public: Creates a new Command
     #
@@ -17,12 +18,23 @@ module Mercenary
     #
     # Returns nothing
     def initialize(name, parent = nil)
-      @name = name
-      @options = []
-      @commands =  {}
-      @actions = []
-      @map = {}
-      @parent = parent
+      @name     = name
+      @options  = []
+      @commands = {}
+      @actions  = []
+      @map      = {}
+      @parent   = parent
+      @trace    = false
+    end
+
+    # Public: Sets or gets the command version
+    #
+    # version - the command version (optional)
+    #
+    # Returns the version and sets it if an argument is non-nil
+    def version(version = nil)
+      @version = version if version
+      @version
     end
 
     # Public: Sets or gets the syntax string
@@ -32,7 +44,12 @@ module Mercenary
     # Returns the syntax string and sets it if an argument is present
     def syntax(syntax = nil)
       @syntax = syntax if syntax
-      @syntax
+      syntax_list = []
+      if parent
+        syntax_list << parent.syntax.to_s.gsub(/<[\w\s-]+>/, '').gsub(/\[[\w\s-]+\]/, '').strip
+      end
+      syntax_list << (@syntax || name.to_s)
+      syntax_list.join(" ")
     end
 
     # Public: Sets or gets the command description
@@ -71,8 +88,9 @@ module Mercenary
     #
     # Returns nothing
     def option(sym, *options)
-      @options << options
-      @map[options[0]] = sym
+      new_option = Option.new(sym, options)
+      @options << new_option
+      @map[new_option.hash] = sym
     end
 
     # Public: Adds a subcommand
@@ -112,15 +130,16 @@ module Mercenary
     # level - the logger level (a Logger constant, see docs for more info)
     #
     # Returns the instance of Logger
-    def logger(level = Logger::INFO)
+    def logger(level = nil)
       unless @logger
         @logger = Logger.new(STDOUT)
+        @logger.level = level || Logger::INFO
         @logger.formatter = proc do |severity, datetime, progname, msg|
-          "#{ident} (#{severity}): #{msg}\n"
+          "#{identity} | " << "#{severity.downcase.capitalize}:".ljust(7) << " #{msg}\n"
         end
       end
 
-      @logger.level = level
+      @logger.level = level unless level.nil?
       @logger
     end
 
@@ -134,6 +153,7 @@ module Mercenary
     def go(argv, opts, config)
       opts.banner = "Usage: #{syntax}"
       process_options(opts, config)
+      add_default_options(opts)
 
       if argv[0] && cmd = commands[argv[0].to_sym]
         logger.debug "Found subcommand '#{cmd.name}'"
@@ -153,13 +173,36 @@ module Mercenary
     #
     # Returns nothing
     def process_options(opts, config)
-      options.each do |o|
-        opts.on(*o) do |x|
-          config[map[o[0]]] = x
+      options.each do |option|
+        opts.on(*option.for_option_parser) do |x|
+          config[map[option.hash]] = x
         end
       end
     end
 
+    # Public: Add version and help options to the command
+    #
+    # opts - instance of OptionParser
+    #
+    # Returns nothing
+    def add_default_options(opts)
+      option 'show_help', '-h', '--help', 'Show this message'
+      option 'show_version', '-v', '--version', 'Print the name and version'
+      opts.on("-v", "--version", "Print the version") do
+        puts "#{name} #{version}"
+        abort
+      end
+
+      opts.on('-t', '--trace', 'Show full backtrace if an error occurs') do
+        @trace = true
+      end
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts self
+        exit
+      end
+    end
+
     # Public: Execute all actions given the inputted args and options
     #
     # argv - (optional) command-line args (sans opts)
@@ -188,19 +231,39 @@ module Mercenary
     #
     # Returns a string which identifies this command
     def ident
-      "<Command name=#{name}>"
+      "<Command name=#{identity}>"
+    end
+
+    # Public: Get the full identity (name & version) of this command
+    #
+    # Returns a string containing the name and version if it exists
+    def identity
+      "#{full_name} #{version if version}".strip
+    end
+
+    # Public: Get the name of the current command plus that of
+    #   its parent commands
+    #
+    # Returns the full name of the command
+    def full_name
+      the_name = []
+      the_name << parent.full_name if parent && parent.full_name
+      the_name << name
+      the_name.join(" ")
+    end
+
+    # Public: Build a string containing a summary of the command
+    #
+    # Returns a one-line summary of the command.
+    def summarize
+      "  #{name.to_s.ljust(20)}  #{description}"
     end
 
     # Public: Build a string containing the command name, options and any subcommands
     #
     # Returns the string identifying this command, its options and its subcommands
     def to_s
-      msg = ''
-      msg += "Command: #{name}\n"
-      options.each { |o| msg += "  " + o.inspect + "\n"}
-      msg += "\n"
-      commands.each { |k, v| msg += commands[k].inspect }
-      msg
+      Presenter.new(self).print_command
     end
   end
 end

data/lib/mercenary/option.rb

@@ -0,0 +1,80 @@
+module Mercenary
+  class Option
+    attr_reader :config_key, :description, :switches
+
+    # Public: Create a new Option
+    #
+    # config_key - the key in the config hash to which the value of this option will map
+    # info       - an array containing first the switches, then a description of the option
+    #
+    # Returns nothing
+    def initialize(config_key, info)
+      @config_key = config_key
+      @description = info.last unless info.last.start_with?("-")
+      set_switches(info.take(info.size - [@description].reject(&:nil?).size))
+    end
+
+    # Public: Fetch the array containing the info OptionParser is interested in
+    #
+    # Returns the array which OptionParser#on wants
+    def for_option_parser
+      [switches.reject(&:empty?), description].reject{ |o| o.nil? || o.empty? }.flatten
+    end
+
+    # Public: Build a string representation of this option including the
+    #   switches and description
+    #
+    # Returns a string representation of this option
+    def to_s
+      "#{formatted_switches}  #{description}"
+    end
+
+    # Public: Build a beautifully-formatted string representation of the switches
+    #
+    # Returns a formatted string representation of the switches
+    def formatted_switches
+      [
+        switches.first.rjust(10),
+        switches.last.ljust(13)
+      ].join(", ").gsub(/ , /, '   ').gsub(/,   /, '    ')
+    end
+
+    # Public: Hash based on the hash value of instance variables
+    #
+    # Returns a Fixnum which is unique to this Option based on the instance variables
+    def hash
+      instance_variables.map do |var|
+        instance_variable_get(var).hash
+      end.reduce(:&)
+    end
+
+    # Public: Check equivalence of two Options based on equivalence of their
+    #   instance variables
+    #
+    # Returns true if all the instance variables are equal, false otherwise
+    def eql?(other)
+      return false unless self.class.eql?(other.class)
+      instance_variables.map do |var|
+        instance_variable_get(var).eql?(other.instance_variable_get(var))
+      end.all?
+    end
+
+    private
+
+    # Private: Set the full switches array, ensuring the first element is the
+    #   short switch and the second element is the long switch
+    #
+    # Returns the corrected switches array
+    def set_switches(switches)
+      if switches.size < 2
+        if switches.first.start_with?("--")
+          switches.unshift ""
+        else
+          switches << ""
+        end
+      end
+      @switches = switches
+    end
+
+  end
+end

data/lib/mercenary/presenter.rb

@@ -0,0 +1,80 @@
+module Mercenary
+  class Presenter
+    attr_accessor :command
+
+    # Public: Make a new Presenter
+    #
+    # command - a Mercenary::Command to present
+    #
+    # Returns nothing
+    def initialize(command)
+      @command = command
+    end
+
+    # Public: Builds a string representation of the command usage
+    #
+    # Returns the string representation of the command usage
+    def usage_presentation
+      "  #{command.syntax}"
+    end
+
+    # Public: Builds a string representation of the options
+    #
+    # Returns the string representation of the options
+    def options_presentation
+      return nil unless command.options.size > 0
+      command.options.map(&:to_s).join("\n")
+    end
+
+    # Public: Builds a string representation of the subcommands
+    #
+    # Returns the string representation of the subcommands
+    def subcommands_presentation
+      return nil unless command.commands.size > 0
+      command.commands.values.map(&:summarize).join("\n")
+    end
+
+    # Public: Builds the command header, including the command identity and description
+    #
+    # Returns the command header as a String
+    def command_header
+      header = "#{command.identity}"
+      header << " -- #{command.description}" if command.description
+      header
+    end
+
+    # Public: Builds a string representation of the whole command
+    #
+    # Returns the string representation of the whole command
+    def command_presentation
+      msg = []
+      msg << command_header
+      msg << "Usage:"
+      msg << usage_presentation
+
+      if opts = options_presentation
+        msg << "Options:\n#{opts}"
+      end
+      if subcommands = subcommands_presentation
+        msg << "Subcommands:\n#{subcommands_presentation}"
+      end
+      msg.join("\n\n")
+    end
+
+    # Public: Turn a print_* into a *_presentation or freak out
+    #
+    # meth  - the method being called
+    # args  - an array of arguments passed to the missing method
+    # block - the block passed to the missing method
+    #
+    # Returns the value of whatever function is called
+    def method_missing(meth, *args, &block)
+      if meth.to_s =~ /^print_(.+)$/
+        send("#{$1.downcase}_presentation")
+      else
+        super # You *must* call super if you don't handle the method,
+              # otherwise you'll mess up Ruby's method lookup.
+      end
+    end
+  end
+end

data/lib/mercenary/program.rb

@@ -13,19 +13,9 @@ module Mercenary
       super(name)
     end
 
-    # Public: Sets or gets the program version
-    #
-    # version - the program version (optional)
-    #
-    # Returns the version and sets it if an argument is present
-    def version(version = nil)
-      @version = version if version
-      @version
-    end
-
     # Public: Run the program
     #
-    # argv   - an array of string args (usually ARGV)
+    # argv - an array of string args (usually ARGV)
     #
     # Returns nothing
     def go(argv)
@@ -35,18 +25,22 @@ module Mercenary
 
       @optparse = OptionParser.new do |opts|
         cmd = super(argv, opts, @config)
-
-        opts.on('-v', '--version', 'Print the version') do
-          puts "#{name} #{version}"
-          abort
-        end
       end
 
       @optparse.parse!(argv)
 
       logger.debug("Parsed config: #{@config.inspect}")
 
-      cmd.execute(argv, @config)
+      begin
+        cmd.execute(argv, @config)
+      rescue => e
+        if cmd.trace
+          raise e
+        else
+          logger.error e.message
+          abort
+        end
+      end
     end
   end
 end

data/lib/mercenary/version.rb

@@ -1,3 +1,3 @@
 module Mercenary
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/script/cibuild

@@ -1,3 +1,6 @@
 #! /bin/sh
 
+set -ex
+
 bundle exec rspec
+./script/examples

data/script/console

@@ -0,0 +1,3 @@
+#! /bin/bash
+
+irb -r./lib/mercenary.rb

data/script/examples

@@ -0,0 +1,17 @@
+#! /bin/bash
+
+set -e
+
+function run () {
+  echo "+ ruby ./examples/$@"
+  ruby -e "puts '=' * 79"
+  ruby ./examples/$@
+  ruby -e "puts '=' * 79"
+}
+
+run logging.rb
+run help_dialogue.rb -h
+run help_dialogue.rb some_subcommand -h
+run help_dialogue.rb another_subcommand -h
+run help_dialogue.rb some_subcommand yet_another_sub -h
+run help_dialogue.rb some_subcommand yet_another_sub -b

data/spec/command_spec.rb

@@ -35,6 +35,12 @@ describe(Mercenary::Command) do
       expect(add_sub.call(command).parent).to eq(command)
     end
 
+    it "can set its version" do
+      version = "1.4.2"
+      command.version version
+      expect(command.version).to eq(version)
+    end
+
     it "can set its syntax" do
       syntax_string = "my_name [options]"
       cmd = described_class.new(:my_name)
@@ -50,10 +56,20 @@ describe(Mercenary::Command) do
 
     it "can set its options" do
       name = "show_drafts"
-      opt  = ['--drafts', 'Render posts in the _drafts folder']
-      command.option name, *opt
-      expect(command.options).to eq([opt])
-      expect(command.map).to include({opt.first => name})
+      opts  = ['--drafts', 'Render posts in the _drafts folder']
+      option = Mercenary::Option.new(name, opts)
+      command.option name, *opts
+      expect(command.options).to eql([option])
+      expect(command.map).to include({option.hash => name})
+    end
+
+    it "knows its full name" do
+      expect(command_with_parent.full_name).to eql("my_parent i_have_parent")
+    end
+
+    it "knows its identity" do
+      command_with_parent.version '1.8.7'
+      expect(command_with_parent.identity).to eql("my_parent i_have_parent 1.8.7")
     end
 
     it "raises an ArgumentError if I specify a default_command that isn't there" do

data/spec/option_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe(Mercenary::Option) do
+  let(:config_key)  { "largo" }
+  let(:description) { "This is a description" }
+  let(:switches)    { ['-l', '--largo'] }
+  let(:option)      { described_class.new(config_key, [switches, description].flatten.reject(&:nil?)) }
+
+  it "knows its config key" do
+    expect(option.config_key).to eql(config_key)
+  end
+
+  it "knows its description" do
+    expect(option.description).to eql(description)
+  end
+
+  it "knows its switches" do
+    expect(option.switches).to eql(switches)
+  end
+
+  it "knows how to present itself" do
+    expect(option.to_s).to eql("        -l, --largo        #{description}")
+  end
+
+  it "has an OptionParser representation" do
+    expect(option.for_option_parser).to eql([switches, description].flatten)
+  end
+
+  it "compares itself with other options well" do
+    new_option = described_class.new(config_key, ['-l', '--largo', description])
+    expect(option.eql?(new_option)).to be_true
+    expect(option.hash.eql?(new_option.hash)).to be_true
+  end
+
+  it "has a custom #hash" do
+    expect(option.hash.to_s).to match(/\d+/)
+  end
+
+  context "with just the long switch" do
+    let(:switches) { ['--largo'] }
+
+    it "adds an empty string in place of the short switch" do
+      expect(option.switches).to eql(['', '--largo'])
+    end
+
+    it "sets its description properly" do
+      expect(option.description).to eql(description)
+    end
+
+    it "knows how to present the switch" do
+      expect(option.formatted_switches).to eql("            --largo      ")
+    end
+  end
+
+  context "with just the short switch" do
+    let(:switches) { ['-l'] }
+
+    it "adds an empty string in place of the long switch" do
+      expect(option.switches).to eql(['-l', ''])
+    end
+
+    it "sets its description properly" do
+      expect(option.description).to eql(description)
+    end
+
+    it "knows how to present the switch" do
+      expect(option.formatted_switches).to eql("        -l               ")
+    end
+  end
+
+  context "without a description" do
+    let(:description) { nil }
+
+    it "knows there is no description" do
+      expect(option.description).to be_nil
+    end
+
+    it "knows both inputs are switches" do
+      expect(option.switches).to eql(switches)
+    end
+  end
+
+end

data/spec/presenter_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe(Mercenary::Presenter) do
+  let(:supercommand) { Mercenary::Command.new(:script_name) }
+  let(:command) { Mercenary::Command.new(:subcommand, supercommand) }
+  let(:presenter) { described_class.new(command) }
+
+  before(:each) do
+    command.version '1.4.2'
+    command.description 'Do all the things.'
+    command.option 'one', '-1', '--one', 'The first option'
+    command.option 'two', '-2', '--two', 'The second option'
+    supercommand.commands[command.name] = command
+  end
+
+  it "knows how to present the command" do
+    expect(presenter.command_presentation).to eql("script_name subcommand 1.4.2 -- Do all the things.\n\nUsage:\n\n  script_name subcommand\n\nOptions:\n        -1, --one          The first option\n        -2, --two          The second option")
+  end
+
+  it "knows how to present the subcommands" do
+    expect(described_class.new(supercommand).subcommands_presentation).to eql("  subcommand            Do all the things.")
+  end
+
+  it "knows how to present the usage" do
+    expect(presenter.usage_presentation).to eql("  script_name subcommand")
+  end
+
+  it "knows how to present the options" do
+    expect(presenter.options_presentation).to eql("        -1, --one          The first option\n        -2, --two          The second option")
+  end
+
+  it "allows you to say print_* instead of *_presentation" do
+    expect(presenter.print_usage).to       eql(presenter.usage_presentation)
+    expect(presenter.print_subcommands).to eql(presenter.subcommands_presentation)
+    expect(presenter.print_options).to     eql(presenter.options_presentation)
+    expect(presenter.print_command).to     eql(presenter.command_presentation)
+  end
+end

data/spec/program_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe(Mercenary::Program) do
+
+  context "a basic program" do
+    let(:program) { Mercenary::Program.new(:my_name) }
+
+    it "can be created with just a name" do
+      expect(program.name).to eql(:my_name)
+    end
+
+    it "can set its version" do
+      version = Mercenary::VERSION
+      program.version version
+      expect(program.version).to eq(version)
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mercenary
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Tom Preston-Werner
@@ -9,48 +9,48 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-26 00:00:00.000000000 Z
+date: 2014-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.14'
 description: Lightweight and flexible library for writing command-line apps in Ruby.
@@ -61,22 +61,31 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".travis.yml"
+- .gitignore
+- .rspec
+- .travis.yml
 - Gemfile
 - History.markdown
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/help_dialogue.rb
+- examples/logging.rb
+- examples/trace.rb
 - lib/mercenary.rb
 - lib/mercenary/command.rb
+- lib/mercenary/option.rb
+- lib/mercenary/presenter.rb
 - lib/mercenary/program.rb
 - lib/mercenary/version.rb
 - mercenary.gemspec
 - script/bootstrap
 - script/cibuild
+- script/console
+- script/examples
 - spec/command_spec.rb
+- spec/option_spec.rb
+- spec/presenter_spec.rb
 - spec/program_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/jekyll/mercenary
@@ -89,21 +98,23 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Lightweight and flexible library for writing command-line apps in Ruby.
 test_files:
 - spec/command_spec.rb
+- spec/option_spec.rb
+- spec/presenter_spec.rb
 - spec/program_spec.rb
 - spec/spec_helper.rb