terminitor 0.4.1 → 0.5.0

data/lib/terminitor/cores/cmd_core/windows_console.rb

@@ -0,0 +1,83 @@
+module Terminitor
+
+  class CurrentWindowsConsole
+    include Input
+    def send_command(cmd)
+      # puts "[current] #{cmd}"
+      type_in cmd
+    end
+  end
+  
+
+  
+  class WindowsConsole
+    include Windows::Process
+    include Windows::Handle
+    include Windows::Window
+    include Input
+ 
+    Windows::API.new('SetForegroundWindow', 'L', 'I', 'user32')
+
+    attr_accessor :name
+    attr_accessor :parameters
+    attr_accessor :title
+    attr_reader :pid
+    attr_reader :thread_id
+    attr_reader :hwnd
+
+    def initialize(options = {})
+      @name = options[:name] || name
+      @title = options[:title] || name
+      @parameters = options[:parameters]
+
+      start
+    end
+
+    def start
+      command_line = name
+      command_line = name + ' ' + parameters if parameters
+
+      # returns a struct, raises an error if fails
+      process_info = Process.create(
+         :command_line => command_line,
+         :close_handles => false,
+         :creation_flags => Process::CREATE_NEW_CONSOLE
+      )
+      @pid = process_info.process_id
+      @thread_id = process_info.thread_id
+      @process_handle = process_info.process_handle
+      @thread_handle = process_info.thread_handle
+
+      @pid
+    end
+
+    def kill!
+      CloseHandle(@process_handle)
+      CloseHandle(@thread_handle)
+
+      Process::kill(9, pid)
+    end
+
+    def find_window(process_id)
+      sleep 0.4 #todo - find a better way to wait for console to show up!!
+      child_after = 0
+      while (child_after = FindWindowEx(nil, child_after, nil, nil)) > 0 do 
+        process_id = 0.chr * 4
+        GetWindowThreadProcessId(child_after, process_id)
+        process_id = process_id.unpack('L').first
+        return child_after if process_id == @pid 
+      end
+      
+
+      return nil
+    end
+
+    def send_command(cmd)
+      @hwnd ||= find_window(@thread_id)
+      SetForegroundWindow(@hwnd) 
+      # puts "[#{@hwnd}] #{cmd}"
+      type_in(cmd)
+    end
+  end
+
+end

data/lib/terminitor/cores/terminator_core.rb

@@ -0,0 +1,117 @@
+module Terminitor
+
+  # Terminator core for Terminitor.
+  #
+  # Since Terminator doesn't have a complete IPC interface,
+  # everything is done by using "xdotool" to simulate keypresses.
+  class TerminatorCore < AbstractCore
+    def initialize(path)
+      abort("xdotool required for Terminator support") if (@xdotool = `which xdotool`.chomp).empty?
+      super
+    end
+
+    def execute_command(cmd, options = {})
+      # add a cr to the end if missing
+      cmd += "\n" if (cmd =~ /\n\Z/).nil?
+      run_in_active_terminator cmd, options
+      true
+    end
+
+    def open_tab(options = nil)
+      send_keypress "ctrl+shift+t", options
+    end
+
+    def open_window(options = nil)
+      send_keypress "ctrl+shift+i", options
+    end
+
+    protected
+
+    # Run arbitrary command in active terminator window.
+    # abort()s if the active window is not a terminator window.
+    #
+    # @param cmd [String] command.
+    # @param options [Hash] options hash.
+    def run_in_active_terminator(cmd, options)
+      winid = window_id
+      type_in_window winid, cmd
+    end
+
+    # Send keypresses to active window.
+    #
+    # @param keys [String] keypresses in the form expected by xdotool.
+    # @param options [Hash] options hash from terminitor.
+    def send_keypress(keys, options)
+      winid = window_id
+      xdotool("key --window #{winid} #{keys}")
+    end
+
+    # Get the X11 window ID of the active terminator window.
+    #
+    # If the active window is not a terminator window, abort.
+    #
+    # @return [String] X11 window ID of active terminator window.
+    def window_id
+      active = get_active_window
+      if get_terminator_windows.include? active
+        return active
+      else
+        abort("not running in Terminator")
+      end
+    end
+
+    # Use xdotool to get the window id of the active window.
+    #
+    # @return [String] active X11 window ID.
+    def get_active_window
+      xdotool("getactivewindow").chomp
+    end
+
+    # Use xdotool to get the window IDs of all visible
+    # terminator windows.
+    #
+    # @return [Array] String array of terminator window IDs.
+    def get_terminator_windows
+      xdotool("search --onlyvisible --class terminator").split("\n")
+    end
+
+    # Focus window with given id.
+    #
+    # @param id [String] X11 window id.
+    def focus_window(id)
+      xdotool("windowfocus #{id}")
+    end
+
+    # Raise window with given id.
+    #
+    # @param id [String] X11 window id.
+    def raise_window(id)
+      xdotool("windowraise #{id}")
+    end
+
+    # Send arbitrary text to given window.
+    #
+    # @param winid [String] X11 window id.
+    # @param text [String] text to type.
+    def type_in_window(winid, text)
+      xdotool("type --window #{winid} \"#{text}\"")
+    end
+
+    # Run arbitrary xdotool commands.
+    #
+    # @param cmd [String] command as string.
+    # @return [String] result as string.
+    def xdotool(cmd)
+      execute("#{@xdotool} #{cmd}")
+    end
+
+    # Execute arbitrary command and return result string.
+    #
+    # @param cmd [String] command string.
+    # @return [String] result as string.
+    def execute(cmd)
+      IO.popen(cmd).read
+    end
+  end
+end
+

