commandable 0.2.0 → 0.2.1

data/README.markdown

@@ -1,45 +1,55 @@
 # Commandable
-The easiest way to add command line control to your Ruby app.
+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.
+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 must 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.
+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. 
+* Put a `command "I do something!"` line above your method.
+* And finally make 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!)
+Now any method you want to make accessible from the command line requires just a single line of code and it's right where your method is so it's easy to find when you do want to change some functionality.
+
+Don't think of **Commandable** as a way to add command line switches, it's much more than that. Think of it as a way to allow your app to be driven directly from the command line. 
+
+You can now "use your words" to let people interact with your apps in a natural way. 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.
 
 ## 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. 
+In an effort to make the best possible software I'm asking anyone that would like to help out to run the BDD/TDD tests included with the gem. If you don't already have the `rubygems-test` gem installed please install it:
+
+    $ gem install rubygems-test
+
+And then run the tests on your machine:
 
-You can take a look at the test results yourself here:
+    $ gem test commandable
 
-<http://test.rubygems.org/gems/hashmodel/v/0.4.0>
+And of course upload them when it asks you if it can. You can take a look at the test results yourself here:
+
+<http://test.rubygems.org/gems/commandable/v/0.2.0>
 
 Thanks for your help.
 
 
 ## Status
 
-2011-03-21 - Release Cadidate: 0.2.0.rc1
+2011-04-04 - Version: 0.2.1 
 
+See change history for additions.
 
 ## Principle of Least Surprise
 
-I've tried to follow the principle of least surprise so Commandable should just work like you would expect it to. As long as you expect it to work the same way as I do.
+I've tried to follow the principle of least surprise so Commandable should just work like you would expect it to. As long as you expect it to work the same way as I do.  
 
 ## Requirements ##
 
 * Ruby 1.9.2
