terminitor 0.1.0 → 0.2.0

data/README.md

@@ -106,6 +106,39 @@ or with a block:
     end
 
 
+##### Settings #####
+
+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
+      run "echo 'named tab'"
+      run "ls"
+    end
+
+How about a window with a specific size:
+
+    window :bounds => [10,20,300,200] do
+
+    end
+
+Currently, the following options are available:
+
+__tabs__
+
+* :settings     - [String]  Set the tab to terminal settings
+* :selected     - [Boolean] Sets whether the tab is active
+* :miniaturized - [Boolean] Sets whether its miniaturized
+* :visible      - [Boolean] Sets whether its visible
+
+
+__windows__
+
+* :bounds       - [Array]  Sets the bounds
+* :miniaturized - [Boolean] Sets whether its miniaturized
+* :visible      - [Boolean] Sets whether its visible
+
 ### Running Terminitor Projects ###
 
 Once the project file has been declared to your satisfaction, simply execute any project defined in the `~/.terminitor` directory with:
@@ -167,6 +200,14 @@ 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 ###
+
+Terminitor has the ability to also capture your terminal setup and settings simply with:
+
+    $ terminitor edit my_project --capture
+    
+this will open up a new terminitor project with the captured settings for you to continuing modifying as you see fit.
+
 
 ### Fetching Github Projects with Terminitor ###
 
@@ -198,12 +239,17 @@ Limitations
 #### MacCore ####
 
 Right now the Mac OS X Terminal tabs are created by invoking keystrokes which means there are limitations with the terminal being in
-focus during execution of these commands. Obviously the long term goal is to solve this issue as well but in all honesty,
-this solution works well enough most of the time.
+focus during execution of these commands. Obviously the long term goal is to solve this issue as well but in all honesty, this solution works well enough most of the time.
 
 #### Fetching ####
 
-The fetch task only pulls off Github repositories at the moment(which is cool). Later on, this functionality will be extended to non github repository(probably later this week.)
+The fetch task only pulls off Github repositories at the moment. Later on, this functionality will be extended to non github repository.
+
+
+#### Settings and Captures ####
+
+This feature is currently only available in Mac OS X at the moment.
+
 
 Authors
 -------