data/lib/terminitor/dsl.rb

@@ -2,6 +2,7 @@ module Terminitor
   # This class parses the Termfile to fit the new Ruby Dsl Syntax
   class Dsl
 
+    # @param [String] path to termfile
     def initialize(path)
       file = File.read(path)
       @setup    = []
@@ -12,8 +13,11 @@ module Terminitor
 
     # Contains all commands that will be run prior to the usual 'workflow'
     # e.g bundle install, setup forks, etc ...
-    # setup "bundle install", "brew update"
-    # setup { run('bundle install') }
+    # @param [Array<String>] array of commands
+    # @param [Proc]
+    # @example
+    #   setup "bundle install", "brew update"
+    #   setup { run('bundle install') }
     def setup(*commands, &block)
       if block_given?
         in_context @setup, &block
@@ -23,8 +27,11 @@ module Terminitor
     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') }
+    # @param [Hash] options hash.
+    # @param [Proc] 
+    # @example
+    #   window(:name => 'new window', :size => [80,30], :position => [9, 100]) { tab('ls','gitx') }
+    #   window { tab('ls', 'gitx') }
     def window(options = {}, &block)
       window_name     = "window#{@windows.keys.size}"
       window_contents = @windows[window_name] = {:tabs => {'default' => {:commands =>[]}}}
@@ -33,20 +40,26 @@ module Terminitor
     end
 
     # stores command in context
-    # run 'brew update'
+    # @param [Array<String>] Array of commands
+    # @example
+    #   run 'brew update'
     def run(*commands)
-      if @_context.is_a?(Hash) && @_context[:tabs] # if we are in a window context, append commands to default tab.
+      # if we are in a window context, append commands to default tab.
+      if @_context.is_a?(Hash) && @_context[:tabs] 
         current = @_context[:tabs]['default'][:commands]
       else
         current = @_context
       end
-      current << commands.join(" && ")
+      current << commands.map { |c| "(#{c})" }.join(" && ")
     end
 
     # runs commands before each tab in window context
-    # window do
-    #   before { run 'whoami' }
-    # end
+    # @param [Array<String>] Array of commands
+    # @param [Proc]
+    # @example
+    #   window do
+    #     before { run 'whoami' }
+    #   end
     def before(*commands, &block)
       @_context[:before] ||= []
       if block_given?
@@ -57,8 +70,11 @@ module Terminitor
     end
 
     # sets command context to be run inside specific tab
-    # tab(:name => 'new tab', :settings => 'Grass') { run 'mate .' }
-    # tab 'ls', 'gitx'
+    # @param [Array<String>] Array of commands
+    # @param [Proc]
+    # @example
+    #   tab(:name => 'new tab', :settings => 'Grass') { run 'mate .' }
+    #   tab 'ls', 'gitx'
     def tab(*args, &block)
       tabs     = @_context[:tabs]
       tab_name = "tab#{tabs.keys.size}"
@@ -78,6 +94,7 @@ module Terminitor
     end
 
     # Returns yaml file as Terminitor formmatted hash
+    # @return [Hash] Return hash format of Termfile
     def to_hash
       { :setup => @setup, :windows => @windows }
     end

data/lib/terminitor/runner.rb

@@ -2,8 +2,13 @@ module Terminitor
   # This module contains all the helper methods for the Cli component.
   module Runner
 
+    # Terminitor Global Path
+    TERM_PATH = File.join(ENV['HOME'],'.config','terminitor')
+
     # Finds the appropriate platform core, else say you don't got it.
-    # find_core RUBY_PLATFORM
+    # @param [String] the ruby platform
+    # @example
+    #   find_core RUBY_PLATFORM
     def find_core(platform)
       core = case platform.downcase
       when %r{darwin} then 
@@ -12,12 +17,20 @@ module Terminitor
         else
           Terminitor::MacCore
         end
