consular-iterm 1.0.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in consular-iterm.gemspec
+gemspec

data/README.md

@@ -0,0 +1,81 @@
+# Consular - iTerm Core
+
+Automate your iTerm Terminal with Consular
+
+
+# Setup && Installation
+
+If you haven't already, install Consular:
+
+  gem install consular
+
+then install consular-iterm:
+
+  gem install consular-iterm
+
+
+next, run `init`:
+
+  consular init
+
+This will generate a global directory and also a `.consularc` in your home
+directory. On the top of your `.consularc`, just require this core like
+so:
+
+```ruby
+# You can require your additional core gems here.
+require 'consular/osx'
+
+# You can set specific Consular configurations
+# here.
+Consular.configure do |c|
+end
+```
+
+
+## Additional Features
+
+With `consular-iterm`, you can also genrate `panes` likes so:
+
+```ruby
+pane do
+  run "top"
+  pane "ps"
+end
+
+window do
+  pane "gitx"
+end
+```
+
+Splitting tabs into panes works as follows:
+
+    tab do
+      pane "gitx" # first pane
+        pane do      # second pane level => horizontal split
+          run "irb"
+        end
+      pane 'ls'   # first pane level => vertical split
+    end
+
+should result into something like this:
+
+    #    ###########################
+    #    #            #            #
+    #    #            #            #
+    #    #   'gitx'   #            #
+    #    #            #            #
+    #    #            #            #
+    #    ##############    'ls'    #
+    #    #            #            #
+    #    #            #            #
+    #    #   'irb'    #            #
+    #    #            #            #
+    #    #            #            #
+    #    ###########################
+
+It is not possible to split the second level panes (the horizontal ones). 
+Nevertheless you should be able to split tabs into any kind of pane pattern you wish
+with this syntax.
+
+Now you can use iTerm Terminal to run your Consular scripts!

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new(:spec) do |test|
+  test.libs << 'lib' << 'spec'
+  test.pattern = 'spec/**/*_spec.rb'
+  test.verbose = true
+end
+

data/consular-iterm.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "consular-iterm"
+  s.version     = "1.0.0"
+  s.authors     = ["Arthur Chiu"]
+  s.email       = ["mr.arthur.chiu@gmail.com"]
+  s.homepage    = "http://www.github.com/achiu/consular-iterm"
+  s.summary     = %q{Automate your ITerm with Consular}
+  s.description = %q{Terminal Automation for ITerm via Consular}
+
+  s.rubyforge_project = "consular-iterm"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'consular'
+
+  s.add_development_dependency 'minitest'
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/consular/iterm.rb

