vimrunner 0.0.4 → 0.1.0

data/README.md

@@ -1,55 +1,87 @@
-Using Vim's client/server functionality, this library exposes a way to spawn a
-Vim instance and control it programatically. Apart from being a fun party
-trick, this could be used to do integration testing on vimscript.
+# Vimrunner [![Build Status](https://secure.travis-ci.org/AndrewRadev/vimrunner.png?branch=master)](http://travis-ci.org/AndrewRadev/vimrunner)
+
+Using Vim's
+[client/server](http://vimdoc.sourceforge.net/htmldoc/remote.html#clientserver)
+functionality, this library exposes a way to spawn a Vim instance and control
+it programatically. Apart from being a fun party trick, this can be used to do
+integration testing on Vimscript.
 
 This is still fairly experimental, so use with caution. Any issue reports or
 contributions are very welcome on the
-[github issue tracker](https://github.com/AndrewRadev/Vimrunner/issues)
+[GitHub issue tracker](https://github.com/AndrewRadev/Vimrunner/issues).
 
 ## Usage
 
-There are two objects that can be used to control Vim, a "server" and a
-"client". The server takes care of spawning a server vim instance that will be
-controlled, and the client is its interface.
+Vimrunner can be used in one of two main ways:
 
-A server can be started in two ways:
+```ruby
+# Vim will automatically be started and killed.
+Vimrunner.start do |vim|
+  vim.edit "file.txt"
+  vim.insert "Hello"
+  vim.write
+end
+```
 
-  - `Vimrunner::Server.start`: Starts a terminal instance. Since it's
-    "invisible", it's nice for use in automated tests. If it's impossible to
-    start a terminal instance due to missing requirements for the `vim` binary
-    (see "Requirements" below), a GUI instance will be started.
-  - `Vimrunner::Server.start(:gui => true)`: Starts a GUI instance of Vim. On
-    Linux, it'll be a `gvim`, on Mac it defaults to `mvim`.
+```ruby
+# Vim will automatically be started but you must manually kill it when you are
+# finished.
+vim = Vimrunner.start
+vim.edit "file.txt"
+vim.insert "Hello"
+vim.write
+vim.kill
+```
 
-Both methods return a `Server` instance. For a more comprehensive list of
-options you can start the server with, check out
-[the docs](http://rubydoc.info/gems/vimrunner/Vimrunner/Server).
+Vimrunner will attempt to start up the most suitable version of Vim available,
+meaning:
 
-To be able to send commands to the server, you need a client that knows some
-details about it:
+* `vim` if it supports headlessly creating servers;
+* `mvim` if you are on Mac OS X;
+* `gvim`.
 
-``` ruby
-server = Vimrunner::Server.start
+If you wish to always start a GUI Vim (viz. skip using a headless `vim`) then
+you can use `start_gvim` like so:
+
+```ruby
+Vimrunner.start_gvim do |vim|
+  # ...
+end
+```
+
+If you require an even more specific version of Vim, you can pass the path to
+it by instantiating your own `Server` instance like so:
 
-client = Vimrunner::Client.new(server)
-# or,
-client = server.new_client
+```ruby
+Vimrunner::Server.new("/path/to/my/specific/vim").start do |vim|
+  vim.edit "file.txt"
+end
 ```
 
-There are also two convenience methods that start a server and return a
-connected client -- `Vimrunner.start_vim` and `Vimrunner.start_gui_vim`.
+(You can also use the non-block form of `start` in both of the above
+examples.)
 
-For a full list of methods you can invoke on the remote vim instance, check out
-the methods on the `Client` class in
-[the docs](http://rubydoc.info/gems/vimrunner/Vimrunner/Client).
+Calling `start` (or `start_gvim`) will return a `Client` instance with which
+you can control Vim. For a full list of methods you can invoke on the remote
+vim instance, check out the [`Client`
+documentation](http://rubydoc.info/gems/vimrunner/Vimrunner/Client).
 
 ## Requirements
 
 Vim needs to be compiled with `+clientserver`. This should be available with
-the `normal`, `big` and `huge` featuresets. The client/server functionality
-(regrettably) needs a running X server to function, even for a terminal vim.
-This means that if you're using it for automated tests on a remote server,
-you'll probably need to start it with xvfb.
+the `normal`, `big` and `huge` featuresets or by using
+[MacVim](http://code.google.com/p/macvim/) on Mac OS X. In order to start a
+server without a GUI, you will also need `+xterm-clipboard` [as described in
+the Vim
+manual](http://vimdoc.sourceforge.net/htmldoc/remote.html#x11-clientserver).
+
+The client/server functionality (regrettably) needs a running X server to
+function, even without a GUI. This means that if you're using it for
+automated tests on a remote server, you'll probably need to start it with
+xvfb.
+
+If you are using MacVim, note that you will need the `mvim` binary in your
+`PATH` in order to start and communicate with Vim servers.
 
 ## Experimenting
 

data/bin/vimrunner

@@ -5,6 +5,6 @@ $: << File.expand_path('../../lib', __FILE__)
 require 'irb'
 require 'vimrunner'
 
-$vim = Vimrunner.start_gui_vim
+$vim = Vimrunner.start_gvim
 
 IRB.start

data/lib/vimrunner.rb

@@ -1,16 +1,51 @@
-require 'vimrunner/client'
-require 'vimrunner/server'
+require "vimrunner/server"
+require "vimrunner/platform"
 
 module Vimrunner
-  # Starts a new Server with a terminal vim instance and returns a client,
-  # connected to it.
-  def self.start_vim
-    Client.new(Server.start)
+
+  # Public: Start a Vim process and return a Client through which it can be
+  # controlled.
+  #
+  # vim - The String path to the Vim you wish to use (default: the most
+  #       appropriate Vim for your system).
+  # blk - An optional block which will be passed a Client with which you can
+  #       communicate with the Vim process. Upon exiting the block, the Vim
+  #       process will be terminated.
+  #
+  # Examples
+  #
+  #   client = Vimrunner.start
+  #   # => #<Vimrunner::Client>
+  #
+  #   Vimrunner.start do |client|
+  #     client.command("version")
+  #   end
+  #
+  # Returns a Client for the started Server.
+  def self.start(vim = Platform.vim, &blk)
+    Server.new(vim).start(&blk)
   end
 
-  # Starts a new Server with a GUI vim instance and returns a client, connected
-  # to it.
-  def self.start_gui_vim
-    Client.new(Server.start(:gui => true))
+  # Public: Start a Vim process with a GUI and return a Client through which
+  # it can be controlled.
+  #
+  # vim - The String path to the Vim you wish to use (default: the most
+  #       appropriate Vim for your system).
+  # blk - An optional block which will be passed a Client with which you can
+  #       communicate with the Vim process. Upon exiting the block, the Vim
+  #       process will be terminated.
+  #
+  # Examples
+  #
+  #   client = Vimrunner.start
+  #   # => #<Vimrunner::Client>
+  #
+  #   Vimrunner.start do |client|
+  #     client.command("version")
+  #   end
+  #
+  # Returns a Client for the started Server.
+  def self.start_gvim(&blk)
+    Server.new(Platform.gvim).start(&blk)
   end
 end

data/lib/vimrunner/client.rb

@@ -1,62 +1,79 @@
-require 'vimrunner/shell'
-
 module Vimrunner
-
-  # A Client is simply a proxy to a Vim server. It's initialized with a Server
-  # instance and sends commands, keys and signals to it.
   class Client
+    attr_reader :server
+
     def initialize(server)
       @server = server
     end
 
-    # Adds a plugin to Vim's runtime. Initially, Vim is started without
-    # sourcing any plugins to ensure a clean state. This method can be used to
-    # populate the instance's environment.
+    # Public: Adds a plugin to Vim's runtime. Initially, Vim is started
+    # without sourcing any plugins to ensure a clean state. This method can be
+    # used to populate the instance's environment.
     #
     # dir          - The base directory of the plugin, the one that contains
     #                its autoload, plugin, ftplugin, etc. directories.
-    # entry_script - The Vim script that's runtime'd to initialize the plugin.
-    #                Optional.
+    # entry_script - The Vim script that's runtime'd to initialize the plugin
+    #                (optional).
     #
-    # Example:
+    # Examples
     #
     #   vim.add_plugin 'rails', 'plugin/rails.vim'
     #
+    # Returns nothing.
     def add_plugin(dir, entry_script = nil)
       command("set runtimepath+=#{dir}")
       command("runtime #{entry_script}") if entry_script
     end
 
-    # Invokes one of the basic actions the Vim server supports, sending a key
-    # sequence. The keys are sent as-is, so it'd probably be better to use the
-    # wrapper methods, #normal, #insert and so on.
+    # Public: Switches Vim to normal mode and types in the given keys.
+    #
+    # Returns nothing.
+    def normal(keys = "")
+      server.remote_send("<C-\\><C-n>#{keys}")
+    end
+
+    # Public: Invokes one of the basic actions the Vim server supports,
+    # sending a key sequence. The keys are sent as-is, so it'd probably be
+    # better to use the wrapper methods, #normal, #insert and so on.
+    #
+    # Returns nothing.
     def type(keys)
-      invoke_vim '--remote-send', keys
+      server.remote_send(keys)
     end
 
-    # Executes the given command in the Vim instance and returns its output,
-    # stripping all surrounding whitespace.
-    def command(vim_command)
+    # Public: Starts a search in Vim for the given text. The result is that
+    # the cursor is positioned on its first occurrence.
+    #
+    # Returns nothing.
+    def search(text)
       normal
+      type "/#{text}<CR>"
+    end
 
-      expression = "VimrunnerEvaluateCommandOutput('#{vim_command.to_s}')"
+    # Public: Switches Vim to insert mode and types in the given text.
+    #
+    # Returns nothing.
+    def insert(text)
+      normal "i#{text}"
+    end
 
-      invoke_vim('--remote-expr', expression).strip.tap do |output|
-        raise InvalidCommandError if output =~ /^Vim:E\d+:/
-      end
+    # Public: Writes the file being edited to disk. Note that you probably
+    # want to set the file's name first by using Runner#edit.
+    def write
+      command :write
     end
 
-    # Starts a search in Vim for the given text. The result is that the cursor
-    # is positioned on its first occurrence.
-    def search(text)
-      normal
-      type "/#{text}<cr>"
+    # Public: Echo each expression with a space in between.
+    #
+    # Returns the String output.
+    def echo(*expressions)
+      command "echo #{expressions.join(' ')}"
     end
 
-    # Sets a setting in Vim. If +value+ is nil, the setting is considered to be
-    # a boolean.
+    # Public: Sets a setting in Vim. If +value+ is nil, the setting is
+    # considered to be a boolean.
     #
-    # Examples:
+    # Examples
     #
     #   vim.set 'expandtab'  # invokes ":set expandtab"
     #   vim.set 'tabstop', 3 # invokes ":set tabstop=3"
@@ -69,41 +86,39 @@ module Vimrunner
       end
     end
 
-    # Edits the file +filename+ with Vim.
+    # Public: Edits the file +filename+ with Vim.
     #
     # Note that this doesn't use the '--remote' Vim flag, it simply types in
-    # the command manually. This is necessary to avoid the Vim instance getting
-    # focus.
+    # the command manually. This is necessary to avoid the Vim instance
+    # getting focus.
+    #
+    # Returns nothing.
     def edit(filename)
       command "edit #{filename}"
     end
 
-    # Writes the file being edited to disk. Note that you probably want to set
-    # the file's name first by using Runner#edit.
-    def write
-      command :write
-    end
-
-    # Switches Vim to insert mode and types in the given text.
-    def insert(text = '')
-      normal "i#{text}"
-    end
+    # Public: Executes the given command in the Vim instance and returns its
+    # output, stripping all surrounding whitespace.
+    #
+    # Returns the string output.
+    # Raises InvalidCommandError if the command is not recognised by vim.
+    def command(commands)
+      expression = "VimrunnerEvaluateCommandOutput('#{escape(commands)}')"
 
-    # Switches Vim to normal mode and types in the given keys.
-    def normal(keys = '')
-      type "<c-\\><c-n>#{keys}"
+      server.remote_expr(expression).tap do |output|
+        raise InvalidCommandError if output =~ /^Vim:E\d+:/
+      end
     end
 
     # Kills the server it's connected to.
     def kill
-      @server.kill
+      server.kill
     end
 
     private
 
-    def invoke_vim(*args)
-      args = [@server.vim_path, '--servername', @server.name, *args]
-      Shell.run *args
+    def escape(string)
+      string.to_s.gsub("'", "''")
     end
   end
 end

data/lib/vimrunner/errors.rb

@@ -1,6 +1,12 @@
 module Vimrunner
   class InvalidCommandError < RuntimeError; end
 
+  class NoSuitableVimError < RuntimeError
+    def message
+      "No suitable Vim executable could be found for this system."
+    end
+  end
+
   class TimeoutError < RuntimeError
     def message
       "Timed out while waiting for serverlist. Is an X11 server running?"

data/lib/vimrunner/platform.rb

@@ -0,0 +1,77 @@
+require "rbconfig"
+
+require "vimrunner/errors"
+
+module Vimrunner
+
+  # Public: The Platform module contains logic for finding a Vim executable
+  # that supports the clientserver functionality on the current system. Its
+  # methods can be used to fetch a Vim path for initializing a Server.
+  #
+  # Examples
+  #
+  #   Vimrunner::Platform.vim
+  #   # => "gvim"
+  module Platform
+    extend self
+
+    # Public: Looks for a Vim executable that's suitable for the current
+    # platform. Also attempts to find an appropriate GUI vim if terminal ones
+    # are unsuitable.
+    #
+    # Returns the String Vim executable.
+    # Raises NoSuitableVimError if no suitable Vim can be found.
+    def vim
+      vims.find { |vim| suitable?(vim) } or raise NoSuitableVimError
+    end
+
+    # Public: Looks for a GUI Vim executable that's suitable for the current
+    # platform.
+    #
+    # Returns the String Vim executable.
+    # Raises NoSuitableVimError if no suitable Vim can be found.
+    def gvim
+      gvims.find { |gvim| suitable?(gvim) } or raise NoSuitableVimError
+    end
+
+    private
+
+    def gvims
+      if mac?
+        %w( mvim gvim )
+      else
+        %w( gvim )
+      end
+    end
+
+    def vims
+      %w( vim ) + gvims
+    end
+
+    def suitable?(vim)
+      features = features(vim)
+
+      if gui?(vim)
+        features.include?("+clientserver")
+      else
+        features.include?("+clientserver") && features.include?("+xterm_clipboard")
+      end
+    end
+
+    def gui?(vim)
+      executable = File.basename(vim)
+
+      executable[0, 1] == "g" || executable[0, 1] == "m"
+    end
+
+    def features(vim)
+      IO.popen([vim, "--version"]) { |io| io.read.strip }
+    rescue Errno::ENOENT
+      ""
+    end
+
+    def mac?
+      RbConfig::CONFIG["host_os"] =~ /darwin/
+    end
+  end
+end

data/lib/vimrunner/server.rb

@@ -1,152 +1,122 @@
-require 'timeout'
-require 'rbconfig'
-require 'pty'
+require "timeout"
+require "pty"
 
-require 'vimrunner/errors'
-require 'vimrunner/shell'
-require 'vimrunner/client'
+require "vimrunner/errors"
+require "vimrunner/client"
 
 module Vimrunner
 
-  # The Server is a wrapper around the Vim server process that is controlled by
-  # clients. It will attempt to start the most appropriate Vim binary available
-  # on the system, though there are some options that can control this
-  # behaviour. See #initialize for more details.
+  # Public: A Server has the responsibility of starting a Vim process and
+  # communicating with it through the clientserver interface. The process can
+  # be started with "start" and stopped with "kill". A Client would be
+  # necessary as the actual interface, though it is possible to use a Server
+  # directly to invoke --remote commands on its Vim instance.
   class Server
-    class << self
+    VIMRC = File.expand_path("../../../vim/vimrc", __FILE__)
 
-      # A convenience method that initializes a new server and starts it.
-      def start(options = {})
-        server = new(options)
-        server.start
-      end
-
-      # A convenience method that returns a new Client instance, connected to
-      # the server.
-      def new_client
-        Client.new(self)
-      end
-
-      # The default path to use when starting a server with a terminal Vim. If
-      # the "vim" executable is not compiled with clientserver capabilities,
-      # the GUI version is started instead.
-      def vim_path
-        'vim'
-      end
-
-      # The default path to use when starting a server with the GUI version of
-      # Vim. Defaults to "mvim" on a mac and "gvim" on linux.
-      def gui_vim_path
-        if mac?
-          'mvim'
-        else
-          'gvim'
-        end
-      end
-
-      # The path to a vimrc file containing some required vimscript. The server
-      # is started with no settings or a vimrc, apart from this one.
-      def vimrc_path
-        File.join(File.expand_path('../../..', __FILE__), 'vim', 'vimrc')
-      end
-
-      # Returns true if the current operating system is Mac OS X.
-      def mac?
-        host_os =~ /darwin/
-      end
+    attr_reader :name, :executable
 
-      # Returns true if the given Vim binary is compiled with support for the
-      # client/server functionality.
-      def clientserver_enabled?(vim_path)
-        vim_version = %x[#{vim_path} --version]
-        vim_version.include? '+clientserver' and vim_version.include? '+xterm_clipboard'
-      end
-
-      private
-
-      def host_os
-        RbConfig::CONFIG['host_os']
-      end
+    # Public: Initialize a Server
+    #
+    # executable - a String representing a Vim executable.
+    def initialize(executable)
+      @executable = executable
+      @name = "VIMRUNNER#{rand}"
     end
 
-    attr_accessor :pid
-    attr_reader :name, :vim_path
-
-    # A Server is initialized with two options that control its behaviour:
+    # Public: Start a Server. This spawns a background process.
     #
-    #   :gui      - Whether or not to start Vim with a GUI, either 'gvim' or 'mvim'
-    #               depending on the OS. The default is false, which means that
-    #               the server will start itself as a terminal instance. Note
-    #               that, if the terminal Vim doesn't have client/server
-    #               support, a GUI version will be started anyway.
+    # Examples
     #
-    #   :vim_path - A path to a custom Vim binary. If this option is not set,
-    #               the server attempts to guess an appropriate one, given the
-    #               :gui option and the current OS.
+    #   client = Vimrunner::Server.new("vim").start
+    #   # => #<Vimrunner::Client>
     #
-    # Note that simply initializing a Server doesn't start the binary. You need
-    # to call the #start method to do that.
+    #   Vimrunner::Server.new("vim").start do |client|
+    #     client.edit("foo")
+    #   end
     #
-    # Examples:
-    #
-    #   server = Server.new                              # Will start a 'vim' if possible
-    #   server = Server.new(:gui => true)                # Will start a 'gvim' or 'mvim' depending on the OS
-    #   server = Server.new(:vim_path => '/opt/bin/vim') # Will start a server with the given vim instance
-    #
-    def initialize(options = {})
-      @gui      = options[:gui]
-      @vim_path = options[:vim_path]
-      @name     = "VIMRUNNER#{rand.to_s}"
+    # Returns a new Client instance initialized with this Server.
+    # Yields a new Client instance initialized with this Server.
+    def start
+      if block_given?
+        spawn do |r, w, pid|
+          begin
+            wait_until_started
+            @result = yield(new_client)
+          ensure
+            r.close
+            w.close
+          end
+        end
 
-      if not @vim_path or not Server.clientserver_enabled? @vim_path
-        @vim_path = Server.vim_path
-      end
+        @result
+      else
+        @r, @w, @pid = spawn
+        wait_until_started
 
-      if @gui or not Server.clientserver_enabled? @vim_path
-        @gui      = true
-        @vim_path = Server.gui_vim_path
+        new_client
       end
     end
 
-    # Starts a Vim server.
-    def start
-      command = "#{vim_path} -f -u #{Server.vimrc_path} --noplugin --servername #{name}"
-
-      if gui?
-        @pid = Kernel.spawn(command, [:in, :out, :err] => :close)
-      else
-        _out, _in, @pid = PTY.spawn(command)
-      end
+    # Public: Kills the Vim instance in the background.
+    #
+    # Returns self.
+    def kill
+      @r.close
+      @w.close
+      Process.detach(@pid)
 
-      wait_until_started
       self
     end
 
-    # Returns true if the server is a GUI version of Vim. This can be forced by
-    # instantiating the server with :gui => true
-    def gui?
-      @gui
+    # Public: A convenience method that returns a new Client instance,
+    # connected to this server.
+    #
+    # Returns a Client.
+    def new_client
+      Client.new(self)
     end
 
-    # Kills the Vim instance in the background by sending it a TERM signal.
-    def kill
-      Shell.kill(@pid)
+    # Public: Retrieves a list of names of currently running Vim servers.
+    #
+    # Returns an Array of String server names currently running.
+    def serverlist
+      execute([executable, "--serverlist"]).split("\n")
     end
 
-    # Retrieve a list of names of currently running Vim servers.
-    def serverlist
-      %x[#{vim_path} --serverlist].strip.split "\n"
+    # Public: Evaluates an expression in the Vim server and returns the result.
+    # A wrapper around --remote-expr.
+    #
+    # expression - a String with a Vim expression to evaluate.
+    #
+    # Returns the String output of the expression.
+    def remote_expr(expression)
+      execute([executable, "--servername", name, "--remote-expr", expression])
+    end
+
+    # Public: Sends the given keys
+    # A wrapper around --remote-expr.
+    #
+    # keys - a String with a sequence of Vim-compatible keystrokes.
+    #
+    # Returns nothing.
+    def remote_send(keys)
+      execute([executable, "--servername", name, "--remote-send", keys])
     end
 
     private
 
+    def execute(command)
+      IO.popen(command) { |io| io.read.strip }
+    end
+
+    def spawn(&blk)
+      PTY.spawn(executable, "-f", "--servername", name, "-u", VIMRC, &blk)
+    end
+
     def wait_until_started
       Timeout.timeout(5, TimeoutError) do
-        servers = serverlist
-        while servers.empty? or not servers.include? name
-          sleep 0.1
-          servers = serverlist
-        end
+        sleep 0.1 while !serverlist.include?(name)
       end
     end
   end

data/lib/vimrunner/version.rb

@@ -1,3 +1,3 @@
 module Vimrunner
-  VERSION = '0.0.4'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vimrunner
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-22 00:00:00.000000000 Z
+date: 2012-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &20415700 !ruby/object:Gem::Requirement
+  requirement: &19072460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *20415700
+  version_requirements: *19072460
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &20415020 !ruby/object:Gem::Requirement
+  requirement: &19071860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,21 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *20415020
+  version_requirements: *19071860
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &19071280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19071280
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &20414500 !ruby/object:Gem::Requirement
+  requirement: &19069980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +54,10 @@ dependencies:
         version: 2.0.0
   type: :development
   prerelease: false
-  version_requirements: *20414500
-description: ! "    Using vim's client/server functionality, this library exposes
-  a way to\n    spawn a vim instance and control it programatically. Apart from being
-  a fun\n    party trick, this could be used to do integration testing on vimscript.\n"
+  version_requirements: *19069980
+description: ! "    Using Vim's client/server functionality, this library exposes
+  a way to\n    spawn a Vim instance and control it programatically. Apart from being
+  a fun\n    party trick, this can be used to integration test Vim script.\n"
 email:
 - andrey.radev@gmail.com
 executables:
@@ -56,8 +67,8 @@ extra_rdoc_files: []
 files:
 - lib/vimrunner.rb
 - lib/vimrunner/errors.rb
-- lib/vimrunner/shell.rb
 - lib/vimrunner/server.rb
+- lib/vimrunner/platform.rb
 - lib/vimrunner/version.rb
 - lib/vimrunner/client.rb
 - vim/vimrc
@@ -78,7 +89,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 507320625350919209
+      hash: 3979564230760095821
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -90,5 +101,5 @@ rubyforge_project: vimrunner
 rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
-summary: Lets you control a vim instance through ruby
+summary: Lets you control a Vim instance through Ruby
 test_files: []

data/lib/vimrunner/shell.rb

@@ -1,24 +0,0 @@
-module Vimrunner
-
-  # The Shell module contains functions that interact directly with the shell.
-  # They're general utilities that help with some of the specific use cases
-  # that pop up with the vim runner.
-  module Shell
-    extend self
-
-    # Executes a shell command, waits until it's finished, and returns the
-    # output
-    def run(*command)
-      IO.popen(command) { |io| io.read.strip }
-    end
-
-    # Sends a TERM signal to the given PID. Returns true if the process was
-    # found and killed, false otherwise.
-    def kill(pid)
-      Process.kill('TERM', pid)
-      true
-    rescue Errno::ESRCH
-      false
-    end
-  end
-end