ing 0.1.5 → 0.2.1

data/README.md

@@ -32,8 +32,8 @@ The ing command line is generally parsed as
 
     [ing command] [ing command options] [subcommand] [args] [subcommand options]
     
-But in cases where the first argument isn't an built-in ing command or options, it's 
-simplified to
+But in cases where the first argument isn't a built-in ing command or options, 
+it's simplified to
 
     [subcommand] [args] [subcommand options]
 

data/lib/ing.rb

@@ -1,25 +1,26 @@
 ['ing/version',
+ 'ing/util',
  'ing/lib_trollop',
  'ing/trollop/parser',
- 'ing/util',
- 'ing/dispatcher',
+ 'ing/option_parsers/trollop',
  'ing/shell',
  'ing/common_options',
- 'ing/boot',
  'ing/files',
  'ing/task',
  'ing/generator',
+ 'ing/command',
+ 'ing/commands/boot',
  'ing/commands/implicit',
+ 'ing/commands/generate',
  'ing/commands/list',
- 'ing/commands/help',
- 'ing/commands/generate'
+ 'ing/commands/help'
 ].each do |f| 
   require_relative f
 end
 
 module Ing
   extend self
-  
+    
   Error = Class.new(StandardError)
   FileNotFoundError = Class.new(Error)
   
@@ -29,53 +30,74 @@ module Ing
     @shell_class ||= Shell::Basic
   end
       
-  def implicit_booter
-    ["Implicit"]
+      
+  class << (Callstack = Object.new)
+    
+    def index(klass, meth)
+      stack.index {|e| e == [klass,meth]}
+    end
+    
+    def push(klass, meth)
+      stack << [klass, meth]
+    end
+    
+    def clear
+      stack.clear
+    end
+    
+    def to_a
+      stack.dup
+    end
+    
+    private
+    def stack
+      @stack ||= []
+    end
+    
+  end
+  
+  def run(args=ARGV)
+    booter = extract_boot_class!(args) || implicit_booter
+    execute booter, *args
   end
   
-  # Dispatch command line to boot class (if specified, or Implicit otherwise), 
-  # which in turn dispatches the command after parsing args. 
-  #
-  # Note boot dispatch happens within +Ing::Commands+ namespace.
-  #
-  def run(argv=ARGV)
-    booter = extract_boot_class!(argv) || implicit_booter
-    run_boot booter, "call", *argv
+  def execute(klass, meth=:call, *args, &config)
+    cmd = command.new(klass, meth, *args)
+    _callstack.push(cmd.command_class, cmd.command_meth)
+    cmd.execute(&config)
   end
   
-  # Dispatch to the command via +Ing::Boot#call_invoke+
-  # Use this when you want to invoke a command from another command, but only
-  # if it hasn't been run yet. For example,
-  #
-  #   invoke Some::Task, :some_instance_method, some_argument, :some_option => true
-  #
-  # You can skip the method and it will assume +#call+ :
-  #
-  #   invoke Some::Task, :some_option => true
-  def invoke(klass, *args)
-    run_boot implicit_booter, "call_invoke", klass, *args
+  def invoke(klass, meth=:call, *args, &config)
+    execute(klass, meth, *args, &config) unless executed?(klass, meth)
   end
   
-  # Dispatch to the command via +Ing::Boot#call_execute+
-  # Use this when you want to execute a command from another command, and you
-  # don't care if it has been run yet or not. See equivalent examples for 
-  # +invoke+.
-  #
-  def execute(klass, *args)
-    run_boot implicit_booter, "call_execute", klass, *args
+  def executed?(klass, meth)
+    !!_callstack.index(klass, meth)
+  end
+  
+  def callstack
+    _callstack.to_a
   end
   
   private
   
-  def run_boot(booter, *args)
-    Dispatcher.new(["Ing","Commands"], booter, *args).dispatch
+  def command
+    Command
+  end
+  
+  def _callstack
+    Callstack
+  end
+  
+  def implicit_booter
+    Commands::Implicit
   end
   
   def extract_boot_class!(args)
-    c = Util.to_class_names(args.first)
-    if (Commands.const_defined?(c.first, false) rescue nil)
-      args.shift; c
-    end
+    c = Util.decode_class(args.first, Ing::Commands)
+    args.shift; c
+  rescue NameError
+    nil
   end
-
-end
+  
+end

data/lib/ing/command.rb