@@ -218,6 +264,7 @@ Thanks to the following people for their contributions so far:
 
  * Pat George ([pcg79](http://github.com/pcg79)) for contributing a patch for when a project is not found.
  * Flavio Castelli ([flavio](http://github.com/flavio)) for contributing Konsole(KDE) core.
+ * Alexey Kuleshov ([kulesa](http://github.com/kulesa)) for contributing the terminal settings and terminal settings capture functionality
 
 Acknowledgements
 -----------------

data/lib/templates/example.term.tt

@@ -7,11 +7,15 @@ setup 'echo "setup"'
 tab "echo 'default'", "echo 'default tab'"
 
 window do
+
   tab "echo 'first tab'", "echo 'of window'"
   
-  tab "named tab" do
+  tab "named tab", :settings => "Ocean" do
     run "echo 'named tab'"
     run "ls"
   end
 end
 
+window "autotest" do 
+  tab "echo 'window and tab without options'"
+end

data/lib/terminitor.rb

@@ -1,18 +1,20 @@
-require 'rubygems'
-require File.expand_path('../terminitor/yaml', __FILE__)
-require File.expand_path('../terminitor/dsl', __FILE__)
-require File.expand_path('../terminitor/runner', __FILE__)
-require File.expand_path('../terminitor/abstract_core', __FILE__)
-require File.expand_path('../terminitor/cli', __FILE__)
+require 'terminitor/yaml'
+require 'terminitor/dsl'
+require 'terminitor/runner'
+require 'terminitor/abstract_core'
+require 'terminitor/cli'
+require 'terminitor/abstract_capture'
 
 module Terminitor
-  autoload :Version, File.expand_path('../terminitor/version', __FILE__)
+  autoload :Version, 'terminitor/version'
   case RUBY_PLATFORM.downcase
   when %r{darwin}
     require 'appscript'
-    autoload :MacCore,     File.expand_path('../terminitor/cores/mac_core', __FILE__)
+    autoload :MacCore,        'terminitor/cores/mac_core'
+    autoload :MacCapture,     'terminitor/capture/mac_capture'  
   when %r{linux}
     require 'dbus'
-    autoload :KonsoleCore, File.expand_path('../terminitor/cores/konsole_core', __FILE__)
+    autoload :KonsoleCore,    'terminitor/cores/konsole_core'
+    autoload :KonsoleCapture, 'terminitor/capture/konsole_capture'    
   end
 end

data/lib/terminitor/abstract_capture.rb

@@ -0,0 +1,36 @@
+module Terminitor
+  # This AbstractCapture defines the basic methods that the Capture class should inherit
+  class AbstractCapture
+    # Generates .term file from settings of currently opened terminal windows and tabs
+    def capture_settings
+      capture_windows.inject("") do |config, w|
+        config << generate_object_dsl('window', w) do |dsl|
+          w[:tabs].each do |t|
+            dsl << generate_object_dsl('tab', t, 4)
+          end
+        end
+      end
+    end
+  
+    # Returns array of settings of currently opened windows, 
+    # [{:options => {:window_option1 => ... }, :tabs => [{:options => {:tab_option1 => ... }}]}]
+    # Needs to be defined for specific platform
+    def capture_windows
+    end
+    
+    private
+    
+    # Helper method to generate the .term file
+    def generate_object_dsl(name, object, ident = 0, &block)
+      dsl, margin = "", " "*ident
+
+      params = object[:options].inject([]) do |params, option|
+        params << ":#{option[0]} => #{option[1].inspect}"
+      end.join(", ")
+
+      dsl << margin + "#{name} #{params} do\n"
+      yield(dsl) if block_given?
+      dsl << margin + "end\n\n"
+    end
+  end
+end

data/lib/terminitor/abstract_core.rb

@@ -18,22 +18,34 @@ module Terminitor
     # Executes the Termfile
     def process!
       term_windows = @termfile[:windows]
-      run_in_window(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'].to_s.empty?
       term_windows.delete('default')
-      term_windows.each_pair { |window_name, tabs| run_in_window(tabs) }
+      term_windows.each_pair { |window_name, window_content| run_in_window(window_name, window_content) }
     end
 
     # this command will run commands in the designated window
-    # run_in_window {:tab1 => ['ls','ok']}
-    def run_in_window(tabs, options = {})
-      open_window unless options[:default]
-      tabs.each_pair do |tab_name,commands|
-        tab = open_tab
-        commands.insert(0,  "cd \"#{@working_dir}\"") unless @working_dir.to_s.empty?
-        commands.each do |cmd|
+    # run_in_window 'window1', {:tab1 => ['ls','ok']}
+    def run_in_window(window_name, window_content, options = {})
+      window_options = window_content[:options]      
+      first_tab = true
+      window_content[:tabs].each_pair do |tab_name, 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]
+        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)
+        end
+        tab_content[:commands].insert(0,  "cd \"#{@working_dir}\"") unless @working_dir.to_s.empty?
+        tab_content[:commands].each do |cmd|
           execute_command(cmd, :in => tab)
         end
       end
+      set_delayed_options
     end
 
     # Loads commands via the termfile and returns them as a hash
@@ -52,7 +64,7 @@ module Terminitor
     end
 
     # Opens a new tab and returns itself.
-    def open_tab
+    def open_tab(options = nil)
       @working_dir = Dir.pwd # pass in current directory.
     end
 
@@ -61,7 +73,13 @@ module Terminitor
     end
 
     # Opens a new window and returns the tab object.
-    def open_window
+    def open_window(options = nil)
+      @working_dir = Dir.pwd # pass in current directory.      
+    end
+    
+    # For options which should be set after all tabs have been opened
+    def set_delayed_options
+      @working_dir = Dir.pwd # not nil
     end
 
   end

data/lib/terminitor/capture/konsole_capture.rb

@@ -0,0 +1,8 @@
+module Terminitor
+  # Captures terminal windows and tabs for Linux   
+  class KonsoleCapture < AbstractCapture    
+    def initialize
+      super
+    end
+  end
+end

data/lib/terminitor/capture/mac_capture.rb

@@ -0,0 +1,51 @@
+module Terminitor
+  # Captures terminal windows and tabs for Mac OS X 
+  class MacCapture < AbstractCapture
+    include Appscript
+    
+    # Defines what options of window or tab to capture and how
+    # just in case we'll need to get other properties
+    OPTIONS_MASK = {
+      :window => {
+        :bounds => "bounds"
+      },
+      :tab => {
+        :settings => "current_settings.name"
+      }
+    }
+    
+    # Initialize @terminal with Terminal.app, Load the Windows, store the Termfile
+    # Terminitor::MacCore.new('/path')
+    def initialize
+      @terminal = app('Terminal.app')
+    end
+
+    # Returns settings of currently opened windows and tabs.    
+    def capture_windows
+      windows = []
+      # for some reason terminal.windows[] contain duplicated elements
+      @terminal.windows.get.uniq.each do |window| 
+        if window.visible.get
+          tabs = window.tabs.get.inject([]) do |tabs, tab|
+            tabs << {:options => object_options(tab)}
+          end
+          windows << {:options => object_options(window), :tabs => tabs}
+        end
+      end
+      windows
+    end
+    
+    # Returns hash of options of window or tab
+    def object_options(object)
+      options = {}
+      class_ =  object.class_.get
+      if class_ && OPTIONS_MASK[class_]
+        OPTIONS_MASK[class_].each_pair do |option, getter|
+          value = object.instance_eval(getter).get
+          options[option] = value
+        end
+      end
+      options
+    end
+  end
+end

data/lib/terminitor/cli.rb

@@ -23,7 +23,7 @@ module Terminitor
     method_option :root,    :type => :string, :default => '.',    :aliases => '-r'
     method_option :setup, :type => :boolean, :default => true
     def fetch(username, project)
-      fetch_repo username, project, options
+      github_repo username, project, options
     end
 
     desc "list", "lists all terminitor scripts"
@@ -43,10 +43,28 @@ module Terminitor
     method_option :root,    :type => :string, :default => '.',    :aliases => '-r'
     method_option :editor,  :type => :string, :default => nil,    :aliases => '-c'
     method_option :syntax,  :type => :string, :default => 'term', :aliases => '-s'
+    method_option :capture, :type => :boolean,   :default => false,  :aliases => '-g'
     def edit(project="")
       syntax = project.empty? ? 'term' : options[:syntax] # force Termfile to use term syntax
       path =  config_path(project, syntax.to_sym)
-      template "templates/example.#{syntax}.tt", path, :skip => true
+      if options[:capture] && !File.exists?(path)
+        # capture settings of currently opened windows and tabs
+        if syntax == 'term'
+          if core = capture_core(RUBY_PLATFORM)
+            term = core.new().capture_settings
+            (f = File.new(path, "w") << term).close
+          else
+            say("No suitable core found!")
+            return
+          end
+        else
+          say "Terminal settings can be captured only to DSL format."
+          return
+        end
+      else 
+        # use standard template
+        template "templates/example.#{syntax}.tt", path, :skip => true
+      end
       open_in_editor(path,options[:editor])
     end
 

data/lib/terminitor/cores/konsole_core.rb

@@ -18,7 +18,7 @@ module Terminitor
     end
 
     # Opens a new tab and returns itself.
-    def open_tab
+    def open_tab(options = nil)
       session_number = @konsole.newSession
       session_object = @konsole_service.object("/Sessions/#{session_number}")
       session_object.introspect
@@ -26,7 +26,7 @@ module Terminitor
     end
 
     # Opens a new window and returns the tab object.
-    def open_window
+    def open_window(options = nil)
       session_number = @konsole.currentSession
       session_object = @konsole_service.object("/Sessions/#{session_number}")
       session_object.introspect

data/lib/terminitor/cores/mac_core.rb

@@ -4,12 +4,18 @@ module Terminitor
   class MacCore < AbstractCore
     include Appscript
     
+    ALLOWED_OPTIONS = {
+      :window => [:bounds, :visible, :miniaturized],
+      :tab => [:settings, :selected, :miniaturized, :visible]
+    }
+    
     # Initialize @terminal with Terminal.app, Load the Windows, store the Termfile
     # Terminitor::MacCore.new('/path')
     def initialize(path)
       super
       @terminal = app('Terminal')
       @windows  = @terminal.windows
+      @delayed_options = []
     end
             
     # executes the given command via appscript
@@ -19,15 +25,21 @@ module Terminitor
     end
 
     # Opens a new tab and returns itself.
-    def open_tab
-      super
+    def open_tab(options = nil)
       terminal_process.keystroke("t", :using => :command_down)
+      set_options(return_last_tab, options) if options
       return_last_tab
     end
-
-    # Opens A New Window and returns the tab object.
-    def open_window
+    
+    # Opens A New Window, applies settings to the first tab and returns the tab object.
+    def open_window(options = nil)
       terminal_process.keystroke("n", :using => :command_down)
+      # Options of the first tab must be set before window options, 
+      # because change of the first tab options causes change of window size
+      if options    
+        set_options(return_last_tab, allowed_options(:tab, options))
+        set_options(active_window, allowed_options(:window, options))
+      end
       return_last_tab
     end
 
@@ -52,6 +64,42 @@ module Terminitor
         window.properties_.get[:frontmost] rescue false
       end
     end
+    
+    # Sets options of the given object
+    def set_options(object, options = {})
+      options.each_pair do |option, value| 
+        case option
+        when :settings   # works for windows and tabs, for example :settings => "Grass"
+          begin
+            object.current_settings.set(@terminal.settings_sets[value])
+          rescue Appscript::CommandError => e
+            puts "Error: invalid settings set '#{value}'"
+          end
+        when :bounds # works only for windows, for example :bounds => [10,20,300,200]
+          # the only working sequence to restore window size and position! 
+          object.bounds.set(value)
+          object.frame.set(value)
+          object.position.set(value)
+        when :selected # works for tabs, for example tab :active => true
+          delayed_option(option, value, object)
+        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
+          end
+        end
+      end
+    end
+    
+    # Apply delayed options and remove them from the queue
+    def set_delayed_options
+      @delayed_options.length.times do 
+        option = @delayed_options.shift
+        option[:object].instance_eval(option[:option]).set(option[:value])
+      end
+    end
 
     private
     
@@ -75,5 +123,18 @@ module Terminitor
       window.custom_title.set(title)
     end
     
+    # selects options allowed for window or tab
+    def allowed_options(object_type, options)
+      Hash[ options.select {|option, value| ALLOWED_OPTIONS[object_type].include?(option) }]
+    end
+    
+    # Add option to the list of delayed options
+    def delayed_option(option, value, object)
+      @delayed_options << {
+        :option => option.to_s, 
+        :value => value, 
+        :object => object
+      }
+    end
   end
 end

data/lib/terminitor/dsl.rb

@@ -26,10 +26,15 @@ module Terminitor
     end
 
     # sets command context to be run inside a specific window
-    # window('new window') { tab('ls','gitx') }
-    def window(name = nil, &block)
-      window_tabs = @windows[name || "window#{@windows.keys.size}"] = {}
-      @_context, @_old_context = window_tabs, @_context
+    # 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 => {}}
+      window_contents[:options] = options unless options.empty?
+      @_context, @_old_context = window_contents[:tabs], @_context
       instance_eval(&block)
       @_context = @_old_context
     end
@@ -41,17 +46,20 @@ module Terminitor
     end
 
     # sets command context to be run inside specific tab
-    # tab('new tab') { run 'mate .' }
+    # tab(:name => 'new tab', :settings => 'Grass') { run 'mate .' }
     # tab 'ls', 'gitx'
-    def tab(name= nil, *commands, &block)
+    def tab(name = nil, options = nil, *commands, &block)
+      options ||= {}
       if block_given?
-        tab_tasks = @_context[name || "tab#{@_context.keys.size}"] = []
-        @_context, @_old_context = tab_tasks, @_context
+        options, name = name, nil if name.is_a?(Hash)    
+        tab_name = name || "tab#{@_context.keys.size}"
+        tab_contents = @_context[tab_name] = {:commands => []}
+        tab_contents[:options] = options unless options.empty?
+        @_context, @_old_context = tab_contents[:commands], @_context
         instance_eval(&block)
         @_context = @_old_context
       else
-        tab_tasks = @_context["tab#{@_context.keys.size}"] = []
-        tab_tasks.concat([name] + commands)
+        tab_tasks = @_context["tab#{@_context.keys.size}"] = { :commands => [name] + [options] +commands}
       end
     end
 
@@ -60,7 +68,6 @@ module Terminitor
       { :setup => @setup, :windows => @windows }
     end
 
-
     private
 
     #

data/lib/terminitor/runner.rb

@@ -11,6 +11,15 @@ module Terminitor
       else nil
       end
     end
+    
+    # Defines how to capture terminal settings on the specified platform
+    def capture_core(platform)
+      core = case platform.downcase
+      when %r{darwin} then Terminitor::MacCapture
+      when %r{linux}  then Terminitor::KonsoleCapture # TODO check for gnome and others
+      else nil
+      end
+    end
 
     # Execute the core with the given method.
     # execute_core :process!, 'project'
@@ -80,7 +89,7 @@ module Terminitor
     # This will clone a repo in the current directory.
     # It will first try to clone via ssh(read/write),
     # if not fall back to git-read only, else, fail.
-    def clone_repo(username, project)
+    def github_clone(username, project)
       github = `which github`
       return false if github.empty?
       command = "github clone #{username} #{project}"
@@ -89,8 +98,8 @@ module Terminitor
 
     # Fetch the git repo and run the setup block
     # fetch_repo 'achiu', 'terminitor', :setup => true
-    def fetch_repo(username, project, options ={})
-      if clone_repo(username, project)
+    def github_repo(username, project, options ={})
+      if github_clone(username, project)
         path = File.join(Dir.pwd, project)
         FileUtils.cd(path)
         invoke(:setup, []) if options[:setup]

data/lib/terminitor/version.rb

@@ -1,3 +1,3 @@
 module Terminitor
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/abstract_capture_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../teststrap', __FILE__)
+
+context "AbstractCapture" do
+  context "capture_settings" do 
+    setup do
+      @capture = Terminitor::AbstractCapture.new()
+      any_instance_of(Terminitor::AbstractCapture) do |core|
+        stub(core).capture_windows  { [
+          {:options => {:size => [10,20], :name => "main window"}, 
+           :tabs => [
+             {:options => {:settings => "Grass"}}
+             ]},
+          {:options => {:size => [14,30], :name => "another window"},
+           :tabs => [{:options => {:settings => "Yello"}}]}
+        ] }
+      end
+    end
+    
+    setup { @capture.capture_settings() }
+    asserts_topic.equivalent_to <<-OUTPUT
+window :size => [10, 20], :name => "main window" do
+    tab :settings => "Grass" do
+    end
+
+end
+
+window :size => [14, 30], :name => "another window" do
+    tab :settings => "Yello" do
+    end
+
+end
+
+OUTPUT
+
+  end
+end

data/test/abstract_core_test.rb

@@ -20,57 +20,90 @@ context "AbstractCore" do
     context "without default" do
       setup do
         any_instance_of(Terminitor::AbstractCore) do |core|
-          stub(core).load_termfile('/path/to')  { {:windows => {'tab1' => ['ls', 'ok'], 'default' => [] } } }
+          stub(core).load_termfile('/path/to') do 
+            {:windows => {'window1' => {:tabs => {'tab1' => ['ls', 'ok']}}, 'default' => [] }}
+          end
         end
       end
       setup { @core = Terminitor::AbstractCore.new('/path/to') }
-      setup { mock(@core).run_in_window(['ls', 'ok']) }
+      setup { mock(@core).run_in_window('window1', {:tabs => {'tab1' => ['ls', 'ok']}}) }
       asserts("ok") { @core.process! }
     end
 
     context "with default" do
       setup do
         any_instance_of(Terminitor::AbstractCore) do |core|
-          stub(core).load_termfile('/path/to')  { {:windows => {'tab1' => ['ls', 'ok'], 'default' => ['echo'] } } }
+          stub(core).load_termfile('/path/to') do
+            {:windows => {'window1' => {:tabs => {'tab1' => ['ls', 'ok']} }, 
+                          'default' => {:tabs => {'tab0' => ['echo']} }
+                         }
+            }
+          end
         end
       end
       setup { @core = Terminitor::AbstractCore.new('/path/to') }
-      setup { mock(@core).run_in_window(['echo'], :default => true) }
-      setup { mock(@core).run_in_window(['ls', 'ok']) }
+      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! }
     end
 
   end
 
   context "run_in_window" do
-    setup do
-      any_instance_of(Terminitor::AbstractCore) do |core|
-        stub(core).load_termfile('/path/to')  { true }
+    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']}}}}} }
+        end
+        @core = Terminitor::AbstractCore.new('/path/to')
       end
-      @core = Terminitor::AbstractCore.new('/path/to')
-    end
 
-    context "with default" do
-      setup { mock(@core).open_window { true  } }
-      setup { mock(@core).open_tab    { true  } }
-      setup { mock(@core).execute_command('ls', :in => true)  }
-      setup { mock(@core).execute_command('ok', :in => true)  }
-      asserts("ok") { @core.run_in_window('tab' => ['ls','ok']) }
-    end
-
-    context "without default" do
-      setup { mock(@core).open_tab { true  } }
-      setup { mock(@core).execute_command('ls', :in => true)  }
-      setup { mock(@core).execute_command('ok', :in => true)  }
-      asserts("ok") { @core.run_in_window({'tab' => ['ls','ok']}, :default => true) }
-    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! }
+      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)}
+      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({'tab' => ['ls']}) }
+      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']}}}) }
+      end
+    end
+    
+    context "with options" 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'}},  
+                                                 }, 
+                                        :options => {:bounds => [10,10]}}}
+            }
+          end
+        end
+        @core = 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! }
     end
   end
 

