commandable 0.2.0.rc1 → 0.2.0

data/README.markdown

@@ -1,7 +1,9 @@
 # Commandable
-The easiest way to add command line control to your Ruby app. If you don't find **Commandable** incredibly easy to use I will give you one billions dollars!\* (\*not a legally binding offer)
+The easiest way to add command line control to your Ruby app.
 
-Stop wasting time writing wet command line interpreters or even writing code for the existing ones. Then writing help functions that you have to constantly change as your code changes. Now you can add a single line above an existing method and that method will be available from the command line. Best of all the help/usage instructions are automatically generated using the method itself so if you change your methods the help instructions change without any more effort on your part!
+Stop wasting time writing WET (Write Everything Twice) command line interpreters, or repeatedly writing code for existing ones like optparser, then writing help/usage methods that you constantly have to update as your code changes. Now you can add a single line above an existing method and that method will be available from the command line.
+
+Best of all the help/usage instructions are automatically generated using the method itself! When you change your methods the help instructions change automajically! There's no extra effort needed on your part.
 
 The whole process can take as little as four lines of code:  
 
@@ -14,6 +16,17 @@ Don't think of **Commandable** as a way to add command line switches to your app
 
 You can now "use your words" to let people interact with your apps in a natural way.
 
+## Testing for a Better Tomorrow ##
+
+I have the gem set up to ask if you would like to test on install so please allow the tests to run and upload. This will allow me to find any problems on different platforms. 
+
+You can take a look at the test results yourself here:
+
+<http://test.rubygems.org/gems/hashmodel/v/0.4.0>
+
+Thanks for your help.
+
+
 ## Status
 
 2011-03-21 - Release Cadidate: 0.2.0.rc1
@@ -172,23 +185,23 @@ One of the great features of **Commandable** is that it will automatically creat
 
 A typical help output looks something like this:  
 
-  Commandable - The easiest way to add command line control to your app.
-  Copyrighted free software - Copyright (c) 2011 Mike Bethany.
-  Version: 0.2.0
+    Commandable - The easiest way to add command line control to your app.
+    Copyrighted free software - Copyright (c) 2011 Mike Bethany.
+    Version: 0.2.0
 
-  Usage: commandable <command> [parameters] [<command> [parameters]...]
+    Usage: commandable <command> [parameters] [<command> [parameters]...]
 
-  Command Parameters Description
-    error            : Will raise a programmer error, not a user error
-                       so you see what happens when you have bad code
- examples [path]     : Copies the test classes to a folder so
-                       you can see a bunch of small examples
-   readme            : displays the readme file (default)
-        v            : <xor> Application Version
-  version            : <xor> Application Version
-   widget [path]     : Copies a fully working app demonstrating how
-                       to use Commandable with RSpec and Cucumber
-     help            : you're looking at it now
+    Command Parameters Description
+      error            : Will raise a programmer error, not a user error
+                         so you see what happens when you have bad code
+   examples [path]     : Copies the test classes to a folder so
+                         you can see a bunch of small examples
+     readme            : displays the readme file (default)
+          v            : <xor> Application Version
+    version            : <xor> Application Version
+     widget [path]     : Copies a fully working app demonstrating how
+                         to use Commandable with RSpec and Cucumber
+       help            : you're looking at it now
 
 
 
@@ -203,20 +216,20 @@ If you would like to see a bunch of simple classes that demonstrate its uses run
 
 ### Commandable Options
 
-There are the basic options you will want to be aware of. Specifically you really want to set `Commandable#app_name` and `Commandable#app_info` so that the help/usage instructions are fully fleshed out.
+These are the basic options you will want to be aware of. Specifically you really want to set `Commandable#app_exe` and `Commandable#app_info` so that the help/usage instructions are fully fleshed out.
 
-**Commandable.app\_name**  
+**Commandable.app\_exe**  
 _default = ""_  
-Set this and the help instructions will include your application's name.
+This is what a user would type to run your app; don't set it to "My App" set it to "myapp". When this is set the help instructions will include a usage line with your executables name. 
 
 **Commandable.app\_info**  
 _default = ""_  
 This is informational text that will print above the help/usage instructions.
 
 **Commandable.verbose\_parameters**  