@@ -0,0 +1,96 @@
+module Ing
+  
+  class Command
+  
+    class << self
+      attr_writer :parser
+      def parser
+        OptionParsers::Trollop
+      end
+      
+      def execute(klass, *args, &config)
+        new(klass, *args).execute(&config)
+      end
+    end
+    
+    attr_accessor :options, :command_class, :command_meth, :args
+    
+    def initialize(klass, *args)
+      self.options        = (Hash === args.last ? args.pop : {})
+      self.command_class = klass
+      self.command_meth  = extract_method!(args, command_class)
+      self.args           = args
+    end
+    
+    def classy?
+      command_class.respond_to?(:new)
+    end
+    
+    def instance
+      @instance ||= build_command
+    end
+    
+    def execute
+      yield instance if block_given?
+      classy? ? instance.send(command_meth, *args) : 
+                instance.send(command_meth, *args, options)
+    end
+
+    def describe
+      with_option_parser {|p| p.describe}
+    end
+    
+    def help
+      with_option_parser {|p| p.help}
+    end
+    
+    def with_option_parser
+      return unless command_class.respond_to?(:specify_options)
+      p = self.class.parser.new
+      command_class.specify_options(p.parser)
+      yield p
+    end
+    
+    private
+    
+    def build_command
+      parse_options!
+      classy? ? command_class.new(options) : command_class
+    end
+ 
+    # Note options merged into parsed options (reverse merge)
+    # so that passed options (in direct invoke or execute) override defaults
+    def parse_options!
+      self.options = (parsed_options_from_args || {}).merge(self.options)
+    end
+    
+    # memoized to avoid duplicate args processing
+    def parsed_options_from_args
+      @parsed_options ||= with_option_parser do |p|
+                            p.parse! self.args
+                          end
+    end
+        
+    def extract_method!(args, klass)
+      return :call if args.empty?
+      if meth = whitelist(args.first, klass)
+        args.shift
+      else
+        meth = :call
+      end
+      meth
+    end
+        
+    # Note this currently does no filtering, but basically checks for respond_to
+    def whitelist(meth, klass)
+      finder = Proc.new {|m| m == meth.to_sym}
+      if klass.respond_to?(:new)
+        klass.public_instance_methods(true).find(&finder)
+      else
+        klass.public_methods.find(&finder)
+      end
+    end
+    
+  end
+  
+end

data/lib/ing/{boot.rb → commands/boot.rb}

@@ -8,6 +8,14 @@
   #
   module Boot
 
+    # Before hook passed unprocessed args, override in target class
+    def before(*args)
+    end
+    
+    # After hook, override in target class
+    def after
+    end
+    
     # Configure the command prior to dispatch.
     # Default behavior is to set the shell of the dispatched command.
     # Override in target class as needed; if you want to keep the default 
@@ -15,7 +23,7 @@
     def configure_command(cmd)
       cmd.shell = Ing.shell_class.new if cmd.respond_to?(:"shell=")
     end
-    
+
     # Main processing of arguments and dispatch from command line (+Ing.run+)
     # Note that three hooks are provided for target classes, 
     #   +before+::  runs before any processing of arguments or dispatch of command
@@ -23,32 +31,24 @@
     #   +after+::   runs after command dispatched
     #
     def call(*args)
-      before *args if respond_to?(:before)
-      ns         = Ing::Util.to_class_names(options[:namespace] || 'object')
-      classes    = Ing::Util.to_class_names(args.shift)
-      Dispatcher.new(ns, classes, *args).dispatch do |cmd|
+      before *args
+      klass         = _extract_class!(args)
+      Ing.execute(klass, *args) do |cmd|
         configure_command cmd
       end
-      after if respond_to?(:after)
+      after
     end    
+
+    private
     
-    # Dispatch from +Ing.invoke+
-    def call_invoke(klass, meth, *args)
-      before *args if respond_to?(:before)
-      Dispatcher.invoke(klass, meth, *args) do |cmd|
-        configure_command cmd
-      end
-      after if respond_to?(:after)
+    def _extract_class!(args)
+      Util.decode_class(args.shift, _namespace_class)
     end
     
-    # Dispatch from +Ing.execute+
-    def call_execute(klass, meth, *args)
-      before *args if respond_to?(:before)
-      Dispatcher.execute(klass, meth, *args) do |cmd|
-        configure_command cmd
-      end
-      after if respond_to?(:after)
+    def _namespace_class
+      return ::Object unless ns = options[:namespace]
+      Util.decode_class(ns)
     end
-        
+    
   end
 end

data/lib/ing/commands/generate.rb

@@ -26,6 +26,11 @@ module Ing
         @generator_root ||= File.expand_path(options[:gen_root])
       end
       
+      attr_accessor :options
+      def initialize(options)
+        self.options = options
+      end
+      
       # Require libs and ing_file, then
       # locate and require the generator ruby file identified by the first arg,
       # before dispatching to it.

data/lib/ing/commands/help.rb

@@ -36,14 +36,19 @@
         require_ing_file
       end
     
-      def call(cmd="help")
+      def call(cmd="help")      
         before