data/test/capture/mac_capture_test.rb

@@ -0,0 +1,42 @@
+require File.expand_path('../../teststrap',__FILE__)
+
+if platform?("darwin") # Only run test if it's darwin
+  context "MacCapture" do
+    # Stub out the initialization
+    setup do
+      @terminal = Object.new
+      any_instance_of(Terminitor::MacCapture) do |core|
+        stub(core).app('Terminal.app') { @terminal  }
+      end 
+    end
+    setup { @mac_capture = Terminitor::MacCapture.new() }
+
+    context "capture_windows" do 
+      setup do 
+        window, tab = Object.new, Object.new
+        stub(@terminal).windows.stub!.get { [window]}
+        stub(window).tabs.stub!.get {[tab]}
+        stub(window).visible.stub!.get { true }
+        mock(@mac_capture).object_options(window) { {:window_option => true} }
+        mock(@mac_capture).object_options(tab)    { {:tab_option => true} }        
+        # any_instance_of(Terminitor::MacCapture) {|core| stub(core).object_options(anything) { {} }}
+      end
+      setup { @mac_capture.capture_windows}
+      asserts_topic.equals [{:tabs=>[{:options=>{:tab_option=>true}}], :options=>{:window_option=>true}}]
+    end
+
+    context "object_options" do
+      setup do
+        @object = Object.new
+        stub(@object).class_.stub!.get { :window }
+        stub(@object).bounds.stub!.get { [10,20,30,40]}
+      end
+      setup { @mac_capture.object_options(@object) }
+      asserts_topic.equals { {:bounds => [10,20,30,40]} }
+    end
+  end
+else
+  context "MacCore" do
+    puts "Nothing to do, you are not on OSX"
+  end
+end

