bales 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a449ca597147ec6bc515f40ff54bd657662f9e80
+  data.tar.gz: af9b1836f3d639cb968cdfba34daccd60e95ef0c
+SHA512:
+  metadata.gz: 3dd8e473c927c35175c378f49ba43f5cd62e639ab929b50dc7f5dfe6f3f5af08a78dee252a72904071d1d737154ff94008a6348428b6857ee0073320c1e26f45
+  data.tar.gz: eb9675b63e316b5a316991d4066b054c2698ec799ede8bf966a721de528789296b0b62643acfab94916a5a959d5f28182a5f68d89726c3a2f30bef1342233ee3

data/README.md

@@ -0,0 +1,93 @@
+# Ruby on Bales
+
+![bales](https://upload.wikimedia.org/wikipedia/commons/2/2c/DavidBrown-Verdon.jpg)
+
+## What is it?
+
+It's a framework for writing command-line applications.
+
+## What does it look like?
+
+Why, like this!
+
+```ruby
+#!/usr/bin/env ruby
+# /usr/local/bin/simple-app
+require 'bales'
+
+module SimpleApp
+  class Application < Bales::Application
+    version "0.0.1"
+  end
+
+  class Command < Bales::Command
+    action do
+      Bales::Command::Help.run
+    end
+
+    class Smack < Command
+      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
+        end
+      end
+    end
+  end
+end
+
+SimpleApp::Application.parse_and_run
+```
+
+And like this (assuming the above script lives in `/usr/local/bin/simple-app`)!
+
+```
+$ 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.
+```
+
+## So how does it work?
+
+A Bales app is basically a collection of classes: one class representing the application itself (`SimpleApp::Application` in the above example) and one or more classes representing the application's commands (`SimpleApp::Command` and its children in the above example).
+
+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.
+
+* `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.
+
+## What kind of a silly names 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.
+
+## 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.

data/lib/bales.rb

@@ -0,0 +1,27 @@
+# :main: README.md
+
+require 'bales/application'
+require 'bales/command'
+
+##
+# 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
+end
+
+# Helper stuff; please ignore
+class String
+  def underscore
+    self.
+      gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+      gsub(/([a-z\d])([A-Z])/, '\1_\2').
+      tr('-', '_').
+      downcase
+  end
+end

data/lib/bales.rb~

@@ -0,0 +1,236 @@
+# :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/#command.rb#

@@ -0,0 +1,196 @@
+require 'optparse'
+
+##
+# 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"
+# ```
+module Bales
+  class Command
+    def self.options
+      @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) unless @action.nil?
+    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("_","-")
+
+      opts[:type] = String if opts[:type].nil?
+
+      unless opts[:type].is_a? Class
+        raise ArgumentError, ":type option should be a valid class"
+      end
+
+      if (opts[:type].ancestors & [TrueClass, FalseClass]).empty?
+        opts[:arg] ||= name
+      end
+
+      opts[:default] = false if opts[:type].ancestors.include? TrueClass
+      opts[:default] = true if opts[:type].ancestors.include? FalseClass
+
+      result = options
+      result[name] = opts
+      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[:short_form]
+        if (opts[:type].ancestors & [TrueClass,FalseClass]).empty?
+          argstring = opts[:arg].to_s.upcase
+          if opts[:required]
+            parser_args.push "#{opts[:long_form]} #{argstring}"
+          else
+            parser_args.push "#{opts[:long_form]} [#{argstring}]"
+          end
+          parser_args.push opts[:type]
+        else
+          parser_args.push opts[:long_form]
+        end
+        parser_args.push opts[:description]
+
+        if opts[:type].ancestors.include? FalseClass
+          optparser.on(*parser_args) do
+            result[name] = false
+          end
+        elsif opts[:type].ancestors.include? TrueClass
+          optparser.on(*parser_args) do
+            result[name] = true
+          end
+        else
+          optparser.on(*parser_args) do |value|
+            result[name] = value
+          end
+        end
+      end
+
+      optparser.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/application.rb

