terminitor 0.2.2 → 0.3.0

data/.gitignore

@@ -1,3 +1,4 @@
 pkg/*
 *.gem
 .bundle
+*.swp

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    terminitor (0.2.1)
+    terminitor (0.2.2)
       github (~> 0.4.5)
       rb-appscript
       thor (~> 0.14.0)
@@ -17,15 +17,15 @@ GEM
     highline (1.5.2)
     json (1.4.6)
     rb-appscript (0.5.3)
-    riot (0.11.4)
+    riot (0.12.0)
       rr
       term-ansicolor
-    rr (1.0.0)
+    rr (1.0.2)
     term-ansicolor (1.0.5)
     text-format (1.0.0)
       text-hyphen (~> 1.0.0)
     text-hyphen (1.0.0)
-    thor (0.14.4)
+    thor (0.14.6)
 
 PLATFORMS
   ruby
@@ -35,7 +35,7 @@ DEPENDENCIES
   fakefs
   github (~> 0.4.5)
   rb-appscript
-  riot (~> 0.11.0)
-  rr (= 1.0.0)
+  riot (~> 0.12.0)
+  rr (~> 1.0.0)
   terminitor!
   thor (~> 0.14.0)

data/README.md

@@ -1,7 +1,7 @@
 Terminitor
 ===========
 
-Terminitor automates your development workflow by allowing you to script the commands to run in your terminal to begin working on a given project.
+Terminitor automates your development workflow setup. Less time setting up,  more time getting things done.
 
 Installation
 ------------
@@ -47,16 +47,24 @@ To use the legacy syntax, you can invoke it with terminitor like so:
 
     $ terminitor edit foo --syntax yml
 
+It is recommended that you move over to the newer Ruby DSL Syntax as it
+provides more robust features, however terminitor will still support the older
+YAML syntax.
+
 
 #### Ruby DSL Syntax ####
 
-    setup 'echo "setup"'
+    setup 'echo "setup"'   # code to run during setup
 
+    # open a tab in current window with these commands
     tab "echo 'default'", "echo 'default tab'"
 
     window do
-      tab "echo 'first tab'", "echo 'of window'"
-  
+      before { run 'cd /path' } # run this command before each command.
+      
+      run 'padrino start' # run in new window
+
+      tab "echo 'first tab'", "echo 'of window'" # create a new tab in window and run it.
       tab "named tab" do
         run "echo 'named tab'"
         run "ls"
@@ -83,13 +91,40 @@ or even pass it a block:
 to create windows, we can simply invoke the window command with a block containing additional commands like:
 
     window do
-      tab "echo 'hi'"
-      tab "mate ."
-      tab do
+
+      run "whoami"    # Runs the command in the current window.
+
+      tab "echo 'hi'" # Creates another tab
+      tab "mate ."    # And another
+      tab do          # Last hoorah
         run "open http://www.google.com"
       end
     end
 
+
+##### Before #####
+
+Sometimes you'll want to create a few commands that you want to run in each tab instance. You can do that with 'before':
+
+    before { run "cd /path" } # execute this command before other commands in the default window
+    run "whoami"
+    tab 'uptime'
+
+    # In this instance, "cd /path" wil be executed in the default window before 'whoami' 
+    # and also in the tab before 'uptime'.
+    # You can also use this inside a specific window context:
+
+    window do
+      before 'cd /tmp'
+      run 'watchr test.watchr' # "cd /tmp" first than run watchr
+
+      tab do
+        run 'padrino start' # "cd /tmp" is ran beforehand and then padrino start is executed
+      end
+    end
+
+
+
 ##### Setup #####
 
 The setup block allows you to store commands that can be ran specifically before a project and can be defined with:
@@ -103,20 +138,29 @@ or with a block:
     setup do
       run "echo 'hi'"
       run "bundle install"
+      run 'git remote add upstream git://github.com/achiu/terminitor.git'
     end
 
 
+Once defined, you can invoke your projects setup with:
+
+    terminitor setup my_project
+
 ##### Settings #####
+_currently only available for Mac OSX Terminal_
 
 You can also set settings on each of your tabs and windows. for example, this is possible:
 
 Open a tab with terminal settings "Grass"
 
-    tab "named tab", :settings => "Grass" do
+    tab :name => "named tab", :settings => "Grass" do
       run "echo 'named tab'"
       run "ls"
     end
 
+This will create a tab with a title of 'named tab' using Terminals 'Grass' setting.
+
+
 How about a window with a specific size:
 
     window :bounds => [10,20,300,200] do
@@ -187,7 +231,7 @@ Now, when you or another developer clones a project, you could simply:
 
     $ git clone git://path/to/my/foo/project.git
     $ cd project
-    $ bundle install
+    $ terminitor setup
     $ terminitor start
 
 This would clone the project repo, and then install all dependencies and then launch the ideal development environment for the project. Clearly
@@ -201,7 +245,7 @@ In addition, you are in the project folder and you wish to remove the Termfile,
 This will clear the `Termfile` for the particular project.
 
 ### Capturing Terminal Settings with Terminitor ###
-
+_Currently Mac OSX Terminal only_
 Terminitor has the ability to also capture your terminal setup and settings simply with:
 
     $ terminitor edit my_project --capture
@@ -211,10 +255,10 @@ this will open up a new terminitor project with the captured settings for you to
 
 ### Fetching Github Projects with Terminitor ###
 
-Terminitor can also fetch code repositories off Skynet, I mean Github. This will have terminitor clone the repo into the current directory:
+Terminitor can also fetch code repositories off Github. This will have terminitor clone the repo into the current directory:
 
     $ terminitor fetch achiu terminitor
-    
+
 After the repo has been fetched, terminitor will go ahead and run the setup block from the Termfile included in the repository. In the event you wouldn't want the setup block to be executed, simply set setup to false:
 
     $ terminitor fetch achiu terminitor --setup=false
@@ -278,4 +322,4 @@ Finally, we decided the time had come to release this code back to the world as
 
 Also, we didn't take any code from [Project](http://github.com/joshnesbitt/project) by Josh but that project did inspire us to setup terminit
 as a gem. Basically, project is a great gem but there were a couple issues with the fact that the terminal doesn't save the session state in some cases.
-I had already been using terminit for years so we decided to package this up for easy use.
+I had already been using terminit for years so we decided to package this up for easy use.

data/lib/terminitor/abstract_core.rb

@@ -11,14 +11,15 @@ module Terminitor
     # Run the setup block in Termfile
     def setup!
       @working_dir = Dir.pwd
-      commands = @termfile[:setup].insert(0, "cd #{working_dir}")
+      commands = @termfile[:setup].insert(0, "cd #{@working_dir}")
       commands.each { |cmd| execute_command(cmd, :in => active_window) }
     end
 
     # Executes the Termfile
     def process!
+      @working_dir = Dir.pwd
       term_windows = @termfile[:windows]
-      run_in_window('default', term_windows['default'], :default => true) unless term_windows['default'].to_s.empty?
+      run_in_window('default', term_windows['default'], :default => true) unless term_windows['default'][:tabs].empty?
       term_windows.delete('default')
       term_windows.each_pair { |window_name, window_content| run_in_window(window_name, window_content) }
     end
@@ -26,21 +27,25 @@ module Terminitor
     # this command will run commands in the designated window
     # run_in_window 'window1', {:tab1 => ['ls','ok']}
     def run_in_window(window_name, window_content, options = {})
-      window_options = window_content[:options]      
+      window_options = window_content[:options]
       first_tab = true
-      window_content[:tabs].each_pair do |tab_name, tab_content|
+      window_content[:tabs].each_pair do |tab_key, tab_content|
         # Open window on first 'tab' statement
         # first tab is already opened in the new window, so first tab should be
         # opened as a new tab in default window only
         tab_options = tab_content[:options]
+        tab_name    = tab_options[:name] if tab_options
         if first_tab && !options[:default]
           first_tab = false 
           window_options = Hash[window_options.to_a + tab_options.to_a] # safe merge
           tab = window_options.empty? ? open_window(nil) : open_window(window_options)
         else
-          tab = open_tab(tab_options)
+          tab = ( tab_key == 'default' ? active_window : open_tab(tab_options) ) # give us the current window if its default, else open a tab.
         end
-        tab_content[:commands].insert(0,  "cd \"#{@working_dir}\"") unless @working_dir.to_s.empty?
+        tab_content[:commands].insert(0, 'clear') if tab_name || !@working_dir.to_s.empty? # clean up prompt
+        tab_content[:commands].insert(0, "PS1=$PS1\"\\e]2;#{tab_name}\\a\"") if tab_name   # add title to tab
+        tab_content[:commands].insert(0, "cd \"#{@working_dir}\"") unless @working_dir.to_s.empty?
+        tab_content[:commands].insert(0, window_content[:before]).flatten! if window_content[:before] # append our before block commands.
         tab_content[:commands].each do |cmd|
           execute_command(cmd, :in => tab)
         end
@@ -59,7 +64,8 @@ module Terminitor
     # yay.
 
     # Executes the Command
-    # execute_command 'cd /path/to', {}
+    # should use the :in key to interact with terminal object.
+    # execute_command 'cd /path/to', {:in => #<TerminalObject>}
     def execute_command(cmd, options = {})
     end
 

data/lib/terminitor/cores/mac_core.rb

@@ -6,7 +6,7 @@ module Terminitor
     
     ALLOWED_OPTIONS = {
       :window => [:bounds, :visible, :miniaturized],
-      :tab => [:settings, :selected, :miniaturized, :visible]
+      :tab => [:settings, :selected]
     }
     
     # Initialize @terminal with Terminal.app, Load the Windows, store the Termfile
@@ -82,12 +82,15 @@ module Terminitor
           object.position.set(value)
         when :selected # works for tabs, for example tab :active => true
           delayed_option(option, value, object)
+        when :miniaturized # works for windows only
+          delayed_option(option, value, object)
+        when :name
+          # ignore it.
         else # trying to apply any other option
           begin
             object.instance_eval(option.to_s).set(value)
-          rescue Appscript::CommandError => e
-            puts "Error setting '#{option} = #{value}' on #{object.inspect}"
-            puts e.message
+          rescue
+            puts "Error setting #{option} = #{value} on #{object.inspect}"
           end
         end
       end

data/lib/terminitor/dsl.rb

@@ -4,9 +4,9 @@ module Terminitor
 
     def initialize(path)
       file = File.read(path)
-      @setup = []
-      @windows = { 'default' => {:tabs => {}}}
-      @_context = @windows['default'][:tabs]
+      @setup    = []
+      @windows  = { 'default' => {:tabs => {'default' =>{:commands=>[]}}}}
+      @_context = @windows['default']
       instance_eval(file)
     end
 
@@ -15,51 +15,58 @@ module Terminitor
     # setup "bundle install", "brew update"
     # setup { run('bundle install') }
     def setup(*commands, &block)
-      setup_tasks = @setup
       if block_given?
-        @_context, @_old_context = setup_tasks, @_context
-        instance_eval(&block)
-        @_context = @_old_context
+        in_context @setup, &block
       else
-        setup_tasks.concat(commands)
+        @setup.concat(commands)
       end
     end
 
     # sets command context to be run inside a specific window
     # window(:name => 'new window', :size => [80,30], :position => [9, 100]) { tab('ls','gitx') }
     # window { tab('ls', 'gitx') }
-    def window(name =nil, options = nil, &block)
-      options ||= {}
-      options, name = name, nil if name.is_a?(Hash)    
-      window_name = name || "window#{@windows.keys.size}"
-      window_contents = @windows[window_name] = {:tabs => {}}
+    def window(options = {}, &block)
+      window_name     = "window#{@windows.keys.size}"
+      window_contents = @windows[window_name] = {:tabs => {'default' => {:commands =>[]}}}
       window_contents[:options] = options unless options.empty?
-      @_context, @_old_context = window_contents[:tabs], @_context
-      instance_eval(&block)
-      @_context = @_old_context
+      in_context window_contents, &block
     end
 
     # stores command in context
     # run 'brew update'
     def run(command)
-      @_context << command
+      if @_context.is_a?(Hash) && @_context[:tabs] # if we are in a window context, append commands to default tab.
+        @_context[:tabs]['default'][:commands]<<(command)
+      else
+        @_context<<(command)
+      end
+    end
+
+    # runs commands before each tab in window context
+    # window do
+    #   before { run 'whoami' }
+    # end
+    def before(*commands, &block)
+      @_context[:before] ||= []
+      if block_given?
+        in_context @_context[:before], &block
+      else
+        @_context[:before].concat(commands)
+      end
     end
 
     # sets command context to be run inside specific tab
     # tab(:name => 'new tab', :settings => 'Grass') { run 'mate .' }
     # tab 'ls', 'gitx'
-    def tab(name = nil, options = nil, *commands, &block)
-      options ||= {}
+    def tab(options = {}, *commands, &block)
+      tabs     = @_context[:tabs]
+      tab_name = "tab#{tabs.keys.size}"
       if block_given?
-        options, name = name, nil if name.is_a?(Hash)    
-        tab_name = name || "tab#{@_context.keys.size}"
-        tab_contents = @_context[tab_name] = {:commands => []}
+        tab_contents = tabs[tab_name] = {:commands => []}
         tab_contents[:options] = options unless options.empty?
-        @_context, @_old_context = tab_contents[:commands], @_context
-        instance_eval(&block)
-        @_context = @_old_context
+        in_context tab_contents[:commands], &block
       else
-        tab_tasks = @_context["tab#{@_context.keys.size}"] = { :commands => [name] + [options] +commands}
+        tabs[tab_name] = { :commands => [options] + commands}
       end
     end
 
@@ -70,17 +77,12 @@ module Terminitor
 
     private
 
-    #
-    # in_context @setup, commands, &block
-    # in_context @tabs["name"], commands, &block
-    def in_context(tasks_instance,*commands, &block)
-      if block_given?
-        @_context, @_old_context = instance_variable_get(name), @_context
-        instance_eval(&block)
-        @_context = @_old_context
-      else
-        @setup << commands
-      end
+    # in_context @setup, &block
+    # in_context @tabs["name"], &block
+    def in_context(context, &block)
+      @_context, @_old_context = context, @_context
+      instance_eval(&block)
+      @_context = @_old_context
     end
 
 

data/lib/terminitor/version.rb

@@ -1,3 +1,3 @@
 module Terminitor
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/terminitor.gemspec

@@ -24,8 +24,8 @@ Gem::Specification.new do |s|
   s.add_dependency "thor",   "~>0.14.0"
   s.add_dependency "github", "~>0.4.5"
   s.add_development_dependency "bundler", "~>1.0.0"
-  s.add_development_dependency "riot",    "~>0.11.0"
-  s.add_development_dependency "rr",      "=1.0.0"
+  s.add_development_dependency "riot",    "~>0.12.0"
+  s.add_development_dependency "rr",      "~>1.0.0"
   s.add_development_dependency "fakefs"
   s.post_install_message = %q{********************************************************************************
 

data/test/abstract_core_test.rb

@@ -2,37 +2,36 @@ require File.expand_path('../teststrap', __FILE__)
 
 context "AbstractCore" do
 
-  context "setup!" do
-    setup do
-      any_instance_of(Terminitor::AbstractCore) do |core|
-        stub(core).load_termfile('/path/to')  { { :setup => ['ls','ok'] } }
-        mock(core).active_window  { true }.times 3
-      end
+  asserts "#setup! executes setup block" do
+    any_instance_of(Terminitor::AbstractCore) do |core|
+      stub(core).load_termfile('/path/to')  { { :setup => ['ls','ok'] } }
+      mock(core).active_window  { true }.times 3
     end
-    setup { @core = Terminitor::AbstractCore.new('/path/to') }
-    setup { mock(@core).execute_command("cd #{Dir.pwd}", :in => true)}
-    setup { mock(@core).execute_command('ls', :in => true) }
-    setup { mock(@core).execute_command('ok', :in => true) }
-    asserts("ok") { @core.setup! }
+    core = Terminitor::AbstractCore.new('/path/to')
+    mock(core).execute_command("cd #{Dir.pwd}", :in => true)
+    mock(core).execute_command('ls', :in => true)
+    mock(core).execute_command('ok', :in => true)
+    core.setup!
   end
 
-  context "process!" do
-    context "without default" do
-      setup do
-        any_instance_of(Terminitor::AbstractCore) do |core|
+  context "#process!" do
+
+    should "execute without default" do
+      any_instance_of(Terminitor::AbstractCore) do |core|
           stub(core).load_termfile('/path/to') do 
-            {:windows => {'window1' => {:tabs => {'tab1' => ['ls', 'ok']}}, 'default' => [] }}
+            {:windows => {'window1' => {:tabs => {'tab1' => ['ls', 'ok']}}, 
+                          'default' => {:tabs => {}}
+                         }
+            }
           end
-        end
       end
-      setup { @core = Terminitor::AbstractCore.new('/path/to') }
-      setup { mock(@core).run_in_window('window1', {:tabs => {'tab1' => ['ls', 'ok']}}) }
-      asserts("ok") { @core.process! }
+      core = Terminitor::AbstractCore.new('/path/to')
+      mock(core).run_in_window('window1', {:tabs => {'tab1' => ['ls', 'ok']}})
+      core.process!
     end
 
-    context "with default" do
-      setup do
-        any_instance_of(Terminitor::AbstractCore) do |core|
+    should "execute with default" do
+      any_instance_of(Terminitor::AbstractCore) do |core|
           stub(core).load_termfile('/path/to') do
             {:windows => {'window1' => {:tabs => {'tab1' => ['ls', 'ok']} }, 
                           'default' => {:tabs => {'tab0' => ['echo']} }
@@ -40,45 +39,63 @@ context "AbstractCore" do
             }
           end
         end
-      end
-      setup { @core = Terminitor::AbstractCore.new('/path/to') }
-      setup { mock(@core).run_in_window('default',{:tabs => {'tab0'=>['echo']}}, :default => true) }
-      setup { mock(@core).run_in_window('window1', {:tabs => {'tab1' => ['ls', 'ok']}}) }
-      asserts("ok") { @core.process! }
+      core = Terminitor::AbstractCore.new('/path/to')
+      mock(core).run_in_window('default',{:tabs => {'tab0'=>['echo']}}, :default => true)
+      mock(core).run_in_window('window1', {:tabs => {'tab1' => ['ls', 'ok']}})
+      core.process!
     end
 
   end
 
-  context "run_in_window" do
+  context "#run_in_window" do
+
     context "without options" do 
       setup do
         any_instance_of(Terminitor::AbstractCore) do |core|
-          stub(core).load_termfile('/path/to')  { {:windows => {'window1' => {:tabs => {'tab1' => {:commands => ['ls', 'ok']}, 'tab2' => {:commands => ['ps']}}}}} }
+          stub(core).load_termfile('/path/to')  { 
+            {:windows => {'window1' => {:tabs => {'tab1' => {:commands => ['ls', 'ok']}, 
+                                                  'tab2' => {:commands => ['ps']}}},
+                          'default' => {:tabs => {}}
+                         }
+            }
+          }
         end
-        @core = Terminitor::AbstractCore.new('/path/to')
+        stub(Dir).pwd { nil }
+        Terminitor::AbstractCore.new('/path/to')
+      end
+
+      should "execute without default" do
+        core = topic.dup
+        mock(core).open_window(nil)    { "first"  }
+        mock(core).open_tab(nil)       { "second" }
+        mock(core).set_delayed_options { true     }
+        mock(core).execute_command('ls', :in => "first")
+        mock(core).execute_command('ok', :in => "first")
+        mock(core).execute_command('ps', :in => "second")
+        core.process!
       end
 
-      context "without default" do
-        setup { mock(@core).open_window(nil)          { "first"  } }
-        setup { mock(@core).open_tab(nil)             { "second"  } }  
-        setup { mock(@core).set_delayed_options       { true      } }  
-        setup { mock(@core).execute_command('ls', :in => "first")  }
-        setup { mock(@core).execute_command('ok', :in => "first")  }
-        setup { mock(@core).execute_command('ps', :in => "second")  }        
-        asserts("ok") { @core.process! }
+      should "execute with default window" do
+        core = topic.dup
+        mock(core).open_tab(nil) { true  }
+        mock(core).execute_command('echo', :in => true)
+        core.run_in_window('default',{:tabs => {'tab0'=>{:commands => ['echo']}}}, :default => true)
       end
 
-      context "with default" do
-        setup { mock(@core).open_tab(nil) { true  } }        
-        setup { mock(@core).execute_command('echo', :in => true)  }
-        asserts("ok") { @core.run_in_window('default',{:tabs => {'tab0'=>{:commands => ['echo']}}}, :default => true)}
+      should "execute with default tab" do
+        core = topic.dup
+        mock(core).active_window { true }
+        mock(core).execute_command('uptime', :in => true)
+        core.run_in_window('default',{:tabs => {'default'=>{:commands=>['uptime']}}}, :default => true)
       end
 
-      context "with working_dir" do
-        setup { stub(Dir).pwd { '/tmp/path' } }
-        setup { mock(@core).execute_command("cd \"/tmp/path\"", :in => '/tmp/path')  }
-        setup { mock(@core).execute_command('ls', :in => '/tmp/path')  }
-        asserts("ok") { @core.run_in_window('window1', {:tabs => {'tab1' => {:commands => ['ls']}}}) }
+      should "execute with working_dir" do
+        core = topic.dup
+        stub(Dir).pwd { '/tmp/path' }
+        mock(core).execute_command("cd \"/tmp/path\"", :in => '/tmp/path')
+        mock(core).execute_command('clear', :in => '/tmp/path')
+        mock(core).execute_command('ls', :in => '/tmp/path')
+        core.run_in_window('window1', {:tabs => {'tab1' => {:commands => ['ls']}}})
       end
     end
     
@@ -86,24 +103,66 @@ context "AbstractCore" do
       setup do
         any_instance_of(Terminitor::AbstractCore) do |core|
           stub(core).load_termfile('/path/to') do 
-            {:windows => {'window1' => {:tabs => {'tab1' => {:commands => ['ls', 'ok'], :options => {:settings => 'cool', :name => 'first tab'}}, 
-                                                  'tab2' => {:commands => ['ps'], :options => {:settings => 'grass', :name => 'second tab'}},  
+            {:windows => {'window1' => {:tabs => {'tab1' => {:commands => ['ls', 'ok'], 
+                                                             :options => {:settings => 'cool', :name => 'first tab'}}, 
+                                                  'tab2' => {:commands => ['ps'], 
+                                                             :options => {:settings => 'grass', :name => 'second tab'}},  
                                                  }, 
-                                        :options => {:bounds => [10,10]}}}
+                                        :options => {:bounds => [10,10]}},
+                          'default' => {:tabs => {}}
+                         }
             }
           end
         end
-        @core = Terminitor::AbstractCore.new('/path/to')
+        stub(Dir).pwd { nil }
+        Terminitor::AbstractCore.new('/path/to')
       end
       
-      setup { mock(@core).open_window(:bounds => [10,10], :settings => 'cool', :name => "first tab")  { "first"  } }
-      setup { mock(@core).open_tab(:settings => 'grass', :name => 'second tab')    { "second"  } }
-      setup { mock(@core).set_delayed_options { true  } }       
-      setup { mock(@core).execute_command('ls', :in => "first")  }
-      setup { mock(@core).execute_command('ok', :in => "first")  }
-      setup { mock(@core).execute_command('ps', :in => "second")  }
-      
-      asserts("ok") { @core.process! }
+      should "execute" do
+        core = topic.dup
+        mock(core).open_window(:bounds => [10,10], :settings => 'cool', :name => "first tab")  { "first"  }
+        mock(core).open_tab(:settings => 'grass', :name => 'second tab')    { "second"  }
+        mock(core).set_delayed_options { true  }
+        mock(core).execute_command('PS1=$PS1"\e]2;first tab\a"', :in => 'first')
+        mock(core).execute_command('clear', :in => 'first')
+        mock(core).execute_command('ls', :in => "first")
+        mock(core).execute_command('ok', :in => "first")
+        mock(core).execute_command('PS1=$PS1"\e]2;second tab\a"', :in => 'second')
+        mock(core).execute_command('clear', :in => 'second')
+        mock(core).execute_command('ps', :in => "second")
+        core.process!
+      end  
+    end
+  
+
+    context "with before" do 
+      setup do
+        any_instance_of(Terminitor::AbstractCore) do |core|
+          stub(core).load_termfile('/path/to')  { 
+            {:windows => {'window1' => {:tabs => {'tab1' => {:commands => ['ls']}, 
+                                                  'tab2' => {:commands => ['ps']}},
+                                        :before => ['whoami']
+                                       },
+                          'default' => {:tabs => {}}
+                         }
+            }
+          }
+        end
+        stub(Dir).pwd { nil }
+        Terminitor::AbstractCore.new('/path/to')
+      end
+
+      should "execute without default" do
+        core = topic.dup
+        mock(core).open_window(nil)    { "first"  }
+        mock(core).open_tab(nil)       { "second" }
+        mock(core).set_delayed_options { true     }
+        mock(core).execute_command('whoami', :in => 'first')
+        mock(core).execute_command('ls', :in => "first")
+        mock(core).execute_command('whoami', :in => "second")
+        mock(core).execute_command('ps', :in => "second")
+        core.process!
+      end
     end
   end