-        ns        = Ing::Util.to_class_names(options[:namespace] || 'object')
-        cs        = Ing::Util.to_class_names(cmd)
-        help = Dispatcher.new(ns, cs).help
-        shell.say help.read
+        klass         = Util.decode_class(cmd, _namespace_class)
+        help = Command.new(klass).help
+        shell.say help
       end
       
+      private
+      def _namespace_class
+        return ::Object unless ns = options[:namespace]
+        Util.decode_class(ns)
+      end      
+      
     end
     
     H = Help

data/lib/ing/commands/list.rb

@@ -36,28 +36,32 @@
         require_ing_file
       end
       
-      def call(namespace=options[:namespace])
+      def call(ns=nil)
         before
-        ns        = Ing::Util.to_class_names(namespace)
-        mod       = Ing::Util.namespaced_const_get(ns)
+        mod       = _namespace_class(ns)
         data = mod.constants.map do |c|
-          desc = Dispatcher.new(ns, [c]).describe
-          [ "ing #{Ing::Util.encode_class_names(ns + [c])}", 
-            (desc.gets || '(no description)').chomp
+          klass = mod.const_get(c)
+          desc = (Command.new(klass).describe || '')[/.+$/]
+          [ "ing #{Ing::Util.encode_class(mod)}:#{Ing::Util.encode_class_names([c])}", 
+            (desc || '(no description)').chomp
           ]
         end.sort
-        shell.say desc_lines(ns, data).join("\n")
+        shell.say desc_lines(mod, data).join("\n")
       end
       
       private 
+      def _namespace_class(ns=options[:namespace])
+        return ::Ing::Commands unless ns
+        Util.decode_class(ns)
+      end      
                   
-      def desc_lines(ns, data)
+      def desc_lines(mod, data)
         colwidths = data.inject([0,0]) {|max, (line, desc)| 
           max[0] = line.length if line.length > max[0]
           max[1] = desc.length if desc.length > max[1]
           max
         }
-        ["#{ns.join(' ')}: all tasks",
+        ["#{mod}: all tasks",
          "-" * 80
         ] +
         data.map {|line, desc|

data/lib/ing/files.rb

@@ -40,26 +40,11 @@ module Ing
   #   attr_reader :source_root, :destination_root
   #   attr_reader :shell, :options
   #
-  # Adds to target class options:
-  #   verbose, force, pretend, revoke, quiet, skip.
+  # and should provide these options (otherwise all defaulted nil):
+  # verbose, force, pretend, revoke, quiet, skip.
   #
   module Files
 
-    # a bit of trickiness to change a singleton method...
-    def self.included(base)
-      meth = base.method(:specify_options) if base.respond_to?(:specify_options)
-      base.send(:define_singleton_method, :specify_options) do |expect|
-        meth.call(expect) if meth
-        expect.text "\nCommon Options:"
-        expect.opt :verbose, "Run verbosely by default", :short => nil
-        expect.opt :force, "Overwrite files that already exist", :short => nil
-        expect.opt :pretend, "Run but do not make any changes", :short => nil
-        expect.opt :revoke, "Revoke action (not available for all generators)", :short => nil
-        expect.opt :quiet, "Suppress status output", :short => nil
-        expect.opt :skip, "Skip files that already exist", :short => nil
-      end
-    end
-
     def pretend?
       !!options[:pretend]
     end

data/lib/ing/generator.rb

@@ -3,6 +3,12 @@
         
     opt :dest, "Destination root", :type => :string
     opt :source, "Source root", :type => :string
+    opt :verbose, "Run verbosely by default"
+    opt :force, "Overwrite files that already exist"
+    opt :pretend, "Run but do not make any changes"
+    opt :revoke, "Revoke action (not available for all generators)"
+    opt :quiet, "Suppress status output"
+    opt :skip, "Skip files that already exist"
         
     include Ing::Files
         

data/lib/ing/option_parsers/trollop.rb

@@ -0,0 +1,35 @@
+require 'stringio'
+module Ing
+
+  # Classes in this namespace provide a uniform interface to different
+  # option parsers.
+  #
+  module OptionParsers
+  
+    class Trollop
+      
+      def parser
+        @parser ||= ::Trollop::Parser.new
+      end
+      
+      def parse!(args)
+        ::Trollop.with_standard_exception_handling(parser) { parser.parse(args) }
+      end
+      
+      def describe
+        s=StringIO.new
+        parser.educate_banner s
+        s.rewind; s.read      
+      end
+      
+      def help
+        s=StringIO.new
+        parser.educate s
+        s.rewind; s.read      
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/ing/task.rb

@@ -11,8 +11,18 @@ module Ing
 
     class << self
     
+      attr_accessor :inherited_options
+      
       def inherited(subclass)
-        subclass.set_options self.options.dup
+        subclass.inherited_options = self.options.dup
+      end
+      
+      def inherited_option?(name)
+        inherited_options.has_key?(name)
+      end
+      
+      def option?(name)
+        options.has_key?(name)
       end
       
       # Modify the option named +name+ according to +specs+ (Hash).
@@ -23,8 +33,13 @@ module Ing
       #   modify_option :file, :required => true
       #
       def modify_option(name, specs)
-        opt(name) unless options[name]
-        options[name].opts.merge!(specs)
+        if inherited_option?(name)
+          inherited_options[name].opts.merge!(specs)
+        elsif option?(name)
+          options[name].opts.merge!(specs)
+        else
+          opt(name, '', specs)
+        end
       end
       
       # Modify the default for option +name+ to +val+.
@@ -69,6 +84,12 @@ module Ing
             parser.opt *opt.to_args
           end
         end
+        unless inherited_options.empty?
+          parser.text "\nCommon Options:"
+          inherited_options.each do |name, opt|
+            parser.opt *opt.to_args
+          end
+        end
       end
       
       # Description lines
@@ -82,7 +103,7 @@ module Ing
       end
       
       # Options hash. Note that in a subclass, options are copied down from 
-      # superclass.
+      # superclass into inherited_options.
       def options
         @options ||= {}
       end
@@ -105,6 +126,31 @@ module Ing
       given
     end
 
+    # Build a hash of options that weren't given from command line via +ask+
+    # (i.e., $stdin.gets).
+    #
+    # Note it currently does not cast options to appropriate types.
+    # Also note because the shell is not available until after initialization,
+    # this must be called from command method(s), e.g. +#call+
+    #
+    def ask_unless_given(*opts)
+      opts.inject({}) do |memo, opt|
+        next memo if options[:"#{opt}_given"]
+        msg = self.class.options[opt].desc + "?"
+        df  = self.class.options[opt].default
+        memo[opt] = shell.ask(msg, :default => df)
+        memo
+      end
+    end
+    
+    # Shortcut for:
+    #
+    #   options.merge! ask_unless_given :opt1, :opt2
+    #
+    def ask_unless_given!(*opts)
+      self.options.merge! ask_unless_given(*opts)
+    end
+    
     # Use in initialization for option validation (post-parsing).
     #
     # Example:

data/lib/ing/util.rb

@@ -2,10 +2,17 @@
   module Util
     extend self
     
-    def to_class_names(str)
+    def decode_class(str, base=::Object)
+      namespaced_const_get( decode_class_names(str), base )
+    end
+    
+    def decode_class_names(str)
       str.split(':').map {|c| c.gsub(/(?:\A|_+)(\w)/) {$1.upcase} }
+    end    
+    
+    def encode_class(klass)
+      encode_class_names(klass.to_s.split('::'))
     end
-    alias decode_class_names to_class_names
     
     def encode_class_names(list)
       list.map {|c| c.to_s.gsub(/([A-Z])/) {
@@ -13,15 +20,7 @@
         } 
       }.join(':')
     end
-    
-    def encode_class(klass)
-      encode_class_names(klass.to_s.split('::'))
-    end
-    
-    def to_classes(str, base=::Object)
-      namespaced_const_get( to_class_names(str), base )
-    end
-    
+        
     def namespaced_const_get(list, base=::Object)
       list.inject(base) {|m, klass| m.const_get(klass, false)}
     end

data/lib/ing/version.rb

@@ -1,3 +1,3 @@
 module Ing
-  VERSION = '0.1.5'
+  VERSION = '0.2.1'
 end

data/test/acceptance/ing_run_tests.rb

@@ -8,9 +8,15 @@ describe Ing do
   end
 
   def reset
-    Ing::Dispatcher.dispatched.clear
+    Ing::Callstack.clear
   end
   
+  def count_executions_of(klass, meth)
+    Ing.callstack.count {|(k, m)| 
+      k == klass && m == meth
+    }    
+  end
+    
   describe "#run" do
 
     describe "no method or args given" do
@@ -150,6 +156,13 @@ describe Ing do
     it 'should run with expected output' do
       assert_equal "1\n2\n3\n", capture_run(subject)
     end
+    
+    it 'should only list one execution in the call stack for invoked commands' do
+      capture_run(subject)
+      assert_equal 1, count_executions_of(Invoking::Counter, :one)
+      assert_equal 1, count_executions_of(Invoking::Counter, :two)
+      assert_equal 1, count_executions_of(Invoking::Counter, :three)
+    end
   end
   
   describe "executing within tasks" do
@@ -159,6 +172,14 @@ describe Ing do
     it 'should run with expected output' do
       assert_equal "1\n2\n3\n3\n", capture_run(subject)
     end    
+    
+    it 'should only list each execution in the call stack for executed commands' do
+      capture_run(subject)
+      assert_equal 1, count_executions_of(Executing::Counter, :one)
+      assert_equal 1, count_executions_of(Executing::Counter, :two)
+      assert_equal 2, count_executions_of(Executing::Counter, :three)
+    end
+    
   end
   
 end

data/test/suite.rb

@@ -1,4 +1,4 @@
-Dir[ File.expand_path('{actions,acceptance}/*.rb',
+Dir[ File.expand_path('{unit,actions,acceptance}/*.rb',
                       File.dirname(__FILE__))
    ].each do |f| 
     puts "Loading tests: #{f.gsub(Dir.pwd,'.')}"

data/test/unit/command_test.rb

@@ -0,0 +1,334 @@
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+describe Ing::Command do
+
+  def dummy_command_class
+    Class.new do
+      attr_reader :options
+      def initialize(options); @options = options; end
+      def dummy; end
+    end
+  end
+
+  def dummy_command_class_with_specify_options
+    Class.new do
+      def self.specify_options(expect); end
+      attr_reader :options
+      def initialize(options); @options = options; end
+      def dummy; end
+    end
+  end
+  
+  def dummy_command_proc
+    x = Proc.new { }
+    def x.dummy; end
+    x
+  end
+    
+  #-----------------------------------------------------------------------------
+  describe ".new" do
+  
+    describe "when only command class passed" do
+      subject { Ing::Command.new dummy_command_class }
+      
+      it "should have command_meth == :call" do
+        assert_equal :call, subject.command_meth
+      end
+      
+      it "should have options == {}" do
+        assert_equal Hash.new, subject.options
+      end
+      
+      it "should have args == []" do
+        assert_equal [], subject.args
+      end  
+    end
+    
+    describe "when command class and options hash passed" do
+      subject       { Ing::Command.new dummy_command_class, options }
+      let(:options) { {:one => 1, :two => 2} }
+      
+      it "should have command_meth == :call" do
+        assert_equal :call, subject.command_meth
+      end
+      
+      it "should have options == passed options" do
+        assert_equal options, subject.options
+      end
+      
+      it "should have args == []" do
+        assert_equal [], subject.args
+      end   
+    end
+    
+    describe "when command class and method passed" do
+      subject    { Ing::Command.new dummy_command_class, meth, *args }
+      let(:meth) { "dummy" }
+      let(:args) { ["one", "two"] }
+      
+      it "should have command_meth == passed method" do
+        assert_equal meth.to_sym, subject.command_meth
+      end
+      
+      it "should have options == {}" do
+        assert_equal Hash.new, subject.options
+      end
+      
+      it "should have args == remaining args" do
+        assert_equal args, subject.args
+      end   
+    end
+    
+    describe "when command proc and method passed" do
+      subject    { Ing::Command.new dummy_command_proc, meth, *args }
+      let(:meth) { "dummy" }
+      let(:args) { ["one", "two"] }
+      
+      it "should have command_meth == passed method" do
+        assert_equal meth.to_sym, subject.command_meth
+      end
+      
+      it "should have options == {}" do
+        assert_equal Hash.new, subject.options
+      end
+      
+      it "should have args == remaining args" do
+        assert_equal args, subject.args
+      end       
+    end
+    
+    describe "when command class and non-public-instance-method arg passed" do
+      subject    { Ing::Command.new dummy_command_class, arg, *args }
+      let(:arg)  { "remove_instance_variable" }
+      let(:args) { ["one", "two"] }
+      
+      it "should have command_meth == :call" do
+        assert_equal :call, subject.command_meth
+      end
+      
+      it "should have options == {}" do
+        assert_equal Hash.new, subject.options
+      end
+      
+      it "should have args == all passed args" do
+        assert_equal [arg] + args, subject.args
+      end      
+    end
+    
+    describe "when command proc and non-public-method arg passed" do
+      subject    { Ing::Command.new dummy_command_proc, arg, *args }
+      let(:arg)  { "extended" }
+      let(:args) { ["one", "two"] }
+      
+      it "should have command_meth == :call" do
+        assert_equal :call, subject.command_meth
+      end
+      
+      it "should have options == {}" do
+        assert_equal Hash.new, subject.options
+      end
+      
+      it "should have args == all passed args" do
+        assert_equal [arg] + args, subject.args
+      end          
+    end
+    
+    describe "when command class and option arg passed" do
+      subject    { Ing::Command.new dummy_command_class, arg, *args }
+      let(:arg)  { "--nonsense" }
+      let(:args) { ["one", "two"] }
+      
+      it "should have command_meth == :call" do
+        assert_equal :call, subject.command_meth
+      end
+      
+      it "should have options == {}" do
+        assert_equal Hash.new, subject.options
+      end
+      
+      it "should have args == all passed args" do
+        assert_equal [arg] + args, subject.args
+      end      
+    end
+    
+    describe "when command proc and option arg passed" do
+      subject    { Ing::Command.new dummy_command_proc, arg, *args }
+      let(:arg)  { "--help" }
+      let(:args) { ["one", "two"] }
+      
+      it "should have command_meth == :call" do
+        assert_equal :call, subject.command_meth
+      end
+      
+      it "should have options == {}" do
+        assert_equal Hash.new, subject.options
+      end
+      
+      it "should have args == all passed args" do
+        assert_equal [arg] + args, subject.args
+      end          
+    end
+    
+  end
+  
+  #-----------------------------------------------------------------------------
+  describe "#instance" do
+    subject             { Ing::Command.new command_class }
+    let(:command_class) { dummy_command_class }
+    
+    it "should return an instance of the passed class" do
+      assert_kind_of command_class, subject.instance
+    end
+    
+    describe "and passed class defines specify_options" do
+      
+      def mock_parser_given(args, ret={})
+        parser = MiniTest::Mock.new
+        parser.expect(:parser,nil)
+        parser.expect(:"parse!",ret,[args]) 
+        parserclass = MiniTest::Mock.new
+        parserclass.expect(:new, parser)
+        parserclass
+      end
+      
+      def expecting_parser_given(args, ret={})
+        Ing::Command.stub(:parser, mock_parser_given(args, ret)) do |stub|
+          #puts stub.parser.inspect
+          yield
+        end
+      end
+ 
+# These don't work because `parse_options!` is indivisible from `instance` 
+# and you need an unstubbed :command_class for `parse_options!`
+#
+#      def mock_command_constructor_given(opts)
+#        cmd = MiniTest::Mock.new
+#        cmd.expect(:new,nil,[opts])
+#        cmd
+#      end
+#      
+#      def expecting_command_constructor_given(ing_cmd, opts)
+#        ing_cmd.stub(:command_class, 
+#                     mock_command_constructor_given(opts)) do |stub|
+#          #puts stub.command_class.inspect
+#          yield
+#        end
+#      end
+      
+      subject { Ing::Command.new command_class, *args }
+      let(:command_class) { dummy_command_class_with_specify_options }
+      let(:args)          { ["one", "two", "three"] }
+      
+      it "should interact with parser as expected" do
+        expecting_parser_given(args) do
+          subject.instance
+        end
+      end
+      
+      describe "and an option hash is passed as the last arg" do
+        subject              { Ing::Command.new command_class, *args, options }
+        let(:command_class)  { dummy_command_class_with_specify_options }
+        let(:args)           { ["--two", "2", "--four", "4", "--three", "1"] }
+        let(:options)        { {:one => 1, :two => 2, :three => 3} }
+        let(:parsed_options) { {:two => 2, :four => 4, :three => 1} }
+        
+        it "should merge passed options into the options parsed from other args" do
+          expecting_parser_given(args, parsed_options) do
+            merged_options = parsed_options.merge(options)
+            it = subject.instance
+            # note dummy.options returns what it was passed in constructor
+            assert_equal merged_options, it.options   
+          end
+        end
+   
+      end
+      
+    end
+    
+  end
+  
+  #-----------------------------------------------------------------------------
+  describe "#execute" do
+  
+    def mock_instance_sent(meth, args=[])
+      inst = MiniTest::Mock.new
+      inst.expect(:send, nil, [meth] + args)
+      inst
+    end
+    
+    def expecting_instance_sent(ing_cmd, meth, args=[])
+      ing_cmd.stub(:instance, mock_instance_sent(meth, args)) do |stub|
+        #puts stub.instance.inspect
+        yield
+      end
+    end
+    
+    describe "when only command class passed" do
+      subject { Ing::Command.new dummy_command_class }
+      
+      it "instance should receive :call and no args" do
+        subject.instance
+        expecting_instance_sent(subject, :call) do
+          subject.execute
+        end
+      end
+      
+    end
+
+    describe "when command class and options hash passed" do
+      subject       { Ing::Command.new dummy_command_class, options }
+      let(:options) { {:one => 1, :two => 2} }
+    
+      it "instance should receive :call and no args" do
+        subject.instance
+        expecting_instance_sent(subject, :call) do
+          subject.execute
+        end
+      end
+      
+    end
+    
+    describe "when command class and method passed with args" do
+      subject    { Ing::Command.new dummy_command_class, meth, *args }
+      let(:meth) { "dummy" }
+      let(:args) { ["one", "two"] }
+
+      it "instance should receive passed method and args" do
+        subject.instance
+        expecting_instance_sent(subject, meth.to_sym, args) do
+          subject.execute
+        end
+      end
+            
+    end
+    
+    describe "when command proc and method passed" do
+      subject    { Ing::Command.new dummy_command_proc, meth, *args }
+      let(:meth) { "dummy" }
+      let(:args) { ["one", "two"] }
+      
+      it "instance should receive passed method, args, and empty options hash" do
+        subject.instance
+        expecting_instance_sent(subject, meth.to_sym, args + [{}]) do
+          subject.execute
+        end
+      end
+      
+    end
+
+    describe "when command proc and options hash passed" do
+      subject       { Ing::Command.new dummy_command_proc, options }
+      let(:options) { {:one => 1, :two => 2} }
+      
+      it "instance should receive :call and passed options hash" do
+        subject.instance
+        expecting_instance_sent(subject, :call, [options]) do
+          subject.execute
+        end
+      end
+      
+    end
+    
+  end
+
+end

data/test/unit/ing_test.rb

@@ -0,0 +1,67 @@
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+# These don't test much, basically just the `extract_boot_class!` logic.
+# More comprehensive tests under acceptance/ing_run_tests.
+#
+describe Ing do
+
+  #-----------------------------------------------------------------------------
+  describe ".run" do
+      
+    def mock_command_execute(klass, args)
+      cmd = MiniTest::Mock.new
+      cmd.expect(:execute, nil)
+      cmd.expect(:command_class, nil)
+      cmd.expect(:command_meth, nil)
+      cmdclass = MiniTest::Mock.new
+      cmdclass.expect(:new, cmd, [klass] + args)
+      cmdclass
+    end
+    
+    def stubbing_command_execute(klass, args)
+      ::Ing.stub(:command, mock_command_execute(klass, args)) do |stub|
+        #puts stub.command.inspect
+        yield
+      end
+    end
+    
+    def mock_callstack_push(klass, meth)
+      callst = MiniTest::Mock.new
+      callst.expect(:push, nil, [klass, meth])
+      callst
+    end
+    
+    def stubbing_callstack_push(klass, meth)
+      ::Ing.stub(:_callstack, mock_callstack_push(klass, meth)) do |stub|
+        yield
+      end
+    end
+    
+    
+    describe "when first arg is built-in command" do
+      subject { ["generate"] + args }
+      let(:args) { ["something"] }
+
+      it "should execute with the specified command class and remaining args" do
+        stubbing_command_execute(::Ing::Commands::Generate, args) do
+          Ing.run subject
+        end
+      end
+      
+    end
+    
+    describe "when first arg is not a built-in command" do
+      subject    { ["foo:die"] + args }
+      let(:args) { ["do_it"] }
+      
+      it "should execute with the implicit command class and whole command line" do
+        stubbing_command_execute(::Ing::Commands::Implicit, subject) do
+          Ing.run subject
+        end
+      end
+    end
+    
+  end
+  
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ing
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-17 00:00:00.000000000Z
+date: 2012-09-20 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &14733000 !ruby/object:Gem::Requirement
+  requirement: &7756700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *14733000
+  version_requirements: *7756700
 - !ruby/object:Gem::Dependency
   name: fakeweb
-  requirement: &14677360 !ruby/object:Gem::Requirement
+  requirement: &7756220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *14677360
+  version_requirements: *7756220
 description: ! "\nAn alternative to Rake and Thor, Ing has a command-line syntax similar
   to \nThor's, and it incorporates Thor's (Rails') generator methods and shell \nconventions.
   But unlike Thor or Rake, it does not define its own DSL. Your tasks\ncorrespond
@@ -62,16 +62,17 @@ files:
 - lib/ing/actions/empty_directory.rb
 - lib/ing/actions/file_manipulation.rb
 - lib/ing/actions/inject_into_file.rb
-- lib/ing/boot.rb
+- lib/ing/command.rb
+- lib/ing/commands/boot.rb
 - lib/ing/commands/generate.rb
 - lib/ing/commands/help.rb
 - lib/ing/commands/implicit.rb
 - lib/ing/commands/list.rb
 - lib/ing/common_options.rb
-- lib/ing/dispatcher.rb
 - lib/ing/files.rb
 - lib/ing/generator.rb
 - lib/ing/lib_trollop.rb
+- lib/ing/option_parsers/trollop.rb
 - lib/ing/shell.rb
 - lib/ing/task.rb
 - lib/ing/trollop/parser.rb
@@ -107,6 +108,8 @@ files:
 - test/spec_helper.rb
 - test/suite.rb
 - test/test_helper.rb
+- test/unit/command_test.rb
+- test/unit/ing_test.rb
 - todo.yml
 homepage: https://github.com/ericgj/ing
 licenses: []
@@ -162,4 +165,6 @@ test_files:
 - test/spec_helper.rb
 - test/suite.rb
 - test/test_helper.rb
+- test/unit/command_test.rb
+- test/unit/ing_test.rb
 has_rdoc: 

data/lib/ing/dispatcher.rb

@@ -1,143 +0,0 @@
-require 'stringio'
-require 'set'
-      
-module Ing
-
-  # Generic router for ing commands (both built-in and user-defined).
-  # Resolves class, parses options with Trollop if target class 
-  # defines +specify_options+, then dispatches like (simplifying):
-  #
-  #   Target.new(options).send(*args)
-  #
-  # if the target is class-like, i.e. responds to +new+. Otherwise it dispatches
-  # to the target as a callable:
-  #   
-  #   Target.call(*args, options)
-  #
-  class Dispatcher
-    
-    # Global set of dispatched commands as [dispatch_class, dispatch_meth], 
-    # updated before dispatch
-    def self.dispatched
-      @dispatched ||= Set.new
-    end
-    
-    # +Ing.invoke+
-    def self.invoke(klass, *args, &config)
-      allocate.tap {|d| d.initialize_preloaded(true, klass, *args) }.
-        dispatch(&config)
-    end
-    
-    # +Ing.execute+
-    def self.execute(klass, *args, &config)
-      allocate.tap {|d| d.initialize_preloaded(false, klass, *args) }.
-        dispatch(&config)
-    end
-        
-    attr_accessor :dispatch_class, :dispatch_meth, :args, :options
-    
-    # True if current dispatch class/method has been dispatched before
-    def dispatched?
-      Dispatcher.dispatched.include?([dispatch_class,dispatch_meth])
-    end
-    
-    # Default constructor from +Ing.run+ (command line)
-    def initialize(namespaces, classes, *args)
-      ns                  = Util.namespaced_const_get(namespaces)
-      self.dispatch_class = Util.namespaced_const_get(classes, ns)
-      self.dispatch_meth  = extract_method!(args, dispatch_class)
-      self.args           = args
-      @invoking           = false
-    end
-    
-    # Alternate constructor for preloaded object and arguments
-    # i.e. from +invoke+ or +execute+ instead of +run+
-    def initialize_preloaded(invoking, klass, *args)
-      self.options        = (Hash === args.last ? args.pop : {})
-      self.dispatch_class = klass
-      self.dispatch_meth  = extract_method!(args, dispatch_class)
-      self.args           = args
-      @invoking           = invoking
-    end
-    
-    # Returns stream (StringIO) of description text from specify_options.
-    # Note this does not parse the options. Used by +Ing::Commands::List+.
-    def describe
-      s=StringIO.new
-      with_option_parser(self.dispatch_class) do |p|
-        p.educate_banner s
-      end
-      s.rewind; s
-    end
-    
-    # Returns stream (StringIO) of help text from specify_options.
-    # Note this does not parse the options. Used by +Ing::Commands::Help+.
-    def help
-      s=StringIO.new
-      with_option_parser(self.dispatch_class) do |p|
-        p.educate s
-      end
-      s.rewind; s   
-    end
-    
-    # Public dispatch method used by all types of dispatch (run, invoke,
-    # execute). Does not dispatch if invoking and already dispatched.
-    def dispatch(&config)
-      unless @invoking && dispatched?
-        record_dispatch
-        execute(&config)
-      end
-    end
-    
-    def with_option_parser(klass)   # :nodoc:
-      return unless klass.respond_to?(:specify_options)
-      klass.specify_options(p = Trollop::Parser.new)
-      yield p
-    end
-    
-    private
-    
-    def record_dispatch
-      Dispatcher.dispatched.add [dispatch_class, dispatch_meth]
-    end
-    
-    def execute
-      self.options = parse_options!(args, dispatch_class) || {}
-      if dispatch_class.respond_to?(:new)
-        cmd = dispatch_class.new(options)
-        yield cmd if block_given?
-        cmd.send(dispatch_meth, *args)
-      else
-        dispatch_class.call *args, options
-      end
-    end
-        
-    def parse_options!(args, klass)
-      with_option_parser(klass) do |p|
-        Trollop.with_standard_exception_handling(p) { p.parse(args) }
-      end
-    end
-    
-    def extract_method!(args, klass)
-      return :call if args.empty?
-      if meth = whitelist(args.first, klass)
-        args.shift
-      else
-        meth = :call
-      end
-      meth
-    end
-        
-    # Note this currently does no filtering, but basically checks for respond_to
-    def whitelist(meth, klass)
-      finder = Proc.new {|m| m == meth.to_sym}
-      if klass.respond_to?(:new)
-        klass.public_instance_methods(true).find(&finder)
-      else
-        klass.public_methods.find(&finder)
-      end
-    end
-    
-  end
-  
-end