heytmux 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cb566cb530c83ebd00f2dcfb707eb0e992593ee7
+  data.tar.gz: a0a6b6a585a503d1d5ceab93752345b897c125b2
+SHA512:
+  metadata.gz: 3e768bf1f0f205cfe32546253338856ca6d0a6d6742cf8f6ab9244e146be6cf2978823114517cad0554a10ea94e7fbd65e8f54fdeda84a85ed04135a23b4632d
+  data.tar.gz: 2df1f6fcff06149be16865c6991238519f5163bebaca3180c2a410a7dbf764edcadfd404c56b84642599d5cd335848d739037f3f7bc5f544d5bbc41a1decafc4

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in heytmux.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Junegunn Choi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,317 @@
+Hey tmux!
+=========
+
+Tmux scripting made easy.
+
+Installation
+------------
+
+Heytmux requires Ruby 2.0+ and tmux 2.3+.
+
+#### As Ruby gem
+
+```sh
+gem install heytmux
+```
+
+- Installs `heytmux` executable
+
+#### As Vim plugin
+
+Using [vim-plug](https://github.com/junegunn/vim-plug):
+
+```vim
+Plug 'junegunn/heytmux'
+```
+
+- Registers `:Heytmux` command
+- No need to install Gem
+
+Usage
+-----
+
+Create a YAML file that describes a desired tmux workspace.
+
+```yaml
+# workspace.yml
+- first window:
+    layout: tiled
+    panes:
+      - first pane: sleep 1
+      - second pane: sleep 2
+      - third pane: |
+          sleep 3
+          sleep 4
+
+- second window:
+    layout: even-vertical
+    pane-border-status: top
+    synchronize-panes: true
+    panes:
+      - pane 2-1: sleep 5
+      - pane 2-2: sleep 6
+```
+
+Then run `heytmux workspace.yml`.
+
+Instead of creating a new session from scratch, Heytmux looks at the current
+session and only creates windows and panes that are not found. So you can
+repeatedly run the same input file only to issue commands on the existing
+panes.
+
+Heytmux identifies windows and panes by their names and titles, so renaming
+them can confuse Heytmux. Duplicate names are okay as long as you don't
+reorder windows or panes of the same names.
+
+More examples can be found [here](examples/).
+
+Heytmux can read STDIN, so `cat workspace.yml | heytmux` is also
+[valid][caat]. It may seem pointless, but it allows you to do `:w !heytmux`
+with a visual selection in Vim.
+
+[caat]: http://porkmail.org/era/unix/award.html
+
+Step-by-step tutorial
+---------------------
+
+#### List of window names
+
+In the simplest case, input file only has to contain the names of windows as
+the top-level list. Create `workspace.yml` and add the following lines.
+
+```yaml
+- window 1
+- window 2
+- window 3
+```
+
+`heytmux workspace.yml` will create 3 windows with the given names. If you
+re-run the same command, you'll notice Heytmux doesn't create more windows as
+they already exist.
+
+#### Windows and panes
+
+Well, that was not particularly interesting. Let's split the windows and run
+some commands.
+
+First run `heytmux --kill workspace.yml` to kill the windows we just created,
+and update your input file as follows:
+
+```yaml
+- window 1:
+  - echo 1-1
+  - echo 1-2
+  - echo 1-3
+- window 2:
+  - echo 2-1
+  - echo 2-2
+- window 3:
+  - sleep 3
+```
+
+Run Heytmux with it and you'll see that panes are created under the windows to
+run those commands. If you rerun the same command, Heytmux will send them
+again to the same panes. No new panes are created.
+
+#### Pane titles
+
+However, if you change a command on the input file (e.g. `echo 1-1` to
+`sleep 1`) and run Heytmux, a new pane for the command will be created. That's
+because Heytmux identifies windows and panes by their names and titles, and in
+the above case, the title of a pane is implicitly set to the given command. So
+changing the command changes the identifier of the pane, and Heytmux no longer
+can find the previous pane.
+
+To reuse the existing panes, you have to explictly name the panes. Update the
+input file, close the windows (`heytmux --kill workspace.yml`), and rerun the
+command.
+
+```yaml
+- window 1:
+  - pane 1: sleep 1
+  - pane 2: sleep 2
+  - pane 3: sleep 3
+- window 2:
+  - pane 2-1: sleep 1
+  - pane 2-2: |
+      sleep 2
+      sleep 3
+```
+
+Now, you can freely change the commands without worrying about getting extra
+panes. You can also create and use input files for any subset of the panes.
+
+```yaml
+# In another file
+- window 2:
+  - pane 2: echo 'I slept 5 seconds!'
+```
+
+#### Window layout and options
+
+What if we want to change the layout of the windows, or if we want to set some
+window options of tmux? To do that, move the list of panes to `panes` under
+each window entry, so you can specify additional settings.
+
+```yaml
+- window 1:
+    layout: even-horizontal
+    synchronize-panes: true
+    pane-border-status: bottom
+    panes:
+      - pane 1: sleep 1
+      - pane 2: sleep 2
+      - pane 3: sleep 3
+- window 2:
+    layout: even-horizontal
+    synchronize-panes: true
+    pane-border-status: top
+    panes:
+      - pane 2-1: sleep 1
+      - pane 2-2: |
+          sleep 1
+          sleep 2
+```
+
+#### Root layout and options
+
+That's nice, but looks like we're repeating ourselves with the same options.
+We can reorganize the input file as follows to define the root layout and
+options that are applied to all windows.
+
+```yaml
+layout: even-horizontal
+synchronize-panes: true
+pane-border-status: bottom
+
+windows:
+  - window 1:
+      panes:
+        - pane 1: sleep 1
+        - pane 2: sleep 2
+        - pane 3: sleep 3
+  - window 2:
+      # Override root option
+      pane-border-status: top
+      panes:
+        - pane 2-1: sleep 1
+        - pane 2-2: |
+            sleep 1
+            sleep 2
+```
+
+#### Expanding panes with `{{ item }}`
+
+The panes under `window 1` in the previous example are similar in their names
+and commands, and this is a very common case. To avoid repetition, set `items`
+list for a window, then panes with `{{ item }}` in their titles will be
+expanded according to the list.
+
+```yaml
+# Equivalent to the previous example
+- window 1:
+    items: [1, 2, 3]
+    panes:
+      - pane {{item}}: sleep {{item}}
+```
+
+This is often useful when you have to work with a series of log files or with
+a set of servers.
+
+```yaml
+- servers:
+    layout: tiled
+    items:
+      - west-host1
+      - west-host2
+      - east-host1
+      - east-host2
+    panes:
+      - ssh user@{{item}} tail -f /var/log/server-{{item}}.log
+```
+
+
+#### Referring to environment variables
+
+You can refer to environment variables using `{{ $ENV_VAR }}` syntax. For
+default values, use `{{ $ENV_VAR | the-default-value }}` syntax. Heytmux will
+not start if an environment variable is not defined and there's no default
+value.
+
+#### Expecting pattern
+
+Sometimes it's not enough to just send lines of text at once. For example, the
+following example will not work as expected.
+
+```yaml
+- servers:
+  - server 1: |
+      ssh server1
+      {{ $MY_SSH_PASSWORD }}
+      uptime
+```
+
+With `expect` construct, you can make Heytmux wait until a certain regular
+expression pattern appears on the the pane (a la [Expect][expect]).
+
+[expect]: https://en.wikipedia.org/wiki/Expect
+
+```yaml
+- servers:
+  - server 1:
+    - ssh server1
+    - expect: '[Pp]assword:'
+    - {{ $MY_SSH_PASSWORD }}
+    - uptime
+```
+
+Vim plugin
+----------
+
+You don't really need a Vim plugin for Heytmux (because `:w !heytmux` will
+just do), but here's one anyway, to save you some typing.
+
+- `:Heytmux [OPTIONS]`
+    - Run with the current file
+- `:Heytmux [OPTIONS] FILES...`
+    - Run with the files
+- `:'<,'>Heytmux [OPTIONS]` (in visual mode)
+    - Run with the given range
+
+Use bang version of the command (`:Heytmux!`) not to move focus. It is
+equivalent to passing `-d` flag to heytmux executable.
+
+Related projects
+----------------
+
+Many of the ideas were borrowed from [Tmuxinator][tmuxinator] and
+[Ansible][ansible], but Heytmux solves a different problem.
+
+[tmuxinator]: https://github.com/tmuxinator/tmuxinator
+[ansible]: https://github.com/ansible/ansible
+
+There are also other projects that are similar to tmuxinator.
+
+- [teamocil](https://github.com/remiprev/teamocil)
+- [tmuxp](https://github.com/tony/tmuxp)
+
+#### How is this different from tmuxinator?
+
+With Tmuxinator, you can manage session configurations each of which defines
+the initial layout of a tmux session.
+
+On the other hand, Heytmux does not care about sessions, instead it simply
+creates windows and panes on the current session, and it only creates the ones
+that don't exist. So it can be used not only to bootstrap the initial
+workspace, but also to send commands to any subset of the existing panes,
+which means you can use it for scripting your tasks that span multiple tmux
+windows and panes. Heytmux somehow feels like a hybrid of Tmuxinator and
+Ansible.
+
+I primarily use Heytmux to write Markdown documents with fenced code blocks of
+YAML snippets that I can easily select and run with Heytmux in my editor.
+
+License
+-------
+
+MIT

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/exe/heytmux

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require 'heytmux'
+
+if ARGV.include?('--version')
+  puts Heytmux::VERSION
+  exit
+end
+
+focus = ARGV.delete('-d').nil?
+kill = ARGV.delete('--kill')
+abort 'usage: heytmux [-d] [--kill] YAML_SPECS...' if ARGV.empty? && $stdin.tty?
+abort 'Not on tmux' unless ENV['TMUX']
+
+if (unreadable = ARGV.find { |f| !File.readable?(f) })
+  abort "Cannot read #{unreadable}"
+end
+
+require 'yaml'
+strings = [$stdin.tty? ? nil : ['standard input', $stdin.read],
+           *ARGV.map { |f| [f, File.read(f)] }].compact
+specs = strings.map do |name, str|
+  begin
+    str = Heytmux.replace_env_vars(str)
+    YAML.respond_to?(:safe_load) ? YAML.safe_load(str) : YAML.load(str)
+  rescue => e
+    abort("Failed to parse #{name}: #{e}")
+  end
+end
+
+begin
+  specs.each do |s|
+    Heytmux::Validations.validate(s)
+  end
+rescue ArgumentError, RegexpError => e
+  abort(e.message)
+end
+
+if kill
+  specs.each { |spec| Heytmux.kill! spec }
+else
+  specs.each { |spec| Heytmux.process! spec, focus }
+end

data/heytmux.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'heytmux/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'heytmux'
+  spec.version       = Heytmux::VERSION
+  spec.authors       = ['Junegunn Choi']
+  spec.email         = ['junegunn.c@gmail.com']
+
+  spec.summary       = 'Hey tmux!'
+  spec.description   = 'Tmux scripting made easy'
+  spec.homepage      = 'https://github.com/junegunn/heytmux'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(/^(bin|test|spec|features|plugin|examples|\.)/)
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.0'
+  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'minitest', '~> 5.10'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'coveralls'
+end

data/lib/heytmux.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'set'
+
+# Hey tmux!
+module Heytmux
+  DEFAULT_LAYOUT = ->(num_panes) { num_panes <= 3 ? 'even-vertical' : 'tiled' }
+  DEFAULT_OPTIONS = {
+    'automatic-rename'   => 'off',
+    'allow-rename'       => 'off',
+    'pane-base-index'    => 0,
+    'pane-border-status' => 'bottom',
+    'pane-border-format' => '#{pane_title}'
+  }.freeze
+
+  SUPPORTED_ACTIONS = %w[expect].to_set.freeze
+
+  WINDOWS_KEY = 'windows'
+  LAYOUT_KEY = 'layout'
+  PANES_KEY = 'panes'
+  ITEMS_KEY = 'items'
+  ITEM_PAT = /{{ *item *}}/i
+  ENV_PAT = /{{ *\$([a-z0-9_]+) *(?:\| *(.*?) *)?}}/i
+
+  EXPECT_SLEEP_INTERVAL = 0.5
+  EXPECT_TIMEOUT = 60
+end
+
+require 'heytmux/version'
+require 'heytmux/validations'
+require 'heytmux/tmux'
+require 'heytmux/core'

data/lib/heytmux/core.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+# Core functions of Heytmux
+module Heytmux
+  module_function
+
+  def replace_env_vars(raw_input)
+    raw_input.gsub(ENV_PAT) do
+      name = Regexp.last_match[1]
+      default = Regexp.last_match[2]
+      ENV.fetch(name, default) ||
+        raise(ArgumentError, "Missing environment variable: #{name}")
+    end
+  end
+
+  # Processes spec struct
+  def process!(root_spec, focus)
+    # Find window indexes
+    windows, root_options = interpret_root_spec(root_spec, Tmux.list)
+    root_layout = root_options.delete(LAYOUT_KEY)
+
+    # Create windows if not found (no :index)
+    found_windows, new_windows = create_if_missing(windows, :index) do |window|
+      create_first_pane(window)
+    end
+
+    # Process panes in windows
+    threads = (found_windows + new_windows).flat_map.with_index do |window, idx|
+      process_window!(window, root_options, root_layout, focus && idx.zero?)
+    end
+    threads.each(&:join)
+  end
+
+  # Kills windows specified in the input
+  def kill!(root_spec)
+    windows, = interpret_root_spec(root_spec, Tmux.list)
+    windows.map { |w| w[:index] }.compact.sort.reverse.each do |index|
+      Tmux.kill(index)
+    end
+  end
+
+  # Executes tasks to the window
+  def process_window!(window, root_options, root_layout, focus)
+    index, panes, options, layout =
+      window.values_at(:index, :panes, :options, :layout)
+    layout ||= root_layout
+
+    # Set additional options
+    Tmux.set_window_options(index, root_options.merge(options))
+
+    # Split panes
+    found_panes, new_panes = create_if_missing(panes, :index) do |pane|
+      pane_index =
+        split_and_select_layout(index,
+                                pane[:title],
+                                layout || DEFAULT_LAYOUT[panes.length])
+      pane.merge(index: pane_index)
+    end
+
+    # Select layout when it's explicitly given
+    Tmux.select_layout(index, layout) if layout && new_panes.empty?
+
+    # Focus window
+    Tmux.select_window(index) if focus
+
+    # Execute commands
+    (found_panes + new_panes).map do |pane|
+      Thread.new { process_command!(index, pane) }
+    end
+  end
+
+  def process_command!(window_index, pane)
+    pane_index, item, commands = pane.values_at(:index, :item, :command)
+    [*commands].each do |command|
+      case command
+      when Hash
+        _action, regex = command.first
+        regex = Regexp.compile(regex.to_s)
+        wait_until do
+          content = Tmux.capture(window_index, pane_index)
+          content =~ regex
+        end
+      else
+        command = command.gsub(ITEM_PAT, item) if item
+        Tmux.paste(window_index, pane_index, command)
+      end
+    end
+  end
+
+  def wait_until
+    timeout = Time.now + EXPECT_TIMEOUT
+    loop do
+      sleep EXPECT_SLEEP_INTERVAL
+      return if yield
+      raise 'Timed out' if Time.now > timeout
+    end
+  end
+
+  # Groups entities by the group key and extracts unique, sorted indexes and
+  # returns stateful indexer that issues index number for the given group key
+  def indexer(entities, group_key, index_key)
+    indexes =
+      Hash[entities.group_by { |e| e[group_key] }
+                   .map { |g, es| [g, es.map { |e| e[index_key] }.sort.uniq] }]
+    ->(group) { indexes.fetch(group, []).shift }
+  end
+  private_class_method :indexer
+
+  # Interprets root spec for workspace
+  def interpret_root_spec(root_spec, all_panes)
+    window_indexer = indexer(all_panes, :window_name, :window_index)
+    windows = window_specs(root_spec).map do |window|
+      interpret_window_spec(window, all_panes, window_indexer)
+    end
+    [windows, root_options(root_spec)]
+  end
+
+  def window_specs(root_spec)
+    # The list of window specs can be specified under top-level 'windows' keys,
+    # or it can be given as the top-level array.
+    windows = root_spec.is_a?(Array) ? root_spec : root_spec[WINDOWS_KEY]
+    windows.map do |window|
+      window.is_a?(String) ? { window => {} } : window
+    end
+  end
+  private_class_method :window_specs
+
+  def root_options(root_spec)
+    if root_spec.is_a?(Array)
+      {}
+    else
+      root_spec.dup.tap { |copy| copy.delete(WINDOWS_KEY) }
+    end
+  end
+  private_class_method :root_options
+
+  # Interprets spec for a window
+  def interpret_window_spec(window, all_panes, window_indexer)
+    name, spec = window.first
+    spec = { PANES_KEY => spec } if spec.is_a?(Array)
+    index = window_indexer[name]
+    existing_panes = all_panes.select { |h| h[:window_index] == index }
+    pane_indexer = indexer(existing_panes, :pane_title, :pane_index)
+
+    spec = spec.dup || {}
+    layout = spec.delete(LAYOUT_KEY)
+    items = spec.delete(ITEMS_KEY)
+    items = items ? items.map { |item| Regexp.escape(item.to_s) } : ['\0']
+    panes = spec.delete(PANES_KEY) || []
+    panes = panes.flat_map do |pane|
+      interpret_and_expand_pane_spec(pane, items, pane_indexer)
+    end
+
+    { name: name, index: index, panes: panes, layout: layout, options: spec }
+  end
+
+  def interpret_and_expand_pane_spec(pane, items, pane_indexer)
+    title, command = pane.is_a?(Hash) ? pane.first : [pane.tr("\n", ' '), pane]
+    if title =~ ITEM_PAT
+      items.map do |item|
+        title_sub = title.gsub(ITEM_PAT, item.to_s)
+        { title: title_sub, command: command,
+          item: item.to_s, index: pane_indexer[title_sub] }
+      end
+    else
+      [{ title: title, command: command, index: pane_indexer[title] }]
+    end
+  end
+
+  # Checks if there are entities without the required_field and creates them
+  # with the given block. Returns two arrays of found and created entities.
+  def create_if_missing(entities, required_field)
+    found, missing = entities.partition { |e| e[required_field] }
+    [found, missing.map { |e| yield e }]
+  end
+  private_class_method :create_if_missing
+
+  # Creates a new tmux window and sets the title of its first pane.
+  # Returns the index of the new window.
+  def create_first_pane(window)
+    name, panes = window.values_at(:name, :panes)
+    pane_title = panes.map { |pane| pane[:title] }.first
+    new_index = Tmux.create_window(name, pane_title, DEFAULT_OPTIONS)
+    if pane_title
+      panes = panes.dup
+      panes[0] = panes[0].dup.tap do |pane|
+        pane[:index] = DEFAULT_OPTIONS['pane-base-index']
+      end
+    end
+    window.merge(index: new_index, panes: panes)
+  end
+
+  # To avoid 'pane too small' error, we rearrange panes after every split
+  def split_and_select_layout(window_index, pane_title, layout)
+    Tmux.split_window(window_index, pane_title).tap do
+      Tmux.select_layout(window_index, layout)
+    end
+  end
+  private_class_method :split_and_select_layout
+end

data/lib/heytmux/tmux.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+require 'tempfile'
+
+module Heytmux
+  # Tmux integration
+  module Tmux
+    module_function
+
+    def tmux(*args)
+      args = args.flatten.map { |a| Shellwords.escape(a.to_s) }
+      command = "tmux #{args.join(' ')}"
+      (@mutex ||= Mutex.new).synchronize do
+        puts command if ENV['HEYTMUX_DEBUG']
+        `#{command}`.chomp
+      end
+    end
+
+    def list
+      labels = %i[window_index window_name pane_index pane_title]
+      delimiter = '::::'
+      list = tmux(%w[list-panes -s -F],
+                  labels.map { |label| "\#{#{label}}" }.join(delimiter))
+      list.each_line.map do |line|
+        Hash[labels.zip(line.chomp.split(delimiter))].tap do |h|
+          h[:window_index] = h[:window_index].to_i
+          h[:pane_index] = h[:pane_index].to_i
+        end
+      end
+    end
+
+    def create_window(window_name, pane_title, window_options)
+      tmux(%w[new-window -d -P -F #{window_index} -n],
+           window_name).to_i.tap do |index|
+        set_window_options(index, window_options)
+        if pane_title
+          base_index = window_options.fetch('pane-base-index', 0)
+          set_pane_title(index, base_index, pane_title)
+        end
+      end
+    end
+
+    def paste(window_index, pane_index, keys)
+      file = Tempfile.new('heytmux')
+      file.puts keys
+      file.close
+
+      tmux(%w[load-buffer -b heytmux], file.path,
+           %w[; paste-buffer -d -b heytmux],
+           target(window_index, pane_index))
+    ensure
+      file.unlink
+    end
+
+    # Applies a set of window options
+    def set_window_options(window_index, opts)
+      args = opts.flat_map do |k, v|
+        [';', 'set-window-option', target(window_index),
+         k, { true => 'on', false => 'off' }.fetch(v, v)]
+      end.drop(1)
+      tmux(*args) if args.any?
+    end
+
+    # Splits the window and returns the index of the new pane
+    def split_window(window_index, pane_title)
+      tmux(%w[split-window -P -F #{pane_index} -d],
+           target(window_index)).to_i.tap do |pane_index|
+        set_pane_title(window_index, pane_index, pane_title)
+        tmux('select-pane', target(window_index, pane_index))
+      end
+    end
+
+    # Sets the title of the pane
+    def set_pane_title(window_index, pane_index, title)
+      # The space at the beginning is for preventing it from being added to
+      # shell history
+      paste(window_index, pane_index,
+            %( sh -c "printf '\\033]2;#{title}\\033\\';clear"))
+    end
+
+    # Selects window layout
+    def select_layout(window_index, layout)
+      tmux('select-layout', target(window_index), layout)
+    end
+
+    # Selects window
+    def select_window(window_index)
+      tmux('select-window', target(window_index))
+    end
+
+    # Queries tmux
+    def query(*indexes, print_format)
+      tmux(%w[display-message -p -F], print_format, target(*indexes))
+    end
+
+    # Kills window
+    def kill(index)
+      tmux('kill-window', target(index))
+    end
+
+    # Captures pane content
+    def capture(window_index, pane_index)
+      file = Tempfile.new('heytmux')
+      file.close
+      tmux('capture-pane', target(window_index, pane_index),
+           ';', 'save-buffer', file.path)
+      File.read(file.path).strip
+    ensure
+      file.unlink
+    end
+
+    # Returns target identifier for tmux commands
+    def target(*indexes)
+      ['-t', ':' + indexes.join('.')]
+    end
+  end
+end

data/lib/heytmux/validations.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Heytmux
+  # Validates workspace specification
+  module Validations
+    module_function
+
+    # Validates spec struct and raises ArgumentError on error
+    def validate(spec)
+      windows = case spec
+                when Hash
+                  unless spec.key?(WINDOWS_KEY)
+                    raise(ArgumentError, 'windows key is not found')
+                  end
+                  spec[WINDOWS_KEY]
+                when Array then spec
+                else
+                  raise ArgumentError, "Not a valid spec: #{spec}"
+                end
+
+      unless windows.is_a?(Array)
+        raise ArgumentError, 'windows must be given as a list'
+      end
+      windows.each { |window| validate_window(window) }
+      nil
+    end
+
+    # Validates spec struct for a window and raises ArgumentError on error
+    # - window_name
+    # - window_name => [panes...]
+    # - window_name => { 'panes' => [panes...], ... }
+    def validate_window(window_spec)
+      message = "Not a valid window spec: #{window_spec.inspect}"
+      case window_spec
+      when Hash
+        unless single_spec?(window_spec, Hash, Array)
+          raise ArgumentError, message
+        end
+        spec = window_spec.first.last
+        spec = { PANES_KEY => spec } if spec.is_a?(Array)
+        spec.fetch(PANES_KEY, []).each do |pane|
+          validate_pane(pane)
+        end
+      else
+        # Just the name
+        raise ArgumentError, message unless valid_name?(window_spec)
+      end
+      nil
+    end
+
+    # - pane_name
+    # - { pane_name => command_string }
+    # - { pane_name => [commands...] }
+    def validate_pane(pane_spec)
+      message = "Not a valid pane spec: #{pane_spec.inspect}"
+      case pane_spec
+      when Hash
+        raise ArgumentError, message unless single_spec?(pane_spec)
+        validate_commands(pane_spec.first.last)
+      else
+        raise ArgumentError, message unless valid_name?(pane_spec)
+      end
+    end
+
+    # - command_string
+    # - [command_strings_or_hashes...]
+    def validate_commands(commands)
+      return if commands.is_a?(String)
+      message = "Invalid command: #{commands.inspect}"
+      case commands
+      when Array
+        hashes, strings = commands.partition { |command| command.is_a?(Hash) }
+        hashes.each do |command|
+          raise ArgumentError, message unless single_spec?(command)
+          action, condition = command.first
+          unless SUPPORTED_ACTIONS.include?(action)
+            raise ArgumentError, "Unsupported action: #{action}"
+          end
+          raise ArgumentError, message unless valid_name?(condition)
+          Regexp.compile(condition.to_s)
+        end
+        strings.each do |command|
+          raise ArgumentError, message unless valid_name?(command)
+        end
+      else
+        raise ArgumentError, message unless valid_name?(commands)
+      end
+      nil
+    end
+
+    # Checks if the given hash only contains one mapping from a string to
+    # a hash
+    def single_spec?(spec, *klasses)
+      (key, value), second = spec.take(2)
+      second.nil? && !key.to_s.empty? &&
+        (klasses.empty? || klasses.any? { |k| value.is_a?(k) })
+    end
+    private_class_method :single_spec?
+
+    def valid_name?(value)
+      !(value.nil? || value.is_a?(Array) || value.to_s.empty?)
+    end
+    private_class_method :valid_name?
+  end
+end

data/lib/heytmux/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Heytmux
+  VERSION = '0.0.0'
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: heytmux
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Junegunn Choi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Tmux scripting made easy
+email:
+- junegunn.c@gmail.com
+executables:
+- heytmux
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- exe/heytmux
+- heytmux.gemspec
+- lib/heytmux.rb
+- lib/heytmux/core.rb
+- lib/heytmux/tmux.rb
+- lib/heytmux/validations.rb
+- lib/heytmux/version.rb
+homepage: https://github.com/junegunn/heytmux
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Hey tmux!
+test_files: []