commandeer 0.0.1 → 0.1.0

data/LICENSE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,209 @@
+# Commandeer
+Commandeer is a simple (and rather ghetto) implementation of a class-based CLI builder.
+
+## Needs/Goals
+- Easily create git-style subcommands
+- Be option parser agnostic
+- Not be a framework
+
+The idea is simply that you can expose any class as a git-style CLI option. Your bin script can then simply call `Commandeer.parse!(ARGV)`.
+
+This came about when trying to create a simple all-in-one CLI application. I wanted to be able to do:
+
+- `myapp log search [options here]`
+- `myapp log tail [options here]`
+- `myapp deploy appname`
+- `myapp someother command [options here]`
+
+However I didn't want to maintain a single option parser. The cli app was modular and I just wanted to keep the options for a command in the class that handled it.
+In this way, I didn't have to remember to go update the option parser defintion/bin script when I added new functionality.
+
+### Simple example
+
+```ruby
+# test-app.rb
+require 'commandeer'
+
+class Foo
+  include Commandeer
+  command "run"
+
+  def self.parse(opts)
+    puts opts
+  end
+end
+
+Commandeer.parse!(ARGV, __FILE__)
+```
+
+Without any options:
+
+```
+Usage: ./test-app.rb [command options] or [command subcommand options]
+
+	run
+```
+
+Once you add a known subcommand to the arguments, everything is passed off to the class' parse method. In the above example, it simply prints the passed args to output.
+What this means is that you can use ANY option parser (or none at all) that you like. You could conceivably use `slop`, `optparse` and custom stuff all in the same codebase.
+Commandeer is like honey badger. It just doesn't give a damn.
+
+The only "requirement" is that the parser for the class be a class method.
+
+By default, Commandeer will look for a class method called `parse` but most everything is overrideable:
+
+- method name: _You can call a method other than parse_
+- class: _You can call another class' parse method_
+- parent: _You can set the command to be a subcommand by giving it a parent. The parent can, but doesn't have to be, a real command._
+
+### Complex example
+
+```ruby
+# override-all-the-things
+class Override
+  def self.zing(args)
+    puts "I am overriding all the things:"
+    puts args
+  end
+end
+
+class AllTheThings
+  include Commandeer
+
+  command "all-the-things", :parent => 'override', :klass => "Override", :parser => "zing"
+end
+
+Commandeer.parse!(ARGV)
+```
+
+Output:
+
+```
+$ test-app.rb
+Usage: ./test-app.rb [command options] or [command subcommand options]
+
+	override	Subcommands: all-the-things
+
+$ test-app.rb override
+`override` has the following registered subcommands:
+	all-the-things
+
+$ ./test-app.rb override all-the-things for-great-justice
+I am overriding all the things:
+for-great-justice
+```
+
+### Mixing command options and subcommands
+You can even add a subcommand to a top-level command that has its own parser (but you'll get a nasty warning about it).
+
+```ruby
+require 'commandeer'
+require 'optparse'
+
+class Parent
+  include Commandeer
+
+  command "parent"
+
+  def self.parse(args)
+    options = {}
+    opts = OptionParser.new do |opts|
+      opts.banner = "parent [options]"
+
+      opts.on("-p", "--parent PARENTTHING", "The option for parent") do |f|
+        options[:f] = f
+      end
+      opts.on_tail("-h", "--help", "parent help") do
+        puts opts
+        exit(1)
+      end
+    end
+    begin
+      opts.parse!(args)
+    rescue OptionParser::InvalidOption => e
+      puts e
+      puts opts
+    end
+  end
+end
+
+class Child
+  include Commandeer
+
+  command "child", :parent => 'parent'
+
+  def self.parse(args)
+    options = {}
+    opts = OptionParser.new do |opts|
+      opts.banner = "child [options]"
+
+      opts.on("-c", "--child CHILDTHING", "The option for child") do |f|
+        options[:f] = f
+      end
+      opts.on_tail("-h", "--help", "child help") do
+        puts opts
+        exit(1)
+      end
+    end
+    begin
+      opts.parse!(args)
+    rescue OptionParser::InvalidOption => e
+      puts e
+      puts opts
+    end
+  end
+end
+
+Commandeer.parse!(ARGV,__FILE__)
+```
+
+Output:
+
+```
+$ ./test-app.rb 
+Usage: ./test-app.rb [command options] or [command subcommand options]
+
+	parent	Subcommands: child
+
+$ ./test-app.rb parent
+`parent` has the following registered subcommands:
+	child
+
+$ ./test-app.rb parent --help
+parent [options]
+    -p, --parent PARENTTHING         The option for parent
+    -h, --help                       parent help
+exit
+
+$ ./test-app.rb parent child
+        Warning! `child` is a registered subcommand for `parent` but `parent` also takes options.
+        This can cause unexpected results if `parent` has an option named `child`
+
+$ ./test-app.rb parent child --help
+        Warning! `child` is a registered subcommand for `parent` but `parent` also takes options.
+        This can cause unexpected results if `parent` has an option named `child`
+child [options]
+    -c, --child CHILDTHING           The option for child
+    -h, --help                       child help
+```
+
+# Contributing
+
+* Fork
+* New branch
+* Pull Request
+* Collect eternal gratitude
+
+
+# Fun fact of the day
+I really wanted to call this "cylon" so you could do this:
+
+```ruby
+class Foo
+  include Cylon
+
+  by_your_command "kill_humans"
+end
+```
+
+Oh well.

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+
+desc "Run all tests"
+task :test do
+  tests = Dir.glob('test/test_*.rb')
+  tests.shuffle.each do |test|
+    sh %{/usr/bin/env ruby #{test}}
+  end
+end

data/lib/commandeer.rb

@@ -1,5 +1,5 @@
 module Commandeer
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 
   @commands = {}
 
@@ -40,18 +40,19 @@ module Commandeer
 
     # No args. Let's show what we have registered
     if (args.size == 0) || (args[0] =~ /^-/)
-      puts "Usage: #{@script_name} [command options] or [command subcommand options]\n\n"
-      puts "Registered commands\n"
+      output = ''
+      output << "Usage: #{@script_name} [command options] or [command subcommand options]\n\n"
       @commands.each do |command, options|
         next if (command==:klass || command==:parser)
-        puts " #{command}"
+        output << "\t#{command}\t"
         unless options["subcommands"].nil?
-          puts "  subcommands:"
+          output << "Subcommands:"
           options["subcommands"].each do |sub, opts|
-            puts "   #{sub}"
+            output << " #{sub}"
           end
         end
       end
+      puts output
       exit
     end
 
@@ -64,29 +65,28 @@ module Commandeer
 
     subcommands = command["subcommands"]
 
-    if subcommands
+    if subcommands && args.size == 0
       output = ''
       output << "`#{scope}` has the following registered subcommands:\n"
       subcommands.keys.each {|x| output << "\t#{x}" }
       puts output
-    end if args.size == 0
+    end
 
-    if command.has_key?(:parser)
-      output = ''
-      output << "\n`#{scope}` also takes options"
-      output << "\ntry running '#{@script_name} #{scope} --help'"
-      puts output
-    end if args.size == 0
+    if command.has_key?(:parser) && args.size == 0
+      # We should just pass this straight to the parser and be done
+      parser = command[:parser]
+      klass = command[:klass]
+    end
 
     if args.size > 0 
-      if subcommands.has_key?(args[0])
+      if subcommands && subcommands.has_key?(args[0])
         # Okay so the next arg is a registered subcommand. Let's shift args
         new_scope = args.shift
         warning =<<-EOF
         Warning! `#{new_scope}` is a registered subcommand for `#{scope}` but `#{scope}` also takes options.
         This can cause unexpected results if `#{scope}` has an option named `#{new_scope}`
         EOF
-        puts warning
+        puts warning if command.has_key?(:parser)
 
         parser = subcommands[new_scope][:parser]
         klass = subcommands[new_scope][:klass]

data/test/{test_helper.rb → helper.rb}

@@ -1,4 +1,7 @@
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "test")))
-require 'commandeer'
+gem 'minitest'
+require 'minitest/pride'
 require 'minitest/autorun'