data/test/cli_test.rb

@@ -67,6 +67,32 @@ context "Terminitor" do
       setup { mock.instance_of(Terminitor::Cli).open_in_editor('/tmp/sample_project/Termfile','nano') { true }.once }
       asserts("runs nano") { capture(:stdout) { Terminitor::Cli.start(['edit','-r=/tmp/sample_project','-c=nano']) } }
     end
+    
+    context "for capture flag" do 
+      context "for yaml" do 
+        setup { capture(:stdout) { Terminitor::Cli.start(['edit','foobar', '-s=yml', '--capture']) } }
+        asserts_topic.matches %r{Terminal settings can be captured only to DSL format.}
+      end
+      
+      context "for term" do 
+        context "with no core returned" do
+          setup { mock.instance_of(Terminitor::Cli).capture_core(anything) { nil } }
+          setup { FileUtils.touch("#{ENV['HOME']}/.terminitor/delete_this.term") }
+          setup { capture(:stdout) { Terminitor::Cli.start(['edit', 'test_foo_bar2', '--capture']) } }
+          asserts_topic.matches %r{No suitable core found!}
+        end
+
+        context "for known core" do
+          setup do 
+            core = Object.new
+            mock.instance_of(Terminitor::Cli).capture_core(anything) { core }  
+            stub(core).new.stub!.capture_settings { "settings"}
+            mock.instance_of(Terminitor::Cli).open_in_editor("#{ENV['HOME']}/.terminitor/test_foo_bar2.term",nil) { true }            
+          end
+          asserts("ok") { Terminitor::Cli.start(['edit','test_foo_bar2', '--capture']) } 
+        end
+      end
+    end
 
   end
 