-      when %r{linux}  then Terminitor::KonsoleCore # TODO check for gnome and others
+      when %r{linux}  then
+       if not `which terminator`.chomp.empty?
+         Terminitor::TerminatorCore
+       else
+         Terminitor::KonsoleCore # TODO silly fallback, make better check
+       end
+      when %r{mswin|mingw} then
+        Terminitor::CmdCore
       else nil
       end
     end
     
     # Defines how to capture terminal settings on the specified platform
+    # @param [String] the ruby platform
     def capture_core(platform)
       core = case platform.downcase
       when %r{darwin} then 
@@ -26,14 +39,22 @@ module Terminitor
         else
           Terminitor::MacCapture
         end
-      when %r{linux}  then Terminitor::KonsoleCapture # TODO check for gnome and others
+      when %r{linux}  then
+        if not `which terminator`.chomp.empty?
+          Terminitor::TerminatorCapture
+        else
+          Terminitor::KonsoleCapture # TODO silly fallback, make better check
+        end
       else nil
       end
     end
 
     # Execute the core with the given method.
-    # execute_core :process!, 'project'
-    # execute_core :setup!, 'my_project'
+    # @param [Symbol] symbol of method
+    # @param [String] Termfile name
+    # @example
+    #   execute_core :process!, 'project'
+    #   execute_core :setup!, 'my_project'
     def execute_core(method, project)
       if path = resolve_path(project)
         core = find_core(RUBY_PLATFORM)
@@ -44,7 +65,10 @@ module Terminitor
     end
 
     # opens doc in system designated editor
-    # open_in_editor '/path/to', 'nano'
+    # @param [String] path to termfile
+    # @param [String] editor
+    # @example
+    #   open_in_editor '/path/to', 'nano'
     def open_in_editor(path, editor=nil)
       editor = editor || ENV['TERM_EDITOR'] || ENV['EDITOR']
       say "please set $EDITOR or $TERM_EDITOR in your .bash_profile." unless editor
@@ -52,7 +76,8 @@ module Terminitor
     end
 
     # returns path to file
-    # resolve_path 'my_project'
+    # @param [String] Termfile name
+    # @example resolve_path 'my_project'
     def resolve_path(project)
       unless project.empty?
         path = config_path(project, :yml) # Give old yml path
@@ -68,26 +93,29 @@ module Terminitor
     end
 
     # returns first line of file
-    # grab_comment_for_file '/path/to'
+    # @param [String] Termfile path
+    # @example grab_comment_for_file '/path/to'
     def grab_comment_for_file(file)
       first_line = File.readlines(file).first
       first_line =~ /^\s*?#/ ? ("-" + first_line.gsub("#","")) : "\n"
     end
 
     # Return file in config_path
-    # config_path '/path/to', :term
+    # @param [String] Termfile path
+    # @param [Symbol] Type of file
+    # @example config_path '/path/to', :term
     def config_path(file, type = :yml)
       return File.join(options[:root],"Termfile") if file.empty?
-      dir = File.join(ENV['HOME'],'.terminitor')
       if type == :yml
-        File.join(dir, "#{file.sub(/\.yml$/, '')}.yml")
+        File.join(TERM_PATH, "#{file.sub(/\.yml$/, '')}.yml")
       else
-        File.join(dir, "#{file.sub(/\.term$/, '')}.term")
+        File.join(TERM_PATH, "#{file.sub(/\.term$/, '')}.term")
       end
     end
 
     # Returns error message depending if project is specified
-    # return_error_message 'hi
+    # @param [String] Termfile name
+    # @example return_error_message 'hi
     def return_error_message(project)
       unless project.empty?
         say "'#{project}' doesn't exist! Please run 'terminitor open #{project.gsub(/\..*/,'')}'"
@@ -99,6 +127,9 @@ 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.
+    # @param [String] Github username
+    # @param [String] Github project name
+    # @example github_clone 'achiu', 'terminitor'
     def github_clone(username, project)
       github = `which github`
       return false if github.empty?
@@ -107,7 +138,10 @@ module Terminitor
     end
 
     # Fetch the git repo and run the setup block
-    # fetch_repo 'achiu', 'terminitor', :setup => true
+    # @param [String] Github username
+    # @param [String] Github project
+    # @param [Hash] options hash
+    # @example fetch_repo 'achiu', 'terminitor', :setup => true
     def github_repo(username, project, options ={})
       if github_clone(username, project)
         path = File.join(Dir.pwd, project)

data/lib/terminitor/version.rb

@@ -1,3 +1,3 @@
 module Terminitor
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/lib/terminitor/yaml.rb

@@ -6,11 +6,13 @@ module Terminitor
     attr_accessor :file
     
     # Load in the Yaml file...
+    # @param [String] Path to termfile
     def initialize(path)
       @file = YAML.load File.read(path)
     end
     
     # Returns yaml file as Terminitor formmatted hash
+    # @return [Hash] Hash format of termfile
     def to_hash
       combined = @file.inject({}) do |base, item| 
         item = {item.keys.first => {:commands => item.values.first, :options => {}}}