mani 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1b269a1ad0554dc57959f8142fe75d121b9bf472
+  data.tar.gz: 76ead7572bb2b1b3ce1d05def8a96b54acad42e9
+SHA512:
+  metadata.gz: 18e6bbc6919d0d1744b3894b9ea948dbdfc652befde15b8561c450404978d34741d69c53fceb4aca2e5391f8da597ce8c4b9fead94d05fe99ac35a50930bb6a4
+  data.tar.gz: e3b81f2cbc77d58f183414f867ed51389db569ef6809c9f189ec52aa21c7f5bda1711f860d4143e2ca10a91250f380cd77d99fb584a20fbecb28153113e48747

data/.gitignore

@@ -0,0 +1,18 @@
+/*.gem
+/*.rbc
+/.bundle
+/.config
+/coverage
+/InstalledFiles
+/lib/bundler/man
+/pkg
+/rdoc
+/spec/reports
+/test/tmp
+/test/version_tmp
+/tmp
+
+# YARD artifacts
+/.yardoc
+/_yardoc
+/doc/

data/.rubocop.yml

@@ -0,0 +1,8 @@
+Metrics/CyclomaticComplexity:
+  Max: 8
+
+Metrics/PerceivedComplexity:
+  Max: 8
+
+Metrics/MethodLength:
+  Max: 18

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,80 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (4.1.6)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    addressable (2.3.6)
+    builder (3.2.2)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    docile (1.1.5)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    git (1.2.8)
+    github_api (0.12.1)
+      addressable (~> 2.3)
+      descendants_tracker (~> 0.0.4)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 3.2)
+      multi_json (>= 1.7.5, < 2.0)
+      nokogiri (~> 1.6.3)
+      oauth2
+    hashie (3.3.1)
+    highline (1.6.21)
+    i18n (0.6.11)
+    jeweler (2.0.1)
+      builder
+      bundler (>= 1.0)
+      git (>= 1.2.5)
+      github_api
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      rake
+      rdoc
+    json (1.8.1)
+    jwt (1.0.0)
+    mini_portile (0.6.0)
+    minitest (5.4.2)
+    multi_json (1.10.1)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    nokogiri (1.6.3.1)
+      mini_portile (= 0.6.0)
+    oauth2 (1.0.0)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.3.2)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.2.1)
+    shoulda-matchers (2.7.0)
+      activesupport (>= 3.0.0)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    thread_safe (0.3.4)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  jeweler (~> 2.0.1)
+  rdoc (~> 3.12)
+  shoulda
+  simplecov

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2014, Nick Sinopoli <nsinopoli@gmail.com> All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of Nick Sinopoli nor the names of his contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Makefile

@@ -0,0 +1,12 @@
+all: style test
+
+install:
+	gem install rubocop
+
+style:
+	rubocop lib
+
+test:
+	ruby spec.rb
+
+.PHONY: test

data/README.md

@@ -0,0 +1,318 @@
+# Mani
+
+**Mani** is a window automation tool. Common tasks (such as launching programs,
+visiting websites, and typing text) can be scripted using a simple Ruby DSL.
+
+While [xmonad](http://xmonad.org/) is currently the only supported window
+manager, Mani can support any window manager for the X Window System with just
+a few lines of code. Please open an
+[issue](https://github.com/NSinopoli/mani/issues) to add support for your
+favorite window manager.
+
+## Installation
+
+```bash
+gem install mani
+```
+
+### xmonad
+
+You'll have to do a few things to get Mani to work as expected under xmonad.
+
+1. Install [xdotool](http://www.semicomplete.com/projects/xdotool/).
+2. Add [XMonad.Hooks.EwmhDesktops](http://xmonad.org/xmonad-docs/xmonad-contrib/XMonad-Hooks-EwmhDesktops.html)
+   to your xmonad configuration, and then restart xmonad.
+
+```haskell
+import XMonad.Hooks.EwmhDesktops
+
+main = xmonad $ ewmh defaultConfig{ handleEventHook =
+           handleEventHook defaultConfig <+> fullscreenEventHook }
+```
+
+## Getting Started
+
+Here's a simple example:
+
+```ruby
+# hello.rb
+Mani.new(window_manager: :xmonad) do
+  window :hello, launch: 'urxvt' do
+    run 'echo "Hello, world."'
+  end
+end
+```
+
+Run it:
+
+```bash
+$ mani hello.rb
+```
+
+Provided you have
+[rxvt-unicode](http://software.schmorp.de/pkg/rxvt-unicode.html) installed, a
+new terminal will open and the command `echo "Hello, world."` will run inside
+it.
+
+## Examples
+
+Check out the [examples](examples) directory for more examples.
+
+## DSL Overview
+
+`Mani.new` should be at the beginning of every script. It takes an options
+hash, which can take the following keys:
+
+* `:window_manager` - the window manager (currently only `:xmonad` is supported)
+* `:switch_to_workspace` - an optional proc which, when called, returns a
+  sequence which, when interpreted, will switch to the specified workspace
+  (defaults to the default sequence used by the `:window_manager` to change
+  workspaces)
+
+```ruby
+switcher = ->(space) { "super+#{space}" }
+Mani.new(window_manager: :xmonad, switch_to_workspace: switcher) do
+  # Switch to workspace 1
+  workspace 1
+
+  # Switch to workspace 2
+  workspace 2
+end
+```
+
+`workspace` switches to the specified workspace. If a block is supplied, it
+will be called.
+
+```ruby
+Mani.new(window_manager: :xmonad) do
+  # Switch to workspace 1, launch a terminal and run 'echo "Hello, world."'
+  workspace 1 do
+    window :hello, launch: 'urxvt' do
+      run 'echo "Hello, world."'
+    end
+  end
+
+  # Switch to workspace 2
+  workspace 2
+end
+```
+
+`window` serves as the container for window commands. Its first argument is the
+window name. Its second (optional) argument is an options hash, which can take
+the following keys:
+
+* `:launch` - the program to be launched
+* `:delay` - the amount of time, in seconds, to delay after launching the
+  program (defaults to 0.5)
+
+If a block is supplied, it will be called.
+
+```ruby
+Mani.new(window_manager: :xmonad) do
+  # Create a new terminal window, wait one second, and then run 'ls'
+  window :ls do
+    launch 'urxvt', delay: 1 do
+      run 'ls'
+    end
+  end
+
+  # The same process can be accomplished using this condensed syntax:
+  window :ls, launch: 'urxvt', delay: 1 do
+    run 'ls'
+  end
+
+  # Just launch a program
+  window :thunderbird, launch: 'thunderbird'
+
+  # Return to the :ls window, and then run 'date'
+  window :ls do
+    run 'date'
+  end
+end
+```
+
+`launch` launches a program. It takes an optional options hash, which can take
+the following keys:
+
+* `:delay` - the amount of time, in seconds, to delay after launching the
+  program (defaults to 0.5)
+
+```ruby
+Mani.new(window_manager: :xmonad) do
+  # Create a new terminal window, wait one second, and then run 'ls'
+  window :ls do
+    launch 'urxvt', delay: 1 do
+      run 'ls'
+    end
+  end
+end
+```
+
+`run` executes a [combination](#combination-syntax) within a window. It takes
+an optional options hash, which can take the following keys:
+
+* `:delay` - the amount of time, in seconds, to delay after running the
+  command (defaults to 0.5)
+
+```ruby
+Mani.new(window_manager: :xmonad) do
+  # Run 'ls'
+  window :ls, launch: 'urxvt', delay: 1 do
+    run 'ls'
+  end
+end
+```
+
+`type` types a [combination](#combination-syntax) within a window. It takes an
+optional options hash, which can take the following keys:
+
+* `:delay` - the amount of time, in seconds, to delay after typing the text
+  (defaults to 0.5)
+
+```ruby
+Mani.new(window_manager: :xmonad) do
+  # Launch gvim
+  window :gvim, launch: 'gvim -f', delay: 2 do
+    # Wait two seconds, then move to the end of the buffer, start a new line,
+    # and type "Hello, world."
+    type 'GoHello, world.'
+  end
+end
+```
+
+`visit` is used to visit a website. It takes an optional options hash, which
+can take the following keys:
+
+* `:delay` - the amount of time, in seconds, to delay after entering the url
+  (defaults to 0.5)
+
+Note that depending on the browser, you may need to insert an "F6"
+[keystroke](#combination-syntax) at the beginning of the url.
+
+```ruby
+Mani.new(window_manager: :xmonad) do
+  window :chromium, launch: 'chromium', delay: 1.5 do
+    visit 'localhost:8080'
+  end
+
+  window :firefox, launch: 'firefox', delay: 1.5 do
+    # Type "F6" first so that the cursor is in the address bar before typing
+    # the url.
+    visit '{{F6}}gmail.com'
+  end
+end
+```
+
+`browser_tab` is used to either create a new browser tab or switch to a
+specific tab. Its first argument, when `:new`, will create a new tab. If it is
+an integer, the browser will instead switch to that tab. Its second argument
+is an optional options hash, which can take the following keys:
+
+* `:delay` - the amount of time, in seconds, to delay after handling the tab
+  (defaults to 0.5)
+
+If a block is supplied, it will be called.
+
+```ruby
+Mani.new(window_manager: :xmonad) do
+  window :chromium, launch: 'chromium', delay: 1.5 do
+    # Visit 'localhost:8080' within the initial tab
+    visit 'localhost:8080'
+
+    # Create a new tab and visit 'news.ycombinator.com'
+    browser_tab :new do
+      visit 'news.ycombinator.com'
+    end
+
+    # Switch back to the first tab (localhost:8080)
+    browser_tab 1
+  end
+end
+```
+
+### Combination Syntax
+
+Simulating keystrokes for function keys and modifiers requires the use of a
+special syntax. The `{{` and `}}` tags are used to indicate a sequence.
+Chording is achieved by separating keys with a `+` sign.
+
+```ruby
+Mani.new(window_manager: :xmonad) do
+  window :firefox, launch: 'firefox', delay: 1.5 do
+    # Type "F6" first so that the cursor is in the address bar before typing
+    # the url.
+    visit '{{F6}}gmail.com'
+
+    # Paste the contents of the clipboard into the url.
+    visit 'localhost:8080/reports/{{ctrl+v}}/preview'
+  end
+end
+```
+
+In the event a literal `{{` or `}}` is desired, a `%` sign can be added as a
+prefix to escape the sequence.
+
+```ruby
+Mani.new(window_manager: :xmonad) do
+  window :hello, launch: 'urxvt' do
+    run 'echo "%{{literal opening brackets"'
+    run 'echo "literal closing brackets%}}"'
+    run 'echo "%{{literal opening and closing brackets%}}"'
+  end
+end
+```
+
+## Contributing
+
+Please follow the guidelines below.
+
+### Issue Reporting
+
+* Use the [issue tracker](https://github.com/NSinopoli/mani/issues) to report
+  any issues or ideas for improvements.
+* Check that the issue has not already been reported.
+* Check that the issue has not already been fixed in the latest code (i.e., on
+  `master`).
+* Be clear, concise, and precise in your description of the problem.
+* Open an issue with a descriptive title and a summary in grammatically
+  correct, complete sentences.
+* Include any relevant code to the issue summary.
+
+### Pull Requests
+
+* Read [how to properly contribute to open source projects on Github](http://gun.io/blog/how-to-github-fork-branch-and-pull-request).
+* Fork the project.
+* Use a topic/feature branch to easily amend a pull request later, if
+  necessary.
+* Write [good commit messages](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
+* Use the same [coding conventions](#code-conventions) as the rest of the
+  project.
+* Commit and push until you are happy with your contribution.
+* Make sure to add [tests](#tests) for it. This is important so I don't break
+  it in a future version unintentionally.
+* Please try not to mess with the version or history. If you want to have your
+  own version, please isolate the change to its own commit so I can cherry-pick
+  around it.
+* [Squash related commits together](http://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html).
+* Open a [pull request](https://help.github.com/articles/using-pull-requests)
+  that relates to *only* one subject with a clear title and description in
+  grammatically correct, complete sentences.
+
+### Code Conventions
+
+**Mani** follows the conventions laid out in the
+[Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide). These
+conventions are enforced by [RuboCop](https://github.com/bbatsov/rubocop).
+
+```
+make install
+make style
+```
+
+Please ensure that any contributed code does not produce any RuboCop offenses.
+
+### Tests
+
+```
+make test
+```

data/bin/mani

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.dirname(File.realpath(__FILE__)) + '/../lib')
+
+require 'mani'
+require 'mani/version'
+
+require 'optparse'
+
+class Mani
+  class CLI
+    # Parses command line options.
+    #
+    # @param [Array] args The command line arguments
+    def self.parse_options(args)
+      option_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: mani FILE"
+
+        opts.separator ""
+
+        opts.separator "Example:"
+        opts.separator "  $ mani workspace_initializer.rb"
+
+        opts.separator ""
+
+        opts.separator "Options:"
+
+        opts.on("-v", "--version", "Print the version") do |v|
+          puts "Mani v#{Mani::Version::VERSION}"
+          exit
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
+
+      option_parser.parse!(args)
+    end
+  end
+end
+
+ARGV << '-h' if ARGV.empty? && $stdin.tty?
+
+Mani::CLI.parse_options(ARGV) if $stdin.tty?
+
+load ARGF.file

data/examples/chording.rb

@@ -0,0 +1,17 @@
+Mani.new do
+  window :urxvt, launch: 'urxvt' do
+    # Copy the most recent report id
+    run %q(
+      ssh 127.0.0.1 -p 49154
+        psql -h localhost -U web_dev web_development <<<
+        'SELECT id FROM reports order by id desc limit 1;'
+      | grep -m 1 \[0-9\] | xclip -selection c
+    ).strip.gsub(/\s+/, ' ')
+    run 'exit'
+  end
+
+  window :chrome, launch: 'google-chrome-stable', delay: 1 do
+    # Paste the report id within the url
+    visit 'localhost:8080/reports/{{ctrl+v}}/preview'
+  end
+end

data/examples/hello.rb

@@ -0,0 +1,5 @@
+Mani.new(window_manager: :xmonad) do
+  window :hello, launch: 'urxvt' do
+    run 'echo "Hello, world."'
+  end
+end

data/examples/workspace_initializer.rb

@@ -0,0 +1,46 @@
+Mani.new(window_manager: :xmonad) do
+  workspace 1 do
+    window :top, launch: 'urxvt' do
+      run 'top'
+    end
+
+    window :date, launch: 'urxvt' do
+      run 'date'
+    end
+  end
+
+  workspace 2 do
+    window :firefox, launch: 'firefox', delay: 1.5 do
+      # Type "F6" first so that the cursor is in the address bar before typing
+      # the url.
+      visit '{{F6}}gmail.com'
+    end
+  end
+
+  workspace 3 do
+    # Use "-f" to prevent vim from forking and detaching from the original
+    # process.
+    window :gvim, launch: 'gvim -f', delay: 2 do
+      type 'GoHello, world.'
+    end
+  end
+
+  workspace 4 do
+    window :thunderbird, launch: 'thunderbird'
+
+    window :hipchat, launch: 'hipchat', delay: 3
+  end
+
+  workspace 8 do
+    window :chromium, launch: 'chromium', delay: 1.5 do
+      visit 'localhost:8080'
+
+      browser_tab :new do
+        visit 'news.ycombinator.com'
+      end
+
+      # Switch back to the first tab (localhost)
+      browser_tab 1
+    end
+  end
+end

data/lib/mani/tokenizer.rb

@@ -0,0 +1,88 @@
+require 'strscan'
+
+class Mani
+  # This class contains methods to handle the tokenization of strings.
+  class Tokenizer
+    # The escape character
+    ESCAPE_CHARACTER = '%'
+
+    # The delimiter signifying the start of a sequence
+    SEQUENCE_OPEN_DELIMITER = '{{'
+
+    # The delimiter signifying the end of a sequence
+    SEQUENCE_CLOSE_DELIMITER = '}}'
+
+    # The delimiter signifying an "open sequence" escape sequence
+    LITERAL_OPEN_DELIMITER = ESCAPE_CHARACTER + SEQUENCE_OPEN_DELIMITER
+
+    # The delimiter signifying a "close sequence" escape sequence
+    LITERAL_CLOSE_DELIMITER = ESCAPE_CHARACTER + SEQUENCE_CLOSE_DELIMITER
+
+    # The pattern to match the start of a sequence
+    SEQUENCE_OPEN = /
+      # find opening delimiter at beginning of string...
+      ^#{SEQUENCE_OPEN_DELIMITER}
+      # ...or elsewhere in the string, provided it's not preceded by
+      # ESCAPE_CHARACTER
+      |[^#{ESCAPE_CHARACTER}]#{SEQUENCE_OPEN_DELIMITER}
+    /x
+
+    # The pattern to match the end of a sequence
+    SEQUENCE_CLOSE = /
+      # find closing delimiter at beginning of string...
+      ^#{SEQUENCE_CLOSE_DELIMITER}
+      # ...or elsewhere in the string, provided it's not preceded by
+      # ESCAPE_CHARACTER
+      |[^#{ESCAPE_CHARACTER}]#{SEQUENCE_CLOSE_DELIMITER}
+    /x
+
+    # Retrieves the tokens comprising the supplied text.
+    #
+    # @param [String] text The text
+    # @return [Array]
+    def self.get_tokens(text)
+      tokenize StringScanner.new(text), []
+    end
+
+    # Strips the comment delimiters from the supplied text.
+    #
+    # @param [String] text The text
+    # @return [String]
+    def self.strip_comment_delimiters(text)
+      text
+        .gsub(LITERAL_OPEN_DELIMITER, SEQUENCE_OPEN_DELIMITER)
+        .gsub(LITERAL_CLOSE_DELIMITER, SEQUENCE_CLOSE_DELIMITER)
+    end
+
+    # Recursively scans the string within the supplied scanner to produce a
+    # list of tokens.
+    #
+    # @param [StringScanner] scanner The string scanner
+    # @param [Array] tokens The tokens
+    # @return [Array]
+    def self.tokenize(scanner, tokens)
+      match = scanner.scan_until SEQUENCE_OPEN
+      unless match
+        static = strip_comment_delimiters scanner.rest
+        tokens.concat [[:static, static]] unless static.empty?
+        return tokens
+      end
+
+      if !scanner.check_until SEQUENCE_CLOSE
+        static = strip_comment_delimiters(match + scanner.rest)
+        tokens.concat [[:static, static]]
+      else
+        static = strip_comment_delimiters match.chomp(SEQUENCE_OPEN_DELIMITER)
+        tokens.concat [[:static, static]] unless static.empty?
+
+        match = scanner.scan_until SEQUENCE_CLOSE
+        match.chomp! SEQUENCE_CLOSE_DELIMITER
+
+        sequence = strip_comment_delimiters match
+        tokens.concat [[:sequence, sequence]] unless sequence.empty?
+
+        tokenize scanner, tokens
+      end
+    end
+  end
+end

data/lib/mani/version.rb

@@ -0,0 +1,7 @@
+class Mani
+  # This class holds the Mani version information.
+  class Version
+    # The current version
+    VERSION = '0.0.2'
+  end
+end

data/lib/mani/window.rb

@@ -0,0 +1,95 @@
+class Mani
+  # This class contains methods to handle operations run within windows.
+  class Window
+    # Creates a new tab, or switches to the supplied tab.
+    #
+    # @param [Symbol, Integer] tab The tab. If :new is specified, a new tab
+    #   will be created and the window will switch to it. If an integer is
+    #   specified, the window will switch to that (previously existing) tab.
+    # @param [Hash] options The options
+    #   * :delay (Numeric) _Optional_ The amount of time, in seconds, to delay
+    #     after handling the tab (defaults to 0.5)
+    # @param [Proc] block The code to execute after handling the tab
+    def browser_tab(tab, options = {}, &block)
+      @windowing_system.focus_window @pid
+
+      if tab == :new
+        @windowing_system.type_keysequence 'ctrl+t'
+        @windowing_system.type_keysequence 'alt+9'
+      elsif tab >= 1 && tab <= 8
+        @windowing_system.type_keysequence "alt+#{tab}"
+      elsif tab > 8
+        @windowing_system.type_keysequence 'alt+8'
+        (tab - 8).times { @windowing_system.type_keysequence 'ctrl+Tab' }
+      else
+        return
+      end
+
+      sleep options[:delay] || 0.5
+
+      instance_eval(&block) if block
+    end
+
+    # Initializes the window.
+    #
+    # @param [Object] windowing_system The windowing system
+    def initialize(windowing_system)
+      @windowing_system = windowing_system
+    end
+
+    # Launches the supplied program.
+    #
+    # @param [String] program The program
+    # @param [Hash] options The options
+    #   * :delay (Numeric) _Optional_ The amount of time, in seconds, to delay
+    #     after launching the program (defaults to 0.5)
+    # @param [Proc] block The code to execute after launching the program
+    def launch(program, options = {}, &block)
+      return if @pid
+
+      @pid = Process.spawn program
+      Process.detach @pid
+
+      sleep options[:delay] || 0.5
+
+      instance_eval(&block) if block
+    end
+
+    # Runs the supplied command within the current window.
+    #
+    # @param [String] command The command
+    # @param [Hash] options The options
+    #   * :delay (Numeric) _Optional_ The amount of time, in seconds, to delay
+    #     after running the command (defaults to 0.5)
+    def run(command, options = {})
+      @windowing_system.focus_window @pid
+      @windowing_system.type_combination command
+      @windowing_system.type_keysequence 'Return'
+
+      sleep options[:delay] || 0.5
+    end
+
+    # Types the supplied text into the current window.
+    #
+    # @param [String] text The text
+    # @param [Hash] options The options
+    #   * :delay (Numeric) _Optional_ The amount of time, in seconds, to delay
+    #     after typing the text (defaults to 0.5)
+    def type(text, options = {})
+      @windowing_system.focus_window @pid
+      @windowing_system.type_combination text
+
+      sleep options[:delay] || 0.5
+    end
+
+    # Enters the supplied url into the current window.
+    #
+    # @param [String] url The url
+    # @param [Hash] options The options
+    #   * :delay (Numeric) _Optional_ The amount of time, in seconds, to delay
+    #     after entering the url (defaults to 0.5)
+    def visit(url, options = {})
+      run url, options
+    end
+  end
+end

data/lib/mani/x.rb

@@ -0,0 +1,48 @@
+require 'x_do'
+
+class Mani
+  # This class contains methods to interface with the X Window System.
+  class X
+    # Initializes XDo to handle the heavy lifting of interfacing with X.
+    def initialize
+      @xdo = XDo.new
+    end
+
+    # Finds the visible window with the supplied pid and focuses it.
+    #
+    # @param [Fixnum] pid The pid
+    def focus_window(pid)
+      @xdo.find_windows(pid: pid, visible: true).first.focus
+    end
+
+    # Types the supplied combination. Note that any text between '{{' and '}}'
+    # delimiters is treated as a sequence. All other text is treated literally.
+    #
+    # @param [String] combination The combination
+    def type_combination(combination)
+      tokens = Mani::Tokenizer.get_tokens combination
+      tokens.each do |token|
+        case token.first
+        when :static
+          type_string token.last
+        when :sequence
+          type_keysequence token.last
+        end
+      end
+    end
+
+    # Types the supplied sequence (e.g., 'ctrl+v', 'F6', 'alt+2').
+    #
+    # @param [String] sequence The sequence
+    def type_keysequence(sequence)
+      @xdo.keyboard.type_keysequence sequence
+    end
+
+    # Types the supplied string. Note that the string is treated literally.
+    #
+    # @param [String] string The string
+    def type_string(string)
+      @xdo.keyboard.type_string string
+    end
+  end
+end

data/lib/mani.rb

@@ -0,0 +1,65 @@
+require 'mani/window'
+require 'mani/tokenizer'
+
+# The base class.
+class Mani
+  # Initializes the windowing system, as well as the window manager options.
+  #
+  # @param [Hash] options The options
+  #   * :window_manager (Symbol) The window manager (currently only handles
+  #     :xmonad)
+  #   * :switch_to_workspace (Proc) _Optional_ The proc which, when called,
+  #     returns a string which, when interpreted, will switch to the specified
+  #     workspace
+  # @param [Proc] block The code to execute after initialization
+  def initialize(options = {}, &block)
+    window_manager = options.delete :window_manager
+    case window_manager
+    when :xmonad
+      require 'mani/x'
+
+      @windowing_system = Mani::X.new
+      @window_manager_options = {
+        switch_to_workspace: ->(space) { "super+#{space}" }
+      }.merge options
+    else
+      fail 'Unrecognized :window_manager.'
+    end
+
+    @windows = {}
+
+    instance_eval(&block)
+  end
+
+  # Creates a new window object, or defers execution of the supplied block to
+  # an existing window object.
+  #
+  # @param [Symbol] name The window name
+  # @param [Hash] options The options
+  #   * :launch (String) _Optional_ The program to launch. If specified, any
+  #     remaining options, as well as the supplied block, will be passed to
+  #     Mani::Window#launch. If not specified, the supplied block will be
+  #     executed (within the context of the window).
+  # @param [Proc] block The code to execute
+  def window(name, options = {}, &block)
+    @windows[name] = Window.new @windowing_system unless @windows[name]
+
+    program = options.delete :launch
+    if program
+      @windows[name].launch program, options, &block
+    else
+      @windows[name].instance_eval(&block)
+    end
+  end
+
+  # Switches to the specified workspace.
+  #
+  # @param [Integer] space The space number
+  # @param [Proc] block The code to execute after switching to the workspace
+  def workspace(space, &block)
+    sequence = @window_manager_options[:switch_to_workspace].call space
+    @windowing_system.type_keysequence sequence
+
+    instance_eval(&block) if block
+  end
+end

data/mani.gemspec

@@ -0,0 +1,19 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'mani/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'mani'
+  gem.homepage      = 'https://github.com/NSinopoli/mani'
+  gem.license       = 'BSD (3-Clause)'
+  gem.summary       = 'A window automation tool'
+  gem.description   = 'A window automation tool'
+  gem.email         = 'NSinopoli@gmail.com'
+  gem.authors       = ['Nick Sinopoli']
+
+  gem.version       = Mani::Version::VERSION
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(spec)/})
+  gem.require_paths = ['lib']
+end

data/spec/lib/tokenizer_spec.rb

@@ -0,0 +1,237 @@
+require 'minitest/autorun'
+require_relative '../../lib/mani/tokenizer'
+
+describe Mani::Tokenizer do
+  describe '.get_tokens' do
+    describe 'when there are no tags' do
+      it 'returns the correct tokens' do
+        source = 'static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [[:static, 'static']]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there is an opening tag and no closing tag' do
+      it 'returns the correct tokens' do
+        source = 'static {{ static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static {{ static'],
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there is a closing tag and no opening tag' do
+      it 'returns the correct tokens' do
+        source = 'static }} static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static }} static']
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there is a commented opening tag and no closing tag' do
+      it 'returns the correct tokens' do
+        source = 'static %{{ static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static {{ static']
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there is a commented closing tag and no opening tag' do
+      it 'returns the correct tokens' do
+        source = 'static %}} static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static }} static']
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there are commented opening and closing tags' do
+      it 'returns the correct tokens' do
+        source = 'static %{{seq%}} static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static {{seq}} static'],
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there is a commented opening tag and a closing tag' do
+      it 'returns the correct tokens' do
+        source = 'static %{{seq}} static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static {{seq}} static'],
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there is an opening tag and a commented closing tag' do
+      it 'returns the correct tokens' do
+        source = 'static {{seq%}} static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static {{seq}} static'],
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there is an empty sequence' do
+      it 'returns the correct tokens' do
+        source = '{{}}'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = []
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there is one, unnested sequence' do
+      it 'returns the correct tokens' do
+        source = 'static {{seq}} static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static '],
+          [:sequence, 'seq'],
+          [:static, ' static']
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there is a sequence with a commented opening tag within' do
+      it 'returns the correct tokens' do
+        source = 'static {{seq %{{ }} static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static '],
+          [:sequence, 'seq {{ '],
+          [:static, ' static']
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there is a sequence with a commented closing tag within' do
+      it 'returns the correct tokens' do
+        source = 'static {{seq %}} }} static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static '],
+          [:sequence, 'seq }} '],
+          [:static, ' static']
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there are commented tags within a sequence' do
+      it 'returns the correct tokens' do
+        source = 'static {{seq %{{ nested %}} }} static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static '],
+          [:sequence, 'seq {{ nested }} '],
+          [:static, ' static']
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there is a sequence within commented tags' do
+      it 'returns the correct tokens' do
+        source = 'static %{{comment {{seq}} %}} static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static {{comment '],
+          [:sequence, 'seq'],
+          [:static, ' }} static']
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there is a sequence within a sequence' do
+      it 'returns the correct tokens' do
+        source = 'static {{nested {{seq}} }} static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, 'static '],
+          [:sequence, 'nested {{seq'],
+          [:static, ' }} static']
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there are multiple, unnested sequence' do
+      it 'returns the correct tokens' do
+        source = '{{seq}} static {{second seq}} more static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:sequence, 'seq'],
+          [:static, ' static '],
+          [:sequence, 'second seq'],
+          [:static, ' more static']
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when there are multiple empty sequence' do
+      it 'returns the correct tokens' do
+        source = '{{}} static {{}}'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, ' static '],
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when the tags are out of order' do
+      it 'returns the correct tokens' do
+        source = '}} static {{'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, '}} static {{'],
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when the commenting tags are out of order' do
+      it 'returns the correct tokens' do
+        source = '%}} static %{{'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, '}} static {{'],
+        ]
+        actual.must_equal expected
+      end
+    end
+
+    describe 'when literal commenting tags are used' do
+      it 'returns the correct tokens' do
+        source = '%%{{ static %%}} more static'
+        actual = Mani::Tokenizer.get_tokens source
+        expected = [
+          [:static, '%{{ static %}} more static'],
+        ]
+        actual.must_equal expected
+      end
+    end
+  end
+end

data/spec.rb

@@ -0,0 +1,3 @@
+Dir.glob('spec/**/*.rb').each do |file|
+  require_relative file.sub(/\.rb$/, '')
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: mani
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Nick Sinopoli
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-14 00:00:00.000000000 Z
+dependencies: []
+description: A window automation tool
+email: NSinopoli@gmail.com
+executables:
+- mani
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rubocop.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- Makefile
+- README.md
+- bin/mani
+- examples/chording.rb
+- examples/hello.rb
+- examples/workspace_initializer.rb
+- lib/mani.rb
+- lib/mani/tokenizer.rb
+- lib/mani/version.rb
+- lib/mani/window.rb
+- lib/mani/x.rb
+- mani.gemspec
+- spec.rb
+- spec/lib/tokenizer_spec.rb
+homepage: https://github.com/NSinopoli/mani
+licenses:
+- BSD (3-Clause)
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.4
+signing_key: 
+specification_version: 4
+summary: A window automation tool
+test_files:
+- spec/lib/tokenizer_spec.rb