@@ -115,7 +141,7 @@ context "Terminitor" do
   end
   
   context "fetch" do
-    setup { mock.instance_of(Terminitor::Cli).fetch_repo('achiu','terminitor', 'root' => '.', 'setup' => true) { true } }
+    setup { mock.instance_of(Terminitor::Cli).github_repo('achiu','terminitor', 'root' => '.', 'setup' => true) { true } }
     asserts("run setup in project dir") { capture(:stdout) { Terminitor::Cli.start(['fetch','achiu','terminitor'])} }
   end
 end

data/test/cores/mac_core_test.rb

@@ -9,7 +9,7 @@ if platform?("darwin") # Only run test if it's darwin
       any_instance_of(Terminitor::MacCore) do |core|
         stub(core).app('Terminal')            { terminal  }
         stub(core).load_termfile('/path/to')  { true      }
-      end
+      end 
     end
     setup { @mac_core = Terminitor::MacCore.new('/path/to') }
 
@@ -31,6 +31,17 @@ if platform?("darwin") # Only run test if it's darwin
       end
       asserts("returns last tab") { @mac_core.open_tab }
     end
+    
+    context "open_tab with options" do
+      setup do
+        process = Object.new
+        mock(process).keystroke('t', :using => :command_down)
+        mock(@mac_core).set_options(true, :option1 => '1', :option2 => '2')        
+        mock(@mac_core).return_last_tab.times(2)   { true    }
+        mock(@mac_core).terminal_process  { process }
+      end
+      asserts("returns last tab") { @mac_core.open_tab(:option1 => '1', :option2 => '2') }
+    end
 
     context "open_window" do
       setup do
