myterm 0.0.3

data/._repath.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+payload = lambda do
+
+  bin_folder="#{`pwd`.strip}/bin"
+  unless File.directory?(bin_folder)
+    return {
+      :message => "not a directory, won't add to PATH: #{bin_folder}"
+    }
+  end
+
+  path = ENV['PATH']
+  path_parts = path.split(':')
+
+  if path.include?(bin_folder)
+    if true or ARGV.include?('-F')
+      unless path_parts.reject! { |p| p == bin_folder }
+        return {
+          :message => "bin folder \"#{bin_folder}\" not found in path \"#{path}\""
+        }
+      end
+      return {
+        :new_path => ( [bin_folder] + [path_parts] ).join(':'),
+        :message  => "rewriting path to have bin folder at the beginning",
+        :success => true
+      }
+    else
+      if 0 == path.index(bin_folder)
+        return {
+          :message => "bin folder is already at front of PATH",
+          :success => true
+        }
+      else
+        return {
+          :message => "bin folder is in path but not at front.  use -F to rewrite PATH",
+          :status => :not_front,
+          :success => true
+        }
+      end
+    end
+  else
+    path_parts.unshift(bin_folder)
+    return {
+      :new_path => path_parts.join(':'),
+      :message  => "prepending bin folder to the beginning of the PATH.",
+      :success  => true
+    }
+  end
+
+end.call
+
+payload[:message] and $stdout.puts "echo #{payload[:message].inspect}"
+payload[:new_path] and $stdout.puts "export PATH=\"#{payload[:new_path]}\""
+$stdout.puts(payload[:success] ? "echo 'hack done.'" : "echo 'hack failed.'")

data/.gitignore

@@ -0,0 +1,3 @@
+/.DS_Store
+/.__tmp.sh
+/.rvmrc

data/.repath.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+ruby ./._repath.rb 1> .__tmp.sh
+source ./.__tmp.sh

data/.rvmrc.example

@@ -0,0 +1 @@
+rvm use 1.9.2@skylab

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    myterm (0.0.1)
+      highline
+      rb-appscript
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    archive-tar-minitar (0.5.2)
+    columnize (0.3.4)
+    highline (1.6.2)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    rb-appscript (0.6.1)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  myterm!
+  ruby-debug19

data/README.md

