consular-gnome-terminal 0.1.0

data/README.rdoc

@@ -0,0 +1,13 @@
+= Terminator support for Consular
+
+This gem is an add-on to Consular that implements support for the Terminator
+terminal emulator on Linux.
+
+Since Terminator does not have an API for controlling it, a commandline tool
+called `xdotool` is used to send keyboard shortcuts to a running Terminator
+in order to control it.
+
+== Copyright
+
+Copyright (c) 2011 Ilkka Laukkanen. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rcov = true
+end
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features)
+
+require 'yard'
+YARD::Rake::YardocTask.new
+
+task :default => [:features, :spec]
+

data/consular-gnome-terminal.gemspec

@@ -0,0 +1,50 @@
+# Gnome Terminal support for Consular
+# Copyright (C) 2011 Jesse Cooke
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+$:.push File.expand_path("../lib", __FILE__)
+require 'consular/gnome-terminal/version'
+
+Gem::Specification.new do |s|
+  s.name = 'consular-gnome-terminal'
+  s.version = Consular::GnomeTerminal::VERSION
+  s.authors = ['Jesse Cooke']
+  s.email = [%q{jesse@jc00ke.com}]
+  s.homepage = %q{http://github.com/jc00ke/consular-gnome-terminal}
+  s.summary = %q{Gnome Terminal support for Consular}
+  s.licenses = ["GPLv3"]
+  s.description = 
+    %q{Add support for automating the Gnome Terminal with Consular.}
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- test/* spec/* features/*`.split("\n")
+
+  s.extra_rdoc_files = [
+    'LICENSE.txt',
+    'README.rdoc'
+  ]
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency('consular')
+
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('yard')
+  s.add_development_dependency('cucumber')
+  s.add_development_dependency('spork')
+  s.add_development_dependency('watchr')
+  s.add_development_dependency('bundler')
+  s.add_development_dependency('mocha')
+end

data/cucumber.yml

@@ -0,0 +1 @@
+default: --color --drb --port 8990

data/features/support/env.rb

@@ -0,0 +1,18 @@
+require 'spork'
+
+Spork.prefork do
+  require 'bundler'
+  begin
+    Bundler.setup(:default, :development)
+  rescue Bundler::BundlerError => e
+    $stderr.puts e.message
+    $stderr.puts "Run `bundle install` to install missing gems"
+    exit e.status_code
+  end
+
+  require 'rspec/expectations'
+end
+
+Spork.each_run do
+
+end

data/lib/consular/gnome-terminal.rb

@@ -0,0 +1,260 @@
+require 'consular'
+require 'rbconfig'
+
+module Consular
+  # Consular core for interacting with GnomeTerminal.
+  #
+  # Since we don't have any real API to work with and just send
+  # keypresses via XTEST, we don't have tab references either.
+  # Instead we just count tabs and return tab indexes.
+  #
+  # Adapted from http://github.com/ikka/consular-terminator
+  class GnomeTerminal < Core
+
+    Consular.add_core self
+
+    class << self
+      # Check to see if current system is valid for this core
+      #
+      # @api public
+      def valid_system?
+        if (RbConfig::CONFIG['host_os'] =~ /linux/) != nil
+          if !(xdotool = `which xdotool`.chomp).empty?
+            begin
+              return File::Stat.new(xdotool).executable?
+            rescue
+              return false
+            end
+          end
+        end
+        return false
+      end
+    end
+
+    # Initialize
+    #
+    # @param [String] path
+    #   path to Termfile.
+    #
+    # @api public
+    def initialize(path)
+      super
+      @tabidx = nil
+    end
+
+    # Method called by runner to Execute Termfile setup.
+    #
+    # @api public
+    def setup!
+      @termfile[:setup].each { |cmd| execute_command(cmd, :in => active_window) }
+    end
+
+    # Method called by runner to execute Termfile.
+    #
+    # @api public
+    def process!
+      windows = @termfile[:windows]
+      default = windows.delete('default')
+      execute_window(default, :default => true) unless default[:tabs].empty?
+      windows.each_pair { |_, cont| execute_window(cont) }
+    end
+
+    # Executes the commands for each designated window.
+    # .run_windows will iterate through each of the tabs in
+    # sorted order to execute the tabs in the order they were set.
+    # The logic follows this:
+    #
+    #   If the content is for the 'default' window,
+    #   then use the current active window and generate the commands.
+    #
+    #   If the content is for a new window,
+    #   then generate a new window and activate the windows.
+    #
+    #   Otherwise, open a new tab and execute the commands.
+    #
+    # @param [Hash] content
+    #   The hash contents of the window from the Termfile.
+    # @param [Hash] options
+    #   Addional options to pass. You can use:
+    #     :default - Whether this is being run as the default window.
+    #
+    # @example
+    #   @core.execute_window contents, :default => true
+    #   @core.execute_window contents, :default => true
+    #
+    # @api public
+    def execute_window(content, options = {})
+      window_options = content[:options]
+      _contents      = content[:tabs]
+      _first_run     = true
+
+      _contents.keys.sort.each do |key|
+        _content = _contents[key]
+        _options = content[:options]
+        _name    = options[:name]
+
+        _tab =
+        if _first_run && !options[:default]
+          open_window options.merge(window_options)
+        else
+          key == 'default' ? nil : open_tab(_options)
+        end
+
+        _first_run = false
+        commands = prepend_befores _content[:commands], _contents[:befores]
+        commands = set_title _name, commands
+        commands.each { |cmd| execute_command cmd, :in => _tab }
+      end
+
+    end
+
+    # Prepend a title setting command prior to the other commands.
+    #
+    # @param [String] title
+    #   The title to set for the context of the commands.
+    # @param [Array<String>] commands
+    #   The context of commands to preprend to.
+    #
+    # @api public
+    def set_title(title, commands)
+      cmd = "PS1=\"$PS1\\[\\e]2;#{title}\\a\\]\""
+      title ? commands.insert(0, cmd) : commands
+    end
+
+    # Prepends the :before commands to the current context's
+    # commands if it exists.
+    #
+    # @param [Array<String>] commands
+    #   The current tab commands
+    # @param [Array<String>] befores
+    #   The current window's :befores
+    #
+    # @return [Array<String>]
+    #   The current context commands with the :before commands prepended
+    #
+    # @api public
+    def prepend_befores(commands, befores = nil)
+      unless befores.nil? || befores.empty?
+        commands.insert(0, befores).flatten! 
+      else
+        commands
+      end
+    end
+
+    # Execute the given command in the context of the
+    # active window.
+    #
+    # @param [String] cmd
+    #   The command to execute.
+    # @param [Hash] options
+    #   Additional options to pass into appscript for the context.
+    #
+    # @example
+    #   @osx.execute_command 'ps aux', :in => @tab_object
+    #
+    # @api public
+    def execute_command(cmd, options = {})
+      run_in_active_gnome_terminal cmd, options
+    end
+
+    # Opens a new tab and return the last instantiated tab(itself).
+    #
+    # @param [Hash] options
+    #   Options to further customize the window. You can use:
+    #     :settings -
+    #     :selected -
+    #
+    # @return
+    #   Returns a refernce to the last instantiated tab of the
+    #   window.
+    #
+    # @api public
+    def open_tab(options = nil)
+      send_keypress(active_gnome_terminal_window, "ctrl+shift+t")
+      # FIXME: horribly hacky but can't come up with any way
+      # to truly make sure tab has opened.
+      sleep 1
+    end
+
+    # Opens a new window and returns its
+    # last instantiated tab.(The first 'tab' in the window).
+    #
+    # @param [Hash] options
+    #   Options to further customize the window. You can use:
+    #     :bound        - Set the bounds of the windows
+    #     :visible      - Set whether or not the current window is visible
+    #     :miniaturized - Set whether or not the window is minimized
+    #
+    # @return
+    #   Returns a refernce to the last instantiated tab of the
+    #   window.
+    #
+    # @api public
+    def open_window(options = nil)
+      windowid_before = active_gnome_terminal_window
+      send_keypress(active_gnome_terminal_window, "ctrl+shift+i")
+      # wait for the active window to change -> new window opened
+      while active_gnome_terminal_window == windowid_before
+        sleep 1
+      end
+      return (@tabidx = 0)
+    end
+
+    private
+
+    # Send keypresses to window winid
+    #
+    # @api private
+    def send_keypress(winid, keys)
+      xdotool("windowfocus #{winid}")
+      xdotool("key #{keys}")
+    end
+
+    # Run command with active gnome-terminal
+    #
+    # @api private
+    def run_in_active_gnome_terminal(cmd, options = {})
+      type_in_window(active_gnome_terminal_window, "#{cmd}\n")
+    end
+
+    # Get active gnome-terminal window winid.
+    # Gets the active window and returns it if it is
+    # a GnomeTerminal window. If it is not a gnome-terminal window,
+    # the method gets all gnome-terminal windows and returns the
+    # first one. If no gnome-terminal windows exist, aborts.
+    #
+    # @api private
+    def active_gnome_terminal_window
+      active = xdotool("getactivewindow").chomp
+      if not all_gnome_terminal_windows.include? active
+        active = all_gnome_terminal_windows.first
+      end
+      if not active
+        abort("No Gnome Terminal windows found")
+      end
+      return active
+    end
+
+    # Get window IDs of all gnome-terminal windows.
+    #
+    # @api private
+    def all_gnome_terminal_windows
+      xdotool("search --onlyvisible --class gnome-terminal").split("\n")
+    end
+
+    # Type text in window winid.
+    #
+    # @api private
+    def type_in_window(winid, text)
+      xdotool("windowfocus #{winid}")
+      xdotool("type \"#{text}\"")
+    end
+
+    # Execute xdotool with the given args and return output
+    #
+    # @api private
+    def xdotool(cmd)
+      IO.popen("xdotool #{cmd}").read
+    end
+  end
+end

data/lib/consular/gnome-terminal/version.rb

@@ -0,0 +1,16 @@
+require 'consular'
+
+module Consular
+  class GnomeTerminal < Core
+    module Version
+      MAJOR = 0
+      MINOR = 1
+      PATCH = 0
+      BUILD = nil
+    end
+
+    VERSION = [
+      Version::MAJOR, Version::MINOR, Version::PATCH, Version::BUILD
+    ].compact.join('.')
+  end
+end

data/spec/gnome-terminal_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'rbconfig'
+
+describe Consular::GnomeTerminal do
+  it 'should be added as a core to Consular' do
+    Consular.cores.should include Consular::GnomeTerminal
+  end
+
+  it 'should treat linux as a valid system' do
+    RbConfig::CONFIG.expects(:[]).with('host_os').returns('x86-linux')
+    Consular::GnomeTerminal.expects(:`).with('which xdotool').returns('/usr/bin/xdotool')
+    stat = mock()
+    stat.expects(:executable?).returns(true)
+    File::Stat.expects(:new).returns(stat)
+    Consular::GnomeTerminal.valid_system?.should == true
+  end
+
+  it 'should treat non-linux as an invalid system' do
+    RbConfig::CONFIG.expects(:[]).with('host_os').returns('darwin')
+    Consular::GnomeTerminal.valid_system?.should == false
+  end
+
+  it 'should treat systems without "which" as invalid' do
+    RbConfig::CONFIG.expects(:[]).with('host_os').returns('x86-linux')
+    Consular::GnomeTerminal.expects(:`).with('which xdotool').returns('which: command not found')
+    File::Stat.expects(:new).throws('no such file')
+    Consular::GnomeTerminal.valid_system?.should == false
+  end
+
+  it 'should treat systems without "xdotool" as invalid' do
+    RbConfig::CONFIG.expects(:[]).with('host_os').returns('x86-linux')
+    Consular::GnomeTerminal.expects(:`).with('which xdotool').returns('')
+    File::Stat.expects(:new).throws('no such file')
+    Consular::GnomeTerminal.valid_system?.should == false
+  end
+
+  it 'should send ctrl+shift+i when creating new window' do
+    f = EmptyTermfile.new
+    core = Consular::GnomeTerminal.new f.path
+    core.expects(:active_gnome_terminal_window).once.returns(1)
+    core.expects(:active_gnome_terminal_window).once.returns(1)
+    core.expects(:xdotool).with("windowfocus 1")
+    core.expects(:xdotool).with("key ctrl+shift+i")
+    core.expects(:active_gnome_terminal_window).once.returns(2)
+    core.open_window
+  end
+
+  it 'should send ctrl+shift+t when creating new tab' do
+    f = EmptyTermfile.new
+    core = Consular::GnomeTerminal.new f.path
+    core.expects(:active_gnome_terminal_window).returns(1)
+    core.expects(:xdotool).with("windowfocus 1")
+    core.expects(:xdotool).with("key ctrl+shift+t")
+    core.open_tab
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'spork'
+
+Spork.prefork do
+  $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+  $LOAD_PATH.unshift(File.dirname(__FILE__))
+  require 'rspec'
+  require 'mocha'
+
+  # Requires supporting files with custom matchers and macros, etc,
+  # in ./support/ and its subdirectories.
+  Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+  RSpec.configure do |config|
+  end
+
+  require 'tempfile'
+
+  class EmptyTermfile < Tempfile
+    def initialize
+      super('consular')
+      write(%q(setup "echo 'setup'"))
+      rewind
+    end
+  end
+end
+
+Spork.each_run do
+  require 'consular/gnome-terminal'
+end
+