editserver 0.1.1

data/.gitignore

@@ -0,0 +1,7 @@
+pkg/*
+*.gem
+.bundle
+Gemfile.lock
+extra/editserver.scpt
+tags
+test/editserverrc

data/Gemfile

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

data/README.markdown

@@ -0,0 +1,28 @@
+
+             __      __
+            /\ \  __/\ \__
+       __   \_\ \/\_\ \ ,_\   ____     __   _ __   __  __     __   _ __
+     /'__`\ /'_` \/\ \ \ \/  /',__\  /'__`\/\`'__\/\ \/\ \  /'__`\/\`'__\
+    /\  __//\ \L\ \ \ \ \ \_/\__, `\/\  __/\ \ \/ \ \ \_/ |/\  __/\ \ \/
+    \ \____\ \___,_\ \_\ \__\/\____/\ \____\\ \_\  \ \___/ \ \____\\ \_\
+     \/____/\/__,_ /\/_/\/__/\/___/  \/____/ \/_/   \/__/   \/____/ \/_/
+
+                                             guns <sung@metablu.com>
+
+
+# Your favorite editor, as a local web service!
+
+For use with [Textaid][1], on OS X with included applescript, or with any other
+http client.
+
+Everything works, and core tests are in place. More information forthcoming.
+
+
+### TODO
+
+ * Finish remaining tests
+ * Improve applescript reliability
+ * Clean up `Editserver::` namespace
+
+
+[1]: https://chrome.google.com/webstore/detail/ppoadiihggafnhokfkpphojggcdigllp

data/Rakefile

@@ -0,0 +1,30 @@
+require 'shellwords'
+require 'fileutils'
+require 'erb'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+desc 'Run all tests'
+task :test do
+  Dir['test/**/*.test.rb'].each { |f| load f }
+end
+
+if RUBY_PLATFORM[/darwin/]
+  $:.unshift File.expand_path('../lib', __FILE__)
+  require 'editserver/command'
+
+  @cmd = Editserver::Command.new
+
+  desc "[PORT=#{@cmd.rackopts[:Port]}] Compile included AppleScript and place in ~/Library/Scripts/"
+  task :applescript do
+    @port   = ENV['PORT'] || @cmd.rackopts[:Port]
+    buf     = ERB.new(File.read 'extra/editserver.applescript.erb').result(binding)
+    outfile = File.expand_path '~/Library/Scripts/editserver.scpt'
+
+    puts "Writing #{outfile}"
+    FileUtils.mkdir_p File.dirname(outfile)
+    system "echo #{buf.shellescape} | osacompile -o #{outfile.shellescape}"
+  end
+end

data/bin/editserver

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'editserver/command'
+Editserver::Command.new(ARGV).run