+require 'commandeer'
+Commandeer.reset!

data/test/helpers/all_override.rb

@@ -1,6 +1,6 @@
 class Foo
   def self.zing(args)
-    puts args
+    puts *args
   end
 end
 

data/test/helpers/namespaced.rb

@@ -6,6 +6,7 @@ module Name
 
     def self.parse(args)
       puts args
+      exit
     end
   end
 end

data/test/test_all_override.rb

@@ -0,0 +1,58 @@
+require "#{File.expand_path(File.join(File.dirname(__FILE__), "helper.rb"))}"
+
+class TestOverrideAll < MiniTest::Unit::TestCase
+  def setup
+    require 'helpers/all_override'
+    @commands = Commandeer.commands
+  end
+
+  def test_has_command
+    assert_includes(@commands.keys, "override")
+  end
+
+  def test_has_subcommands
+    assert_includes(@commands['override'].keys, 'subcommands')
+  end
+
+  def test_has_subcommand
+    assert_includes(@commands['override']['subcommands'].keys, 'random')
+  end
+
+  def test_subcommand_has_parser
+    assert(@commands['override']['subcommands']['random'][:parser], "zing")
+  end
+
+  def test_subcommand_has_klass
+    assert(@commands['override']['subcommands']['random'][:klass], "Foo")
+  end
+
+  def test_output_noopts
+    out, err = capture_io do
+      begin
+        Commandeer.parse! ''
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /^.*Usage.*\n\n\t.*override\tSubcommands: random.*$/)
+  end
+
+  def test_output_override
+    out, err = capture_io do
+      begin
+        Commandeer.parse! %w{override}
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /`override` has the following registered subcommands:\n\trandom.*$/)
+  end
+
+  def test_output_random_options
+    out, err = capture_io do
+      begin
+        Commandeer.parse! %w{override random foo bar baz}
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /^foo\nbar\nbaz\n*$/)
+  end
+end