@@ -42,6 +53,21 @@ if platform?("darwin") # Only run test if it's darwin
       asserts("returns last tab") { @mac_core.open_window }
     end
 
+    context "open_window with options" do
+      setup do
+        process = Object.new
+        window = Object.new
+        tab = Object.new
+        mock(process).keystroke('n', :using => :command_down)
+        mock(@mac_core).set_options(window, :bounds => '1')
+        mock(@mac_core).set_options(tab, :settings => "2")       
+        mock(@mac_core).active_window     { window  }        
+        mock(@mac_core).return_last_tab   { tab     }.times(2)
+        mock(@mac_core).terminal_process  { process }
+      end
+      asserts("opens window with options") { @mac_core.open_window(:bounds => '1', :settings => '2')}
+    end
+    
     context "return_last_tab" do
       setup do
         window = Object.new
@@ -76,6 +102,61 @@ if platform?("darwin") # Only run test if it's darwin
       end
       asserts("gives me window") { Terminitor::MacCore.new('/path/to').active_window }
     end
+    
+    context "set_options" do 
+      setup do 
+        @object, @terminal, @windows= 3.times.collect { Object.new } 
+        any_instance_of(Terminitor::MacCore) do |core|
+          stub(core).app('Terminal')            { @terminal }
+          stub(core).load_termfile('/path/to')  { true      }
+        end
+        stub(@terminal).windows    { @windows }
+      end
+      
+      context "valid settings set" do 
+        setup do
+          stub(@terminal).settings_sets {{:valid_settings => true}}
+          stub(@object).current_settings.stub!.set(anything) { true }
+        end   
+        asserts("applies known settings set") { Terminitor::MacCore.new('/path/to').set_options(@object, :settings => :valid_settings)}
+      end 
+      
+      context "invalid settings set" do 
+        setup do
+          stub(@terminal).settings_sets {{:invalid_settings => true}}
+          stub(Object).raise 
+          stub(@object).current_settings.stub!.set(anything) { raise Appscript::CommandError.new("code","error","object","reference", "command") }
+        end   
+        setup {  capture(:stdout) {Terminitor::MacCore.new('/path/to').set_options(@object, :settings => :invalid_settings)}}
+        asserts_topic.matches %r{invalid settings set}
+      end
+      
+      context "bounds" do 
+        setup do
+          setup { stub(@object).bounds.stub!.set(true) }          
+          setup { stub(@object).frame.stub!.set(true) }          
+          setup { stub(@object).position.stub!.set(true) }          
+        end   
+        asserts("sets bounds") { Terminitor::MacCore.new('/path/to').set_options(@object, :bounds => true)}
+      end
+      
+      context "unknown option" do 
+        setup do 
+          stub(Object).raise 
+          stub(@object).unknown_option.stub!.set(anything) { raise Appscript::CommandError.new("code","error","object","reference", "command") }
+        end
+        setup {  capture(:stdout) { Terminitor::MacCore.new('/path/to').set_options(@object, :unknown_option => true)}}
+        asserts_topic.matches %r{Error}         
+      end
+  
+      context "delayed option" do 
+        setup do 
+          setup { Terminitor::MacCore.new('/path/to').set_options(@object, :selected => true) }
+          stub(@object).selected.stub!.set(true)
+        end
+        asserts("sets delayed options") { @mac_core.set_delayed_options }
+      end
+    end
   end
 else
   context "MacCore" do