-* *Nix OS (Probably works on Windows but not tested yet)
+* Any Posix OS (It works, mostly, on Windows but ironically some of the tests won't run because of some unix commands I use in the tests)
 
 ## Installation  
 From the command line:  
@@ -49,17 +59,17 @@ From the command line:
     
 ## Usage Instructions
 
-After installing the **Commandable** gem require it somewhere that gets loaded before your class does:
+After installing the **Commandable** gem require it somewhere that gets loaded before your class does:  
 
     require 'commandable'
 
-Extend your class with the **Commandable** module:
+Extend your class with the **Commandable** module:  
     
     class Widget
       extend Commandable
     
 Then put `command` and a description above the method you want to make accessible. The description is optional but can be helpful
-since it's used when automatically building your help/usage instructions.
+since it's used when automatically building your help/usage instructions.  
 
       command "create a new widget"
       def new(name)
@@ -71,46 +81,48 @@ since it's used when automatically building your help/usage instructions.
     command ["description"], [:required], [:default], [:priority=>(0...n)], [:xor[=>:group_name]]
 
 _**command**_ _(required)_  
-This is the only thing that's required. It tells **Commandable** to add the method that follows to the list of methods available from the command line.
+This is the only thing that's required. It tells **Commandable** to add the method that follows to the list of methods available from the command line.  
 
 _**description**_ [optional]  
-As you would imagine this is a short description of what the method does. You can have multiple lines by using a new line, `\n`, in the description and your description will be lined up properly. This prints in the help/usage instructions when a user calls your programing using the command "help" or if they try to issue a command that doesn't exist. Help instructions will also print if they try to use your app without any parameters (if there isn't a default method that doesn't require parameters.).
+As you would imagine this is a short description of what the method does. You can have multiple lines by using a new line, `\n`, in the description and your description will be lined up properly. This prints in the help/usage instructions when a user calls your programing using the command "help" or if they try to issue a command that doesn't exist. Help instructions will also print if they try to use your app without any parameters (if there isn't a default method that doesn't require parameters.).  
 
 _**:required**_ [optional]  
-You can mark a method as required and the user must specify this command and any required parameters every time they run your app. Note that while you can have a method marked as both :default and :required that would be kind of pointless since :required means they have to type out the name of the function and :default means they don't.
+You can mark a method as required and the user must specify this command and any required parameters every time they run your app. You can also have a method marked as both :default and :required which allows you to run a method with a required parameter but you don't have to type the method name.
 
 _**:default**_ [optional]  
-You can have one and only one default method. This method will be called if your app is called with just parameters or if the first command line parameter isn't a command. The user can still give more commands after the parameters for the default command too.
+You can have one and only one default method. This method will be called if your app is called with just parameters or if the first command line parameter isn't a command. The user can still give more commands after the parameters for the default command too.  
  
-For instance say your default method is :foo that takes one parameter and you have another method called :bar that also takes one parameter. A user could do this:
+For instance say your default method is :foo that takes one parameter and you have another method called :bar that also takes one parameter. A user could do this:  
 
     yourapp "Some Parameter" bar "A parameter for bar"
 
-Just be aware that if they give an option that has the same name as a function the app will think it's a command.
+Just be aware that if they give an option that has the same name as a function the app will think it's a command.  
 
 _**priority=>n**_ [optional]  
-This optional setting allows you to assign priorities to your methods so if you need them to be executed in a specific order, regardless of how the user specifies them on the command line, you can use this. Then when you execute the command line or ask for a queue of commands they will be sorted for you by priority.
+This optional setting allows you to assign priorities to your methods so if you need them to be executed in a specific order, regardless of how the user specifies them on the command line, you can use this. Then when you execute the command line or ask for a queue of commands they will be sorted for you by priority.  
 
-The higher the priority the sooner the method will be executed. If you do not specify a priority a method will have a priority of 0, the lowest priority. 
+The higher the priority the sooner the method will be executed. If you do not specify a priority a method will have a priority of 0, the lowest priority.  
 
-Note that you can have a default method with a lower priority than a non-default method.
+Note that you can have a default method with a lower priority than a non-default method.  
 
 _**:xor[=>:whatever]**_ [optional]  
-The :xor parameter allows you to configure a group of methods as mutually exclusive, i.e. if method1 and method2 are in the same :xor group the user of your application can only call one of them at a time.
+The :xor parameter allows you to configure a group of methods as mutually exclusive, i.e. if method1 and method2 are in the same :xor group the user of your application can only call one of them at a time.  
 
-You can use just the :xor symbol and the method will be put into the default XOR group, called :xor so :xor=>:xor, but if you need multiple XOR groups you can specify a group name by using a hash instead of just the :xor symbol.
+You can use just the :xor symbol and the method will be put into the default XOR group, called :xor so :xor=>:xor, but if you need multiple XOR groups you can specify a group name by using a hash instead of just the :xor symbol.  
 
-The XOR group name will be printed in the front to the description text so it's probably a good idea to use :xor as the prefix.
+The XOR group name will be printed in the front to the description text so it's probably a good idea to use :xor as the prefix.  
 
 
 ### Parameter lists
-The parameter lists for each method that are printed out in the usage/help instructions are built using the names you give them so you should make sure to use descriptive names. Also keep in mind that all command line parameters are strings so you need to deal with that inside your methods if what you really want is a number.
+When building the help/usage instructions a list of parameters for each command is automatically created using the names you give the parameters in your method; make sure you use descriptive names.  
+
+Also keep in mind that all command line parameters are strings so you need to deal with that inside your methods if what you really want is a number.  
 
-If none of your methods have parameters then there won't be any reference to parameters in the help/usage instructions.
+If none of your methods have parameters then there won't be any reference to parameters in the help/usage instructions. The description text will be moved over to be closer to your commands.  
 
 ### A complete class
 
-A complete class might look like this:
+A complete class might look like this:  
 
     require 'commandable'
 
@@ -123,8 +135,8 @@ A complete class might look like this:
       end
 
       command "destroy an existing widget", :xor
-      def disassemble(name)
-        "No dissaemble #{name}! #{name} is alive!"
+      def delete(name)
+        "No disassemble #{name}! #{name} is alive!"
       end
       
       command "spend lots of money to update a widget", :xor
@@ -132,10 +144,15 @@ A complete class might look like this:
         "You just gave #{name} a nice new coat of paint!"
       end
 
+      command "your security key must be entered for every command", :required
+      def key(security)
+        # blah, blah, blah
+      end
+
     end
 
 #### Class methods
-You can also use it on class methods:
+You can also use it on class methods:  
 
     require "commandable"
 
@@ -156,7 +173,7 @@ You can also use it on class methods:
       end
     end
 
-If you want to do a block of class commands using `class << self` you need to put `extend Commandable` inside the block:
+If you want to do a block of class commands using `class << self` you need to put `extend Commandable` inside the block:  
 
     require "commandable"
 
@@ -177,31 +194,33 @@ If you want to do a block of class commands using `class << self` you need to pu
     end
 
 
-Note: Class methods are called directly on the class while instance methods have an instance created for that call. Keep that in mind if you need to share data between calls. In that case you might want to store your data in a model you create outside the execution queue.
+Note: Class methods are called directly on the class while instance methods have an instance created for all calls to that class. This means if you set an instance variable in one method it will be available to any other method calls to that same class; just as if you had created an instance of your class and called methods on it.
 
 ### Automatic usage/help generation ###
 
-One of the great features of **Commandable** is that it will automatically create usage instructions based on your methods and the descriptions you provide for them. The `help` command is also added for you automatically. If your app has no default or it has a default command that requires parameters the help/usage instructions will be printed if a user just runs your app without any input.
+One of the great features of **Commandable** is that automatically creates usage instructions based on your methods and the descriptions you provide for them and it adds a `help` command for you.  
+
+If your app has no `:default` method or it has a default command that requires parameters the help/usage instructions will be printed if a user just runs your app without any input.  
 
 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]     : Downloads a fully working app demonstrating how
+                          to use Commandable with RSpec and Cucumber
+        help            : you're looking at it now
 
 
 
