commandable 0.2.0.beta01

data/lib/commandable/exceptions.rb

@@ -0,0 +1,61 @@
+module Commandable
+  
+  # Programmer errors
+  
+  # An error made by the programmer when specifiying a command 
+  class SyntaxError < StandardError
+  end
+
+  # A programmer's error raised if setting are specifiying incorrectly, 
+  # For example if you set more than one default method.
+  class ConfigurationError < StandardError
+  end
+
+  # A programmer's error raised if the list of commands is accessed using something other than a string or :symbol
+  # This is meant to catch meta-programming errors.
+  class AccessorError < StandardError
+    # Create a new instance of the AccessorError class
+    def initialize(msg = "You may only access Commandable[] using a string or :symbol" )
+      super(msg)
+    end
+  end
+
+  # User errors
+
+  # An error raised if a user does not provide a required command
+  class MissingRequiredCommandError < ScriptError
+    # Returns a more print friendly error name
+    def friendly_name
+      "Missing Required Command"
+    end
+    # Create a new instance of the MissingRequiredCommandError class
+    def initialize(msg)
+      super("The required command \"#{msg}\" is missing.")
+    end
+  end
+
+  # This error is raised if a user gives two or more commands from the same exclusive group
+  class ExclusiveMethodClashError < ScriptError
+    # Returns a more print friendly error name
+    def friendly_name
+      "Exclusive "
+    end
+    # Create a new instance of the MissingRequiredCommandError class
+    def initialize(msg)
+      super("You may only run one of these commands at a time: \"#{msg}\"")
+    end
+  end
+
+  # A error raised if a user tries to run a command that is not in the commands array
+  class UnknownCommandError < ScriptError
+    # Returns a more print friendly error name
+    def friendly_name
+      "Unknown Command"
+    end
+    # Create a new instance of the MissingRequiredCommandError class
+    def initialize(msg)
+      super("There is no \"#{msg}\" command")
+    end
+  end
+  
+end

data/lib/commandable/version.rb

@@ -0,0 +1,4 @@
+module Commandable
+  # The application's version number
+  VERSION = "0.2.0.beta01"
+end

data/lib/monkey_patch/file_utils.rb

@@ -0,0 +1,11 @@
+require 'fileutils'
+
+module FileUtils
+  # Monkeypatch FileUtils really annoying directory copying
+  def copy_dir(source, dest)
+    files = Dir.glob("#{source}/**")
+    mkdir_p dest
+    cp_r files, dest
+  end
+  module_function :copy_dir
+end

