bales 0.0.4 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3697a0dc2411e2fed3dc7bacbd03a6d33c4ce785
-  data.tar.gz: d5aed1d5f97a63e0505ad77de3199be86b90a7dd
+SHA256:
+  metadata.gz: b6ada6a857baba9d741859d2ec38d4992e6b9e4b409dd3bb7d0aacce7a6b129b
+  data.tar.gz: 1cbc31b944a5bd783aa563d36477bc15bcabaa5a44d7d6a7f03a586d7d02fd3e
 SHA512:
-  metadata.gz: f15a4c35d75271d03d3e22b503c8eae3e8c295e1f912e724249ec7195e375df32282a1899e059901e9f7396d911a7c6675e6497c6c8885e1b8265f5b22eb686c
-  data.tar.gz: 9a979f78d9de61e06e719bd12951c356a8d935c38fef170f9c8ed05815a6b13e09bef24aa7b55cb7f091f1235c464d0e81762f9ea489b51713eceec83f72a531
+  metadata.gz: 2c4b688015b19d0b11a110729ec6b955e6c11e2ca3cf01f2bec922a9aa03203798bd34fe1efb84f599c89e9cc235939d19e812057348b508b6abf1ff230d7b93
+  data.tar.gz: 1c52425d3d50315b2fcf93d78a603bc47df4a2afa083a4646c92edfad7289fb0e7f11e4e6b421035719cae1a2b81267035581404ebfda511241e2145b8b65a84

data/README.md

@@ -26,9 +26,8 @@ module SimpleApp
            short_form: '-2',
            type: String
            
-    action do |args, opts|
-      opts[:recipient] ||= "world"
-      puts "Hello, #{opts[:recipient]}!"
+    action do |recipient: "world"|
+      puts "Hello, #{recipient}!"
     end
     
     # Subcommand
@@ -39,13 +38,13 @@ module SimpleApp
              short_form: '-w',
              long_form: '--with'
              
-      action do |victims, opts|
-        suffix = opts[:weapon] ? " with a #{opts[:weapon]}" : ""
+      action do |*victims, weapon: nil|
+        suffix = weapon ? " with a #{weapon}" : ""
         
         if victims.none?
           puts "You have been smacked#{suffix}."
         else
-          puts "#{victim} has been smacked#{suffix}."
+          victims.each {|v| puts "#{v} has been smacked#{suffix}."}
         end
       end
     end
@@ -53,6 +52,13 @@ module SimpleApp
     # Specify subcommand's parent class
     command "help", parent: Bales::Command::Help
     
+    # Subsubcommands!
+    command "smack with" do
+      action do |weapon, *victims|
+        SimpleApp::Command::Smack.run(*victims, weapon: weapon)
+      end
+    end
+    
     # This is what makes the app actually run!
     parse_and_run
   end
@@ -61,7 +67,8 @@ end
 SimpleApp::Application.parse_and_run
 ```
 
-And like this (assuming the above script lives in `/usr/local/bin/simple-app`)!
+And like this (assuming the above script lives in
+`/usr/local/bin/simple-app`)!
 
 ```
 $ simple-app
@@ -79,59 +86,102 @@ Bruce has been smacked.
 Bruce has been smacked.
 $ simple-app smack Bruce --with fish
 Bruce has been smacked with a fish.
+$ simple-app smack with fish Bruce
+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 an `Application` class under that namespace which inherits
+  from `Bales::Application`
+
 * 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.
+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 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).
+* `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.
 
-Meanwhile, commands *also* have some DSL-ish functions to play around with.
+* `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).
 