data/test/dsl_test.rb

@@ -6,10 +6,14 @@ context "Dsl" do
   asserts_topic.assigns :setup
   asserts_topic.assigns :windows
   asserts_topic.assigns :_context
-
+ 
   context "to_hash" do
     setup { @yaml.to_hash }
-    asserts_topic.equivalent_to(:setup=>["echo \"setup\""], :windows=>{"window1"=>{"named tab"=>["echo 'named tab'", "ls"], "tab0"=>["echo 'first tab'", "echo 'of window'"]}, "default"=>{"tab0"=>["echo 'default'", "echo 'default tab'"]}})
+    asserts_topic.equivalent_to :setup=>["echo \"setup\""], 
+                                :windows=>{
+                                  "window1"=>{:tabs=>{"named tab"=>{:commands=>["echo 'named tab'", "ls"], :options => {:settings=>"Grass"}}, 
+                                                      "tab0"=>{:commands=>["echo 'first tab'", "echo 'of window'", "echo 'than now'"]}}, :options => {:size=>[70,30]}}, 
+                                  "default"=>{"tab0"=>{:commands=>["echo 'default'", "echo 'default tab'", "ok", "for real"]}}}
   end
 
 end

data/test/fixtures/bar.term

@@ -3,14 +3,15 @@
 
 setup 'echo "setup"'
 