-_default = true_  
-If set to false help instructions will not print out default values.  
-**Important!** This should only be set once, before any files load. Changing the value after files are loaded will make no difference since parameters are only parsed when the source file loads.
+_default = false_  
+If set to true help instructions will include the default values in the parameter list.  
+**Important!** This should only be set once, after you `require 'commandable'` but before any of your code files load. Changing the value after files are loaded will make no difference since parameters are only parsed when the source file loads.
     
     Commandable.verbose_parameters = true
     # Will print:
@@ -228,7 +241,7 @@ If set to false help instructions will not print out default values.
 
 ### Colorized Output Options
 
-The help information can be colored using the standard ANSI escape commands found in the `term-ansicolor-hi` gem. The `term-ansicolor-hi` gem it installed as a dependency but just in case you can install it yourself by running:
+The help information can be colored using the standard ANSI escape commands found in the `term-ansicolor-hi` gem. The `term-ansicolor-hi` gem it installed as a dependency but just in case you have problems you can install it yourself by running:
 
     $ [sudo] gem install term-ansicolor-hi
 
@@ -239,7 +252,7 @@ Then you can do something like this:
     c = Term::ANSIColorHI
     
     Commandable.color_app_info           = c.intense_white  + c.bold
-    Commandable.color_app_name           = c.intense_green  + c.bold
+    Commandable.color_app_exe           = c.intense_green  + c.bold
     Commandable.color_command            = c.intense_yellow
     Commandable.color_description        = c.intense_white
     Commandable.color_parameter          = c.intense_cyan
@@ -253,7 +266,7 @@ Then you can do something like this:
 
 **Commandable.color\_output**  
 _default = true_  
-Set to false to disable colorized help/usage instructions. You might find it really, really annoying...
+Set to false to disable colorized help/usage instructions. You might find the colors really, really annoying...
 
 **Commandable.color\_app\_info**  
 _default = intense\_white_ + bold  
@@ -261,7 +274,7 @@ The color the app_info text will be in the help message
 
 **Commandable.color\_app\_name**  
 _default = intense\_green_ + bold  
-The color the app_name will be in the usage line in the help message
+The color the app_exe will be in the usage line in the help message
 
 **Commandable.color\_command**  
 _default = intense\_yellow_  
@@ -292,6 +305,9 @@ _default = intense\_black_ + bold
 The color the error description will be in error messages
 
 
+The best way to see what all this means it just type `commandable help` and you'll see the help instructions in color.
+
+
 ### Executing the Command Line
 
 There are two ways of using **Commandable** to run your methods. You can use its built in execute method to automatically run whatever is entered on the command line or you can have **Commandable** build an array of procs that you can execute yourself. This allows you to have finer grain control over the execution of the commands as you can deal with the return values as you run each command.
@@ -300,29 +316,18 @@ There are two ways of using **Commandable** to run your methods. You can use its
 
 **Commandable#execution_queue(ARGV)**
 
-Now that you've added a command to a method you can send the command line arguments (ARGV) to `Commandable#execution_queue` and it will generate an array of procs you should run sorted in the order of priority you specified when creating the commands.
+After you've added a command method and a description above a method you can then get an array of command you should execute by sending the command line arguments (ARGV) to `Commandable#execution_queue`. That method will generate an array of procs to run based on the user's input.  They're sorted by the order of priority you specified when creating the commands or if they all have the same priority they sort by how they were entered.
 
     # execution_queue returns an array of hashes which 
     # in turn  contains the method name keyed to :method
-    # and a proc key to, you guessed it, :proc
+    # and a proc keyed to, you guessed it, :proc
     # It looks like this:
-    # [{:method => :method_name, :xor=>(:xor group or nil), :parameters=>[...], :priority, :proc => #<proc:>}, ...]
+    # [{:method => :method_name, :xor=>(:xor group or nil), :parameters=>[...], :priority=>0, :proc => #<proc:>}, ...]
     #
     # The array is automatically sorted by priority (higher numbers first, 10 > 0)
-
-    # First get the array of commands
-    command_queue = Commandable.execution_queue(ARGV) # no need to give it ARGV, it's there for testing
-    
-    return_values = (command_queue.shift)[:proc].call
-    # do something with the return values
-   
-    # check for more values however you want
-    more_return_values = command_queue.shift[:proc].call unless command_queue.empty?
-
-If you need a little more control:
     
     # First get the array of commands
