bales 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58dd5ac6bd3070bc03dc5c84db2f92c394a43fd2
-  data.tar.gz: dac3a1f876ae148806de122ceca026ac39db55ed
+  metadata.gz: 1fb40f18edf38481a779d05e661167b9a504577f
+  data.tar.gz: fdfb53af1b8ead967df753d0e03c332c10ffec3f
 SHA512:
-  metadata.gz: 650893c15923467acaa65cb97aad581b66b8cc1dcb037f74cb9013c54887cefa2d41f39897ca06a9823a6517dc24e0caffef08862d600daf8d751be0dff97484
-  data.tar.gz: 4b1f685e20a94a1012ce13ea5ec1152449accd0515c452cf02c4fbdb69a83b407df67b1ad672ba540f6dd801501754a675070b4868400a46eeadb057203aa8be
+  metadata.gz: 08f36ccf3b1ca492be4d60d7881add98f74e9f3732491e0041fe8280cb2e4d61b2ca9817a1086c3e6f5338bf2c535b5b6a04f49346552c3edda00fe0de8f41f7
+  data.tar.gz: 4f86ed0b34ad824ea2bcab12100c1bfaa2fa921d8a7a3213ba9fb805df1375221cf7954c4bef6182bb546c2eac5b5be08950d13f6a51ce901cb0fcd686726fd1

data/README.md

@@ -18,32 +18,43 @@ require 'bales'
 module SimpleApp
   class Application < Bales::Application
     version "0.0.1"
-  end
-
-  class Command < Bales::Command
-    action do
-      Bales::Command::Help.run
+    description "Sample app"
+    
+    # Default action
+    option :recipient,
+           long_form: '--to',
+           short_form: '-2',
+           type: String
+           
+    action do |args, opts|
+      opts[:recipient] ||= "world"
+      puts "Hello, #{opts[:recipient]}!"
     end
-
-    class Smack < Command
+    
+    # Subcommand
+    command "smack" do
       option :weapon,
              type: String,
              description: "Thing to smack with",
              short_form: '-w',
              long_form: '--with'
-
+             
       action do |victims, opts|
         suffix = opts[:weapon] ? " with a #{opts[:weapon]}" : ""
-
+        
         if victims.none?
           puts "You have been smacked#{suffix}."
         else
-          victims.each do |victim|
-            puts "#{victim} has been smacked#{suffix}."
-          end
+          puts "#{victim} has been smacked#{suffix}."
         end
       end
     end
+    
+    # Specify subcommand's parent class
+    command "help", parent: Bales::Command::Help
+    
+    # This is what makes the app actually run!
+    parse_and_run
   end
 end
 
@@ -53,34 +64,35 @@ SimpleApp::Application.parse_and_run
 And like this (assuming the above script lives in `/usr/local/bin/simple-app`)!
 
 ```
+$ simple-app
+Hello, world!
+$ simple-app -2 Bruce
+Hello, Bruce!
+$ simple-app --to Bruce
+Hello, Bruce!
 $ simple-app smack
 You have been smacked.
-$ simple-app smack foo
-foo has been smacked.
-$ simple-app Fred Wilma
-Fred has been smacked.
-Wilma has been smacked.
-$ simple-app smack John -w fish
-John has been smacked with a fish.
-$ simple-app smack John --with fish
-John has been smacked with a fish.
-$ simple-app smack John --with=fish
-John has been smacked with a fish.
+$ simple-app smack Bruce
+Bruce has been smacked.
+$ simple-app smack Bruce Bruce
+Bruce has been smacked.
+Bruce has been smacked.
+$ simple-app smack Bruce --with fish
+Bruce has been smacked with a fish.
 ```
 
 ## So how does it work?
 
 * Come up with a name for your app, like `MyApp`
 * Create an `Application` class under that namespace which inherits from `Bales::Application`