@@ -210,17 +229,19 @@ For a fully working example with RSpec and Cucumber tests run this command:
 
     $ commandable widget [path]
 
-If you would like to see a bunch of simple classes that demonstrate its uses run:
+In addition **Commandable** uses **Commandable** for its own command line options so you can also look at the `lib/commandable/app_controller.rb class` for an example.  
+
+If you would like to see a bunch of simple classes that demonstrate **Commandable**'s uses run:
 
     $ commandable examples [path]
 
 ### Commandable Options
 
-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.
+These are the basic options you'll 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\_exe**  
 _default = ""_  
-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. 
+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 configured the help instructions will include a usage line with your executable's name. 
 
 **Commandable.app\_info**  
 _default = ""_  
@@ -399,11 +420,24 @@ If you have any questions about how the code works I've tried to give as much in
 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.
 
 
+## Version History ##
+
+2011-04-04 - Version: 0.2.1  
+
+* Added ability to use attr\_accessor and att\_writer as commands. You can only write to them of course but it's an easy way to set values.
+* Instance methods now retain state between different calls. In other words if you set an instance variable in one method it will be available to any other instance method calls for that class. It's as if you created an instance of your class and called the methods yourself. You can access the class instances using the hash Commandable.class\_cache. It is has the class name, a string, as the key and the instance of the class as the value. {"ClassName"=>#<ClassName:0x00000100b1f188>}
+* You can now have the execute command work without outputting anything. Just add :silent (or anything other than nil or false) to the execution method. For instance `Commandable.execute(ARGV,:silent)`.
+* Clarified error message for default methods that are also required. If you don't give anything it tells you you need to give a parameter but you don't specifically have to give the switch. 
+
+2011-03-23 - Version: 0.2.0  
+
+* First public release. It's 0.2.0 because 0.1.0 was called Cloptions and wasn't released.
+
 ## To Do
 
-All done... for now.
+Nothing in this version.
 
-###Next version:
+### Next major 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.

data/commandable.gemspec

@@ -13,22 +13,8 @@ Gem::Specification.new do |s|
   s.homepage                = "http://mikbe.tk"
   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.
+The easiest way to add command line control to your Ruby app. 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 definition itself. When you change your methods the help instructions change automajically!
 EOF
 
   s.license = 'MIT'

data/lib/commandable/app_controller.rb

@@ -13,7 +13,7 @@ module Commandable
         `open #{File.expand_path((File.dirname(__FILE__) + '/../../readme.markdown'))}`
       end
       
-      command "Copies a fully working app demonstrating how\nto use Commandable with RSpec and Cucumber"
+      command "Downloads a fully working app demonstrating how\nto use Commandable with RSpec and Cucumber"
       # Creates a simple example app demonstrating a fully working app
       def widget(path="./widget")
         # Test for Git
@@ -21,7 +21,7 @@ module Commandable
           puts "Git must be installed to download Widget (You're a developer and you don't have Git installed?)"
           return
         end
-        # Git already has all of it's own error trapping 
+        # Git already has all of its own error trapping so
         # it would be horrible coupling and duplication
         # of effort to do anything on my end for failures.
         puts "\nUnable to download Widget. You can find the souce code here:\nhttps#{WIDGET_GITHUB}" unless download_widget(path) == 0
@@ -46,7 +46,7 @@ module Commandable
         FileUtils.copy_dir(File.expand_path(File.dirname(__FILE__) + '/../../spec/source_code_examples'),path)
       end
 
-      command "Will raise a programmer error, not a user error\nso you see what happens when you have bad code"
+      command "Will raise a programmer error, not a user error\nso you can see what happens when you have bad code"
       # Causes an error so you can see what it will look like if you have an error in your code.
       def error
         raise Exception, "An example of a non-user error caused by your bad code trapped in Commandable.execute()"

data/lib/commandable/commandable.rb

@@ -53,6 +53,12 @@ module Commandable
       @@commands.dup
     end
     
+    # A hash of instances created when calling instance methods
+    # It's keyed using the class name: {"ClassName"=>#<ClassName:0x00000100b1f188>}
+    def class_cache
+      @@class_cache
+    end
+    
     # Access the command array using the method name (symbol or string)
     def [](index)
       raise AccessorError unless index.is_a? String or index.is_a? Symbol
@@ -68,8 +74,8 @@ module Commandable
       @app_exe = nil
       @verbose_parameters = true
       @@default_method = nil
+      @@class_cache = {}
     end
-    alias :init :reset_all
     
     # Clears all methods from the list of available commands
     # This is mostly useful for testing.
@@ -138,11 +144,12 @@ module Commandable
     # A wrapper for the execution_queue that runs the queue and traps errors. 
     # If an error occurs inside this method it will print out a complete.
     # of availavle methods with usage instructios and exit gracefully.
-    def execute(argv)
+    def execute(argv, silent=false)
       begin
         command_queue = execution_queue(argv)
         command_queue.each do |com|
-          puts com[:proc].call
+          return_value = com[:proc].call
+          puts return_value unless silent
         end
       rescue Exception => exception
         if exception.respond_to?(:friendly_name)