-    command_queue = Commandable.execution_queue(ARGV) # no need to give it ARGV
+    command_queue = Commandable.execution_queue(ARGV) # #ARGV will be cloned so it won't change it
 
     # Loop through the array calling the commands and dealing with the results
     command_queue.each do |cmd|
@@ -352,13 +357,11 @@ If you need a little more control:
 
 **Commandable.execute(ARGV)**
 
-The easiest way to use **Commandable** is to just let it do all the work. This works great if all you need to do is make your methods available from the command line. You can also design a controller class with **Commandable** in mind and run all you command from there.
+The easiest way to use **Commandable** is to just let it do all the work. This works great if all you need to do is make your methods available from the command line. You can also design a controller class with **Commandable** in mind and run all you commands from there.
 
-When you call the `Commandable#execute` method it will return an array of hashes for each method called. Each hash in the array contains the method name and its return values.  
+When you call the `Commandable#execute` method it will print out the return values for each method called automatically. This method is really meant to be the super easy way to do things. No muss, no fuss. Fire and forget. Shooting fish in a barrel... etc.
 
-    [:method_name=>[return,values,array], :method_name2=>[return,values,array],...] 
-
-Simply configure your bin file to run `Commandable#execute`:
+You just need to configure your bin file with the app settings and then run `Commandable#execute`:
 
 **[your Ruby app directory]/bin/your\_app\_name**
 
@@ -367,7 +370,7 @@ Simply configure your bin file to run `Commandable#execute`:
     require 'commandable'
     Commandable.verbose_parameters = false
     Commandable.color_output = true