data/test/test_command.rb

@@ -0,0 +1,42 @@
+require "#{File.expand_path(File.join(File.dirname(__FILE__), "helper.rb"))}"
+
+class TestCommand < MiniTest::Unit::TestCase
+  def setup
+    require 'helpers/command.rb'
+    @commands = Commandeer.commands
+  end
+
+  def test_has_command
+    assert_includes(@commands.keys, "foo")
+  end
+
+  def test_has_parser
+    assert(@commands['foo'][:parser], "parse")
+  end
+
+  def test_has_klass
+    assert(@commands['foo'][:klass], "PrimaryCommand")
+  end
+
+  def test_output_noopts
+    out, err = capture_io do
+      begin
+        Commandeer.parse! ''
+      rescue SystemExit
+      end
+    end
+
+    assert_match(out, /^.*\tfoo.*$/)
+  end
+
+  def test_output_foo
+    out, err = capture_io do
+      begin
+        Commandeer.parse! %w{foo --help}
+      rescue SystemExit
+      end
+    end
+
+    assert_match(out, /^foo \[options\]*$/)
+  end
+end

data/test/test_methods.rb

@@ -0,0 +1,28 @@
+require "#{File.expand_path(File.join(File.dirname(__FILE__), "helper.rb"))}"
+
+class TestMethods < MiniTest::Unit::TestCase
+  def setup
+    @commands = Commandeer.commands
+  end
+
+  def test_commands_is_hash
+    assert_kind_of(Hash, @commands)
+  end
+
+  def test_respond_to_reset
+    assert_respond_to(Commandeer, :reset!)
+  end
+
+  def test_respond_to_add_command
+    assert_respond_to(Commandeer, :add_command)
+  end
+
+  def test_respond_to_parse
+    assert_respond_to(Commandeer, :parse!)
+  end
+
+  def test_respond_to_constantize
+    assert_respond_to(Commandeer, :constantize)
+  end
+
+end

data/test/test_namespaced.rb

@@ -0,0 +1,41 @@
+require "#{File.expand_path(File.join(File.dirname(__FILE__), "helper.rb"))}"
+
+class TestNameSpaced < MiniTest::Unit::TestCase
+  def setup
+    require 'helpers/namespaced.rb'
+    @commands = Commandeer.commands
+  end
+
+  def test_has_command
+    assert_includes(@commands.keys, "namespaced")
+  end
+
+  def test_namespaced_has_parser
+    assert(@commands['namespaced'][:parser], "parse")
+  end
+
+  def test_has_klass
+    assert(@commands['namespaced'][:klass], "Name::Spaced")
+  end
+
+  def test_output_noopts
+    out, err = capture_io do
+      begin
+        Commandeer.parse! ''
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /^.*Usage.*\n\n\t.*namespaced.*$/)
+  end
+
+  def test_output_namespaced
+    out, err = capture_io do
+      begin
+        Commandeer.parse! %w{namespaced an_opt}
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /an_opt/)
+  end
+
+end

data/test/test_sub_of_real.rb