-* `option`: defines a command-line option, like `--verbose` or `-f` or something.  It takes the name of the option (which becomes a key in your command's options hash) and some named parameters:
-  * `:type`: a valid Ruby class, like `String`.  For a boolean, you should provide either `TrueClass` or `FalseClass`, which - when set - will set the option in question to `true` or `false` (respectively).
-  * `:short_form`: a short flag, like `'-v'`.  You must specify this if you want a short flag.
-  * `: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.
+Meanwhile, commands *also* have some DSL-ish functions to play around with.
 
-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.
+* `option`: defines a command-line option, like `--verbose` or `-f` or
+  something.  It takes the name of the option (which becomes a key in
+  your command's options hash) and some named parameters:
+
+  * `:type`: a valid Ruby class, like `String`.  For a boolean, you
+    should provide either `TrueClass` or `FalseClass`, which - when
+    set - will set the option in question to `true` or `false`
+    (respectively).
+  
+  * `:short_form`: a short flag, like `'-v'`.  You must specify this
+    if you want a short flag.
+  
+  * `: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 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
+
+* 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
+
+* 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.
+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...
+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
-
-Copyright (c) 2015 Ryan S. Northrup
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+MIT License; see COPYING for details.

data/lib/bales/application.rb

@@ -45,7 +45,7 @@ module Bales
     end
 
     ##
-    # Set or retrieve the application's banner.
+    # Set or retrieve the application's banner
     def self.banner(text=nil)
       root_command.banner(text) unless text.nil?
       root_command.banner
@@ -58,6 +58,12 @@ module Bales
       root_command.description
     end
 
+    ##
+    # Alias for +description+
+    def self.desc(text=nil)
+      self.description(text)
+    end
+
     ##
     # Set or retrieve the application's summary
     def self.summary(text=nil)
@@ -124,21 +130,15 @@ module Bales
       command ||= default_command
       opts, args = command.parse_opts result
       return command, args, opts
-    end
-
-    ##
-    # 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})"
+      puts "Usage: #{command.usage}"
       exit!
     rescue OptionParser::InvalidOption
       flag = $!.message.gsub("invalid option: ", '')
       puts "#{$0}: error: unknown option (#{flag})"
+      puts "Usage: #{command.usage}"
       exit!
     rescue ArgumentError
       raise unless $!.message.match(/wrong number of arguments/)
@@ -148,9 +148,23 @@ module Bales
                              .gsub(")", '')
                              .split(" for ")
       puts "#{$0}: error: expected #{expected} args but got #{received}"
+      puts "Usage: #{command.usage}"
       exit!
     end
 
+    ##
+    # 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
+      # OptionParser includes nil values for missing options, so we
+      # need to make sure those don't clobber the command's defaults.
+      command.method(:run).parameters.select {|p| p[0] == :key}.map do |p|
+        opts.delete p[1] if opts[p[1]].nil?
+      end
+      run command, *args, **opts
+    end
+
     private
 
     def self.parse_command_name(argv)
@@ -165,10 +179,14 @@ module Bales
                  .map { |p| p.capitalize }
                  .join
           name = "#{const}::#{part}"
-          if const.const_defined? name
-            const = eval(name)
-            depth += 1
-          else
+          begin
+            if const.const_defined? name
+              const = eval(name)
+              depth += 1
+            else
+              break
+            end
+          rescue NameError
             break
           end
         end

data/lib/bales/command.rb

@@ -60,6 +60,12 @@ module Bales
       const_set "DESCRIPTION", "(no description)"
     end
 
+    ##
+    # Alias for +description+
+    def self.desc(text=nil)
+      self.description(text)
+    end
+
     ##
     # Get the command's summary, or set it if a string is passed to
     # it.
@@ -87,6 +93,60 @@ module Bales
       end
     end
 
+    ##
+    # Translates the command's class name to a more complete name
+    # passed on the command line, including the subcommand, all
+    # commands leading to it, and the root command.
+    def self.full_name
+      parts = self
+             .name
+             .split('::')
+             .map { |p| p.gsub(/(.)([A-Z])/, '\1-\2').downcase }
+      parts = parts[2..-1].join(' ')
+      "#{$0} #{parts}"
+    end
+
+    ##
+    # Print the command's usage statement.
+    def self.usage
+      usage = []
+
+      # Name
+      usage << full_name
+
+      # Arguments
+      method(:run).parameters.each do |type, name|
+        # We don't handle keys and keyrests, since they're going to be
+        # taken care of once we start dealing with options.
+        case type
+        when :req then usage << "<#{name}>"
+        when :opt then usage << "[<#{name}>]"
+        when :rest then usage << "[<#{name}> ...]"
+        end
+      end
+
+      # Options
+      options.each_pair do |opt, args|
+        case
+        when (args[:type] <= TrueClass or args[:type] <= FalseClass)
+          if args.key?(:short_form)
+            usage << "[(#{args[:long_form]}|#{args[:short_form]})]"
+          else
+            usage << "[#{args[:long_form]}]"
+          end
+        else
+          if args.key?(:short_form)
+            usage << "[(#{args[:long_form]}|#{args[:short_form]}) " \
+                     "<#{args[:arg]}>]"
+          else
+            usage << "[#{args[:long_form]} <#{args[:arg]}>]"
+          end
+        end
+      end
+
+      usage.join(' ')
+    end
+
     ##
     # Creates a new subcommand of the current command.  Identical in
     # usage to +Bales::Application.command+, the only significant
@@ -203,6 +263,8 @@ module Bales
       opts[:default] = false if opts[:type] <= TrueClass
       opts[:default] = true if opts[:type] <= FalseClass
 
+      opts[:description] = opts[:desc] if opts.key?(:desc)
+
       result = options
       result[name] = opts
       options = result

data/lib/bales/command/help.rb

@@ -14,6 +14,7 @@ class Bales::Command::Help < Bales::Command
     end
 
     print_summary(target)
+    print_usage(target)
     print_options(target)
     print_commands(target)
   end
@@ -40,8 +41,13 @@ class Bales::Command::Help < Bales::Command
     end
 
     ns.constants
-      .select { |c| ns.const_defined? "#{ns}::#{c}" }
-      .select { |c| eval("#{ns}::#{c}").class == Class }
+      .select { |c|
+      begin
+        ns.const_defined? "#{ns}::#{c}"
+      rescue NameError
+        false
+      end
+    }.select { |c| eval("#{ns}::#{c}").class == Class }
       .select { |c| eval("#{ns}::#{c}") <= Bales::Command }
       .map { |c| eval "#{ns}::#{c}" }
   end
@@ -109,6 +115,10 @@ class Bales::Command::Help < Bales::Command
     print "Description:\n#{command.description}\n\n"
   end
 
+  def self.print_usage(command)
+    print "Usage: #{command.usage}\n\n"
+  end
+
   def self.print_commands(namespace)
     cmds = commands(namespace)
 

data/lib/bales/version.rb

@@ -1,3 +1,3 @@
 module Bales
-  VERSION="0.0.4"
+  VERSION="0.1.3"
 end

metadata

@@ -1,38 +1,33 @@
 --- !ruby/object:Gem::Specification
 name: bales
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.3
 platform: ruby
 authors:
 - Ryan S. Northrup
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-08-17 00:00:00.000000000 Z
+date: 2020-10-26 00:00:00.000000000 Z
 dependencies: []
 description: A framework for building command-line applications
 email:
-- rnorthrup@newleaders.com
+- northrup@yellowapple.us
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - README.md
 - lib/bales.rb
-- lib/bales.rb~
 - lib/bales/application.rb
-- 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
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -47,9 +42,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.6
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Ruby on Bales
 test_files: []

data/lib/bales.rb~

@@ -1,236 +0,0 @@
-# :main: README.md
-
-##
-# Ruby on Bales (or just "Bales" for short) is to command-line apps what
-# Ruby on Rails (or just "Rails" for short) is to websites/webapps.
-#
-# The name (and concept) was shamelessly stolen from Jason R. Clark's
-# "Testing the Multiverse" talk at Ruby on Ales 2015.  Here's to hoping that
-# we, as a Ruby programming community, can get a headstart on a command-line
-# app framework *before* the Puma-Unicorn Wars ravage the Earth.
-module Bales
-  ##
-  # 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:
-  #
-  # ```ruby
-  # class MyApp::Application < Bales::Application
-  #   # insert customizations here
-  # end
-  #
-  # MyApp::Application.parse_and_run
-  # ```
-  class Application
-    ##
-    # 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.
-    def self.run(command=Bales::Command::Help, *args, **opts)
-      command.run *args, **opts
-    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
-    def self.parse(argv=ARGV)
-      command, result = parse_command_name argv.dup
-      opts, args = command.parse_opts result
-      return command, args, opts
-    end
-
-    ##
-    # 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
-    end
-
-    private
-
-    def parse_command_name(argv)
-      command_name_parts = []
-      argv.each do |arg|
-        last if arg.match(/^-/)
-        test = args_to_constant [*command_name_parts, arg]
-        if eval("defined? #{test}") == "constant"
-          command_name_parts.push argv.shift
-        else
-          last
-        end
-      end
-      command = args_to_constant [*command_name_parts, arg]
-      command, argv
-    end
-
-    def args_to_constant(argv)
-      result = argv.dup
-      result.map! do |arg|
-        arg.capitalize
-        arg.gsub('-','_').split('_').map { |e| e.capitalize}.join
-      end
-      result.join('::')
-    end
-  end
-
-  ##
-  # Base class for all Bales commands.  Subclass this class to create your
-  # own command, like so:
-  #
-  # ```ruby
-  # class MyApp::Command::Hello < Bales::Command
-  #   def self.run(*args, **opts)
-  #     puts "Hello, world!"
-  #   end
-  # end  # produces a `my-app hello` command that prints "Hello, world!"
-  # ```
-  #
-  # Note that the above will accept any number of arguments (including none
-  # at all!).  If you want to change this behavior, change `self.run`'s
-  # signature, like so:
-  #
-  # ```ruby
-  # class MyApp::Command::Smack < Bales::Command
-  #   def self.run(target, **opts)
-  #     puts "#{target} has been smacked with a large trout"
-  #   end
-  # end
-  # ```
-  #
-  # Subcommands are automatically derived from namespacing, like so:
-  #
-  # ```ruby
-  # class MyApp::Command::Foo::Bar < Bales::Command
-  #   def self.run(*args, **opts)
-  #     # ...
-  #   end
-  # end  # produces `my-app foo bar`
-  # ```
-  #
-  # Camel-cased command classes can be accessed using either hyphenation or
-  # underscores, like so:
-  #
-  # ```ruby
-  # class MyApp::Command::FooBarBaz < Bales::Command
-  #   # ...
-  # end
-  # # valid result: "my-app foo-bar-baz"
-  # # also valid: "my-app foo_bar_baz"
-  # ```
-  class Command
-    @options = {}
-
-    ##
-    # Runs the command with the provided list of arguments and named options.
-    # Your command should override this method (which by default does
-    # nothing), since this is the method that `Bales::Application.run` calls
-    # in order to actually run your command.
-    #
-    # For example:
-    #
-    # ```ruby
-    # class MyApp::Command::Hello < Bales::Command
-    #   def self.run(*args, **opts)
-    #     puts "Hello, world!"
-    #   end
-    # end
-    # ```
-    def self.run(*args, **opts)
-    end
-
-    ##
-    # 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"`.
-    #
-    # `: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"`
-    #
-    # `:type` (optional)
-    # : The type that this option represents.  Defaults to `TrueClass` if
-    #   `:arg` is not specified; else, defaults to `String`.  This must be a
-    #   valid class name.
-    #
-    #   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` (required unless `:type` is `TrueClass` or `FalseClass`)
-    # : The name of the argument this option accepts.  This must not be
-    #   defined if `:type` is either `TrueClass` or `FalseClass`; for all
-    #   other types, this must be specified.  As mentioned above, though, if
-    #   `:type` is unspecified, the existence of `:arg` then determines
-    #   whether the option's `:type` should default to `TrueClass` or
-    #   `String`.  This should be a symbol, like `:level`.
-    #
-    # 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("_","-")
-
-      unless opts[:type].class == Class
-        raise ArgumentError, ":type option should be a valid class"
-      end
-
-      if opts[:type] == TrueClass or opts[:type] == FalseClass
-        raise ArgumentError, ":arg in boolean opt" unless opts[:arg].nil?
-      else
-        raise ArgumentError, "missing :arg" if opts[:arg].nil?
-      end
-
-      @options[name] = opts
-    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.
-    #
-    # 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]
-        parser_args.push opts[:long_form]
-        unless opts[:type] == TrueClass or opts[:type] == FalseClass
-          parser_args.push opts[:type]
-        end
-        parser_args.push opts[:description]
-
-        if opts[:type] == FalseClass
-          optparser.on(*parser_args) do |value|
-            result[name] = !value
-          end
-        else
-          optparser.on(*parser_args) do |value|
-            result[name] = value
-          end
-        end
-      end
-    end
-  end
-
-  class Command::Help < Command
-    def self.run(*args, **opts)
-      puts "This will someday output some help text"
-
-    end
-  end
-end

data/lib/bales/application.rb~

@@ -1,71 +0,0 @@
-##
-# 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:
-#
-# ```ruby
-# class MyApp::Application < Bales::Application
-#   # insert customizations here
-# end
-#
-# MyApp::Application.parse_and_run
-# ```
-class Bales::Application
-  @default_command = Bales::Command::Help
-  def self.default(command=Bales::Command::Help)
-    @default_command = command
-  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.
-  def self.run(command, *args, **opts)
-    command.run *args, **opts
-  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
-  def self.parse(argv=ARGV)
-    command, result = parse_command_name argv.dup
-    command ||= @default_command
-    opts, args = command.parse_opts result
-    return command, args, opts
-  end
-
-  ##
-  # 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
-  end
-
-  private
-
-  def self.parse_command_name(argv)
-    command_name_parts = []
-    argv.each do |arg|
-      last if arg.match(/^-/)
-      test = args_to_constant [*command_name_parts, arg]
-      if eval("defined? #{test}") == "constant"
-        command_name_parts.push argv.shift
-      else
-        last
-      end
-    end
-    command = args_to_constant [*command_name_parts]
-    return command, argv
-  end
-
-  def self.args_to_constant(argv)
-    result = argv.dup
-    result.map! do |arg|
-      arg.capitalize
-      arg.gsub('-','_').split('_').map { |e| e.capitalize}.join
-    end
-    eval result.join('::')
-  end
-end

data/lib/bales/command.rb~

@@ -1,189 +0,0 @@
-##
-# Base class for all Bales commands.  Subclass this class to create your
-# own command, like so:
-#
-# ```ruby
-# class MyApp::Command::Hello < Bales::Command
-#   def self.run(*args, **opts)
-#     puts "Hello, world!"
-#   end
-# end  # produces a `my-app hello` command that prints "Hello, world!"
-# ```
-#
-# Note that the above will accept any number of arguments (including none
-# at all!).  If you want to change this behavior, change `self.run`'s
-# signature, like so:
-#
-# ```ruby
-# class MyApp::Command::Smack < Bales::Command
-#   def self.run(target, **opts)
-#     puts "#{target} has been smacked with a large trout"
-#   end
-# end
-# ```
-#
-# Subcommands are automatically derived from namespacing, like so:
-#
-# ```ruby
-# class MyApp::Command::Foo::Bar < Bales::Command
-#   def self.run(*args, **opts)
-#     # ...
-#   end
-# end  # produces `my-app foo bar`
-# ```
-#
-# Camel-cased command classes can be accessed using either hyphenation or
-# underscores, like so:
-#
-# ```ruby
-# class MyApp::Command::FooBarBaz < Bales::Command
-#   # ...
-# end
-# # valid result: "my-app foo-bar-baz"
-# # also valid: "my-app foo_bar_baz"
-# ```
-class Bales::Command
-  @options = {}
-  def self.options
-    @options
-  end
-  def self.options=(new)
-    @options = new
-  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:
-  #
-  # ```ruby
-  # class MyApp::Hello < Bales::Command
-  #   action do |args, opts|
-  #     puts "Hello, world!"
-  #   end
-  # end
-  # ```
-  def self.action(&code)
-    @action = code
-  end
-
-  def self.run(*args, **opts)
-    @action.call(args, opts)
-  end
-
-  ##
-  # 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"`.
-  #
-  # `: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"`
-  #
-  # `:type` (optional)
-  # : The type that this option represents.  Defaults to `TrueClass`.
-  #   Should be a valid class name, like `String` or `Integer`
-  #
-  #   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`.
-  #
-  #   If this is an array, and `:type` is set to `Enumerable` or some
-  #   subclass thereof, this will instead be interpreted as a list of
-  #   sample arguments during option parsing.  It's recommended you set
-  #   this accordingly if `:type` is `Enumerable` or any of its subclasses.
-  #
-  # `:required` (optional)
-  # : Whether or not the option is required.  This should be a boolean
-  #   (`true` or `false`).  Default is `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("_","-")
-
-    unless opts[:type].is_a? Class
-      raise ArgumentError, ":type option should be a valid class"
-    end
-
-    unless opts[:type].is_a?(TrueClass) or opts[:type].is_a?(FalseClass)
-      opts[:arg] ||= name
-    end
-
-    # if opts[:type] == TrueClass or opts[:type] == FalseClass
-    #   raise ArgumentError, ":arg in boolean opt" unless opts[:arg].nil?
-    # else
-    #   raise ArgumentError, "missing :arg" if opts[:arg].nil?
-    # end
-
-    result = {}
-    result[name] = opts
-    self.options = result
-  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.
-  #
-  # 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[:type].is_a?(TrueClass) or opts[:type].is_a?(FalseClass)
-        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}]"
-          parser_args.push opts[:type]
-        end
-        parser_args.push opts[:description]
-
-        if opts[:type].is_a? FalseClass
-          optparser.on(*parser_args) do |value|
-            result[name] = !value
-          end
-        else
-          optparser.on(*parser_args) do |value|
-            result[name] = value
-          end
-        end
-      end
-
-      opt_parser.parse! argv
-      return result, argv
-    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/command/help.rb~

@@ -1,37 +0,0 @@
-##
-# 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/version.rb~

@@ -1,3 +0,0 @@
-module Bales
-  VERSION="0.0.0"
-end