@@ -170,7 +177,8 @@ module Commandable
       end
       arguments << "help" if arguments.empty?
       
-      # Parse the commad line into methods and their parameters
+      # Parse the command line into methods and their parameters
+      
       arguments.each do |arg|
         if Commandable[arg]
           last_method = arg.to_sym
@@ -190,29 +198,45 @@ module Commandable
           end
           method_hash[last_method] << arg
         end
-        @@commands.select do |key, value| 
-          raise MissingRequiredCommandError, key if value[:required] and method_hash[key].nil?
+        # Test for missing required switches
+        @@commands.select do |key, value|
+          if value[:required] and method_hash[key].nil?
+            # If the required switch is also a default have the error be a missing parameter instead of a missing command
+            if value[:default]
+              method_hash.merge!(key=>[])
+            else
+              raise MissingRequiredCommandError, key 
+            end
+          end
         end
       end
-
+      #puts "method_hash: #{method_hash}" if method_hash.to_s.include?("required_default")
+      
       # Build an array of procs to be called for each method and its given parameters
       proc_array = []
       method_hash.each do |meth, params|
         command = @@commands[meth]
+
+        if command[:parameters] && !command[:parameters].empty?
+          
+          #Change the method name for attr_writers
+          meth = "#{meth}=" if command[:parameters][0][0] == :writer
         
-        # Test for missing parameters
-        required = command[:parameters].select{|param| param[0]==:req} if command[:parameters]
-        if required
+          # Get a list of required parameters and make sure all of them were provided
+          required = command[:parameters].select{|param| [:req, :writer].include?(param[0])}
           required.shift(params.count)
-          raise MissingRequiredParameterError, {:method=>meth, :parameters=>required.collect!{|meth| meth[1]}.to_s[1...-1].gsub(":","")} unless required.empty?
+          raise MissingRequiredParameterError, {:method=>meth, :parameters=>required.collect!{|meth| meth[1]}.to_s[1...-1].gsub(":",""), :default=>command[:default]} unless required.empty?
         end
-
+        
         # Test for duplicate XORs
         proc_array.select{|x| x[:xor] and x[:xor]==command[:xor] }.each {|bad| raise ExclusiveMethodClashError, "#{meth}, #{bad[:method]}"}
 
         klass = Object
         command[:class].split(/::/).each { |name| klass = klass.const_get(name) }
-        klass = klass.new unless command[:class_method]
+        ## Look for class in class cache
+        unless command[:class_method]
+          klass = (@@class_cache[klass.name] ||= klass.new)
+        end
         proc_array << {:method=>meth, :xor=>command[:xor], :parameters=>params, :priority=>command[:priority], :proc=>lambda{klass.send(meth, *params)}}
       end
       proc_array.sort{|a,b| a[:priority] <=> b[:priority]}.reverse
@@ -221,8 +245,8 @@ module Commandable
    
     # Set colors to their default values
     def reset_colors
-      # Colors - off by default
       @color_output      ||= true
+
       # Build the default colors
       Term::ANSIColorHI.coloring = color_output
       c = Term::ANSIColorHI
@@ -253,7 +277,7 @@ module Commandable
     def set_colors
       if color_output
         @c_app_info           = @color_app_info
-        @c_app_exe           = @color_app_exe
+        @c_app_exe            = @color_app_exe
         @c_command            = @color_command
         @c_description        = @color_description
         @c_parameter          = @color_parameter
@@ -273,7 +297,9 @@ module Commandable
     end
 
   end
-  init # automatically configure the module when it's loaded
+  
+  # inititialize the Commandable's settings when it's loaded
+  reset_all
 
   private 
   
@@ -281,6 +307,7 @@ module Commandable
   # It lets you add a method to the list of command line methods
   def command(*cmd_parameters)
 
+    @@attribute = nil
     @@method_file = nil
     @@method_line = nil
     @@command_options = {}