@@ -0,0 +1,333 @@
+require 'consular'
+require 'appscript'
+require File.expand_path('../iterm_dsl', __FILE__)
+
+module Consular
+
+  # Consular Core to interact with iTerm2 for Mac OS X
+  #
+  class ITerm < Core
+    include Appscript
+
+    Consular.add_core self
+
+    class << self
+
+      # Checks to see if the current system is darwin and 
+      # if $TERM_PROGRAM is iTerm.app
+      #
+      # @api public
+      def valid_system?
+        (RUBY_PLATFORM.downcase =~ /darwin/) && ENV['TERM_PROGRAM'] == 'iTerm.app'
+      end
+
+      # Returns the name of Core. Used in CLI core selection.
+      #
+      # @api public
+      def to_s
+        "Consular::ITerm Mac OSX iTerm2"
+      end
+
+    end
+
+    # Initializes a reference to the iTerm.app via appscript
+    #
+    # @param [String] path
+    #   Path to Termfile
+    #
+    # @api public
+    def initialize(path)
+      super
+      @terminal = app('iTerm')
+    end
+
+    # Method called by runner to Execute Termfile setup.
+    #
+    # @api public
+    def setup!
+      @termfile[:setup].each { |cmd| execute_command(cmd) }
+    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
+
+    # 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
+
+    # 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
+
+    # 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' ? active_tab : open_tab(_options) && active_tab
+        end
+
+        _first_run = false
+        commands = prepend_befores _content[:commands], content[:before]
+        commands = set_title _name, commands
+
+        if content.key? :panes
+          commands.each { |cmd| execute_command cmd, :in => _tab }
+          execute_panes content
+          content.delete :panes
+        else
+          commands.each { |cmd| execute_command cmd, :in => _tab }
+        end
+      end
+    end
+
+    # Execute the tab and associated panes with the designated content
+    #
+    # @param [Hash] content
+    #   The Context containing panes.
+    #
+    # @api public
+    def execute_panes(content)
+      panes    = content[:panes]
+      commands = content[:tabs][:commands]
+      top_level_pane_split panes, commands
+    end
+
+    # Execute commands in the context of a top level pane
+    #
+    # @param [Hash] panes
+    #   Pane contexts.
+    # @param [Array] commands
+    #   Current context tab commands.
+    #
+    # @api public
+    def top_level_pane_split(panes, commands)
+      first_pane      = true
+
+      panes.keys.sort.each do |pane_key|
+        pane_content  = panes[pane_key]
+        pane_commands = pane_content[:commands]
+
+        vertical_split if first_pane
+        execute_pane_commands(pane_commands,commands)
+
+        if pane_content.key?(:panes)
+          select_pane('Left') if first_pane
+          execute_subpanes pane_content[:panes], commands
+          pane_content.delete :panes
+        end
+
+        first_pane = false if first_pane
+      end
+
+    end
+
+    # Execute commands in the context of sub panes
+    #
+    # @param [Array] subpanes
+    #   Sub panes for the top level pane
+    # @param [Array] tabcommands
+    #   Tab commands
+    #
+    # @api public
+    def execute_subpanes(subpanes, tab_commands)
+      subpanes.keys.sort.each do |subpane_key|
+        subpane_commands = subpanes[subpane_key][:commands]
+        horizontal_split
+        execute_pane_commands(subpane_commands, tab_commands)
+        select_pane 'Right'
+      end
+    end
+
+    # Execute the commands within a pane
+    #
+    # @param [Array] pane_commands
+    #   Commands for the designated pane.
+    # @param [Array] tab_commands
+    #   Commands for the designated tabs.
+    #
+    # @api public
+    def execute_pane_commands(pane_commands, tab_commands)
+      pane_commands = (tab_commands || []) + (pane_commands || [])
+      pane_commands.each { |cmd| execute_command cmd }
+    end
+
+    # Split the active tab with vertical panes
+    #
+    # @api public
+    def vertical_split
+      call_ui_action "Shell", nil, "Split Vertically with Current Profile"
+    end
+
+    # Split the active tab with horizontal panes
+    #
+    # @api public
+    def horizontal_split
+      call_ui_action "Shell", nil, "Split Horizontally with Current Profile"
+    end
+
+    # to select panes; iTerm's Appscript select method does not work
+    # as expected, we have to select via menu instead
+    # 
+    # @param [String] direction
+    #   Direction to split the pane. The valid directions are:
+    #   'Above', 'Below', 'Left', 'Right'
+    #
+    # @api public
+    def select_pane(direction)
+      valid_directions = %w[Above Below Left Right]
+      if valid_directions.include?(direction)
+        call_ui_action("Window", "Select Split Pane", "Select Pane #{direction}")
+      else
+        puts "Error: #{direction} is not a valid direction to select a pane; Only Above/Below/Left/Right are valid directions"
+      end
+    end
+
+
+    # Opens a new tab and focuses on it.
+    #
+    # @param [Hash] options
+    #   Additional options to further customize the tab.
+    #
+    # @api public
+    def open_tab(options = nil)
+      active_window.launch_ :session => 'New session'
+    end
+
+    # Opens a new window and focuses
+    # on the new tab.
+    #
+    # @param [Hash] options
+    #   Additional options to further customize the window.
+    #
+    # @api public
+    def open_window(options = nil)
+      window = @terminal.make :new => :terminal
+      window.launch_ :session => 'New session'
+    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 = {})
+      context = options[:in] || active_tab
+      context.write :text => cmd
+    end
+
+    # Returns the active tab e.g the active terminal session.
+    #
+    # @api public
+    def active_tab
+      active_window.current_session
+    end
+
+    # Returns the active window/tab e.g the active terminal window.
+    #
+    # @api public
+    def active_window
+      @terminal.current_terminal
+    end
+
+    # Returns a reference to the iTerm menu bar.
+    #
+    # @api public
+    def iterm_menu
+      _process = app("System Events").processes["iTerm"]
+      _process.menu_bars.first
+    end
+
+    # Execute the menu action via UI.
+    #
+    # @param [String] menu
+    #   Top level menu name
+    # @param [String] submenu
+    #   Sub level menu name
+    # @param [String] action
+    #   Action name/description.
+    #
+    # @example
+    #   @core.call_ui_action 'Edit', 'Find', 'Find Next'
+    #   @core.call_ui_action 'Shell', nil, 'Split Vertically With Same Profile'
+    #
+    # @api public
+    def call_ui_action(menu, submenu, action)
+      menu = iterm_menu.menu_bar_items[menu].menus[menu]
+      menu = menu.menu_items[submenu].menus[submenu] if submenu
+      menu.menu_items[action].click
+    end
+
+  end
+end