-    Commandable.app_name = "My App"
+    Commandable.app_exe = "myapp"
     Commandable.app_info =
     """
       My App - It does stuff and things!
@@ -378,36 +381,38 @@ Simply configure your bin file to run `Commandable#execute`:
     # a configuration file to load the settings then your app
     # See the Widget app for an example of this.
     require 'yourappname'
-    return_values = Commandable.execute(ARGV)
-    # do stuff
+    Commandable.execute(ARGV)
+ 
 
+I actually prefer to create a separate file for my **Commandable** configuration and load it in my main app  file in the `lib` directory. Again, take a look at `Widget` to see what I mean. 
 
-I actually prefer to create a separate file for my **Commandable** configuration and load it in my apps main file in the `lib` directory. Just make sure you load the **Commandable** configuration file first. For a complete example of this run `commandable widget [path]` and it will copy the example app to the directory you specify.
+You can get a copy of widget by running `commandable widget [path]` and it will copy the example app to the directory you specify.
 
 ## In closing... ##
 
-One really cool thing about this design is you can extend another app and add your own command line controls without having to crack open their code. The other app doesn't even have to use **Commandable**. You can just write your own methods that call the methods of the original program.
+One really cool thing about this design is you can dynamically extend another app and add your own command line controls without having to crack open their code. The other app doesn't even have to use **Commandable**. You can just write your own methods that call the methods of the original program.
 
 I should also say the code is really, really ugly right now. Thats the very next thing I will be working on for this project. This is the "rough draft" version that works perfectly well but is very ugly code-wise. I needed to use it right now so am putting it out as is.
 
 If you have any questions about how the code works I've tried to give as much info in these docs as possible but I am also an OCD level commenter so you should be able to find fairly good explanations of what I'm doing in the code.
 
-Most of all it should be simple to use so if you have any problems please drop me a line. Also if you make any changes please send me a pull request. I when people that don't respond to them, even to deny them, so I'm pretty good about that sort of thing.
+Most of all it should be simple to use so if you have any problems please drop me a line. Also if you make any changes please send me a pull request. I hate when people don't respond to them, even to deny them, so I'm pretty good about that sort of thing.
 
 
 ## To Do
 
-Done with 0.2.0. Release to final beta.
+All done... for now.
 
 ###Next version:
 
+* Add a way to use or discover version numbers. Might have to force standardization and not allow configuration since it should be DRY.
 * Needs a massive refactoring.
-* Generator to add Commandable support to your app.
+* Add a generator to automatically add Commandable support to your app.
 * Reorganize docs to be more logical and less the result of my scribblings as I develop.
-* Try to figure out how to trap `alias` without an additional `command` use
-* Better formatting of help instructions, the existing one is fairly ugly.
+* Try to figure out how to trap `alias` so I don't you don't have to use  an additional `command`.
+* Better formatting of help/usage instructions, the existing one is fairly ugly.
 * Use comments below `command` as the description text so you don't have to repeat yourself to get RDoc to give you docs for your functions.
-* Clean up RSpecs. I'm doing too many ugly tests of internal state instead of specifying behavior.
+* Clean up RSpecs. I'm doing too many ugly tests instead of specifying behavior.
 * Allow sorting of commands alphabetically or by priority
 
 ###Future versions:

data/bin/commandable

@@ -3,7 +3,7 @@ $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
 require 'commandable'
 Commandable.color_output = true
 Commandable.verbose_parameters = false
-Commandable.app_name = "commandable"
+Commandable.app_exe = "commandable"
 Commandable.app_info =  
 """
   \e[92mCommandable\e[0m - The easiest way to add command line control to your app.

data/commandable.gemspec

@@ -11,8 +11,26 @@ Gem::Specification.new do |s|
   s.authors                 = ["Mike Bethany"]
   s.email                   = ["mikbe.tk@gmail.com"]
   s.homepage                = "http://mikbe.tk"
-  s.summary                 = %q{The easiest way to add command line control to your app.}
-  s.description             = %q{The easiest way to add command line control to your app.\nAdding command line control to your app is as easy as putting 'command "this command does xyz"' above a method.\nParameter lists and a help command are automatically built for you.}
+  s.summary                 = %q{The easiest way to add command line control to your Ruby apps.}
+  s.description             = <<EOF
+The easiest way to add command line control to your Ruby app.
+
+Stop wasting time writing WET (Write Everything Twice) command line interpreters, or repeatedly writing code for existing ones like optparser, then writing help/usage methods that you constantly have to update as your code changes. Now you can add a single line above an existing method and that method will be available from the command line.
+
+Best of all the help/usage instructions are automatically generated using the method itself! When you change your methods the help instructions change automajically! There's no extra effort needed on your part.
+
+The whole process can take as little as four lines of code:  
+
+* You put a `command "I do something!"` line above your method.
+* Add a `require 'commandable'` line somewhere (I'd put it in my bin).
+* Then an `extend Commandable` inside your class.
+* And finally a call to `Commandable.execute(ARGV)` in your bin file. 
+
+Don't think of Commandable as a way to add command line switches to your app but as a way to allow your app to be driven directly from the command line. No more confusing switches that mean one thing in one program and something completely different in another. (Can you believe some apps actually use `-v` for something other than "version" and `-h` for something other than "help?" Madness I say! Madness!)
+
+You can now "use your words" to let people interact with your apps in a natural way.
+EOF
+
   s.license = 'MIT'
 
   s.add_dependency("term-ansicolor-hi", "~>1.0.7")

data/lib/commandable/commandable.rb

@@ -20,8 +20,8 @@ module Commandable
     # Describes your application, printed at the top of help/usage messages
     attr_accessor :app_info
   
-    # Used when building the usage line, e.g. Usage: app_name [command] [parameters]
-    attr_accessor :app_name
+    # Used when building the usage line, e.g. Usage: app_exe [command] [parameters]
+    attr_accessor :app_exe
   
     # If optional parameters show default values, true by default
     attr_accessor :verbose_parameters
@@ -30,8 +30,8 @@ module Commandable
     attr_accessor :color_output
     # What color the app_info text will be in the help message
     attr_accessor :color_app_info
-    # What color the app_name will be in the usage line in the help message
-    attr_accessor :color_app_name
+    # What color the app_exe will be in the usage line in the help message
+    attr_accessor :color_app_exe
     # What color the word "command" and the commands themselves will be in the help message
     attr_accessor :color_command
     # What color the description column header and text will be in the help message
@@ -65,7 +65,7 @@ module Commandable
       clear_commands
       reset_colors
       @app_info = nil
-      @app_name = nil
+      @app_exe = nil
       @verbose_parameters = true
       @@default_method = nil
     end
@@ -100,10 +100,10 @@ module Commandable
 
       usage_text = "  #{@c_usage}Usage:#{@c_reset} "
 
-      if Commandable.app_name      
+      if Commandable.app_exe      
         cmd_text = "<#{@c_command + @c_bold}command#{@c_reset}>"
         parm_text = " [#{@c_parameter + @c_bold}parameters#{@c_reset}]" if max_parameter > 0
-        usage_text += "#{@c_app_name + app_name + @c_reset} #{cmd_text}#{parm_text} [#{cmd_text}#{parm_text}...]"
+        usage_text += "#{@c_app_exe + app_exe + @c_reset} #{cmd_text}#{parm_text} [#{cmd_text}#{parm_text}...]"
       end
 
       array =  [usage_text, ""]
@@ -227,7 +227,7 @@ module Commandable
       Term::ANSIColorHI.coloring = color_output
       c = Term::ANSIColorHI
       @color_app_info           = c.intense_white  + c.bold
-      @color_app_name           = c.intense_green  + c.bold
+      @color_app_exe           = c.intense_green  + c.bold
       @color_command            = c.intense_yellow
       @color_description        = c.intense_white
       @color_parameter          = c.intense_cyan
@@ -253,7 +253,7 @@ module Commandable
     def set_colors
       if color_output
         @c_app_info           = @color_app_info
-        @c_app_name           = @color_app_name
+        @c_app_exe           = @color_app_exe
         @c_command            = @color_command
         @c_description        = @color_description
         @c_parameter          = @color_parameter
@@ -266,7 +266,7 @@ module Commandable
         @c_bold               = @color_bold
         @c_reset              = @color_reset
       else
-        @c_app_info, @c_app_name, @c_command, @c_description,
+        @c_app_info, @c_app_exe, @c_command, @c_description,
         @c_parameter, @c_usage, @c_bold, @c_reset, @c_error_word,
         @c_error_name, @c_error_description = [""]*12
       end

data/lib/commandable/version.rb

@@ -3,7 +3,7 @@ module Commandable
     MAJOR  = 0
     MINOR  = 2
     TINY   = 0
-    PRE    = "rc1"
+    PRE    = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
 

data/spec/commandable/app_controller_spec.rb

@@ -6,7 +6,7 @@ describe Commandable do
     Commandable.reset_all
     Commandable.color_output = true
     Commandable.verbose_parameters = false
-    Commandable.app_name = "commandable"
+    Commandable.app_exe = "commandable"
     Commandable.app_info =  
     """
       \e[92mCommandable\e[0m - The easiest way to add command line control to your app.

data/spec/commandable/command_line_execution_spec.rb

@@ -4,7 +4,7 @@ describe Commandable do
 
   before(:each) {
     Commandable.reset_all
-    Commandable.app_name = "mycoolapp"
+    Commandable.app_exe = "mycoolapp"
     Commandable.app_info = 
 """
   My Cool App - It does stuff and things!

data/spec/commandable/help_generator_spec.rb

@@ -51,13 +51,13 @@ describe Commandable do
     it "adds the application name to the help output if it's given" do
       Commandable.color_output = false
       load 'parameter_class.rb'
-      Commandable.app_name = "mycoolapp"
+      Commandable.app_exe = "mycoolapp"
       Commandable.help.to_s.should match(/Usage: mycoolapp <command>/)
     end
 
     it "adds appliction information if given" do
       load 'parameter_class.rb'
-      Commandable.app_name = "mycoolapp"
+      Commandable.app_exe = "mycoolapp"
       app_info = 
 """
   My Cool App - It does stuff and things!
@@ -81,7 +81,7 @@ describe Commandable do
       end
 
       it "hides the doesn't show [parameters] in the usage instructions" do
-        Commandable.app_name = "fakeapp"
+        Commandable.app_exe = "fakeapp"
         execute_output_s([]).should_not match(/\[parameters\]/)
       end
 
@@ -108,7 +108,7 @@ describe Commandable do
 
     before(:each) do 
       load 'private_methods_bad.rb'
-      Commandable.app_name = "mycoolapp"
+      Commandable.app_exe = "mycoolapp"
       Commandable.app_info = 
 """  My Cool App - It does stuff and things!
   Copyright (c) 2011 Acme Inc."""
@@ -135,8 +135,8 @@ describe Commandable do
         specify {lambda {Commandable.color_app_info = c.black}.should change{Commandable.help}}
       end
 
-      context "when app_name is changed" do
-        specify {lambda {Commandable.color_app_name = c.black}.should change{Commandable.help}}
+      context "when app_exe is changed" do
+        specify {lambda {Commandable.color_app_exe = c.black}.should change{Commandable.help}}
       end
 
       context "when color_command is changed" do

data/spec/commandable/reset_spec.rb

@@ -5,7 +5,7 @@ describe Commandable do
   before(:each) do
     Commandable.reset_all
     load 'parameter_class.rb'
-    Commandable.app_name = "mycoolapp"
+    Commandable.app_exe = "mycoolapp"
     Commandable.app_info = 
 """  My Cool App - It does stuff and things!
   Copyright (c) 2011 Acme Inc."""
@@ -13,7 +13,7 @@ describe Commandable do
   
   context "when reseting all values" do
      
-    specify {lambda{Commandable.reset_all}.should change{Commandable.app_name}.from("mycoolapp").to(nil)}
+    specify {lambda{Commandable.reset_all}.should change{Commandable.app_exe}.from("mycoolapp").to(nil)}
     specify {lambda{Commandable.reset_all}.should change{Commandable.app_info}.
       from(%{  My Cool App - It does stuff and things!\n  Copyright (c) 2011 Acme Inc.}).
       to(nil)

metadata

@@ -1,20 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: commandable
 version: !ruby/object:Gem::Version
-  version: 0.2.0.rc1
-  prerelease: 6
+  version: 0.2.0
+  prerelease: 
 platform: ruby
 authors:
 - Mike Bethany
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-03-21 00:00:00.000000000 -04:00
+date: 2011-03-23 00:00:00.000000000 -04:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: term-ansicolor-hi
-  requirement: &2156630780 !ruby/object:Gem::Requirement
+  requirement: &2158240980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 1.0.7
   type: :runtime
   prerelease: false
-  version_requirements: *2156630780
+  version_requirements: *2158240980
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2156630320 !ruby/object:Gem::Requirement
+  requirement: &2158240520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: '2.5'
   type: :development
   prerelease: false
-  version_requirements: *2156630320
+  version_requirements: *2158240520
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &2156629860 !ruby/object:Gem::Requirement
+  requirement: &2158240040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: '0.10'
   type: :development
   prerelease: false
-  version_requirements: *2156629860
+  version_requirements: *2158240040
 - !ruby/object:Gem::Dependency
   name: aruba
-  requirement: &2156629400 !ruby/object:Gem::Requirement
+  requirement: &2158230600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -55,11 +55,25 @@ dependencies:
         version: '0.3'
   type: :development
   prerelease: false
-  version_requirements: *2156629400
-description: The easiest way to add command line control to your app.\nAdding command
-  line control to your app is as easy as putting 'command "this command does xyz"'
-  above a method.\nParameter lists and a help command are automatically built for
-  you.
+  version_requirements: *2158230600
+description: ! "The easiest way to add command line control to your Ruby app.\n\nStop
+  wasting time writing WET (Write Everything Twice) command line interpreters, or
+  repeatedly writing code for existing ones like optparser, then writing help/usage
+  methods that you constantly have to update as your code changes. Now you can add
+  a single line above an existing method and that method will be available from the
+  command line.\n\nBest of all the help/usage instructions are automatically generated
+  using the method itself! When you change your methods the help instructions change
+  automajically! There's no extra effort needed on your part.\n\nThe whole process
+  can take as little as four lines of code:  \n\n* You put a `command \"I do something!\"`
+  line above your method.\n* Add a `require 'commandable'` line somewhere (I'd put
+  it in my bin).\n* Then an `extend Commandable` inside your class.\n* And finally
+  a call to `Commandable.execute(ARGV)` in your bin file. \n\nDon't think of Commandable
+  as a way to add command line switches to your app but as a way to allow your app
+  to be driven directly from the command line. No more confusing switches that mean
+  one thing in one program and something completely different in another. (Can you
+  believe some apps actually use `-v` for something other than \"version\" and `-h`
+  for something other than \"help?\" Madness I say! Madness!)\n\nYou can now \"use
+  your words\" to let people interact with your apps in a natural way.\n"
 email:
 - mikbe.tk@gmail.com
 executables:
@@ -134,15 +148,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: The easiest way to add command line control to your app.
+summary: The easiest way to add command line control to your Ruby apps.
 test_files:
 - autotest/discover.rb
 - spec/commandable/app_controller_spec.rb