consular-terminator 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-terminator.gemspec

@@ -0,0 +1,50 @@
+# Terminator support for Consular
+# Copyright (C) 2011 Ilkka Laukkanen
+#
+# 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/terminator/version'
+
+Gem::Specification.new do |s|
+  s.name = 'consular-terminator'
+  s.version = Consular::Terminator::VERSION
+  s.authors = ['Ilkka Laukkanen']
+  s.email = [%q{ilkka.s.laukkanen@gmail.com}]
+  s.homepage = %q{http://github.com/ilkka/consular-terminator}
+  s.summary = %q{Terminator support for Consular}
+  s.licenses = ["GPLv3"]
+  s.description = 
+    %q{Add support for automating the Terminator 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/terminator/version.rb

@@ -0,0 +1,16 @@
+require 'consular'
+
+module Consular
+  class Terminator < 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/lib/consular/terminator.rb

@@ -0,0 +1,260 @@
+require 'consular'
+require 'rbconfig'
+
+module Consular
+  # Consular core for interacting with Terminator.
+  #
+  # 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.
+  #
+  # Largely adapted from http://github.com/achiu/consular-osx
+  class Terminator < 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_terminator 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_terminator_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_terminator_window
+      send_keypress(active_terminator_window, "ctrl+shift+i")
+      # wait for the active window to change -> new window opened
+      while active_terminator_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 terminator
+    #
+    # @api private
+    def run_in_active_terminator(cmd, options = {})
+      type_in_window(active_terminator_window, "#{cmd}\n")
+    end
+
+    # Get active terminator window winid.
+    # Gets the active window and returns it if it is
+    # a Terminator window. If it is not a terminator window,
+    # the method gets all terminator windows and returns the
+    # first one. If no terminator windows exist, aborts.
+    #
+    # @api private
+    def active_terminator_window
+      active = xdotool("getactivewindow").chomp
+      if not all_terminator_windows.include? active
+        active = all_terminator_windows.first
+      end
+      if not active
+        abort("No Terminator windows found")
+      end
+      return active
+    end
+
+    # Get window IDs of all terminator windows.
+    #
+    # @api private
+    def all_terminator_windows
+      xdotool("search --onlyvisible --class terminator").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/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/terminator'
+end
+

data/spec/terminator_spec.rb

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

data/tests.watchr

@@ -0,0 +1,151 @@
+#!/usr/bin/env watchr
+# vim:ft=ruby
+
+def have_notify_send?
+  case `which notify-send`.empty?
+  when true
+    false
+  else
+    true
+  end
+end
+
+def have_growl?
+  @have_growl ||= begin
+                    require 'growl'
+                  rescue LoadError
+                    false
+                  end
+end
+
+def error_icon_name 
+  "gtk-dialog-error"
+end
+
+def success_icon_name
+  "gtk-dialog-info"
+end
+
+# Rules
+watch('^spec/.+_spec\.rb$') { |md| spec md[0] }
+watch('^lib/.+\.rb$') { |md| spec "spec/#{File.basename(md[0]).gsub(/\..*?$/, '')}_spec.rb" }
+watch('^features/.+\.feature$') { |md| feature md[0] }
+watch('^features/step_definitions/(.+)_steps\.rb$') { |md| feature "features/#{md[1]}.feature" }
+
+# Notify using notify-send.
+#
+# @param icon [String] name of stock icon to use.
+# @param title [String] title of notification.
+# @param message [String] message for notification body.
+# @return [Boolean] true if the command ran successfully, false
+# otherwise.
+def notify(icon, title, message)
+  system("notify-send -t 3000 -i #{icon} \"#{title}\" \"#{message}\"")
+end
+
+# Notify of success.
+#
+def notify_success
+  puts "Success"
+  if have_notify_send?
+    notify success_icon_name, "All green!", "Now write more tests :)"
+  elsif have_growl?
+    Growl.notify_ok "All green!"
+  end
+end
+
+# Notify of failure.
+#
+def notify_failure
+  puts "Failure"
+  if have_notify_send?
+    notify error_icon_name, "Something is broken", "Now go fix it :)"
+  elsif have_growl?
+    Growl.notify_error "Something is broken"
+  end
+end
+
+# Run a single ruby command. Notify appropriately.
+# 
+# @param cmd [String] command to run.
+def run(cmd)
+  system('clear')
+  puts "Running #{cmd}"
+  if system(cmd)
+    notify_success
+    true
+  else
+    notify_failure
+    false
+  end
+end
+
+# Run a single spec.
+#
+# @param specfiles [String] path to specfile or [Array] of paths.
+def spec(specfiles)
+  specs = case specfiles.respond_to? :join
+             when true
+               specfiles.join(" ")
+             when false
+               specfiles
+             end
+  if run(%Q(rspec #{specs}))
+    if @last_run_failed
+      @last_run_failed = false
+      run_all_specs
+    end
+  else
+    @last_run_failed = true
+  end
+  !@last_run_failed
+end
+
+# Run a single feature.
+#
+# @param featurefiles [String] path to feature file or [Array] of paths.
+def feature(featurefiles)
+  features = case featurefiles.respond_to? :join
+             when true
+               featurefiles.join(" ")
+             when false
+               featurefiles
+             end
+  run(%Q(cucumber #{features}))
+end
+
+# Run all specs.
+#
+def run_all_specs
+  spec Dir['spec/*_spec.rb']
+end
+
+# Run all features.
+#
+def run_features
+  feature Dir['features/*.feature']
+end
+
+# Run specs and features.
+#
+def run_suite
+  run_all_specs && run_features
+end
+
+# Run all specs on Ctrl-\
+Signal.trap('QUIT') { run_all_specs }
+
+# Run full suite on one Ctrl-C, quit on two
+@interrupted = false
+Signal.trap('INT') do
+  if @interrupted
+    abort("\n")
+  else
+    puts "Interrupt a second time to quit"
+    @interrupted = true
+    Kernel.sleep 1.5
+    run_suite
+    @interrupted = false
+  end
+end
+