-* Create a `Command` class under that namespace which inherits from `Bales::Command`
-* Give that `Command` an `action`, which will be what your application does by default if no valid subcommands are passed to it
-* (Optional) Create one or more classes under the `MyApp::Command` namespace, inheriting from some subclass of `Bales::Command` (including the base command you defined previously), if you want some git-style or rails-style subcommands.
+* Use the DSL (or define classes manually, if that's your thing)
 
 Basically, a Bales app is just a bunch of classes with some fairy dust that turns them into runnable commands.  Bales will check the namespace that your subclass of `Bales::Application` lives in for a `Command` namespace, then search there for available commands.
 
-The application has (or *will* have, more precisely; I don't have a whole lot for you on this front just yet) a few available DSL-ish functions for you to play with.
+The application has a few available DSL-ish functions for you to play with.
 
 * `version`: sets your app's version number.  If you use semantic versioning, you can query this with the `major_version`, `minor_version`, and `patch_level` class methods.
+* `command "foo" { ... }`: defines a subcommand called "foo", which turns into a class called `MyApp::Command::Foo` (if you picked the name `MyApp` above).  If you provide a block, said block will be evaluated in the class' context (see below for things you can do in said context).
 
 Meanwhile, commands *also* have some DSL-ish functions to play around with.
 
@@ -90,11 +102,28 @@ Meanwhile, commands *also* have some DSL-ish functions to play around with.
   * `:long_form`: a long flag, like `'--verbose'`.  This will be created from the option's name if you don't override it here.
   * `:description`: a quick description of the option, like `"Whether or not to be verbose"`.
 * `action`: defines what the command should do when it's called.  This is provided in the form of a block.  Said block should accept two arguments (an array of arguments and a hash of options), though you don't *have* to name them with pipes and stuff if you know that your command won't take any arguments or options.
+* `description`: sets a long description of what your command does.  Should be a string.
+* `summary`: sets a short description of what your command does.  Should be a string.  Should also be shorter than `:description`, though this isn't strictly necessary.
+
+Some of the command functions (`option`, `action`, `description`, `summary`) can also be used from within the application class; doing so will define and configure a "root command", which is what is run if you run your app without any arguments.
 
-## What kind of a silly names is "Bales", anyway?
+## What can this thing already do?
+
+* Create a working command-line app
+* Automatically produce subcommands (recursively, in fact) based on the namespaces of the corresponding `Bales::Command` subclasses
+* Provide a DSL defining commands and options
+
+## What might this thing someday do in the future?
+
+* Provide some helpers to wrap things like HighLine, curses, etc.
+* Provide some additional flexibility in how options are specified without requiring users to completely reimplement a command's option parsing functions
+
+## What kind of a silly name is "Bales", anyway?
 
 It's shamelessly stolen^H^H^H^H^H^Hborrowed from Jason R. Clark's "Testing the Multiverse" talk at Ruby on Ales 2015 (which, if you haven't watched, you [totally should](http://confreaks.tv/videos/roa2015-testing-the-multiverse)).  Sorry, Jason.  Hope you don't mind.
 
+Ironically enough, despite ripping off the name from a talk about Ruby testing, Bales currently lacks any formal test suite.  Hm...
+
 ## What's the license?
 
 MIT License

data/lib/bales/application.rb

@@ -1,9 +1,9 @@
 require 'bales/command'
 
 ##
-# Base class for Bales apps.  Your command-line program should create a
-# subclass of this, then call said subclass' +#parse_and_run+ instance
-# method, like so:
+# Base class for Bales apps.  Your command-line program should create
+# a subclass of this, then call said subclass' +#parse_and_run+
+# instance method, like so:
 #
 #   class MyApp::Application < Bales::Application
 #     # insert customizations here
@@ -12,23 +12,92 @@ require 'bales/command'
 #   MyApp::Application.parse_and_run
 module Bales
   class Application
+    def self.inherited(child) # :nodoc:
+      child
+        .base_name
+        .const_set("Command", Class.new(Bales::Command))
+        .const_set("Help", Class.new(Bales::Command::Help))
+    end
+
+    ##
+    # Set or retrieve the application's version number.
+    def self.version(v=nil)
+      const_set("VERSION", v) unless v.nil?
+      const_set("VERSION", "0.0.0") if const_get("VERSION").nil?
+      const_get("VERSION")
+    end
+
+    ##
+    # Define a command (specifically, a subclass of +Bales::Command+).
+    # Command should be a string corresponding to how the command will
+    # be invoked on the command-line; thus, a command with the class
+    # name +FooBar::Baz+ should be passed as "foo-bar baz".
+    def self.command(name=nil, **opts, &code)
+      const_name = "#{base_name.name}::Command"
+      opts[:parent] ||= Bales::Command
+
+      if eval("defined? #{const_name}") == "constant"
+        const = eval(const_name)
+      else
+        const = base_name.const_set('Command', Class.new(opts[:parent]))
+      end
+
+      unless name.nil?
+        name
+          .to_s
+          .split(' ')
+          .map { |p| p
+                 .downcase
+                 .gsub('_','-')
+                 .split('-')
+                 .map { |pp| pp.capitalize }
+                 .join }
+          .each do |part|
+          name = "#{const.name}::#{part}"
+          if const.const_defined? name
+            const = eval(name)
+          else
+            const = const.const_set(part, Class.new(opts[:parent]))
+          end
+        end
+      end
+
+      const.instance_eval(&code) if block_given?
+    end
+
     ##
-    # Set or retrieve the application's version number.  Defaults to "0.0.0".
-    def self.version(v="0.0.0")
-      @version ||= v
-      @version
+    # Set or retrieve the application's banner.
+    def self.banner(text=nil)
+      root_command.banner(text) unless text.nil?
+      root_command.banner
     end
 
     ##
-    # Major version number.  Assumes semantic versioning, but will work with
-    # any versioning scheme with at least major and minor version numbers.
+    # Set or retrieve the application's description
+    def self.description(text=nil)
+      root_command.description(text) unless text.nil?
+      root_command.description
+    end
+
+    ##
+    # Set or retrieve the application's summary
+    def self.summary(text=nil)
+      root_command.summary(text) unless text.nil?
+      root_command.summary
+    end
+
+    ##
+    # Major version number.  Assumes semantic versioning, but will
+    # work with any versioning scheme with at least major and minor
+    # version numbers.
     def self.major_version
       version.split('.')[0]
     end
 
     ##
-    # Minor version number.  Assumes semantic versioning, but will work with
-    # any versioning scheme with at least major and minor version numbers.
+    # Minor version number.  Assumes semantic versioning, but will
+    # work with any versioning scheme with at least major and minor
+    # version numbers.
     def self.minor_version
       version.split('.')[1]
     end
@@ -40,17 +109,37 @@ module Bales
     end
 
     ##
-    # Runs the specified command (should be a valid class; preferably, should
-    # be a subclass of +Bales::Command+).  Takes a list of positional args
-    # followed by named options.
+    # Set an application-level option.  See +Bales::Command+'s
+    # +option+ method for more details.
+    def self.option(name, **opts)
+      root_command.option(name, **opts)
+    end
+
+    ##
+    # Set an application-level action.  See +Bales::Command+'s
+    # +action+ method for more details.
+    def self.action(&code)
+      root_command.action(&code)
+    end
+
+    ##
+    # Runs the specified command (should be a valid class; preferably,
+    # should be a subclass of +Bales::Command+, or should otherwise
+    # have a +.run+ class method that accepts a list of args and a
+    # hash of opts).  Takes a list of positional args followed by
+    # named options.
     def self.run(command, *args, **opts)
-      command.run *args, **opts
+      if opts.none?
+        command.run *args
+      else
+        command.run *args, **opts
+      end
     end
 
     ##
-    # Parses ARGV (or some other array if you specify one), returning the
-    # class of the identified command, a hash containing the passed-in
-    # options, and a list of any remaining arguments
+    # Parses ARGV (or some other array if you specify one), returning
+    # the class of the identified command, a hash containing the
+    # passed-in options, and a list of any remaining arguments
     def self.parse(argv=ARGV)
       command, result = parse_command_name argv.dup
       command ||= default_command
@@ -59,38 +148,54 @@ module Bales
     end
 
     ##
-    # Parses ARGV (or some other array if you specify one) for a command to
-    # run and its arguments/options, then runs the command.
+    # Parses ARGV (or some other array if you specify one) for a
+    # command to run and its arguments/options, then runs the command.
     def self.parse_and_run(argv=ARGV)
       command, args, opts = parse argv
       run command, *args, **opts
+    rescue OptionParser::MissingArgument
+      flag = $!.message.gsub("missing argument: ", '')
+      puts "#{$0}: error: option needs an argument (#{flag})"
+      exit!
+    rescue OptionParser::InvalidOption
+      flag = $!.message.gsub("invalid option: ", '')
+      puts "#{$0}: error: unknown option (#{flag})"
+      exit!
+    rescue ArgumentError
+      raise unless $!.message.match(/wrong number of arguments/)
+      received, expected = $!
+                             .message
+                             .gsub("wrong number of arguments (", '')
+                             .gsub(")", '')
+                             .split(" for ")
+      puts "#{$0}: error: expected #{expected} args but got #{received}"
+      exit!
     end
 
     private
 
     def self.parse_command_name(argv)
-      command_name_parts = [*constant_to_args(base_name), "command"]
+      const = base_name::Command
       depth = 0
-      catch(:end) do
-        argv.each_with_index do |arg, i|
-          throw(:end) if arg.match(/^-/)
-          begin
-            test = args_to_constant [*command_name_parts, arg]
-          rescue NameError
-            throw(:end)
-          end
 
-          if eval("defined? #{test}") == "constant"
-            command_name_parts.push arg
+      argv.each do |arg|
+          part = arg
+                 .downcase
+                 .gsub('_','-')
+                 .split('-')
+                 .map { |p| p.capitalize }
+                 .join
+          name = "#{const}::#{part}"
+          if const.const_defined? name
+            const = eval(name)
             depth += 1
           else
-            throw(:end)
+            break
           end
         end
-      end
-      command = args_to_constant [*command_name_parts]
+
       argv.shift depth
-      return command, argv
+      return const, argv
     end
 
     def self.base_name
@@ -98,6 +203,13 @@ module Bales
       eval result.join('::')
     end
 
+    def self.root_command
+      unless eval("defined? #{base_name}::Command") == "constant"
+        base_name.const_set "Command", Class.new(Bales::Command)
+      end
+      eval "#{base_name}::Command"
+    end
+
     def self.constant_to_args(constant)
       constant.name.split('::').map { |e| e.gsub!(/(.)([A-Z])/,'\1_\2') }
     end

data/lib/bales/command/help.rb

@@ -0,0 +1,159 @@
+##
+# Prints help text for a given namespace
+class Bales::Command::Help < Bales::Command
+  summary "Print this help text"
+  action do |*args, **opts|
+    target = ''
+    if args.empty?
+      target = basename
+    elsif command?(args[0])
+      target = args[0].gsub('_','-').split('-').map { |p| p.capitalize }.join
+      target = eval "#{rootname}::Command::#{target}"
+    else
+      target = basename
+    end
+
+    print_summary(target)
+    print_options(target)
+    print_commands(target)
+  end
+
+  private
+
+  def self.basename(constant=self)
+    eval constant.name.split('::')[0..-2].join('::')
+  end
+
+  def self.rootname(constant=self)
+    eval constant.name.split('::').first
+  end
+
+  def self.command?(name)
+    test = name.gsub('_','-').split('-').map { |p| p.capitalize }.join
+    test = "#{rootname}::Command::#{test}"
+    eval("defined? #{test}") == "constant"
+  end
+
+  def self.commands(ns)
+    unless eval("defined? #{ns}") == "constant"
+      raise ArgumentError, "expected a constant, but got a #{ns.class}"
+    end
+
+    ns.constants
+      .select { |c| ns.const_defined? "#{ns}::#{c}" }
+      .select { |c| eval("#{ns}::#{c}").class == Class }
+      .select { |c| eval("#{ns}::#{c}") <= Bales::Command }
+      .map { |c| eval "#{ns}::#{c}" }
+  end
+
+  def self.format_option(name, opts, width=72)
+    long = "#{opts[:long_form]}"
+    if opts[:type] <= TrueClass or opts[:type] <= FalseClass
+      if opts[:required]
+        long << " #{opts[:arg]}"
+      else
+        long << " [#{opts[:arg]}]"
+      end
+    end
+
+    output = "#{name} (#{opts[:type]}): "
+    output << "#{opts[:short_form]} / " if opts[:short_form]
+    output << long
+    output << "\n"
+    output << opts[:description]
+    output
+  end
+
+  def self.print_options(command)
+    optstrings = command.options.map do |opt|
+      opt = opt[1]
+      result = ""
+      result += "#{opt[:short_form]}, " unless opt[:short_form].nil?
+      result += "#{opt[:long_form]}"
+      result += "=[#{opt[:arg]}]" unless opt[:arg].nil?
+      result
+    end
+
+    unless optstrings.none?
+      max_length = optstrings.max_by(&:length).length
+
+      puts "Options:"
+
+      pairs = command.options.zip optstrings
+
+      pairs.each do |pair|
+        opt, string = *pair
+        opt = opt[1]
+        printf "%-#{max_length}s : %s\n", string, squeeze_text(
+                 opt[:description],
+                 width: ENV['COLUMNS'].to_i - max_length - 3,
+                 offset: max_length,
+                 indent_first_line: false
+               )
+      end
+
+      print "\n"
+    end
+  end
+
+  def self.print_summary(command)
+    if command.name == "#{rootname}::Command"
+      # TODO: allow this to be overridden somewhere (or otherwise make
+      # #command_name smarter)
+      name = rootname
+    else
+      name = command.command_name
+    end
+
+    print "#{name}: #{command.summary}\n\n"
+    print "Description:\n#{command.description}\n\n"
+  end
+
+  def self.print_commands(namespace)
+    cmds = commands(namespace)
+
+    unless cmds.none?
+      max_length = cmds.map { |c| c.command_name }.max_by(&:length).length
+
+      puts "Subcommands:"
+
+      cmds.each do |command|
+        printf "%-#{max_length}s : %s\n", command.command_name, squeeze_text(
+                 command.summary,
+                 width: ENV['COLUMNS'].to_i - max_length - 3,
+                 offset: max_length,
+                 indent_first_line: false
+               )
+      end
+
+      print "\n"
+    end
+  end
+
+  def self.squeeze_text(*strings, **opts)
+    text = strings.join('..')
+    result = ""
+    opts[:indent_with] ||= ' '
+
+    # wrap
+    text.split("\n").map! do |line|
+      if line.length > opts[:width]
+        line.gsub(/(.{1,#{opts[:width]}})(\s+|$)/, "\\1\n").strip
+      else
+        line
+      end
+    end
+
+    # indent
+    text.split("\n").map! do |line|
+      indent = opts[:indent_with] * opts[:offset]
+      (indent + line).sub(/[\s]+$/,'')
+    end
+
+    if opts[:indent_first_line]
+      return text
+    else
+      return text.strip
+    end
+  end
+end

data/lib/bales/command/help.rb~

@@ -0,0 +1,37 @@
+##
+# Prints help text for a given namespace
+class Bales::Command::Help < Bales::Command
+  action do |args, opts|
+    puts "This will someday output some help text"
+  end
+
+  private
+
+  def commands(ns)
+    unless eval("defined? #{ns}") == "constant"
+      raise ArgumentError, "expected a constant, but got a #{ns.class}"
+    end
+
+    ns.constants
+      .select { |c| eval("#{ns}::#{c}") <= Bales::Command }
+      .map { |c| eval "#{ns}::#{c}" }
+  end
+
+  def format_option(name, opts, width=72)
+    long = "#{opts[:long_form]}"
+    if opts[:type] <= TrueClass or opts[:type] <= FalseClass
+      if opts[:required]
+        long << " #{opts[:arg]}"
+      else
+        long << " [#{opts[:arg]}]"
+      end
+    end
+
+    output = "#{name} (#{opts[:type]}): "
+    output << "#{opts[:short_form]} / " if opts[:short_form]
+    output << long
+    output << "\n"
+    output << opts[:description]
+    output
+  end
+end

data/lib/bales/command.rb

@@ -42,20 +42,55 @@ module Bales
     ##
     # Accessor for the options hash generated by +#option+.
     def self.options
-      @options ||= {}
-      @options
+      const_get "OPTIONS"
+    rescue NameError
+      const_set("OPTIONS", {})
     end
+    def self.options=(new) # :nodoc:
+      const_set("OPTIONS", new)
+    end
+
+    ##
+    # Get the command's description, or set it if a string is passed
+    # to it.
+    def self.description(text=nil)
+      const_set "DESCRIPTION", text unless text.nil?
+      const_get "DESCRIPTION"
+    rescue NameError
+      const_set "DESCRIPTION", "(no description)"
+    end
+
+    ##
+    # Get the command's summary, or set it if a string is passed to
+    # it.
+    def self.summary(text=nil)
+      const_set "SUMMARY", text unless text.nil?
+      const_get "SUMMARY"
+    rescue NameError
+      const_set "SUMMARY", "(no summary)"
+    end
+
     ##
-    # Setter for the options hash generated by +#option+.  Usually not
-    # needed, since that's what +#option+ is for.
-    def self.options=(new)
-      @options = new
+    # Translates the command's class name to the corresponding name
+    # passed on the command line.
+    def self.command_name
+      name = self
+             .name
+             .split('::')
+             .last
+             .gsub(/(.)([A-Z])/, '\1-\2')
+             .downcase
+      if name == "command"
+        $0
+      else
+        name
+      end
     end
 
     ##
-    # Assigns an action to this command.  Said action is represented as a
-    # block, which should accept an array of arguments and a hash of options.
-    # For example:
+    # Assigns an action to this command.  Said action is represented
+    # as a block, which should accept an array of arguments and a hash
+    # of options.  For example:
     #
     #   class MyApp::Hello < Bales::Command
     #     action do |args, opts|
@@ -63,50 +98,64 @@ module Bales
     #     end
     #   end
     def self.action(&code)
-      @action = code
+      singleton_class.instance_eval do
+        define_method :run, &code
+      end
     end
 
+    ##
+    # Primary entry point for a +Bales::Command+.  Generally a good
+    # idea to set this with +.action+, but it's possible to override
+    # this manually should you choose to do so.
     def self.run(*args, **opts)
-      @action.call(args, opts) unless @action.nil?
+      my_help_class_name = "#{self.name}::Help"
+      root_help_class_name = "#{self.to_s.split('::').first}::Command::Help"
+      if eval("defined? #{my_help_class_name}")
+        eval(my_help_class_name).run *args, **opts
+      elsif eval("defined? #{root_help_class_name}")
+        eval(root_help_class_name).run *args, **opts
+      else
+        Bales::Command::Help.run *args, **opts
+      end
     end
 
     ##
-    # Defines a named option that the command will accept, along with some
-    # named arguments:
+    # Defines a named option that the command will accept, along with
+    # some named arguments:
     #
-    # [+:short_form+ (optional)] A shorthand flag to use for the option
-    #                            (like +-v+).  This should be a string, like
-    #                            +"-v"+.
+    # [+:short_form+ (optional)]
     #
-    # [+:long_form+ (optional)]  A longhand flag to use for the option (like
-    #                            +--verbose+).  This is derived from the name
-    #                            of the option if not specified.  This should
-    #                            be a string, like +"--verbose"+
+    #     A shorthand flag to use for the option (like +-v+).  This
+    #     should be a string, like +"-v"+.
     #
-    # [+:type+ (optional)]       The type that this option represents.
-    #                            Defaults to +TrueClass+.  Should be a valid
-    #                            class name, like +String+ or +Integer+
+    # [+:long_form+ (optional)]
     #
-    #                            A special note on boolean options: if you
-    #                            want your boolean to default to `true`, set
-    #                            +:type+ to +TrueClass+.  Likewise, if you
-    #                            want it to default to +false+, set +:type+
-    #                            to +FalseClass+.
+    #     A longhand flag to use for the option (like +--verbose+).
+    #     This is derived from the name of the option if not
+    #     specified.  This should be a string, like +"--verbose"+
     #
-    # [+:arg+ (optional)]        The name of the argument this option
-    #                            accepts.  This should be a symbol (like
-    #                            :level) or +false+ (if the option is a
-    #                            boolean flag).  Defaults to the name of the
-    #                            option or (if the option's +:type+ is
-    #                            +TrueClass+ or +FalseClass+) +false+.
+    # [+:type+ (optional)]
     #
-    # [+:required+ (optional)]   Whether or not the option is required.  This
-    #                            should be a boolean (+true+ or +false+).
-    #                            Default is `false`.
+    #     The type that this option represents.  Defaults to
+    #     +TrueClass+.  Should be a valid class name, like +String+ or
+    #     +Integer+
     #
-    # Aside from the hash of option-options, +option+ takes a single +name+
-    # argument, which should be a symbol representing the name of the option
-    # to be set, like +:verbose+.
+    #     A special note on boolean options: if you want your boolean
+    #     to default to `true`, set +:type+ to +TrueClass+.  Likewise,
+    #     if you want it to default to +false+, set +:type+ to
+    #     +FalseClass+.
+    #
+    # [+:arg+ (optional)]
+    #
+    #     The name of the argument this option accepts.  This should
+    #     be a symbol (like :level) or +false+ (if the option is a
+    #     boolean flag).  Defaults to the name of the option or (if
+    #     the option's +:type+ is +TrueClass+ or +FalseClass+)
+    #     +false+.
+    #
+    # Aside from the hash of option-options, +option+ takes a single
+    # +name+ argument, which should be a symbol representing the name
+    # of the option to be set, like +:verbose+.
     def self.option(name, **opts)
       name = name.to_sym
       opts[:long_form] ||= "--#{name.to_s}".gsub("_","-")
@@ -117,12 +166,12 @@ module Bales
         raise ArgumentError, ":type option should be a valid class"
       end
 
-      if (opts[:type].ancestors & [TrueClass, FalseClass]).empty?
+      unless opts[:type] <= TrueClass or opts[:type] <= FalseClass
         opts[:arg] ||= name
       end
 
-      opts[:default] = false if opts[:type].ancestors.include? TrueClass
-      opts[:default] = true if opts[:type].ancestors.include? FalseClass
+      opts[:default] = false if opts[:type] <= TrueClass
+      opts[:default] = true if opts[:type] <= FalseClass
 
       result = options
       result[name] = opts
@@ -130,41 +179,41 @@ module Bales
     end
 
     ##
-    # Takes an ARGV-like array and returns a hash of options and what's left
-    # of the original array.  This is rarely needed for normal use, but is
-    # an integral part of how a +Bales::Application+ parses the ARGV it
-    # receives.
+    # Takes an ARGV-like array and returns a hash of options and
+    # what's left of the original array.  This is rarely needed for
+    # normal use, but is an integral part of how a
+    # +Bales::Application+ parses the ARGV it receives.
     #
-    # Normally, this should be perfectly fine to leave alone, but if you
-    # prefer to define your own parsing method (e.g. if you want to specify
-    # an alternative format for command-line options, or you are otherwise
-    # dissatisfied with the default approach of wrapping OptionParser), this
-    # is the method you'd want to override.
+    # Normally, this should be perfectly fine to leave alone, but if
+    # you prefer to define your own parsing method (e.g. if you want
+    # to specify an alternative format for command-line options, or
+    # you are otherwise dissatisfied with the default approach of
+    # wrapping OptionParser), this is the method you'd want to
+    # override.
     def self.parse_opts(argv)
       optparser = OptionParser.new
       result = {}
       options.each do |name, opts|
         result[name] = opts[:default]
         parser_args = []
-        parser_args.push opts[:short_form] if opts[:short_form]
-        if (opts[:type].ancestors & [TrueClass,FalseClass]).empty?
+        if opts[:type] <= TrueClass or opts[:type] <= FalseClass
+          parser_args.push opts[:short_form] if opts[:short_form]
+          parser_args.push opts[:long_form]
+        else
           argstring = opts[:arg].to_s.upcase
-          if opts[:required]
-            parser_args.push "#{opts[:long_form]} #{argstring}"
-          else
-            parser_args.push "#{opts[:long_form]} [#{argstring}]"
+          if opts[:short_form]
+            parser_args.push "#{opts[:short_form]} #{argstring}"
           end
+          parser_args.push "#{opts[:long_form]} #{argstring}"
           parser_args.push opts[:type]
-        else
-          parser_args.push opts[:long_form]
         end
-        parser_args.push opts[:description]
+        parser_args.push opts[:description] if opts[:description]
 
-        if opts[:type].ancestors.include? FalseClass
+        if opts[:type] <= FalseClass
           optparser.on(*parser_args) do
             result[name] = false
           end
-        elsif opts[:type].ancestors.include? TrueClass
+        elsif opts[:type] <= TrueClass
           optparser.on(*parser_args) do
             result[name] = true
           end
@@ -180,11 +229,3 @@ module Bales
     end
   end
 end
-
-##
-# Default help command.  You'll probably use your own...
-class Bales::Command::Help < Bales::Command
-  action do |args, opts|
-    puts "This will someday output some help text"
-  end
-end

data/lib/bales/version.rb

@@ -1,3 +1,3 @@
 module Bales
-  VERSION="0.0.2"
+  VERSION="0.0.3"
 end

data/lib/bales.rb

@@ -2,6 +2,7 @@
 
 require 'bales/application'
 require 'bales/command'
+require 'bales/command/help'
 
 ##
 # Ruby on Bales (or just "Bales" for short) is to command-line apps what

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bales
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Ryan S. Northrup
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-08 00:00:00.000000000 Z
+date: 2015-07-27 00:00:00.000000000 Z
 dependencies: []
 description: A framework for building command-line applications
 email:
@@ -24,6 +24,8 @@ files:
 - lib/bales/application.rb~
 - lib/bales/command.rb
 - lib/bales/command.rb~
+- lib/bales/command/help.rb
+- lib/bales/command/help.rb~
 - lib/bales/version.rb
 - lib/bales/version.rb~
 homepage: http://github.com/YellowApple/bales