data/spec/commandable/command_line_execution_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe Commandable do
+
+  before(:each) {
+    Commandable.reset_all
+    Commandable.app_name = "mycoolapp"
+    Commandable.app_info = 
+"""
+  My Cool App - It does stuff and things!
+  Copyright (c) 2011 Acme Inc.
+"""
+
+    load 'parameter_class.rb'
+  }
+
+  context "when parsing arguments" do
+  
+    context "and there is an error in the command line" do
+    
+      context "and the default method does not accept parameters" do
+        
+        before(:each) {load 'default_method_no_params.rb'}
+        
+        context "but something that isn't a method is the first thing on the command line" do
+          specify {lambda{Commandable.execution_queue(["potato"])}.should raise_error(Commandable::UnknownCommandError)}
+          specify { execute_output_s(["potato"]).should match(/Unknown Command/)} 
+        end
+        
+      end
+    
+      context "and running procs from the execution queue" do
+        it "raises an error if there is an invalid command given" do
+          lambda{Commandable.execution_queue(["fly", "navy"])}.should raise_error(Commandable::UnknownCommandError)
+        end
+      end
+    
+      context "and running commands automatically via execute" do
+        
+        context "and an unknown command is sent" do
+          it "traps errors" do
+            capture_output{lambda{Commandable.execute(["fly", "navy"])}.should_not raise_error}
+          end
+          it "prints the error" do
+            capture_output{Commandable.execute(["fly", "navy"])}.to_s.should 
+              match(/Error: Unknown Command(.*)There is no \\\"fly\\\" command/)
+          end
+          it "prints usage/help instructions" do
+            capture_output{Commandable.execute(["fly", "navy"])}.to_s.should match(/Usage:/)
+          end
+        end
+
+        context "and an unknown command is sent" do
+          
+          before(:each) { load 'required_methods.rb' }
+          it "traps errors" do
+            capture_output{lambda{Commandable.execute(["non_required_method", "blorp"])}.should_not raise_error}
+          end
+          it "prints the error" do
+            capture_output{Commandable.execute(["non_required_method", "blorp"])}.to_s.should
+             match(/Error: Missing Required Command(.*)The required command \\\"required_method\\\" is missing/)
+          end
+          it "prints usage/help instructions" do
+            capture_output{Commandable.execute(["non_required_method", "blorp"])}.to_s.should match(/Usage:/)
+          end
+        end
+        
+      end
+    
+    end
+
+    context "and the command line is valid" do
+      
+      it "does not raise an error" do
+        capture_output{Commandable.execute(["foo", "1", "2"])}.to_s.should_not match(/Error:/)
+      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 == 
+          ["1821", "Look I've got %special\"characters\" in me"]}
+      end
+
+      context "and using the execution_queue command" do
+
+        context "and only one command is given" do
+          
+          it "only has one command in the array" do
+            command_queue = Commandable.execution_queue(["foo", "1", "2.4"])
+            command_queue.length.should == 1
+          end
+          
+          it "properly parses parameters" do
+            command_queue = Commandable.execution_queue(["foo", "1", "2.4"])
+            command_queue.first[:parameters].should == ["1", "2.4"]
+          end
+          
+        end
+        
+        context "and more than one command is given" do
+          
+          it "has the correct number of commands in the array" do
+            command_queue = Commandable.execution_queue(["foo", "1", "2.4", "bar", "71"])
+            command_queue.length.should == 2
+          end
+
+          it "properly parses parameters" do
+            command_queue = Commandable.execution_queue(["foo", "1", "2.4", "bar", "71"])
+            command_queue.each do |command|
+              command[:parameters].should == ["71"] if command[:method] == :bar
+              command[:parameters].should == ["1", "2.4"] if command[:method] == :foo
+            end
+          end
+          
+        end
+        
+      end
+      
+      context "and there are greedy parameters" do
+        # number_arg1, string_arg2 = "blorp", *array_arg3
+        specify {execute_output_ary(["baz", "9"]).should == ["9", "blorp"]}
+        specify {execute_output_ary(["baz", "81", "Fish"]).should == ["81", "Fish"]}
+        specify {execute_output_ary(["baz", "3278", "Bubba", "Blip"]).should == ["3278", "Bubba", "Blip"]}
+        specify {execute_output_ary(["baz", "0.0234", "Yellow", "Mellow", "Fellow", "bellow", "elbow"]).should == 
+          ["0.0234", "Yellow", "Mellow", "Fellow", "bellow", "elbow"]
+        }
+
+        context "and it has multiple commands" do
+          
+          specify {execute_output_ary(["baz", "0.0234", "Yellow", "Mellow", "elbow", "qux"]).should ==
+              ["1492", "I'm a tricky one",
+              "0.0234", "Yellow", "Mellow", "elbow"]
+          }
+          
+          specify {execute_output_ary(["baz", "0.0234", "Yellow", "Mellow", "elbow", "foo", "17", "432", "qux"]).should == 
+              ["1492", "I'm a tricky one",
+              "17", "432", 
+              "0.0234", "Yellow", "Mellow", "elbow"]
+          }
+
+        end
+        
+      end
+      
+    end
+
+
+  end
+
+end

data/spec/commandable/commandable_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+describe Commandable do
+
+  before(:each) {Commandable.reset_all}
+
+  context "when using Commandable directly" do
+
+    before(:each) { load 'test_class.rb' }
+
+    context "when clearing values" do
+      specify { lambda{Commandable.clear_commands}.should_not raise_error}
+      specify { lambda{Commandable.reset_all}.should change{Commandable.commands.length}.from(2).to(1) }
+    end
+
+    context "when adding command to methods" do
+      specify { lambda{load 'test_class.rb'}.should_not raise_error }
+    end
+
+    context "when checking syntax" do
+    
+      it "shouldn't rasie an error if nothing more than 'switch' is used" do
+        lambda{load 'no_description.rb'}.should_not raise_error(Commandable::SyntaxError)
+      end
+    
+      it "rasies an error if no method follows a description" do
+        lambda{load 'class_bad.rb'}.should raise_error(Commandable::SyntaxError)
+      end
+
+    end
+
+    context "when enumerating" do
+    
+      it "is enumerable using #each" do
+        lambda{Commandable.each {|x|}}.should_not raise_error
+      end
+    
+      it "allows access to methods using []" do
+        lambda{Commandable["test_method"]}.should_not raise_error
+      end
+    
+      context "when using []" do
+    
+        specify { Commandable["test_method"].should_not be_nil }
+        specify { Commandable[:test_method].should_not be_nil }
+        specify { lambda{Commandable[1]}.should raise_error }
+        specify { lambda{Commandable[String]}.should raise_error }
+      
+        context "when using a variable" do
+
+          specify {
+            method = "method"
+            Commandable[:test_method].should_not be_nil
+          }
+
+          specify {
+            method = :method
+            Commandable[:test_method].should_not be_nil
+          }
+      
+        end
+      
+      end
+  
+    end
+  
+    context "when accessing method information" do
+    
+      it "uses a string in #[] to access methods by name" do
+        lambda{Commandable["test_method"]}.should_not raise_error
+      end
+    
+    end
+  
+    context "when accessing method descriptions" do
+
+      it "uses :descriptions" do
+        Commandable["test_method"][:description].should == "does some stuff"
+      end
+    
+    end
+
+    context "when reading class names" do
+     
+      it "uses :class" do
+        Commandable["test_method"][:class].should == "TestClass"
+      end
+         
+      it "reads the fully qualified name including parent modules and classes" do
+        load 'deep_class.rb' 
+        Commandable["deep_method"][:class].should == "TopModule::ParentClass::DeepClass"
+      end
+
+    end
+    
+  end 
+
+  context "when reading the method parameters" do
+    
+    before(:each) { load 'parameter_class.rb' }
+    
+    context "when it has required parameters" do
+      specify{ Commandable[:foo][:argument_list].should == "int_arg1 number_arg2" }
+    end
+    
+    context "when it has optional parameters" do
+      specify {Commandable[:bar][:argument_list].should == %q{int_arg1 [string_arg2="Number 42"]} }
+      specify {Commandable[:qux][:argument_list].should == %q{[string_arg1="1492"] [string_arg2="I'm a tricky one"]} }
+    end
+    
+    context "when it has greedy parameters" do
+      specify {Commandable[:baz][:argument_list].should == %q{number_arg1 [string_arg2="blorp"] *array_arg3} }
+    end
+    
+    context "when it has an instance method" do
+      specify {Commandable[:foo][:class_method].should be_false}
+    end
+    
+    it "saves the list of parameters" do
+      Commandable[:foo][:parameters].should == [[:req, :int_arg1], [:req, :number_arg2]]
+    end
+    
+  end
+
+  context "when there are methods using command and methods not using command" do
+
+    context "and they are instance methods" do
+    
+      before(:each) {load 'command_no_command.rb'}
+
+      specify {Commandable.commands.should include(:command_method1)}
+      specify {Commandable.commands.should include(:command_method2)}
+      specify {Commandable.commands.should_not include(:no_command_method1)}
+      specify {Commandable.commands.should_not include(:no_command_method2)}
+    
+    end
+
+    context "and they are class methods" do
+    
+      before(:each) {load 'class_command_no_command.rb'}
+
+      specify {Commandable.commands.should include(:class_command_method1)}
+      specify {Commandable.commands.should include(:class_command_method2)}
+      specify {Commandable.commands.should_not include(:class_no_command_method1)}
+      specify {Commandable.commands.should_not include(:class_no_command_method2)}
+    
+    end
+
+  end
+
+  context "when using class methods" do
+    
+    before(:each) { load 'class_methods.rb' }
+
+    specify { Commandable["class_method"].should_not be_nil }
+    specify { Commandable["class_method"][:argument_list].should == "string_arg1" }
+    specify { Commandable["class_method2"][:argument_list].should == "integer_arg1" }
+
+    context "grouped class methods" do
+      
+      before(:each) { 
+        load 'class_methods_nested.rb' 
+      }
+     
+      specify{ Commandable[:class_foo][:argument_list].should == "int_arg1 number_arg2" }
+      specify {Commandable[:class_bar][:argument_list].should == %q{int_arg1 [string_arg2="Number 42"]} }
+      specify {Commandable[:class_qux][:argument_list].should == %q{[string_arg1="1492"] [string_arg2="I'm a tricky one"]} }
+      specify {Commandable[:class_baz][:argument_list].should == %q{number_arg1 [string_arg2="blorp"] *array_arg3} }
+    
+    end
+    
+    it "knows it is a class method" do
+      Commandable["class_method"][:class_method].should be_true
+    end
+    
+  end
+
+  context "when there is a default command" do
+    
+    before (:each) { load 'default_method.rb' }
+    
+    it "sets a command as default" do
+      Commandable[:default_method][:default].should == true
+    end
+    
+    it "raises an error if more than one command is set as default" do
+      lambda{load 'default_method_bad.rb'}.should raise_error(Commandable::ConfigurationError)
+    end
+    
+    it "executes the default command if no command is given" do
+      execute_output_ary(["Klaatu"]).should == ["default method called with: Klaatu"]
+    end
+    
+    it "executes a default method and a second command" do
+      execute_output_ary(["Klaatu", "not_a_default_method", "28"]).sort.should == [
+        "default method called with: Klaatu", 
+        "not a default method, called with: Cleveland",
+        "28"].sort
+    end
+    
+  end
+
+  context "when there are no command line parameters" do
+    
+    it "prints help info when there isn't a default command" do
+      execute_output_s([]).should match(/Usage:/)
+    end
+    
+    context "when there is a default command" do
+      it "runs the default command if there are no require parameters " do
+        load "default_method.rb"
+        execute_output_s([]).should match(/Usage:/)
+      end
+      it "prints help/usage info if there are require parameters" do
+        load "default_method_no_params.rb"
+        execute_output_s([]).should match(/default method called, has no params/)
+      end
+    end
+  end
+
+  context "when there is a required command" do
+    
+    before(:each) {load "required_methods.rb"}
+    
+    it "raises an error when a required command isn't given" do
+      lambda{ Commandable.execution_queue(["non_required_method", "this is some input"]) }.should raise_error(Commandable::MissingRequiredCommandError)
+    end
+    
+  end
+
+  context "when there are deeply nested classes and modules" do
+    
+    it "executes the command" do
+      load "super_deep_class.rb"
+      lambda{Commandable.execution_queue(["super_deep_method"]).first[:proc].call}.should_not raise_error
+    end
+
+    it "returns the correct value" do
+      load "super_deep_class.rb"
+      Commandable.execution_queue(["super_deep_method"]).first[:proc].call.should == "you called a deep method"
+    end
+    
+  end
+
+end