data/editserver.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'editserver/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'editserver'
+  s.version     = Editserver::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Sung Pae']
+  s.email       = ['sung@metablu.com']
+  s.homepage    = 'http://github.com/guns/editserver'
+  s.summary     = %q{Your favorite editor, in every app}
+  s.description = %Q{Simple local server for editing text in your favorite editor.}
+
+  s.rubyforge_project = 'editserver'
+
+  s.files         = %x(git ls-files).split "\n"
+  s.test_files    = %x(git ls-files -- {test,spec,features}/*).split "\n"
+  s.executables   = %x(git ls-files -- bin/*).split("\n").map { |f| File.basename f }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'rack', '~> 1.2'
+
+  s.add_development_dependency 'minitest', '~> 2.0'
+  s.add_development_dependency 'ruby-debug19' if RUBY_VERSION >= '1.9.0'
+end

data/extra/editserver.applescript.erb

@@ -0,0 +1,46 @@
+(*
+    Edit in Editserver
+
+    guns <sung@metablu.com>
+    http://github.com/guns/editserver
+    MIT LICENSE
+
+    "AppleScript sucks"
+*)
+
+tell application "System Events"
+    set current_app to name of (first process whose frontmost is true) as text
+end tell
+
+tell application current_app
+    activate -- script is probably being executed by a launcher
+
+    -- HACK: tell messages are async, so we delay, since I don't know how
+    --       to register a callback in AppleScript
+    tell application "System Events"
+        delay 0.5
+        keystroke "a" using command down
+        delay 0.5
+        keystroke "c" using command down
+    end tell
+end tell
+
+-- URI.escape does not escape `&'s; CGI.escape is more thorough
+set output to do shell script "/usr/bin/env ruby -r cgi -e '
+    system *%W[curl -s --data id=applescript
+                       --data url=#{CGI.escape %q(" & current_app & ")}
+                       --data text=#{CGI.escape %x(pbpaste)}
+                       http://127.0.0.1:<%= @port %>]
+    ' | pbcopy" -- pipe to clipboard
+
+tell application current_app
+    activate -- make sure we switch back; not all editors will raise focus
+
+    -- HACK: see above
+    tell application "System Events"
+        delay 0.5
+        keystroke "a" using command down
+        delay 0.5
+        keystroke "v" using command down
+    end tell
+end tell

data/lib/editserver/command.rb

@@ -0,0 +1,108 @@
+require 'optparse'
+require 'yaml'
+require 'rack'
+require 'editserver'
+
+class Editserver
+  class Command
+    def initialize args = []
+      @args = args
+      @opts = { :rcfile => "~/.editserverrc" }
+
+      # keys are strings because YAML.load returns string keys,
+      # and we are not restricting the keys like @rackopts
+      @editoropts = {
+        'default'  => nil,
+        'terminal' => nil
+      }
+
+      @rackopts = {
+        :environment => 'development',
+        :pid         => nil,
+        :Port        => 9999,
+        :Host        => '127.0.0.1',
+        :AccessLog   => [],
+        :config      => ''
+      }
+    end
+
+    def options
+      OptionParser.new do |opt|
+        opt.summary_width = 20
+
+        opt.banner = %Q(\
+          Usage: #{File.basename $0} [options]
+
+          Options:
+        ).gsub /^ +/, ''
+
+        opt.on '-p', '--port NUMBER', Integer, "default: #{rackopts[:Port]}" do |arg|
+          @rackopts[:Port] = arg
+        end
+
+        opt.on '-t', '--terminal CMD', 'Terminal to launch for console editors' do |arg|
+          @editoropts['terminal'] = arg
+        end
+
+        opt.on '--rc PATH', "Path to rc file; #{@opts[:rcfile]} by default",
+               '(Also can be set by exporting EDITSERVERRC to environment)' do |arg|
+          @rcopts = nil # reset cached user opts
+          @opts[:rcfile] = File.expand_path arg
+        end
+
+        opt.on '--no-rc', 'Suppress reading of rc file' do
+          @opts[:norcfile] = true
+        end
+      end
+    end
+
+    def rcopts
+      @rcopts ||= begin
+        empty  = { 'rack' => {}, 'editor' => {} }
+        rcfile = File.expand_path ENV['EDITSERVERRC'] || @opts[:rcfile]
+
+        if @opts[:norcfile]
+          empty
+        elsif File.exists? rcfile
+          opts = YAML.load_file File.expand_path rcfile
+          opts           ||= {}
+          opts['rack']   ||= {}
+          opts['editor'] ||= {}
+          opts
+        else
+          empty
+        end
+      end
+    end
+
+    # returns dup of @rackopts masked by rcopts
+    def rackopts
+      (opts = @rackopts.dup).keys.each do |k|
+        v = rcopts['rack'][k.to_s]
+        v = rcopts['rack'][k.to_s.downcase] if v.nil? # be tolerant of lowercase keys
+        opts[k] = v unless v.nil?
+      end
+
+      opts
+    end
+
+    # returns dup of @editoropts merged with rcopts
+    def editoropts
+      @editoropts.dup.merge rcopts['editor']
+    end
+
+    def server
+      # HACK: Fixed in master -- remove when upgrading min rack dependency
+      # http://groups.google.com/group/rack-devel/browse_thread/thread/8f6c3b79c99809ee
+      srv = Rack::Server.new rackopts
+      srv.instance_variable_set :@app, Editserver.new(editoropts)
+      srv
+    end
+
+    def run
+      options.parse @args
+      $0 = 'editserver'
+      server.start
+    end
+  end
+end

data/lib/editserver/editor.rb

@@ -0,0 +1,47 @@
+require 'shellwords'
+
+class Editserver
+  class Editor
+    class << self
+      attr_accessor :command
+
+      def define_editor editor, *params
+        @command = [%x(which #{editor}).chomp, *params]
+      end
+
+      @@terminal = nil
+
+      def terminal
+        @@terminal
+      end
+
+      def terminal= str
+        @@terminal = case str
+        when String   then str.shellsplit
+        when NilClass then nil
+        end
+      end
+    end # self
+
+    def terminal
+      @@terminal
+    end
+
+    def edit file
+      cmd = self.class.command
+
+      if not File.executable? cmd.first
+        File.open(file, 'w') { |f| f.write "Editor not found: #{cmd.first.inspect}" }
+        return
+      end
+
+      out = %x(#{(cmd + [file]).shelljoin} 2>&1).chomp
+
+      if $?.exitstatus.zero?
+        out
+      else
+        raise EditError, out
+      end
+    end
+  end
+end

data/lib/editserver/response.rb

@@ -0,0 +1,60 @@
+require 'tempfile'
+require 'rack/response'
+
+class Editserver
+  class Response
+    attr_reader :editor, :request, :response
+
+    def initialize editor, request
+      @editor   = editor
+      @request  = request
+      @response = Rack::Response.new
+    end
+
+    def call
+      tempfile = mktemp
+      editor.edit tempfile.path
+      response.write File.read(tempfile.path)
+      response.finish
+    rescue EditError => e
+      response.write e.to_s
+      response.status = 500 # server error
+      response.finish
+    ensure
+      if tempfile
+        tempfile.close
+        tempfile.unlink
+      end
+    end
+
+    private
+
+    def mktemp
+      file = Tempfile.new filename
+
+      if text = request.params['text']
+        file.write text
+        file.rewind
+      end
+
+      file
+    end
+
+    def filename
+      # `id' and `url' sent by TextAid
+      name    = 'editserver'
+      id, url = request.params.values_at 'id', 'url'
+
+      if id or url
+        name << '-' << id  if id
+        name << '-' << url if url
+      else
+        if agent = request.env['HTTP_USER_AGENT']
+          name << '-' << agent.split.first
+        end
+      end
+
+      name.gsub /[^\w\.]+/, '-'
+    end
+  end
+end

data/lib/editserver/terminal/emacs.rb

@@ -0,0 +1,24 @@
+require 'editserver/editor'
+
+class Editserver
+  class Emacs < Editor
+    define_editor *%w[emacsclient --alternate-editor='']
+
+    def start_server
+      pid = fork { exec *(terminal + %w[-e emacs --eval (server-start)]) }
+      sleep 2 # HACK!
+      Process.detach pid
+    end
+
+    def edit file
+      if terminal.nil?
+        File.open(file, 'w') { |f| f.write 'No terminal defined!' }
+      else
+        super
+      end
+    rescue EditError
+      start_server
+      super
+    end
+  end
+end

data/lib/editserver/terminal/vim.rb

@@ -0,0 +1,26 @@
+require 'editserver/editor'
+
+class Editserver
+  class Vim < Editor
+    define_editor *%w[vim --servername EDITSERVER --remote-tab-wait]
+
+    def server_available?
+      %x(vim --serverlist).split("\n").map { |l| l.strip.upcase }.include? 'EDITSERVER'
+    end
+
+    def start_server
+      pid = fork { exec *(terminal + %w[-e vim --servername EDITSERVER]) }
+      sleep 2 # HACK: a moment to initialize before returning
+      Process.detach pid
+    end
+
+    def edit file
+      if terminal.nil?
+        File.open(file, 'w') { |f| f.write 'No terminal defined!' }
+      else
+        start_server unless server_available?
+        super
+      end
+    end
+  end
+end

data/lib/editserver/version.rb

@@ -0,0 +1,3 @@
+class Editserver
+  VERSION = '0.1.1'
+end

data/lib/editserver.rb

@@ -0,0 +1,92 @@
+require 'shellwords'
+require 'rack'
+require 'editserver/response'
+require 'editserver/terminal/vim'
+require 'editserver/terminal/emacs'
+
+class Editserver
+  class EditError < StandardError; end
+  class RoutingError < StandardError; end
+
+  GUI_EDITORS = {
+    # OS X editors
+    'mate'   => 'mate -w',
+    'mvim'   => 'mvim --nofork --servername EDITSERVER', # does not return when app must be launched
+    'kod'    => 'open -a Kod -W',                        # app must quit to release control
+    'bbedit' => 'bbedit -w'                              # does not open file properly when app is launched
+  }
+
+  attr_reader :editors
+
+  # TODO: We are playing with global constants here;
+  #       this is simple, but we should stop
+  def initialize options = {}
+    opts            = options.dup
+    Editor.terminal = opts.delete 'terminal'
+
+    # seed with terminal-based editors, whose server/client modes are a bit too
+    # complicated to configure dynamically
+    @editors = {
+      'vim'   => Vim,
+      'emacs' => Emacs
+    }
+
+    register_editors GUI_EDITORS.merge(opts)
+  end
+
+  # returns Hash of name => EditorClass
+  def register_editors options = {}
+    opts = options.dup
+
+    if default = opts.delete('default')
+      @editors['default'] = default
+    end
+
+    # rest should be editor definitions
+    opts.each do |name, cmd|
+      klass = pascalize name
+      editor, params = cmd.shellsplit.partition.with_index { |w,i| i.zero? }
+
+      self.class.class_eval %Q(                                  # e.g. mate: mate -w
+        class #{klass} < Editor                                  # class Mate < Editor
+          define_editor #{editor[0].inspect}, *#{params.inspect} #   define_editor 'mate', *['-w']
+        end                                                      # end
+      )
+
+      @editors[name] = self.class.const_get klass.to_sym
+    end
+
+    @editors
+  end
+
+  # returns Editserver handler based on path
+  def editor path_info
+    path = path_info[%r(\A([/\w\.-]+)), 1]
+
+    if klass = editors[path[/\/(.*)/, 1]]
+      klass
+    elsif path == '/'
+      klass = editors[editors['default']]
+    end
+
+    raise RoutingError, "No handler for #{path}" if klass.nil?
+    klass
+  end
+
+  def call env
+    request = Rack::Request.new env
+    klass   = editor request.path_info
+    Response.new(klass.new, request).call
+  rescue RoutingError => e
+    warn e.to_s
+    res = Rack::Response.new
+    res.status = 500
+    res.finish
+  end
+
+  private
+
+  def pascalize str
+    str.capitalize.gsub(/[_-]+(.)/) { |m| m[1].chr.upcase }
+  end
+end

data/test/editserver/command.test.rb

@@ -0,0 +1,64 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'editserver/command'
+require 'minitest/pride' if $stdout.tty?
+require 'minitest/autorun'
+
+describe Editserver::Command do
+  describe :initialize do
+    it 'should take a single optional argument' do
+      Editserver::Command.method(:initialize).arity.must_equal -1
+    end
+
+    it 'should set internal state' do
+      cmd = Editserver::Command.new ['--no-rc']
+      cmd.instance_variable_get(:@args).must_equal ['--no-rc']
+      cmd.instance_variable_get(:@opts).must_equal(:rcfile => '~/.editserverrc')
+      cmd.instance_variable_get(:@editoropts).must_equal('default' => nil, 'terminal' => nil)
+      cmd.instance_variable_get(:@rackopts).keys.sort_by(&:to_s).must_equal [
+        :environment, :pid, :Port, :Host, :AccessLog, :config
+      ].sort_by &:to_s
+    end
+  end
+
+  describe :options do
+    before { @cmd = Editserver::Command.new ['--no-rc'] }
+
+    it 'should return an OptionParser object' do
+      @cmd.options.must_be_kind_of OptionParser
+    end
+
+    it 'should modify internal state when parsing a list of arguments' do
+      @cmd.options.parse %w[--port 1000]
+      @cmd.instance_variable_get(:@rackopts)[:Port].must_equal 1000
+
+      @cmd.options.parse %w[--terminal xterm]
+      @cmd.instance_variable_get(:@editoropts)['terminal'].must_equal 'xterm'
+
+      @cmd.options.parse %w[--rc /dev/null]
+      @cmd.instance_variable_get(:@opts)[:rcfile].must_equal '/dev/null'
+
+      @cmd.options.parse %w[--no-rc]
+      @cmd.instance_variable_get(:@opts)[:norcfile].must_equal true
+    end
+  end
+
+  #
+  # TODO: finish tests
+  #
+
+  describe :rcopts do
+  end
+
+  describe :rackopts do
+  end
+
+  describe :editoropts do
+  end
+
+  describe :server do
+  end
+
+  describe :run do
+  end
+end

data/test/editserver/editor.test.rb

@@ -0,0 +1,74 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'tempfile'
+require 'editserver/editor'
+require 'minitest/pride' if $stdout.tty?
+require 'minitest/autorun'
+
+describe Editserver::Editor do
+  before do
+    class Editserver
+      class CleverCat < Editor
+        define_editor 'cat', '--clever'
+      end
+    end
+    @klass = Editserver::CleverCat
+  end
+
+  describe :self do
+    describe :define_editor do
+      it "should populate the new class metaclass's @command" do
+        @klass.instance_variable_get(:@command).must_equal %w[/bin/cat --clever]
+      end
+    end
+
+    describe :@@terminal do
+      it "should have a reader and writer for the metaclass's @@terminal" do
+        @klass.terminal.must_equal nil
+        @klass.terminal = 'xterm -fg white -bg black'
+        @klass.terminal.must_equal %w[xterm -fg white -bg black]
+      end
+    end
+  end # self
+
+  describe :terminal do
+    it 'should have a reader for @@terminal at the instance level' do
+      @klass.terminal = nil
+      @klass.new.terminal.must_equal nil
+      @klass.terminal = 'urxvt -g 80x24'
+      @klass.new.terminal.must_equal %w[urxvt -g 80x24]
+    end
+  end
+
+  describe :edit do
+    before do
+      class Editserver
+        class TestEditor < Editor
+          define_editor File.expand_path('../../test-editor', __FILE__)
+        end
+      end
+      @klass = Editserver::TestEditor
+      @file  = Tempfile.new File.basename($0)
+    end
+
+    after { @file.close; @file.unlink }
+
+    it 'should write file with error message is editor is not found' do
+      class Editserver
+        class MysteryPony < Editor
+          define_editor 'magic-pony', '--mysterious'
+        end
+      end
+
+      Editserver::MysteryPony.new.edit @file.path
+      @file.read.must_match /not found:/
+    end
+
+    it 'should write the passed file' do
+      @file.write 'MAGICPONY'
+      @file.rewind
+      @klass.new.edit @file.path
+      @file.read.must_match /\AMAGICPONY.*test-editor\z/m
+    end
+  end
+end

data/test/editserver/response.test.rb

@@ -0,0 +1,51 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rack/mock'
+require 'editserver/response'
+require 'minitest/pride' if $stdout.tty?
+require 'minitest/autorun'
+
+describe Editserver::Response do
+  before do
+    class Editserver
+      class TestEditor < Editor
+        define_editor File.expand_path('../../test-editor', __FILE__)
+      end
+    end
+
+    @editor = Editserver::TestEditor.new
+    @uri    = 'http://127.0.0.1:9999'
+    @req    = lambda do |uri|
+      Rack::Request.new Rack::MockRequest.env_for(uri)
+    end
+  end
+
+  describe :initialize do
+    it 'should take two arguments' do
+      lambda { Editserver::Response.new }.must_raise ArgumentError
+      lambda { Editserver::Response.new @editor }.must_raise ArgumentError
+      lambda { Editserver::Response.new @editor, @req.call(@uri); raise RuntimeError }.must_raise RuntimeError
+    end
+
+    # implicitly tests attr readers as well
+    it 'should set public internal state' do
+      req = @req.call @uri
+      res = Editserver::Response.new @editor, req
+      res.editor.must_equal @editor
+      res.request.must_equal req
+      res.response.must_be_kind_of Rack::Response
+    end
+  end
+
+  describe :call do
+    it 'should modify the body of the response' do
+      res = Editserver::Response.new @editor, @req.call(@uri)
+      res.call[2].body.join.must_match /test-editor\z/
+    end
+
+    it 'should prepend contents of text param to response body if present' do
+      res = Editserver::Response.new @editor, @req.call(@uri + '/?text=SUGARPLUM')
+      res.call[2].body.join.must_match /\ASUGARPLUM.*test-editor\z/m
+    end
+  end
+end

data/test/editserver/terminal/emacs.test.rb

@@ -0,0 +1,5 @@
+$:.unshift File.expand_path('../../../lib', __FILE__)
+
+require 'editserver/terminal/emacs'
+require 'minitest/pride' if $stdout.tty?
+require 'minitest/autorun'

data/test/editserver/terminal/vim.test.rb

@@ -0,0 +1,5 @@
+$:.unshift File.expand_path('../../../lib', __FILE__)
+
+require 'editserver/terminal/vim'
+require 'minitest/pride' if $stdout.tty?
+require 'minitest/autorun'

data/test/editserver.test.rb

@@ -0,0 +1,160 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+$:.unshift File.dirname(__FILE__)
+
+require 'rack/mock'
+require 'minitest/pride' if $stdout.tty?
+require 'minitest/autorun'
+require 'editserver'
+require 'editserver/version'
+require 'editserver/command'
+
+describe Editserver do
+  describe :VERSION do
+    it 'should have a VERSION constant' do
+      Editserver::VERSION.must_match /\d+\.\d+\.\d+/
+    end
+  end
+
+  describe :ErrorClasses do
+    it 'should have some custom error classes' do
+      Editserver::EditError.new.must_be_kind_of StandardError
+      Editserver::RoutingError.new.must_be_kind_of StandardError
+    end
+  end
+
+  describe :GUI_EDITORS do
+    it 'should be a Hash of string keys and string values' do
+      Editserver::GUI_EDITORS.must_be_kind_of Hash
+      Editserver::GUI_EDITORS.each do |k,v|
+        k.must_be_kind_of String
+        v.must_be_kind_of String
+      end
+    end
+  end
+
+  describe :editors do
+    it 'should be a Hash of string keys and class values' do
+      (srv = Editserver.new).editors.must_be_kind_of Hash
+      srv.editors.each do |k,v|
+        k.must_be_kind_of String
+        v.must_be_kind_of Class
+      end
+    end
+  end
+
+  describe :initialize do
+    it 'should optionally accept an options Hash' do
+      Editserver.method(:initialize).arity.must_equal -1
+      lambda { Editserver.new 'string' }.must_raise TypeError
+    end
+
+    it 'should not mutate passed options Hash' do
+      Editserver.new(opts = { 'terminal' => 'xterm' })
+      opts['terminal'].must_equal 'xterm'
+    end
+
+    it 'should set Editor::terminal' do
+      Editserver.new 'terminal' => 'xterm -fg white'
+      Editserver::Editor.terminal.must_equal %w[xterm -fg white] # gross; on the todo list
+    end
+
+    it 'should set @editors' do
+      srv = Editserver.new
+      { 'vim' => Editserver::Vim, 'emacs' => Editserver::Emacs }.each do |k,v|
+        srv.editors[k].must_equal v
+      end
+
+      srv = Editserver.new 'kitten' => 'cat --with-qte'
+      srv.editors['kitten'].must_equal Editserver::Kitten
+    end
+  end
+
+  describe :register_editors do
+    before { @srv = Editserver.new }
+
+    it 'should not mutate passed options Hash' do
+      opts = { 'default' => 'cat', 'cat' => 'cat --regular' }
+      @srv.register_editors opts
+      opts['default'].must_equal 'cat'
+    end
+
+    it 'should set the default key' do
+      @srv.register_editors 'default' => 'vim'
+      @srv.editors['default'].must_equal 'vim'
+    end
+
+    it 'should create new subclasses of Editor, and place them in the @editors Hash' do
+      @srv.register_editors 'kitty_kitty' => 'cat --here-kitty-kitty'
+      const = Editserver.constants.first.is_a?(String) ? 'KittyKitty' : :KittyKitty
+      Editserver.constants.must_include const
+      @srv.editors['kitty_kitty'].must_equal Editserver::KittyKitty
+    end
+
+    it 'should split editor command like a Bourne shell' do
+      @srv.register_editors 'adorable_cat' => 'cat --with "really long whiskers"'
+      Editserver::AdorableCat.instance_variable_get(:@command).must_equal ['/bin/cat', '--with', 'really long whiskers']
+    end
+
+    it 'should alter @editors and return the value of @editors' do
+      @srv.register_editors('ugly_cat' => 'cat --manginess=100').must_equal @srv.editors
+    end
+  end
+
+  describe :editor do
+    before { @srv = Editserver.new }
+
+    it 'should take a single string argument' do
+      @srv.method(:editor).arity.must_equal 1
+      lambda { @srv.editor %w[/foo] }.must_raise TypeError
+    end
+
+    it 'should raise RoutingError if no handler found for path' do
+      lambda { @srv.editor '/escape-meta-alt-control-shift' }.must_raise Editserver::RoutingError
+    end
+
+    it 'should return an existing subclass of Editor when a handler exists' do
+      @srv.editor('/vim').ancestors.must_include Editserver::Editor
+      @srv.register_editors 'kitty_cat' => 'cat --with-nick'
+      @srv.editor('/kitty_cat').ancestors.must_include Editserver::Editor
+    end
+
+    it 'should return a default handler for / if defined' do
+      lambda { @srv.editor '/' }.must_raise Editserver::RoutingError
+      @srv.register_editors 'default' => 'emacs'
+      @srv.editor('/').must_equal Editserver::Emacs
+    end
+  end
+
+  describe :call do
+    before do
+      bin      = File.expand_path '../test-editor', __FILE__
+      @srv     = Editserver.new 'default' => 'test-editor', 'test-editor' => bin
+      @env_for = Rack::MockRequest.method :env_for
+      @uri     = 'http://127.0.0.1:9999'
+
+      # don't clutter test output
+      $stderr.reopen '/dev/null'
+    end
+
+    after { $stderr.reopen STDERR }
+
+    it 'should take a rack env hash' do
+      @srv.method(:call).arity.must_equal 1
+      lambda { @srv.call :foo => 'bar' }.must_raise NoMethodError
+    end
+
+    it 'should return a rack array' do
+      res = @srv.call @env_for.call(@uri)
+      res.must_be_kind_of Array
+      res.length.must_equal 3
+      res[0].must_be_kind_of Fixnum
+      res[1].must_be_kind_of Hash
+      res[2].must_be_kind_of Rack::Response
+    end
+
+    it 'should spawn the specified editor and return an edited string' do
+      @srv.call(@env_for.call @uri)[2].body.join.must_match /test-editor\z/
+      @srv.call(@env_for.call @uri + '/?text=foobarbaz')[2].body.join.must_match /\Afoobarbaz.*test-editor\z/m
+    end
+  end
+end

data/test/test-editor

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+File.open ARGV[0], 'a' do |f|
+  f.write "\nEdited by #{File.basename $0}"
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification 
+name: editserver
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Sung Pae
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-16 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        version: "1.2"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug19
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Simple local server for editing text in your favorite editor.
+email: 
+- sung@metablu.com
+executables: 
+- editserver
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- bin/editserver
+- editserver.gemspec
+- extra/editserver.applescript.erb
+- lib/editserver.rb
+- lib/editserver/command.rb
+- lib/editserver/editor.rb
+- lib/editserver/response.rb
+- lib/editserver/terminal/emacs.rb
+- lib/editserver/terminal/vim.rb
+- lib/editserver/version.rb
+- test/editserver.test.rb
+- test/editserver/command.test.rb
+- test/editserver/editor.test.rb
+- test/editserver/response.test.rb
+- test/editserver/terminal/emacs.test.rb
+- test/editserver/terminal/vim.test.rb
+- test/test-editor
+has_rdoc: true
+homepage: http://github.com/guns/editserver
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: editserver
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Your favorite editor, in every app
+test_files: 
+- test/editserver.test.rb
+- test/editserver/command.test.rb
+- test/editserver/editor.test.rb
+- test/editserver/response.test.rb
+- test/editserver/terminal/emacs.test.rb
+- test/editserver/terminal/vim.test.rb
+- test/test-editor