data/lib/consular/iterm_dsl.rb

@@ -0,0 +1,40 @@
+module Consular
+  module ITermDSL
+
+    # Generates a pane in the terminal. These can be nested to
+    # create horizontal panes. Vertical panes are created with each top
+    # level nest.
+    #
+    # @param [Array<String>] args
+    #   Array of comamnds
+    # @param [Proc] block
+    #   Block of code to execute in pane context.
+    #
+    # @example
+    #
+    #   pane "top"
+    #   pane { pane "uptime" }
+    #
+    # @api public
+    def pane(*args, &block)
+      @_context[:panes] = {} unless @_context.has_key? :panes
+      panes             = @_context[:panes]
+      pane_name         = "pane#{panes.keys.size}"
+
+      if block_given?
+        pane_contents = panes[pane_name] = {:commands => []}
+        if @_context.has_key? :is_top_pane
+          run_context pane_contents[:commands], &block
+        else
+          pane_contents[:is_top_pane] = true
+          run_context pane_contents, &block
+        end
+      else
+        panes[pane_name] = { :commands => args }
+      end
+    end
+
+  end
+end
+
+Consular::DSL.class_eval { include Consular::ITermDSL }

data/spec.watchr

@@ -0,0 +1,67 @@
+ENV["WATCHR"] = "1"
+system 'clear'
+
+def growl(message)
+  growlnotify = `which growlnotify`.chomp
+  if not growlnotify.empty?
+    title = "Watchr Test Results"
+    image = message.include?('0 failures, 0 errors') ? "~/.watchr_images/passed.png" : "~/.watchr_images/failed.png"
+    options = "-w -n Watchr --image '#{File.expand_path(image)}' -m '#{message}' '#{title}'"
+    system %(#{growlnotify} #{options} &)
+  else
+    puts message
+  end
+end
+
+def run(cmd)
+  puts(cmd)
+  `#{cmd}`
+end
+
+def run_test_file(file)
+  system('clear')
+  result = run(%Q(ruby -I"lib:test" -rubygems #{file}))
+  growl result.split("\n").last rescue nil
+  puts result
+end
+
+def run_all_tests
+  system('clear')
+  result = run "rake spec"
+  growl result.split("\n").last rescue nil
+  puts result
+end
+
+def related_test_files(path)
+  Dir['spec/**/*.rb'].select { |file| file =~ /#{File.basename(path).split(".").first}_spec.rb/ }
+end
+
+def run_suite
+  run_all_tests
+end
+
+watch('spec/spec_helper\.rb') { run_all_tests }
+watch('spec/(.*).*_spec\.rb') { |m| run_test_file(m[0]) }
+watch('lib/.*/.*\.rb') { |m| related_test_files(m[0]).map {|tf| run_test_file(tf) } }
+
+# Ctrl-\
+Signal.trap 'QUIT' do
+  puts " --- Running all tests ---\n\n"
+  run_all_tests
+end
+
+@interrupted = false
+
+# Ctrl-C
+Signal.trap 'INT' do
+  if @interrupted then
+    @wants_to_quit = true
+    abort("\n")
+  else
+    puts "Interrupt a second time to quit"
+    @interrupted = true
+    Kernel.sleep 1.5
+    # raise Interrupt, nil # let the run loop catch it
+    run_suite
+  end
+end

data/spec/fixtures/bar.term

@@ -0,0 +1,27 @@
+pane "top"
+
+window do
+  pane do
+    run "ls"
+    pane "uptime"
+  end
+
+  pane "ps"
+  run  "default"
+  tab  "echo"
+
+  pane "test"
+end
+
+window do
+  run 'tab1'
+
+  pane "second window"
+
+  pane do
+    run  "second pane"
+    pane "third pane"
+  end
+
+  tab "tab2"
+end

data/spec/iterm_dsl_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Consular::ITermDSL do
+
+  before do
+    @dsl = Consular::DSL.new File.expand_path('../fixtures/bar.term', __FILE__)
+  end
+
+  it "includes itself into Consular::DSL" do
+    assert_includes Consular::DSL.included_modules, Consular::ITermDSL
+  end
+
+  describe ".to_hash" do
+    before do
+      @result = @dsl.to_hash
+    end
+
+    it "returns the default window pane" do
+      assert_equal ['top'], @result[:windows]['default'][:panes]['pane0'][:commands]
+    end
+
+    it "returns the first window first panes" do
+      @window1 = @result[:windows]['window1']
+
+      assert @window1[:panes]['pane0'][:is_top_pane], "that this is marked as top most pane"
+      assert_equal ['ls'],     @window1[:panes]['pane0'][:commands]
+      assert_equal ['uptime'], @window1[:panes]['pane0'][:panes]['pane0'][:commands]
+    end
+
+    it "returns the first window's second pane" do
+      @window1 = @result[:windows]['window1']
+      assert_equal ['ps'],    @window1[:panes]['pane1'][:commands]
+      assert_equal ['test'],  @window1[:panes]['pane2'][:commands]
+    end
+
+    it "still returns tabs correctly" do
+      @window1 = @result[:windows]['window1']
+
+      assert_equal ['echo'],    @window1[:tabs]['tab1'][:commands]
+      assert_equal ['default'], @window1[:tabs]['default'][:commands]
+    end
+
+    it "still returns multiple windows" do
+      @window2 = @result[:windows]['window2']
+
+      assert @window2[:panes]['pane1'][:is_top_pane], "that this is marked as top most pane"
+
+      assert_equal ['second window'], @window2[:panes]['pane0'][:commands]
+      assert_equal ['second pane'],   @window2[:panes]['pane1'][:commands]
+      assert_equal ['third pane'],    @window2[:panes]['pane1'][:panes]['pane0'][:commands]
+
+      assert_equal ['tab1'], @window2[:tabs]['default'][:commands]
+      assert_equal ['tab2'], @window2[:tabs]['tab1'][:commands]
+    end
+
+  end
+
+end

data/spec/iterm_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Consular::ITerm do
+  before do
+    @core = Consular::ITerm.new File.expand_path('../fixtures/bar.term', __FILE__)
+  end
+
+  it "should return name of core with #to_s" do
+    assert_equal "Consular::ITerm Mac OSX iTerm2", Consular::ITerm.to_s
+  end
+
+  it "should add itself to Consular cores" do
+    assert_includes Consular.cores, Consular::ITerm
+  end
+
+  it "should set ivars on .initialize" do
+    refute_nil @core.instance_variable_get(:@termfile)
+    refute_nil @core.instance_variable_get(:@terminal)
+  end
+
+  it "should prepend commands with .prepend_befores" do
+    assert_equal ['ps', 'ls'], @core.prepend_befores(['ls'], ['ps'])
+    assert_equal ['ls'],       @core.prepend_befores(['ls'])
+  end
+
+  it "should set .set_title" do
+    assert_equal ["PS1=\"$PS1\\[\\e]2;hey\\a\\]\"",'ls'], @core.set_title('hey', ['ls'])
+    assert_equal ['ls'],                                  @core.set_title(nil,   ['ls'])
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+gem 'minitest'
+require 'minitest/autorun'
+require File.expand_path('../../lib/consular/iterm', __FILE__)
+
+
+class ColoredIO
+  ESC = "\e["
+  NND = "#{ESC}0m"
+
+  def initialize(io)
+    @io = io
+  end
+
+  def print(o)
+    case o
+    when "."
+      @io.send(:print, "#{ESC}32m#{o}#{NND}")
+    when "E"
+      @io.send(:print, "#{ESC}33m#{o}#{NND}")
+    when "F"
+      @io.send(:print, "#{ESC}31m#{o}#{NND}")
+    else
+      @io.send(:print, o)
+    end
+  end
+
+  def puts(*o)
+    super
+  end
+end
+
+MiniTest::Unit.output = ColoredIO.new(MiniTest::Unit.output)

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: consular-iterm
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Arthur Chiu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-02 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: consular
+  requirement: &2161515360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2161515360
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &2161514880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161514880
+description: Terminal Automation for ITerm via Consular
+email:
+- mr.arthur.chiu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- consular-iterm.gemspec
+- lib/consular/iterm.rb
+- lib/consular/iterm_dsl.rb
+- spec.watchr
+- spec/fixtures/bar.term
+- spec/iterm_dsl_spec.rb
+- spec/iterm_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.github.com/achiu/consular-iterm
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: consular-iterm
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Automate your ITerm with Consular
+test_files:
+- spec/fixtures/bar.term
+- spec/iterm_dsl_spec.rb
+- spec/iterm_spec.rb
+- spec/spec_helper.rb