@@ -0,0 +1,86 @@
+require "#{File.expand_path(File.join(File.dirname(__FILE__), "helper.rb"))}"
+
+class TestSubOfRealCommand < MiniTest::Unit::TestCase
+  def setup
+    require 'helpers/sub_of_real_command.rb'
+    @commands = Commandeer.commands
+  end
+
+  def test_has_command
+    assert_includes(@commands.keys, "parent")
+  end
+
+  def test_command_has_parser
+    assert(@commands['parent'][:parser], "parse")
+  end
+
+  def test_command_has_class
+    assert(@commands['parent'][:klass], "Parent")
+  end
+
+  def test_has_subcommands
+    assert_includes(@commands['parent'].keys, 'subcommands')
+  end
+
+  def test_has_subcommand
+    assert_includes(@commands['parent']['subcommands'].keys, 'child')
+  end
+
+  def test_subcommand_has_parser
+    assert(@commands['parent']['subcommands']['child'][:parser], "parse")
+  end
+
+  def test_subcommand_has_klass
+    assert(@commands['parent']['subcommands']['child'][:klass], "Child")
+  end
+
+  def test_output_noopts
+    out, err = capture_io do
+      begin
+        Commandeer.parse! ''
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /^.*Usage.*\n\n\t.*parent\tSubcommands: child.*$/)
+  end
+
+  def test_output_parent
+    out, err = capture_io do
+      begin
+        Commandeer.parse! %w{parent}
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /`parent` has the following registered subcommands:\n\tchild.*$/)
+  end
+
+  def test_output_parent_options
+    out, err = capture_io do
+      begin
+        Commandeer.parse! %w{parent --help}
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /^parent \[options\]*$/)
+  end
+
+  def test_output_child_with_warning
+    out, err = capture_io do
+      begin
+        Commandeer.parse! %w{parent child}
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /^.*Warning! `child` is a registered subcommand for `parent` but `parent` also takes options.*$/)
+  end
+
+  def test_output_child_options
+    out, err = capture_io do
+      begin
+        Commandeer.parse! %w{parent child --help}
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /^.*\nchild \[options\]*$/)
+  end
+end

data/test/test_subcommand.rb

@@ -0,0 +1,58 @@
+require "#{File.expand_path(File.join(File.dirname(__FILE__), "helper.rb"))}"
+
+class TestSubCommand < MiniTest::Unit::TestCase
+  def setup
+    require 'helpers/subcommand.rb'
+    @commands = Commandeer.commands
+  end
+
+  def test_has_command
+    assert_includes(@commands.keys, "fakeparent")
+  end
+
+  def test_has_subcommands
+    assert_includes(@commands['fakeparent'].keys, 'subcommands')
+  end
+
+  def test_has_subcommand
+    assert_includes(@commands['fakeparent']['subcommands'].keys, 'bar')
+  end
+
+  def test_subcommand_has_parser
+    assert(@commands['fakeparent']['subcommands']['bar'][:parser], "parse")
+  end
+
+  def test_has_klass
+    assert(@commands['fakeparent']['subcommands']['bar'][:klass], "SubCommand")
+  end
+
+  def test_output_noopts
+    out, err = capture_io do
+      begin
+        Commandeer.parse! ''
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /^.*Usage.*\n\n\t.*fakeparent\tSubcommands: bar.*$/)
+  end
+
+  def test_output_fakeparent
+    out, err = capture_io do
+      begin
+        Commandeer.parse! %w{fakeparent}
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /`fakeparent` has the following registered subcommands:\n\tbar.*$/)
+  end
+
+  def test_output_bar_options
+    out, err = capture_io do
+      begin
+        Commandeer.parse! %w{fakeparent bar --help}
+      rescue SystemExit
+      end
+    end
+    assert_match(out, /^bar \[options\]*$/)
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: commandeer
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors: 
 - John E. Vincent
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-28 00:00:00 Z
+date: 2011-12-05 00:00:00 Z
 dependencies: []
 
 description: Class-based CLI utility
@@ -25,16 +25,23 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- LICENSE
+- README.md
+- Rakefile
 - commandeer.gemspec
 - lib/commandeer.rb
+- test/helper.rb
 - test/helpers/all_override.rb
 - test/helpers/command.rb
 - test/helpers/namespaced.rb
 - test/helpers/sub_of_real_command.rb
 - test/helpers/subcommand.rb
-- test/test_commands.rb
-- test/test_helper.rb
-- test/test_output.rb
+- test/test_all_override.rb
+- test/test_command.rb
+- test/test_methods.rb
+- test/test_namespaced.rb
+- test/test_sub_of_real.rb
+- test/test_subcommand.rb
 homepage: https://github.com/lusis/commandeer
 licenses: []