@@ -0,0 +1,149 @@
+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:
+#
+# ```ruby
+# class MyApp::Application < Bales::Application
+#   # insert customizations here
+# end
+#
+# MyApp::Application.parse_and_run
+# ```
+module Bales
+  class Application
+    def self.default_command
+      @default_command ||= Bales::Command::Help
+      @default_command
+    end
+    def self.default_command=(command)
+      @default_command = command
+    end
+
+    ##
+    # Set or retrieve the application's version number.  Defaults to "0.0.0".
+    def self.version(v="0.0.0")
+      @version ||= v
+      @version
+    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.
+    def self.minor_version
+      version.split('.')[1]
+    end
+
+    ##
+    # Patch level.  Assumes semantic versioning.
+    def self.patch_level
+      version.split('.')[2]
+    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 = [*constant_to_args(base_name), "command"]
+    #   puts command_name_parts
+    #   argv.each do |arg|
+    #     break if arg.match(/^-/)
+    #     begin
+    #       test = args_to_constant [*command_name_parts, arg]
+    #     rescue NameError
+    #       break
+    #     end
+    #     if eval("defined? #{test}") == "constant"
+    #       command_name_parts.push argv.shift
+    #     else
+    #       break
+    #     end
+    #   end
+    #   command = args_to_constant [*command_name_parts]
+    #   return command, argv
+    # end
+
+    def self.parse_command_name(argv)
+      command_name_parts = [*constant_to_args(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
+            depth += 1
+          else
+            throw(:end)
+          end
+        end
+      end
+      command = args_to_constant [*command_name_parts]
+      argv.shift depth
+      return command, argv
+    end
+
+    def self.base_name
+      result = self.name.split('::') - ["Application"]
+      eval result.join('::')
+    end
+
+    def self.constant_to_args(constant)
+      constant.name.split('::').map { |e| e.gsub!(/(.)([A-Z])/,'\1_\2') }
+    end
+
+    def self.args_to_constant(argv)
+      result = argv.dup
+      result.map! do |arg|
+        arg
+          .capitalize
+          .gsub('-','_')
+          .gsub(/\W/,'')
+          .split('_')
+          .map { |e| e.capitalize}
+          .join
+      end
+      eval result.join('::')
+    end
+  end
+end

data/lib/bales/application.rb~

@@ -0,0 +1,71 @@
+##
+# 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

@@ -0,0 +1,196 @@
+require 'optparse'
+
+##
+# 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"
+# ```
+module Bales
+  class Command
+    def self.options
+      @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) unless @action.nil?
+    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("_","-")
+
+      opts[:type] = String if opts[:type].nil?
+
+      unless opts[:type].is_a? Class
+        raise ArgumentError, ":type option should be a valid class"
+      end
+
+      if (opts[:type].ancestors & [TrueClass, FalseClass]).empty?
+        opts[:arg] ||= name
+      end
+
+      opts[:default] = false if opts[:type].ancestors.include? TrueClass
+      opts[:default] = true if opts[:type].ancestors.include? FalseClass
+
+      result = options
+      result[name] = opts
+      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[:short_form]
+        if (opts[:type].ancestors & [TrueClass,FalseClass]).empty?
+          argstring = opts[:arg].to_s.upcase
+          if opts[:required]
+            parser_args.push "#{opts[:long_form]} #{argstring}"
+          else
+            parser_args.push "#{opts[:long_form]} [#{argstring}]"
+          end
+          parser_args.push opts[:type]
+        else
+          parser_args.push opts[:long_form]
+        end
+        parser_args.push opts[:description]
+
+        if opts[:type].ancestors.include? FalseClass
+          optparser.on(*parser_args) do
+            result[name] = false
+          end
+        elsif opts[:type].ancestors.include? TrueClass
+          optparser.on(*parser_args) do
+            result[name] = true
+          end
+        else
+          optparser.on(*parser_args) do |value|
+            result[name] = value
+          end
+        end
+      end
+
+      optparser.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.rb~

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

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

data/lib/bales/version.rb~

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

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: bales
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ryan S. Northrup
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-08 00:00:00.000000000 Z
+dependencies: []
+description: A framework for building command-line applications
+email:
+- rnorthrup@newleaders.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/bales.rb
+- lib/bales.rb~
+- lib/bales/#command.rb#
+- lib/bales/application.rb
+- lib/bales/application.rb~
+- lib/bales/command.rb
+- lib/bales/command.rb~
+- lib/bales/version.rb
+- lib/bales/version.rb~
+homepage: http://github.com/YellowApple/bales
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.4.6
+signing_key: 
+specification_version: 4
+summary: Ruby on Bales
+test_files: []