-tab "echo 'default'", "echo 'default tab'"
+tab "echo 'default'", "echo 'default tab'", "ok", "for real"
 
-window do
-  tab "echo 'first tab'", "echo 'of window'"
+window :size => [70,30] do
+  tab "echo 'first tab'", "echo 'of window'", "echo 'than now'"
   
-  tab "named tab" do
+  tab "named tab", :settings => "Grass" do
     run "echo 'named tab'"
     run "ls"
   end
 end
 
+

data/test/runner_test.rb

@@ -38,6 +38,13 @@ context "Runner" do
       end
     end
   end
+  
+  context "capture_core" do 
+    context "for Darwin" do
+      setup { @test_runner.capture_core('darwin') }
+      asserts_topic.equals Terminitor::MacCapture
+    end
+  end
 
   context "open_in_editor" do
     context "using $EDITOR" do
@@ -192,40 +199,40 @@ context "Runner" do
     end
   end
 
-  context "clone_repo" do
+  context "github_clone" do
     context "with github" do
       setup { stub(@test_runner).__double_definition_create__.call(:`,'which github') { "github" } }
       context "with read/write priv" do
         setup { mock(@test_runner).system("github clone achiu terminitor --ssh") { true } }
-        asserts("invokes ssh") { @test_runner.clone_repo('achiu','terminitor') }
+        asserts("invokes ssh") { @test_runner.github_clone('achiu','terminitor') }
       end
 
       context "with read only" do
         setup { mock(@test_runner).system("github clone achiu terminitor --ssh") { false } }
         setup { mock(@test_runner).system("github clone achiu terminitor") { true } }
-        asserts("invokes git://") { @test_runner.clone_repo('achiu', 'terminitor') }
+        asserts("invokes git://") { @test_runner.github_clone('achiu', 'terminitor') }
       end
     end
   end
 
-  context "fetch_repo" do
+  context "github_repo" do
     context "with setup" do
-      setup { mock(@test_runner).clone_repo('achiu','terminitor') { true } }
+      setup { mock(@test_runner).github_clone('achiu','terminitor') { true } }
       setup { mock(FileUtils).cd(File.join(Dir.pwd,'terminitor')) { true } }
       setup { mock(@test_runner).invoke(:setup, []) { true } }
-      asserts("invokes setup") { @test_runner.fetch_repo('achiu','terminitor', :setup => true) }
+      asserts("invokes setup") { @test_runner.github_repo('achiu','terminitor', :setup => true) }
     end
 
     context "without setup" do
-      setup { mock(@test_runner).clone_repo('achiu','terminitor') { true } }
+      setup { mock(@test_runner).github_clone('achiu','terminitor') { true } }
       setup { mock(FileUtils).cd(File.join(Dir.pwd,'terminitor')) { true } }
-      asserts("invokes setup") { @test_runner.fetch_repo('achiu','terminitor') }.nil
+      asserts("invokes setup") { @test_runner.github_repo('achiu','terminitor') }.nil
     end
 
     context "failed on repo" do
-      setup { mock(@test_runner).clone_repo('achiu','terminitor') { false } }
+      setup { mock(@test_runner).github_clone('achiu','terminitor') { false } }
       setup { mock(@test_runner).say("could not fetch repo!") { true } }
-      asserts("invokes say") { @test_runner.fetch_repo('achiu', 'terminitor') }
+      asserts("invokes say") { @test_runner.github_repo('achiu', 'terminitor') }
     end
 
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: terminitor
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Arthur Chiu
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-30 00:00:00 -07:00
+date: 2010-11-05 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -144,7 +144,10 @@ files:
 - lib/templates/example.term.tt
 - lib/templates/example.yml.tt
 - lib/terminitor.rb
+- lib/terminitor/abstract_capture.rb
 - lib/terminitor/abstract_core.rb
+- lib/terminitor/capture/konsole_capture.rb
+- lib/terminitor/capture/mac_capture.rb
 - lib/terminitor/cli.rb
 - lib/terminitor/cores/konsole_core.rb
 - lib/terminitor/cores/mac_core.rb
@@ -155,7 +158,9 @@ files:
 - templates/example.yml.tt
 - terminitor.gemspec
 - test.watchr
+- test/abstract_capture_test.rb
 - test/abstract_core_test.rb
+- test/capture/mac_capture_test.rb
 - test/cli_test.rb
 - test/cores/konsole_core_test.rb
 - test/cores/mac_core_test.rb