@@ -310,6 +337,8 @@ module Commandable
     
     set_trace_func proc { |event, file, line, id, binding, classname|
 
+      @@attribute = id if [:attr_accessor, :attr_writer].include?(id)
+      
       # Traps the line where the method is defined so we can look up 
       # the method source code later if there are optional parameters
       if event == "line" and !@@method_file
@@ -328,8 +357,15 @@ module Commandable
   # Add a method to the list of available command line methods
   def add_command(meth)
     @@commands.delete(:help)
-    argument_list = parse_arguments(@@command_options[:parameters])
+    
+    if @@attribute
+      argument_list = "value"
+      meth = meth.to_s.delete("=").to_sym if @@attribute == :attr_writer
+    else
+      argument_list = parse_arguments(@@command_options[:parameters])
+    end
     @@command_options.merge!(:argument_list=>argument_list,:class => self.name)
+    
     @@commands.merge!(meth => @@command_options)
     @@default_method = {meth => @@command_options} if @@command_options[:default]
 
@@ -337,13 +373,22 @@ module Commandable
     
     @@commands.merge!(HELP_COMMAND.dup) # makes sure the help command is always last
     @@command_options = nil
+    @@attribute = nil
   end
 
   # Trap method creation after a command call 
   def method_added(meth)
     set_trace_func(nil)
     return super(meth) if meth == :initialize || @@command_options == nil
-    @@command_options.merge!(:parameters=>self.instance_method(meth).parameters,:class_method=>false)
+    
+    if @@attribute
+      #synthesize parameter
+      @@command_options.merge!(:parameters=>[[:writer, :value]],:class_method=>false)
+    else
+      # create parameter
+      @@command_options.merge!(:parameters=>self.instance_method(meth).parameters,:class_method=>false)
+    end
+    
     add_command(meth)
   end
   
@@ -386,10 +431,10 @@ module Commandable
   # Reads a line from a source code file.
   def readline(file, line_number)
     current_line = 0
-    File.open(file).each { |line_text|
+    File.open(file).each do |line_text|
       current_line += 1
       return line_text.strip if current_line == line_number
-    }
+    end
   end
   
   # Parses a method defition for the optional values of given argument.

data/lib/commandable/exceptions.rb

@@ -43,7 +43,10 @@ module Commandable
     end
     # Create a new instance of the MissingRequiredParameterError class
     def initialize(msg)
-      super("The command \"#{msg[:method]}\" is missing the required parameter \"#{msg[:parameters]}\".")
+      super("""
+  The #{"default " if msg[:default]}command \"#{msg[:method]}\" is missing the required parameter \"#{msg[:parameters]}\".
+  #{"You don't have to specifically say \"#{msg[:method]}\" but you do have to give the parameter." if msg[:default]}"
+      )
     end
   end
 

data/lib/commandable/version.rb

@@ -2,7 +2,7 @@ module Commandable
   module VERSION # :nodoc:
     MAJOR  = 0
     MINOR  = 2
-    TINY   = 0
+    TINY   = 1
     PRE    = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')

data/lib/monkey_patch/os.rb

@@ -0,0 +1,8 @@
+require 'sys/uname'
+include Sys
+
+module Kernel
+  def is_windows?
+    Uname.sysname.downcase.include?('windows')
+  end
+end

data/spec/commandable/attr_accessor_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Commandable do
+  
+    before(:each) {
+    Commandable.reset_all
+    Commandable.color_output = true
+    Commandable.verbose_parameters = false
+    Commandable.app_exe = "fake_app"
+    Commandable.app_info =  
+    """
+      \e[92mFake App!\e[0m - It's not real!
+    """
+  }
+
+  
+  context "when command is used on an attr_accessor" do
+    
+    context 'when there is a single accessor per line' do
+
+      before(:each) { load 'attr_accessor.rb' }
+      
+      context "when testing syntax" do
+        
+        it "should work with an attr_accessor" do
+          lambda{execute_queue(["some_accesor", "a value"])}.should_not raise_error
+        end
+      
+        it "should work with an attr_writer" do
+          lambda{execute_queue(["some_writer", "used the writer"])}.should_not raise_error
+        end
+
+        it "should work with an attr_writer and an attr_accessor" do
+          lambda{execute_queue(["some_accesor", "a value", "some_writer", "used the writer"])}.should_not raise_error
+        end
+      
+        it "should raise an error is a value isn't given" do
+          lambda{execute_queue(["some_accesor"])}.should raise_error(Commandable::MissingRequiredParameterError)
+        end
+      
+        it "should raise an error is a value isn't given" do
+          lambda{execute_queue(["some_writer"])}.should raise_error(Commandable::MissingRequiredParameterError)
+        end
+      
+        it "should raise an error is a value isn't given" do
+          lambda{execute_queue(["some_accesor", "some_writer", "used the writer"])}.should raise_error(Commandable::MissingRequiredParameterError)
+        end
+      
+        it "should raise an error is a value isn't given" do
+          lambda{execute_queue(["some_accesor", "a value", "some_writer"])}.should raise_error(Commandable::MissingRequiredParameterError)
+        end
+      end
+      
+      it {execute_output_s(["some_accesor", "a value"]).should include("a value")}
+      it {execute_output_s(["some_writer", "blah blah blah"]).should include("blah blah blah")}
+      
+    end
+    
+    context 'when there is more than one accessor on the same line' do
+
+      before(:each) { load 'attr_accessor_multi.rb' }
+      
+      context "when testing syntax" do
+        it "should use the first accessor" do
+          lambda{execute_queue(["first_accessor", "a value"])}.should_not raise_error
+        end
+      
+        it "should ignore the second accessor" do
+          lambda{execute_queue(["second_accessor", "blipidy"])}.should raise_error
+        end
+
+        it "should use the first writer" do
+          lambda{execute_queue(["first_writer", "a value"])}.should_not raise_error
+        end
+      
+        it "should ignore the second writer" do
+          lambda{execute_queue(["second_writer", "blipidy"])}.should raise_error
+        end
+      end
+
+      it {execute_output_s(["first_accessor", "my very own accessor"]).should include("my very own accessor")}
+      it {execute_output_s(["first_writer", "Look ma! A writer!"]).should include("Look ma! A writer!")}
+      
+    end
+    
+  end
+  
+end

data/spec/commandable/command_line_execution_spec.rb

@@ -92,13 +92,18 @@ describe Commandable do
       end
 
       context "and automatically executing commands" do
-        specify {execute_output_ary(["foo", "1", "2.4"]).should == ["1", "2.4"]}
-        specify {execute_output_ary(["bar", "234"]).should == ["234", "Number 42"]}
-        specify {execute_output_ary(["bar", "39", "potato"]).should == ["39", "potato"]}
-        specify {execute_output_ary(["qux"]).should == ["1492", "I'm a tricky one"]}
-        specify {execute_output_ary(["qux", "991"]).should == ["991", "I'm a tricky one"]}
-        specify {execute_output_ary(["qux", "1821", "Look I've got %special\"characters\" in me"]).should == 
+        it {execute_output_ary(["foo", "1", "2.4"]).should == ["1", "2.4"]}
+        it {execute_output_ary(["bar", "234"]).should == ["234", "Number 42"]}
+        it {execute_output_ary(["bar", "39", "potato"]).should == ["39", "potato"]}
+        it {execute_output_ary(["qux"]).should == ["1492", "I'm a tricky one"]}
+        it {execute_output_ary(["qux", "991"]).should == ["991", "I'm a tricky one"]}
+        it {execute_output_ary(["qux", "1821", "Look I've got %special\"characters\" in me"]).should == 
           ["1821", "Look I've got %special\"characters\" in me"]}
+          
+        context "when specifying that it should be silent" do
+          it {execute_output_s(["foo", "1", "2.4"], :silent).should be_empty}
+        end
+
       end
 
       context "and using the execution_queue command" do

data/spec/commandable/helpers_spec.rb

@@ -6,11 +6,11 @@ describe Commandable do
     
     before(:each) {load 'private_methods_bad.rb'}
     
-    specify {PrivateMethods.send(:parse_optional, "def bar(x=14243)", "x").should == "14243"} 
-    specify {PrivateMethods.send(:parse_optional,"def bar x = 144444", "x").should == "144444"}
-    specify {PrivateMethods.send(:parse_optional,"def bar x=12", "x").should == "12"}
-    specify {PrivateMethods.send(:parse_optional,'def bar (x="42", y)', "x").should == "\"42\""}
-    specify {PrivateMethods.send(:parse_optional,'def bar(y="kjljlj",x="I love Ruby")', "x").should == "\"I love Ruby\""}
+    specify {PrivateMethodsBad.send(:parse_optional, "def bar(x=14243)", "x").should == "14243"} 
+    specify {PrivateMethodsBad.send(:parse_optional,"def bar x = 144444", "x").should == "144444"}
+    specify {PrivateMethodsBad.send(:parse_optional,"def bar x=12", "x").should == "12"}
+    specify {PrivateMethodsBad.send(:parse_optional,'def bar (x="42", y)', "x").should == "\"42\""}
+    specify {PrivateMethodsBad.send(:parse_optional,'def bar(y="kjljlj",x="I love Ruby")', "x").should == "\"I love Ruby\""}
     
   end
   

data/spec/commandable/instance_methods_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Commandable do
+  
+  context "when calling instance methods" do
+    
+    before(:each) do
+      @first_value = "the first value saved"
+      @second_value = "the second saved value"
+    end
+    
+    it "saves instance variables between method calls" do
+      load 'instance_methods.rb'
+      values = execute_queue(["set_value", @first_value, "get_value"])
+      values[1].should == @first_value
+    end
+
+    context 'when multiple classes are involved' do
+    
+      it "saves instance variables between method calls" do
+        load 'instance_methods.rb'
+        load 'instance_methods2.rb'
+        values2 = execute_queue(["set_value2", @second_value, "get_value2"])
+        values2[1].should == values2[0]
+        execute_queue(["get_value"])[0].should == @first_value
+      end
+    
+    end
+    
+    context "when running the execution queue manually" do
+      
+      it "should give a programmer access to any instances created" do
+        Commandable.reset_all
+        load 'instance_methods.rb'
+        load 'instance_methods2.rb'
+        execute_queue(["set_value", @first_value, "get_value"])
+        execute_queue(["set_value2", @second_value, "get_value2"])
+        Commandable.class_cache.keys.should include("InstanceMethods", "InstanceMethods2")
+      end
+      
+    end
+     
+  end
+  
+end

data/spec/commandable/required_default_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Commandable do
+  
+    before(:each) {
+    Commandable.reset_all
+    Commandable.color_output = true
+    Commandable.verbose_parameters = false
+    Commandable.app_exe = "fake_app"
+    Commandable.app_info =  
+    """
+      \e[92mFake App!\e[0m - It's not real!
+    """
+    load "required_default.rb"
+  }
+
+  
+  context "when there is a required/default command" do
+
+    context "and it has a required parameter" do
+      
+      context "but nothing is given on the command line" do
+        
+        it "should say a required parameter is missing" do
+          lambda{execute_queue([])}.should raise_error(Commandable::MissingRequiredParameterError)
+        end
+        
+        it "should say a required parameter is missing" do
+          execute_output_s([]).should include("default command")
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/source_code_examples/attr_accessor.rb

@@ -0,0 +1,13 @@
+require "commandable"
+
+class AttrAccessor
+  extend Commandable
+
+  command 'uses an attr_accessor'
+  attr_accessor :some_accesor
+
+  command 'uses an attr_writer'
+  attr_writer :some_writer
+ 
+ 
+end

data/spec/source_code_examples/attr_accessor_multi.rb

@@ -0,0 +1,13 @@
+require "commandable"
+
+class AttrAccessorMulti
+  extend Commandable
+
+  # You can do this just realize the second accessor is ignored
+  command 'only runs the first accessor'
+  attr_accessor :first_accessor, :second_accessor
+
+  command 'only runs the first writer'
+  attr_writer :first_writer, :second_writer
+ 
+end

data/spec/source_code_examples/class_command_no_command.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class ClassCommandNoCommand

data/spec/source_code_examples/class_methods.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class ClassMethods

data/spec/source_code_examples/class_methods_nested.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class ClassMethodsNested

data/spec/source_code_examples/command_no_command.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class CommandNoCommand

data/spec/source_code_examples/deep_class.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 module TopModule

data/spec/source_code_examples/default_method.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class DefaultMethods

data/spec/source_code_examples/default_method_multiparameters.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class DefaultMethodsMultiParameters

data/spec/source_code_examples/default_method_no_params.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class DefaultMethodNoParams

data/spec/source_code_examples/instance_methods.rb

@@ -0,0 +1,16 @@
+require "commandable"
+
+class InstanceMethods
+  extend Commandable
+  
+  command "save a value", :priority=>2
+  def set_value(value)
+    @value = value
+  end 
+  
+  command "retreive a value"
+  def get_value
+    @value
+  end
+ 
+end

data/spec/source_code_examples/instance_methods2.rb

@@ -0,0 +1,16 @@
+require "commandable"
+
+class InstanceMethods2
+  extend Commandable
+  
+  command "save a value", :priority=>2
+  def set_value2(value)
+    @value = value
+  end 
+  
+  command "retreive a value"
+  def get_value2
+    @value
+  end
+ 
+end

data/spec/source_code_examples/multi_line_description.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class MultiLineDescription

data/spec/source_code_examples/multi_line_description_no_params.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class MultiLineDescriptionNoParams

data/spec/source_code_examples/no_description.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class NoDescription

data/spec/source_code_examples/parameter_class.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class ParameterClass

data/spec/source_code_examples/parameter_free.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class ParameterFree

data/spec/source_code_examples/required_default.rb

@@ -0,0 +1,11 @@
+require "commandable"
+
+class RequiredDefault
+  extend Commandable
+  
+  command "the default action", :default, :required
+  def required_default(required_value)
+    value
+  end 
+ 
+end

data/spec/source_code_examples/required_methods.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class RequiredMethods

data/spec/source_code_examples/super_deep_class.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 module TopModule

data/spec/source_code_examples/test_class.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class TestClass

data/spec/source_code_examples/xor_class.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class XorClass

data/spec/source_code_for_errors/class_bad.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class ClassBad

data/spec/source_code_for_errors/default_method_bad.rb

@@ -1,4 +1,3 @@
-@@command_options
 require "commandable"
 
 class DefaultMethodsBad

data/spec/source_code_for_errors/private_methods_bad.rb

@@ -1,10 +1,9 @@
-@@command_options
 require "commandable"
 
 # This is just a not so clever way of getting at the instance methods of Commandable
 # Accessing the private methods of a class/module is a bad idea but I really need to
 # test them. Plus making a helper module just to test them is also against best practices
 # so...
-class PrivateMethods
+class PrivateMethodsBad
   extend Commandable
 end

data/spec/spec_helper.rb

@@ -47,16 +47,22 @@ def capture_output
 end
 
 # Executes a command capturing STDOUT and STDERR as an array representing each line
-def execute_output_ary(argv)
-  execute_output_s(argv).split(%r{\n})
+# Traps errors so not to be used for testing lambad{}.should_not raise_error
+# or should raise_error since you won't get the error
+def execute_output_ary(argv, silent=false)
+  execute_output_s(argv, silent).split(%r{\n})
 end
 
 # Executes a command capturing STDOUT and STDERR as one string
-def execute_output_s(argv)
-  output = capture_output{Commandable.execute(argv)}
+# Traps errors so not to be used for testing lambad{}.should_not raise_error
+# or should raise_error since you won't get the error
+def execute_output_s(argv, silent=false)
+  output = capture_output{Commandable.execute(argv, silent)}
   output[:stdout] + output[:stderr]
 end
 
+# Exectues a command queue returning the results
+# Use when you want to make sure you don't raise an error
 def execute_queue(argv)
   queue = Commandable.execution_queue(argv)
   queue.collect{|meth| meth[:proc].call}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: commandable
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-03-23 00:00:00.000000000 -04:00
+date: 2011-04-04 00:00:00.000000000 -04:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: term-ansicolor-hi
-  requirement: &2158240980 !ruby/object:Gem::Requirement
+  requirement: &2153496380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 1.0.7
   type: :runtime
   prerelease: false
-  version_requirements: *2158240980
+  version_requirements: *2153496380
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2158240520 !ruby/object:Gem::Requirement
+  requirement: &2153495800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: '2.5'
   type: :development
   prerelease: false
-  version_requirements: *2158240520
+  version_requirements: *2153495800
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &2158240040 !ruby/object:Gem::Requirement
+  requirement: &2153495200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: '0.10'
   type: :development
   prerelease: false
-  version_requirements: *2158240040
+  version_requirements: *2153495200
 - !ruby/object:Gem::Dependency
   name: aruba
-  requirement: &2158230600 !ruby/object:Gem::Requirement
+  requirement: &2153494600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -55,25 +55,15 @@ dependencies:
         version: '0.3'
   type: :development
   prerelease: false
-  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"
+  version_requirements: *2153494600
+description: ! 'The easiest way to add command line control to your Ruby app. 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
+  definition itself. When you change your methods the help instructions change automajically!
+
+'
 email:
 - mikbe.tk@gmail.com
 executables:
@@ -103,13 +93,19 @@ files:
 - lib/commandable/exceptions.rb
 - lib/commandable/version.rb
 - lib/monkey_patch/file_utils.rb
+- lib/monkey_patch/os.rb
 - spec/commandable/app_controller_spec.rb
+- spec/commandable/attr_accessor_spec.rb
 - spec/commandable/command_line_execution_spec.rb
 - spec/commandable/commandable_spec.rb
 - spec/commandable/help_generator_spec.rb
 - spec/commandable/helpers_spec.rb
+- spec/commandable/instance_methods_spec.rb
+- spec/commandable/required_default_spec.rb
 - spec/commandable/reset_spec.rb
 - spec/commandable/xor_groups_spec.rb
+- spec/source_code_examples/attr_accessor.rb
+- spec/source_code_examples/attr_accessor_multi.rb
 - spec/source_code_examples/class_command_no_command.rb
 - spec/source_code_examples/class_methods.rb
 - spec/source_code_examples/class_methods_nested.rb
@@ -118,11 +114,14 @@ files:
 - spec/source_code_examples/default_method.rb
 - spec/source_code_examples/default_method_multiparameters.rb
 - spec/source_code_examples/default_method_no_params.rb
+- spec/source_code_examples/instance_methods.rb
+- spec/source_code_examples/instance_methods2.rb
 - spec/source_code_examples/multi_line_description.rb
 - spec/source_code_examples/multi_line_description_no_params.rb
 - spec/source_code_examples/no_description.rb
 - spec/source_code_examples/parameter_class.rb
 - spec/source_code_examples/parameter_free.rb
+- spec/source_code_examples/required_default.rb
 - spec/source_code_examples/required_methods.rb
 - spec/source_code_examples/super_deep_class.rb
 - spec/source_code_examples/test_class.rb
@@ -160,12 +159,17 @@ summary: The easiest way to add command line control to your Ruby apps.
 test_files:
 - autotest/discover.rb
 - spec/commandable/app_controller_spec.rb
+- spec/commandable/attr_accessor_spec.rb
 - spec/commandable/command_line_execution_spec.rb
 - spec/commandable/commandable_spec.rb
 - spec/commandable/help_generator_spec.rb
 - spec/commandable/helpers_spec.rb
+- spec/commandable/instance_methods_spec.rb
+- spec/commandable/required_default_spec.rb
 - spec/commandable/reset_spec.rb
 - spec/commandable/xor_groups_spec.rb
+- spec/source_code_examples/attr_accessor.rb
+- spec/source_code_examples/attr_accessor_multi.rb
 - spec/source_code_examples/class_command_no_command.rb
 - spec/source_code_examples/class_methods.rb
 - spec/source_code_examples/class_methods_nested.rb
@@ -174,11 +178,14 @@ test_files:
 - spec/source_code_examples/default_method.rb
 - spec/source_code_examples/default_method_multiparameters.rb
 - spec/source_code_examples/default_method_no_params.rb
+- spec/source_code_examples/instance_methods.rb
+- spec/source_code_examples/instance_methods2.rb
 - spec/source_code_examples/multi_line_description.rb
 - spec/source_code_examples/multi_line_description_no_params.rb
 - spec/source_code_examples/no_description.rb
 - spec/source_code_examples/parameter_class.rb
 - spec/source_code_examples/parameter_free.rb
+- spec/source_code_examples/required_default.rb
 - spec/source_code_examples/required_methods.rb
 - spec/source_code_examples/super_deep_class.rb
 - spec/source_code_examples/test_class.rb