@@ -0,0 +1,56 @@
+# myterm
+
+### _(command line api for playing with iTerm)_
+
+## About
+
+`myterm` is a command line interface for customizing iTerm using AppleScript.  Its most useful feature is that it can throw up a big message in the background of your terminal tab to tell you clearly which tab it is.
+
+
+
+
+## Usage
+
+`myterm` attempts to be as self-documenting as possible.  Try `myterm -h` for help.
+
+The most common use case for me personally is something like: 
+
+    myterm bg --exec node server.js
+
+which will display the string "node server.js" up in the background and then run that.
+
+
+
+
+## Requirements
+
+`myterm` needs ImageMagick and its `convert` executable to be in your path.
+
+`myterm` needs some font file to use.  It has an installer that will try to grab the [Simple Life](http://www.dafont.com/simple-life.font) font by Michael Strobel.
+
+Additionally it needs whatever its gem dependencie(s) are, which at the time of this writing are: rb-appscript, highline.
+
+
+
+
+## Installation
+
+`myterm` is a rubygem.  If you are installing it from a git checkout
+(which at the time of this writing is the only way to install it):
+
+    mkdir ~/src; cd ~/src
+    git clone git@github.com:hipe/myterm.git; cd myterm
+    gem build *.gemspec
+    gem install *.gem
+
+
+## Support
+
+I want this to work for you.  Please contact me via email if it does not!
+
+
+
+
+## Credits
+
+`myterm` started life as an adaptation of Dmytro Shteflyuk's script that he used at Scribd as described  [here](http://kpumuk.info/mac-os-x/how-to-show-ssh-host-name-on-the-iterms-background/).  Thank you Dmytro!

data/bin/myterm

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/myterm/cli', __FILE__)
+
+Skylab::Myterm::Cli.new.run ARGV

data/doc/HISTORY.md

@@ -0,0 +1,17 @@
+# myterm Change History
+
+## Release 0.0.3 - 2011-08-06
+
+  * fix issue with transparency - didn't make refactor
+
+
+## Relelase 0.0.2 - 2011-08-04
+
+  * Add installer for default font file when none is found
+  * Optionally use iTerm foreground color for background image foreground color
+  * Total refactor of code: separated into a 'CLI' and an 'API'
+
+
+## Release 0.0.1
+
+  * initial release, creates background images

data/lib/myterm/api.rb

@@ -0,0 +1,189 @@
+module Skylab; end
+module Skylab::Myterm; end
+
+class Skylab::Myterm::ValidationError < RuntimeError ; end
+
+module Skylab::Myterm::Color
+  Myterm = Skylab::Myterm
+  def self.[] obj
+    obj.extend self
+  end
+  def self.dup color
+    self[color.dup]
+  end
+  def alpha= mixed
+    if mixed.kind_of?(String)
+      md = /\A(\d+(?:\.\d+)?)%?\z/.match(mixed) or
+        raise Myterm::ValidationError.new("invalid format for percent #{val.inspect} -- expecting e.g. \"58%\"")
+      mixed = md[1].to_f
+    end
+    (0.0..100.0).include?(mixed) or
+      raise Myterm::ValidationError.new("Percent value (#{mixed}%) must be between 0 and 100 inclusive.")
+    self[3] = Myterm::ChannelScalarNormalized[mixed / 100.0]
+  end
+  def to_hex
+    '#' + self.map{ |x| int_to_hex(x) }.join('')
+  end
+  TargetPlaces = 2  # each component of an #rrggbb hexadecimal color has 2 places
+  Divisor = 16 ** TargetPlaces
+  def int_to_hex int
+    int.respond_to?(:to_hex) and return int.to_hex
+    (int.to_f / Divisor).round.to_s(16).rjust(TargetPlaces, '0')
+  end
+end
+
+module Skylab::Myterm::ChannelScalarNormalized
+  def self.[] obj
+    obj.extend self
+  end
+  def to_hex
+    (('ff'.to_i(16).to_f * self).to_i).to_s(16).rjust(2, '0')
+  end
+end
+
+class Skylab::Myterm::ImageBuilder
+  Myterm = Skylab::Myterm
+  class << self
+    def build_background_image iterm, lines, opts
+      new(iterm, lines, opts).run
+    end
+  end
+  def initialize iterm, lines, opts
+    @iterm, @lines, @opts = [iterm, lines, opts]
+  end
+  attr_reader :iterm
+  def run
+    require 'RMagick'
+    bg_color = Myterm::Color.dup(@iterm.session.background_color)
+    @opts.key?(:alpha_percent) and bg_color.alpha = @opts[:alpha_percent]
+    img = Magick::Image.new(500, 300) do # copying over hard-coded dimensions from original Dmytro script
+      self.background_color = bg_color.to_hex
+    end
+    build_text_drawing img
+    img
+  end
+private
+  def build_text_drawing img
+    @lines.empty? and return fail("foo")
+    #@todo setters for everything etc
+    draw = Magick::Draw.new
+    draw.gravity         = @opts[:gravity] || Magick::NorthEastGravity
+    @opts[:fill] ||= '#662020'
+    @opts[:fill].kind_of?(Proc) and @opts[:fill] = @opts[:fill].call(self)
+    draw.fill            = @opts[:fill]
+    draw.font            = @opts[:font] || "#{ENV['HOME']}/.fonts/SimpleLife.ttf"
+    draw.font_style      = @opts[:font_style] || Magick::NormalStyle
+    draw.pointsize       = @opts[:point_size] || 60
+    draw.text_antialias  = @opts.key?(:text_antialias) ? @opts[:text_antialias] : true
+    draw.annotate(img, 0,0,20,10, @lines.first)
+    if @lines.length > 1
+      second_line = @lines[1..-1].join(' ')
+      draw.annotate(img, 0,0,20,80, second_line) do
+        self.pointsize = 30
+      end
+    end
+    nil # draw not needed at this point
+  end
+end
+
+class Skylab::Myterm::ItermProxy
+  # ItermProxy is a wrapper around everything Iterm to the extent that its AppleScript interface supports
+
+  Myterm = ::Skylab::Myterm # keep top level name out of the bulk of the code
+
+  MinLen = 50
+
+  def bounds= arr
+    x = arr.detect { |i| i.to_s !~ /^\d+$/ } and return invalid("expecting digit had #{x.inspect}")
+    x = arr[2,2].detect { |i| i.to_i < MinLen } and return invalid("too small: #{x} (min: #{MinLen})")
+    app.windows[0].bounds.set arr
+  end
+
+  def bounds
+    app.windows[0].bounds.get
+  end
+
+  def session
+    tty = `tty`.strip
+    @session ||= begin
+      session = catch(:catch_two) do
+        app.terminals.get.each do |term|
+          sessions = term.sessions.get
+          sessions.each do |session|
+            if session.tty.get == tty
+              throw :catch_two, session
+            end
+          end
+        end
+      end
+      session or fail("couldn't ascertain current session!")
+      SessionProxy.new(session)
+    end
+  end
+
+private
+
+  def app
+    @app ||= begin
+      require 'appscript'
+      Appscript.app('iTerm')
+    end
+  end
+
+  def invalid msg
+    raise Myterm::ValidationError.new(msg)
+  end
+end
+
+module Skylab::Myterm::AppscriptDelegator
+  def delegated_attr_readers *list
+    list.each do |property|
+      lambda do |_property|
+        define_method(_property) do
+          @resource.send(_property).get
+        end
+      end.call(property)
+    end
+  end
+  def delegated_attr_writers *list
+    list.each do |property|
+      lambda do |_property|
+        define_method("#{_property}=") do |val|
+          @resource.send(_property).set val
+        end
+      end.call(property)
+    end
+  end
+  def delegated_attr_accessors *list
+    delegated_attr_readers(*list)
+    delegated_attr_writers(*list)
+  end
+end
+
+class Skylab::Myterm::ItermProxy::SessionProxy
+  Myterm = Skylab::Myterm
+  def initialize session
+    @resource = session
+  end
+  extend Myterm::AppscriptDelegator
+
+  delegated_attr_accessors :background_image_path
+  delegated_attr_readers :tty
+
+  def background_color
+    Myterm::Color[@resource.background_color.get]
+  end
+
+  def foreground_color
+    Myterm::Color[@resource.foreground_color.get]
+  end
+end
+
+module Skylab::Myterm::ChannelScalarNormalized
+  def self.[] obj
+    obj.extend self
+  end
+  def to_hex
+    (('ff'.to_i(16).to_f * self).to_i).to_s(16).rjust(2, '0')
+  end
+end

data/lib/myterm/cli.rb

@@ -0,0 +1,149 @@
+require "#{File.expand_path('../vendor/face/cli', __FILE__)}"
+require "#{File.dirname(__FILE__)}/api"
+require 'ruby-debug'
+require 'open3'
+
+module Skylab; end
+module Skylab::Myterm; end
+
+module Skylab::Myterm::PathPrettifier
+  HomeDirRe = /\A#{Regexp.escape(ENV['HOME'])}/
+protected
+  def pretty_path path
+    path.sub(HomeDirRe, '~')
+  end
+end
+
+class Tmx::Face::Command
+  include Skylab::Myterm::PathPrettifier
+end
+
+class Skylab::Myterm::Cli < Tmx::Face::Cli
+  Myterm = ::Skylab::Myterm # don't use fully qualified name internally
+  include Myterm::PathPrettifier
+
+  version do
+    require "#{File.dirname(__FILE__)}/version"
+    Myterm::VERSION
+  end
+
+  o(:bounds) do |o|
+    syntax "#{path} [x y width height]"
+    o.banner = "gets/sets the bounds of the terminal window\n#{usage_string}"
+  end
+
+  def bounds o, *a
+    case a.length
+    when 4
+      begin ; iterm.bounds = a ; rescue Myterm::ValidationError => e ; return usage e ; end
+    when 0
+      @err.puts iterm.bounds.inspect
+    else
+      return usage("bad number of args #{a.length}: expecting 0 or 4")
+    end
+  end
+
+  o(:'bg') do |o, req|
+    syntax "#{path} [opts] [<text> [<text> [...]]]"
+    o.banner = "Generate a background image with certain text for the terminal\n#{usage_string}"
+    o.on('-e', '--exec <cmd ...>', 'Execute <cmd ...> in shell, also use it as text for background.') { }
+    o.on('-o', '--opacity PERCENT', "Percent by which to make image background opaque",
+      "(0%: tranparent. 100%: solid.  Default: solid)") { |amt| req[:alpha_percent] = amt }
+    req[:font_file] = DefaultFontFile
+    o.on('--font FONTFILE.ttf', "font to use (default: #{pretty_path(req[:font_file])})") do |path|
+      req[:font_file] = path
+    end
+    req[:fill] = '#662020'
+    o.on('--fill[=COLOR]', "Write text in this color (default: #{req[:fill].inspect})",
+      "(when present but with no value, will use \"Text/Normal\" setting of current iTerm tab)" ) do |v|
+      req[:fill] = v || lambda { |img| img.iterm.session.foreground_color.to_hex }
+    end
+    o.on('-v', '--verbose', 'Be verbose.') { req[:verbose] = true }
+  end
+
+  def before_parse_bg req, args
+    idx = args.index { |s| %w(-e --exec).include?(s) } or return true
+    req[:_exec_this] = args[(idx+1)..-1]
+    args.replace idx == 0 ? [] : args[0..(idx-1)]
+    true
+  end
+  protected :before_parse_bg
+
+  def bg req, *args
+    if args.empty?
+      if req[:_exec_this]
+        args.any? and fail("logic error -- see before_parse_bg.")
+        args = req[:_exec_this]
+      else
+        return get_background
+      end
+    end
+    check_font(req) or return
+    img = Myterm::ImageBuilder.build_background_image(iterm, args, req) or return false
+    req[:verbose] and @err.puts "(bg_color: #{img.background_color.inspect})"
+    outpath = "#{ImgDirname}/#{ImgBasename}.#{Process.pid}.png"
+    img.write(outpath)
+    req[:verbose] and @err.puts "(setting background image to: #{outpath})" # doesn't care if --verbose
+    iterm.session.background_image_path = outpath
+    if req[:_exec_this]
+      @err.puts "(#{program_name} executing: #{req[:_exec_this].join(' ')})"
+      exec(req[:_exec_this].join(' '))
+    end
+    true
+  end
+
+  DefaultFontFile = "#{ENV['HOME']}/.fonts/MytermDefaultFont.ttf"
+  ImgDirname  = '/tmp'
+  ImgBasename = 'iTermBG'
+
+private
+  def check_font req
+    File.exist?(req[:font_file]) and return true
+    if req[:font_file] == DefaultFontFile
+      return maybe_download_font req
+    else
+      font_not_found req
+    end
+  end
+
+  DefaultFontUrl              = 'http://img.dafont.com/dl/?f=simple_life'
+  DefaultFontFileNotSimlinked = "#{ENV['HOME']}/.fonts/SimpleLife.ttf"
+
+  def maybe_download_font req
+    target = DefaultFontFileNotSimlinked
+    File.exist?(target) and return true
+    $stdin.tty? && $stdout.tty? or return font_not_found(req)
+    @err.write "Font file #{pretty_path(req[:font_file])} not found.  "
+    require 'highline'
+    require 'fileutils'
+    HighLine.new.agree("Let #{program_name} download it? (Y/n) (recommended: yes)") or return false
+    outfile = DefaultFontFileNotSimlinked.sub(/\.ttf$/, '.zip')
+    font_dir = File.dirname(outfile)
+    File.directory?(font_dir) or FileUtils.mkdir_p(font_dir, :verbose => true)
+    cmds = ["wget -O #{outfile} #{DefaultFontUrl}"]
+    cmds.push "cd #{font_dir}"
+    cmds.push "unzip #{outfile}"
+    cmds.push "ln -s #{DefaultFontFileNotSimlinked} #{DefaultFontFile}"
+    cmds.push("echo 'finished installing for #{program_name}: #{pretty_path(DefaultFontFileNotSimlinked)}. " <<
+      "Please try using it again.'")
+    @err.puts(cmd = cmds.join(' ; '))
+    exec(cmd)
+  end
+
+  def font_not_found req
+    @err.puts "font file not found: #{pretty_path(req[:font_file])}"
+    req.command.usage
+    return false
+  end
+
+  def iterm
+    @iterm ||= Myterm::ItermProxy.new
+  end
+
+  def get_background
+    @err.puts "tty: #{iterm.session.tty}"
+    @err.puts "background_image: #{iterm.session.background_image_path.inspect}"
+    @err.puts "background_color: #{iterm.session.background_color}"
+  end
+
+end

data/lib/myterm/vendor/face/cli.rb

@@ -0,0 +1,391 @@
+require 'optparse'
+
+# an ultralight command-line parser (391 lines)
+# that wraps around OptParse (can do anything it does)
+# with colors
+# with flexible command-like options ('officious' like -v, -h)
+# with commands with arguments based off of method signatures
+# with subcommands, (namespaces) arbitrarily deeply nested
+
+module Tmx; end
+module Tmx::Face; end
+
+module Tmx::Face::Colors
+  def bold str ; style str, :bright, :green end
+  def hi   str ; style str, :green          end
+  def ohno str ; style str, :red            end
+  def yelo str ; style str, :yellow         end
+  Styles = { :bright => 1, :red => 31, :yellow => 33, :green => 32, :cyan => 36 }
+  Esc = "\e"  # "\u001b" ok in 1.9.2
+  def style str, *styles
+    nums = styles.map{ |o| o.kind_of?(Integer) ? o : Styles[o] }.compact
+    "#{Esc}[#{nums.join(';')}m#{str}#{Esc}[0m"
+  end
+  def highlight_header str
+    str.sub(/\A([^:]+:)/) { "#{hi($1)}" }
+  end
+end
+
+module Tmx::Face
+  class Command
+
+    include Colors
+
+    def initialize name, *rest, &block
+      rest.any? and
+        raise ArgumentError.new("too many args for command: #{rest.inspect}")
+      @parser_definition = block # nil ok
+      @intern = name.to_sym
+    end
+
+    class << self
+      alias_method :build, :new
+    end
+
+    def build_option_parser req
+      parser = build_empty_option_parser
+      # we set the default value for the banner after we run the block
+      # to give the client the chance to set the syntax.
+      ugly, ugly_id = [parser.banner.dup, parser.banner.object_id]
+      if @parser_definition
+        args = [parser, req]
+        @parser_definition.arity > 0 and args = args[0, @parser_definition.arity]
+        instance_exec(*args, &@parser_definition)
+      end
+      if ugly == parser.banner && ugly_id = parser.banner.object_id
+        parser.banner = usage_string
+      end
+      parser
+    end
+
+    def for_run parent, name_as_used
+      self.parent = parent
+      @out = @parent.out
+      @err = @parent.err
+      @name_as_used = name_as_used
+      self # careful
+    end
+
+    def method
+      @parent.method method_symbol
+    end
+
+    def method_symbol
+      @intern.to_s.downcase.gsub(/[^a-z0-9]+/, '_').intern
+    end
+
+    def name
+      @intern.to_s
+    end
+
+    def parse argv
+      req = { }
+      req.send(:instance_variable_set, '@method_parameters', argv)
+      class << req
+        attr_accessor :method_parameters, :command
+      end
+      @parent_protected_instance_methods.include?("before_parse_#{@intern}".intern) and
+        ! @parent.send("before_parse_#{@intern}", req, argv) and return false
+      begin
+        build_option_parser(req).parse! argv
+        req
+      rescue OptionParser::ParseError => e
+        @out.puts highlight_header(e.to_s)
+        invite
+        nil
+      end
+    end
+
+    def summary
+      build_option_parser({}).to_s.
+        sub(/\A#{Regexp.escape(hi('usage:'))} /, '').
+        split("\n").select{ |s| ! s.strip.empty? }
+    end
+
+    def syntax *args
+      case args.length
+      when 0; @syntax ||= "#{invocation_string} [opts] [args]"
+      when 1; @syntax = args.first
+      else raise ArgumentError.new("expecting 0 or 1 argument")
+      end
+    end
+
+    def usage_string
+      "#{hi('usage:')} #{syntax}"
+    end
+
+    module Nodeish
+      def build_empty_option_parser
+        OptionParser.new
+      end
+      def invite
+        @err.puts "Try #{hi("#{invocation_string} -h")} for help."
+        nil
+      end
+      def invocation_string
+        "#{@parent.invocation_string} #{name}"
+      end
+      alias_method :path, :invocation_string
+      def parent= parent
+        @parent and fail("won't overwrite existing parent")
+        @parent_protected_instance_methods = parent.class.protected_instance_methods(false).map(&:intern)
+        @parent = parent
+      end
+      def usage msg=nil
+        msg and @err.puts(msg)
+        @err.puts usage_string
+        invite
+      end
+      alias_method :empty_argv, :usage
+    end
+    include Nodeish
+
+    module TreeDefiner
+      def command_tree
+        @command_tree ||= begin
+          defined = command_definitions.map { |cls, a, b| cls.build(*a, &b) }
+          defined_m = defined.map(&:method_symbol).compact
+          implied_m = public_instance_methods(false).map(&:intern) - defined_m
+          implied = implied_m.map { |m| Command.new(m) }
+          Treeish[ defined + implied ]
+        end
+      end
+      # this is nutty: for classes that extend this module, this is
+      # something that is triggered when they are subclasses
+      def inherited cls
+        cls.on('-h', '--help', 'show this screen') { help }
+        # You can rewrite the above in your class with another call to on()
+        # If you want to remove it, try:
+        #   option_definitions.reject! { |a,_| '-h' == a.first }
+      end
+      def namespace name, &block
+        command_definitions.push [Namespace, [name], block]
+      end
+      def on *a, &b
+        block_given? or raise ArgumentError.new("block required")
+        option_definitions.push [a, b]
+      end
+      def option_definitions
+        @option_definitions ||= []
+      end
+      def command_definitions
+        @command_definitions ||= []
+      end
+      def method_added name
+        if @grab_next_method
+          command_definitions.last[1][0] = name.to_sym
+          @grab_next_method = false
+        end
+      end
+      def option_parser *a, &b
+        block_given? or raise ArgumentError.new("block required")
+        if a.empty?
+          @grab_next_method and fail("can't have two anonymous " <<
+          "command definitions in a row.")
+          @grab_next_method = true
+          a = [nil]
+        end
+        command_definitions.push [Command, a, b]
+      end
+      alias_method :o, :option_parser
+    end
+
+    module Treeish
+      def self.[] ary
+        ary.extend self
+      end
+      def ambiguous_command found, given
+        usage("Ambiguous command: #{given.inspect}. " <<
+          " Did you mean #{found.map{ |c| hi(c.name) }.join(' or ')}?")
+      end
+      def command_tree
+        @command_tree ||= begin
+          interface.command_tree.map { |c| c.parent = self; c } # careful
+        end
+      end
+      def expecting
+        interface.command_tree.map(&:name) * '|'
+      end
+      def find_command argv
+        argv.empty? and return empty_argv # should be just for n/s
+        given = argv.first
+        matcher = Regexp.new(/\A#{Regexp.escape(given)}/)
+        found = []
+        interface.command_tree.each do |cmd|
+          given == cmd.name and found = [cmd] and break
+          matcher.match(cmd.name) and found.push(cmd)
+        end
+        case found.size
+        when 0 ; unrecognized_command given
+        when 1 ; found.first.for_run(self, argv.shift)
+        else   ; ambiguous_command found, given
+        end
+      end
+      Indent = '  '
+      def help
+        option_parser and @err.puts option_parser
+        cmds = command_tree
+        if cmds.any?
+          @err.puts hi('commands:')
+          rows = cmds.map { |c| { :name => c.name, :lines => c.summary } }
+          w = rows.map{ |d| d[:name].length }.inject(0){ |m, l| m > l ? m : l }
+          fmt = "%#{w}s  "
+          rows.each do |row|
+            @out.puts "#{Indent}#{hi(fmt % row[:name])}#{row[:lines].first}"
+            row[:lines][1..-1].each do |line|
+              @out.puts "#{Indent}#{fmt % ''}#{line}"
+            end
+          end
+          @err.puts("Try #{hi("#{invocation_string} [cmd] -h")} for command help.")
+        end
+      end
+      def option_parser
+        @option_parser.nil? or return @option_parser
+        op = build_empty_option_parser
+        op.banner = usage_string
+        if interface.option_definitions.any?
+          shorts = interface.option_definitions.map do |args, block|
+            op.on(*args) { instance_eval(&block) }
+            args.first
+          end
+          op.banner << "\n       #{invocation_string} {#{shorts * '|'}}"
+          op.banner << "\n" << hi('options:')
+        end
+        @option_parser = op
+      end
+      def run_opts argv
+        begin
+          option_parser.parse! argv
+        rescue OptionParser::ParseError => e
+          @err.puts highlight_header(e.to_s)
+          invite
+        end
+        if argv.any?
+          @err.puts "(#{hi('ignoring:')} #{argv.map(&:inspect).join(', ')})"
+        end
+        true
+      end
+      def unrecognized_command given
+        usage("Unrecognized command: #{given.inspect}. Expecting: #{hi expecting}")
+      end
+      def usage_string
+        "#{hi('usage:')} #{invocation_string} " <<
+          "{#{interface.command_tree.map(&:name)*'|'}} [opts] [args]"
+      end
+    end
+
+    class Namespace
+      extend TreeDefiner, Colors
+      include Treeish, Nodeish, Colors
+      alias_method :interface, :class
+      def init_for_run parent, name_as_used
+        @name_as_used = name_as_used
+        @parent = parent
+        @out = @parent.out
+        @err = @parent.err
+      end
+      attr_reader :out, :err
+      def name
+        interface.namespace_name
+      end
+      alias_method :inspect, :name
+      def self.build name, &block
+        name = name.to_s
+        Class.new(self).class_eval do
+          self.namespace_name = name
+          x = class << self; self end
+          x.send(:define_method, :inspect) { "#<#{name}:Namespace>" }
+          x.send(:alias_method, :to_s, :inspect)
+          class_eval(&block)
+          self
+        end
+      end
+
+      class << self
+        def for_run parent, name_as_used
+          namespace_runner = new
+          namespace_runner.init_for_run parent, name_as_used
+          namespace_runner
+        end
+        def method_symbol
+          nil # for compat with etc
+        end
+        def name
+          @namespace_name
+        end
+        def namespace_name= ns_name
+          @namespace_name = ns_name.to_s
+        end
+        attr_reader :namespace_name
+        def parent= parent
+          @parent and fail("won't overwrite parent")
+          @parent = parent
+        end
+        def summary
+          a = command_tree.map { |c| hi(c.name) }
+          ["child command#{'s' if a.length != 1}: {#{a * '|'}}"]
+        end
+      end
+    end
+  end
+end
+
+class Tmx::Face::Cli
+  extend Tmx::Face::Command::TreeDefiner
+  include Tmx::Face::Colors
+  include Tmx::Face::Command::Nodeish
+  include Tmx::Face::Command::Treeish
+
+  def initialize
+    @out = $stdout
+    @err = $stderr
+  end
+  attr_reader :out, :err
+  alias_method :interface, :class
+  def argument_error e, cmd
+    e.backtrace[0,2].detect { |s| s.match(/\A[^:]+/)[0] == __FILE__ } or raise e
+    msg = e.message.sub(/\((\d+) for (\d+)\)\Z/) do
+      "(#{$1.to_i - 1} for #{$2.to_i - 1})"
+    end
+    cmd.usage msg
+  end
+  def program_name
+    @program_name ||= File.basename($PROGRAM_NAME)
+  end
+  alias_method :invocation_string, :program_name
+  def run argv
+    argv.empty?        and return empty_argv
+    runner = self
+    begin
+      argv.first =~ /^-/ and return runner.run_opts(argv)
+      cmd = runner.find_command(argv)
+    end while (cmd and cmd.respond_to?(:find_command) and runner = cmd)
+    cmd and req = cmd.parse(argv) and
+    begin
+      req.command = cmd
+      runner.send(cmd.method_symbol, req, * req.method_parameters)
+    rescue ArgumentError => e
+      argument_error e, cmd
+    end
+  end
+  def version
+    @err.puts hi([program_name, interface.version].compact.join(' '))
+  end
+  class << self
+    def version *a, &block
+      if a.any? and block
+        raise ArgumentError.new("can't process args and block together.")
+      elsif a.any? or block
+        option_definitions.detect { |arr, _| '-v' == arr[0] } or
+          on('-v', '--version', 'shows version') { version }
+        if block
+          @version = block
+        else
+          @version = a.length == 1 ? a.first : a
+        end
+      else
+        @version.kind_of?(Proc) ? @version.call : @version
+      end
+    end
+  end
+end

data/lib/myterm/version.rb

@@ -0,0 +1,4 @@
+module Skylab; end
+module Skylab::Myterm
+  VERSION = "0.0.3"
+end

data/lib-iterm.sh

@@ -0,0 +1,163 @@
+#!/usr/bin/env bash
+
+## NOTE for `iterm` users -- this file is not used: it is here for reference.
+## (it lives in a different git repository)
+
+# adapted from http://kpumuk.info/mac-os-x/how-to-show-ssh-host-name-on-the-iterms-background/
+
+HEIGHT_TALL=750
+WIDTH_NARROW=600
+WIDTH_SCROLLBAR=15
+HEIGHT_TITLEBAR_TABS=44
+
+# arr=($(iterm_bounds_get))
+function iterm_bounds_get {
+  local size=( $(
+    osascript -e "
+      tell application \"iTerm\"
+        get the bounds of the first window
+      end tell" | tr ',' ' '
+  ) )
+  echo "${size[@]}"
+}
+
+function iterm_bounds_set {
+  if [[ ! "$1,$2,$3,$4" =~ "^[0-9]+,[0-9]+,[0-9]+,[0-9]+$" ]] ; then
+    echo "bad args to item_bounds_set: ($1, $2, $3, $4)"
+    return
+  fi
+  local exec_me="
+    tell application \"iTerm\"
+      set the bounds of the first window to {$1, $2, $3, $4}
+    end tell
+  "
+  osascript -e "$exec_me"
+}
+
+function iterm_dimensions_get {
+  local size=($(iterm_bounds_get))
+  local x1=${size[0]} y1=${size[1]} x2=${size[2]} y2=${size[3]}
+  local w=$(( $x2 - $x1 - $WIDTH_SCROLLBAR))
+  local h=$(( $y2 - $y1 - $HEIGHT_TITLEBAR_TABS))
+  echo "${w}x${h}"
+}
+
+function iterm_dimensions_set {
+  local w=$1 h=$2
+  local b=($(iterm_bounds_get))
+  local x=${b[0]} y=${b[1]}
+  iterm_bounds_set $x $y $w $h
+}
+
+# check to see if we have the correct terminal for doing this kind of thing
+# this won't work when we sudo something because TERM_PROGRAM isn't picked up
+function iterm_ok {
+  if [ "$(tty)" == 'not a tty' ] || [ "$TERM_PROGRAM" != "iTerm.app" ] ; then
+    echo ''
+  else
+    echo 'ok'
+  fi
+}
+
+function iterm_set {
+  local prop=$1
+  local val=$2
+  local tty=$(tty)
+  osascript -e "
+    tell application \"iTerm\"
+      repeat with theTerminal in terminals
+        tell theTerminal
+          try
+            tell session id \"$tty\"
+              set bounds of window 1 to \"$val\"
+            end tell
+            on error errmesg number errn
+          end try
+        end tell
+      end repeat
+    end tell
+  "
+}
+
+function iterm_bg_image_make {
+  local text1=$1
+  local text2=$2
+  local color_bg=${3:-#000000}
+  local color_fg=${4:-#662020}
+  local dimensions=$(iterm_dimensions_get)
+  local font_ttf=${5:-$HOME/.bash/resources/SimpleLife.ttf}
+  local font_points=${6:-60}
+  local font_style=${7:-Normal} # Font style (Any, Italic, Normal, Oblique)
+  local gravity=${8:-NorthEast}
+      # Text gravity (NorthWest, North, NorthEast,
+      # West, Center, East, SouthWest, South, SouthEast)
+  local offset1=${8:-20,10}
+  local offset2=${9:-20,80}
+  local outpath="/tmp/iTermBG.$$.png"
+  convert \
+    -size "$dimensions" xc:"$color_bg" -gravity "$gravity" -fill "$color_fg" \
+    -font "$font_ttf" -style "$font_style" -pointsize "$font_points" \
+    -antialias -draw "text $offset1 '$text1'" \
+    -pointsize 30 -draw "text $offset2 '$text2'" \
+    "$outpath"
+  echo $outpath
+}
+
+function iterm_bg_image_delete {
+  local path=${1:-/tmp/itermBG.$$.png}
+  rm $path
+}
+
+function iterm_bg_image_empty {
+  local opath="/tmp/iTermBG.empty.png"
+  if [ ! -f /tmp/iTermBG.empty.png ]; then
+    local dims=$(iterm_dimensions_get)
+    convert -size "$dims" xc:"#000000" "$opath"
+  fi
+  echo $opath
+}
+
+function iterm_bg_image_set {
+  local tty=$(tty)
+  osascript -e "
+    tell application \"iTerm\"
+      repeat with theTerminal in terminals
+        tell theTerminal
+          try
+            tell session id \"$tty\"
+              set background image path to \"$1\"
+            end tell
+            on error errmesg number errn
+          end try
+        end tell
+      end repeat
+    end tell
+  "
+}
+
+function iterm_bg_color_set {
+  local tty=$(tty)
+  osascript -e "
+    tell application \"iTerm\"
+      repeat with theTerminal in terminals
+        tell theTerminal
+          try
+            tell session id \"$tty\"
+              set background image path to \"\"
+              set background color to \"$1\"
+            end tell
+            on error errmesg number errn
+          end try
+        end tell
+      end repeat
+    end tell
+  "
+}
+
+function iterm_window_title_set {
+  osascript -e "
+    tell application \"iTerm\"
+      set the name of the first window to \"$1\"
+    end tell
+  "
+}

data/myterm.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "myterm/version"
+
+Gem::Specification.new do |s|
+  s.name        = "myterm"
+  s.version     = Skylab::Myterm::VERSION
+  s.authors     = ["Mark Meves"]
+  s.email       = ["mark.meves@gmail.com"]
+  s.homepage    = "http://botnoise.org"
+  s.summary     = %q{Command line interface for customizing iTerm using AppleScript}
+  s.description = %q{Command line interface for customizing iTerm using AppleScript.
+    Creates meaningful, salient, eye-catching background images that help to discern between iTerm windows.}.gsub(/\n */, ' ')
+
+  s.rubyforge_project = "myterm"
+
+  s.add_dependency 'rb-appscript'
+  s.add_dependency 'highline'
+  s.add_development_dependency "ruby-debug19"
+
+  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"]
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: myterm
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Mark Meves
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-06 00:00:00.000000000 -04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb-appscript
+  requirement: &70161455195900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70161455195900
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: &70161455195480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70161455195480
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &70161455195060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70161455195060
+description: Command line interface for customizing iTerm using AppleScript. Creates
+  meaningful, salient, eye-catching background images that help to discern between
+  iTerm windows.
+email:
+- mark.meves@gmail.com
+executables:
+- myterm
+extensions: []
+extra_rdoc_files: []
+files:
+- ._repath.rb
+- .gitignore
+- .repath.sh
+- .rvmrc.example
+- Gemfile
+- Gemfile.lock
+- README.md
+- bin/myterm
+- doc/HISTORY.md
+- lib-iterm.sh
+- lib/myterm/api.rb
+- lib/myterm/cli.rb
+- lib/myterm/vendor/face/cli.rb
+- lib/myterm/version.rb
+- myterm.gemspec
+has_rdoc: true
+homepage: http://botnoise.org
+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: myterm
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Command line interface for customizing iTerm using AppleScript
+test_files: []