neovim 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d788e73532acb46ec8b33b5391fb1a1077bd69d
-  data.tar.gz: 3456c2d23d5f98802b0bbb2ac29612e20a51e11c
+  metadata.gz: 92074f47bd93b7fbca51aa3b74e813adb8b1004c
+  data.tar.gz: 2c19393d6a5c38342bc30350e5c5da352fff101c
 SHA512:
-  metadata.gz: fa3098403bd3e78a7b56eaf21f8810190d1cb34b17fd8365cfe424537294440b99351d67b33408e3d1f4b094cd2013f193be87b1eb66db6f4d4c6b59cb9e084a
-  data.tar.gz: 5a12541cec062aa8643decc49b580aa76c562f734d1319ce77e8284a503b2b37a6afa9eb075abbe9e2d97278a003a301ea2d51dc469bc05713f1bc121b25e3e1
+  metadata.gz: 0c22b67f54f42edcdbc7a062ff972725508c69810627dd51e3c5ece458dd9c1187cc6e87149044dd4786302181297d5ebc3acb8ed4b29a33c069e2c61c0cb52b
+  data.tar.gz: 3c9dc7fc608a08a0db6ed8a9174b93b5487163745661174c883fe2726be02259e448b1e3e8c79bfda25b082d012e27bdc5fc22fed78e2e826f7395faf669a0f8

data/.gitignore

@@ -16,3 +16,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+spec/workspace

data/.travis.yml

@@ -27,4 +27,4 @@ addons:
 
 env: REPORT_COVERAGE=1
 before_script: travis_retry bundle exec rake neovim:install
-script: travis_retry bundle exec rake
+script: bundle exec rake

data/README.md

@@ -42,34 +42,31 @@ The client's interface is generated at runtime from the `vim_get_api_info` RPC c
 The `neovim-ruby-host` executable can be used to spawn Ruby plugins via the `rpcstart` command. A plugin can be defined like this:
 
 ```ruby
-# my_plugin.rb
+# $VIMRUNTIME/rplugin/ruby/my_plugin.rb
 
 Neovim.plugin do |plug|
-  # Define a command called "Add" which returns the sum of two numbers
-  # The `:sync => true` option tells nvim to wait for a response.
-  # The result of the block will be returned to nvim.
-  plug.command(:Add, :nargs => 2, :sync => true) do |nvim, x, y|
-    x + y
-  end
-  
-  # Define a command called "SetLine" which sets the current line
-  # This command is asynchronous, so nvim won't wait for a response.
+  # Define a command called "SetLine" which sets the current line to the sum of
+  # two values. This command is executed asynchronously, so the return value is
+  # ignored.
   plug.command(:SetLine, :nargs => 1) do |nvim, str|
     nvim.current.line = str
   end
-end
-```
-
-You can start this plugin via the `rpcstart` nvim function. The resulting channel ID can be used to send requests and notifications to the plugin.
 
-```viml
-let host = rpcstart("neovim-ruby-host", ["./my_plugin.rb"])
+  # Define a function called "Sum" which sets the current line. This function
+  # is executed synchronously, so the result of the block will be returned to
+  # nvim.
+  plug.function(:Sum, :nargs => 2, :sync => true) do |nvim, x, y|
+    x + y
+  end
 
-let result = rpcrequest(host, "Add", 1, 2) " result is set to 3
-call rpcnotify(host, "SetLine", "Foo")     " current line is set to 'Foo'
+  # Define an autocmd for the BufEnter event on Ruby files.
+  plug.autocmd(:BufEnter, :pattern => "*.rb") do |nvim|
+    nvim.command("echom 'Ruby file, eh?'")
+  end
+end
 ```
 
-Plugin functionality is very limited right now. Besides `command`, the plugin DSL exposes the `function` and `autocmd` directives, however they are functionally almost identical to `command`. Their purpose is to define a manifest that nvim can load via the `UpdateRemotePlugins` command, which will generate the actual `command`, `function`, and `autocmd` definitions. This piece has not yet been implemented.
+After a call to `:UpdateRemotePlugins`, plugins will be auto-loaded from the `$VIMRUNTIME/rplugin/ruby` directory.
 
 ## Contributing
 

data/lib/neovim.rb

@@ -35,7 +35,13 @@ module Neovim
     end
   end
 
+  def self.logger=(logger)
+    Logging.logger = logger
+  end
 
+  def self.logger
+    Logging.logger
+  end
 
   def self.attach_event_loop(event_loop)
     msgpack_stream = MsgpackStream.new(event_loop)

data/lib/neovim/async_session.rb

@@ -1,8 +1,11 @@
+require "neovim/logging"
 require "neovim/request"
 require "neovim/notification"
 
 module Neovim
   class AsyncSession
+    include Logging
+
     def initialize(msgpack_stream)
       @msgpack_stream = msgpack_stream
       @request_id = 0
@@ -49,6 +52,9 @@ module Neovim
       end
 
       @msgpack_stream.run(msg_cb, setup_cb)
+    rescue => e
+      fatal("got unexpected error #{e}")
+      debug(e.backtrace.join("\n"))
     end
   end
 end

data/lib/neovim/buffer.rb

@@ -10,5 +10,14 @@ module Neovim
     def lines=(arr)
       lines[0..-1] = arr
     end
+
+    def range
+      @range ||= LineRange.new(self, 0, -1)
+    end
+
+    def range=(_range)
+      _end = _range.exclude_end? ? _range.end - 1 : _range.end
+      @range = LineRange.new(self, _range.begin, _end)
+    end
   end
 end

data/lib/neovim/current.rb

@@ -42,14 +42,5 @@ module Neovim
       tabpage = Tabpage.new(tabpage_index, @session)
       @session.request(:vim_set_current_tabpage, tabpage)
     end
-
-    def range
-      @range ||= LineRange.new(buffer, 0, -1)
-    end
-
-    def range=(_range)
-      _end = _range.exclude_end? ? _range.end - 1 : _range.end
-      @range = LineRange.new(buffer, _range.begin, _end)
-    end
   end
 end

data/lib/neovim/event_loop.rb

@@ -1,7 +1,10 @@
+require "neovim/logging"
 require "socket"
 
 module Neovim
   class EventLoop
+    include Logging
+
     def self.tcp(host, port)
       socket = TCPSocket.new(host, port)
       new(socket, socket)
@@ -30,6 +33,7 @@ module Neovim
     def send(data)
       start = 0
       size = data.size
+      debug("sending #{data.inspect}")
 
       begin
         while start < size
@@ -48,9 +52,15 @@ module Neovim
 
       loop do
         break unless @running
-        message_callback.call(@rd.readpartial(1024 * 16))
+        message = @rd.readpartial(1024 * 16)
+        debug("received #{message.inspect}")
+        message_callback.call(message)
       end
     rescue EOFError
+      warn("got EOFError")
+    rescue => e
+      fatal("got unexpected error #{e}")
+      debug(e.backtrace.join("\n"))
     end
   end
 end

data/lib/neovim/host.rb

@@ -1,7 +1,12 @@
+require "neovim/logging"
 require "neovim/manifest"
 
 module Neovim
   class Host
+    include Logging
+
+    attr_reader :manifest
+
     def self.load_from_files(rplugin_paths, target_manifest=Manifest.new)
       old_manifest = Neovim.__configured_plugin_manifest
       old_path = Neovim.__configured_plugin_path
@@ -21,8 +26,6 @@ module Neovim
       end
     end
 
-    attr_reader :manifest
-
     def initialize(manifest)
       @manifest = manifest
       @event_loop = EventLoop.stdio
@@ -32,10 +35,14 @@ module Neovim
 
     def run
       callback = Proc.new do |msg|
+        debug("received #{msg.inspect}")
         @manifest.handle(msg, client)
       end
 
       @async_session.run(callback, callback)
+    rescue => e
+      fatal("got unexpected error #{e}")
+      debug(e.backtrace.join("\n"))
     end
 
     private

data/lib/neovim/logging.rb

@@ -0,0 +1,50 @@
+require "logger"
+require "stringio"
+
+module Neovim
+  module Logging
+    class << self
+      attr_writer :logger
+    end
+
+    def self.logger
+      return @logger if instance_variable_defined?(:@logger)
+
+      if ENV["NVIM_RUBY_LOG_FILE"]
+        @logger = Logger.new(ENV["NVIM_RUBY_LOG_FILE"])
+      else
+        @logger = Logger.new(STDERR)
+      end
+
+      if ENV["NVIM_RUBY_LOG_LEVEL"]
+        @logger.level = Integer(ENV["NVIM_RUBY_LOG_LEVEL"])
+      else
+        @logger.level = Logger::WARN
+      end
+
+      @logger
+    end
+
+    private
+
+    def fatal(msg)
+      logger.fatal(self.class) { msg }
+    end
+
+    def warn(msg)
+      logger.warn(self.class) { msg }
+    end
+
+    def info(msg)
+      logger.info(self.class) { msg }
+    end
+
+    def debug(msg)
+      logger.debug(self.class) { msg }
+    end
+
+    def logger
+      Logging.logger
+    end
+  end
+end

data/lib/neovim/manifest.rb

@@ -1,5 +1,9 @@
+require "neovim/logging"
+
 module Neovim
   class Manifest
+    include Logging
+
     attr_reader :handlers, :specs
 
     def initialize
@@ -19,16 +23,23 @@ module Neovim
     def handle(msg, client)
       default_handler = msg.sync? ? default_sync_handler : default_async_handler
       @handlers.fetch(msg.method_name, default_handler).call(client, msg)
+    rescue => e
+      fatal("got unexpected error #{e}")
+      debug(e.backtrace.join("\n"))
     end
 
     private
 
     def poll_handler
-      @poll_handler ||= Proc.new { |_, req| req.respond("ok") }
+      @poll_handler ||= Proc.new do |_, req|
+        debug("received 'poll' request #{req.inspect}")
+        req.respond("ok")
+      end
     end
 
     def specs_handler
       @specs_handler ||= Proc.new do |_, req|
+        debug("received 'specs' request #{req.inspect}")
         source = req.arguments.fetch(0)
 
         if @specs.key?(source)
@@ -49,13 +60,15 @@ module Neovim
 
     def wrap_sync(handler)
       Proc.new do |client, request|
-        request.respond(handler.call(client, *request.arguments))
+        debug("received #{request.inspect}")
+        request.respond(handler.call(client, *request.arguments[0]))
       end
     end
 
     def wrap_async(handler)
       Proc.new do |client, notification|
-        handler.call(client, *notification.arguments)
+        debug("received #{notification.inspect}")
+        handler.call(client, *notification.arguments[0])
       end
     end
   end

data/lib/neovim/msgpack_stream.rb

@@ -1,7 +1,10 @@
+require "neovim/logging"
 require "msgpack"
 
 module Neovim
   class MsgpackStream
+    include Logging
+
     def initialize(event_loop)
       @event_loop = event_loop
       @unpacker = MessagePack::Unpacker.new
@@ -19,6 +22,7 @@ module Neovim
     end
 
     def send(msg)
+      debug("sending #{msg.inspect}")
       @event_loop.send(MessagePack.pack(msg))
       self
     end
@@ -26,11 +30,15 @@ module Neovim
     def run(message_cb, setup_cb=nil)
       data_cb = Proc.new do |data|
         @unpacker.feed_each(data) do |msg|
+          debug("received #{msg.inspect}")
           message_cb.call(msg)
         end
       end
 
       @event_loop.run(data_cb, setup_cb)
+    rescue => e
+      fatal("got unexpected error #{e}")
+      debug(e.backtrace.join("\n"))
     end
   end
 end

data/lib/neovim/version.rb

@@ -1,3 +1,3 @@
 module Neovim
-  VERSION = Gem::Version.new("0.0.4")
+  VERSION = Gem::Version.new("0.0.5")
 end

data/spec/acceptance/neovim-ruby-host_spec.rb

@@ -3,47 +3,43 @@ require "tmpdir"
 
 RSpec.describe "neovim-ruby-host" do
   it "loads and runs plugins from Ruby source files" do
-    Dir.mktmpdir do |pwd|
-      Dir.chdir(pwd) do
-        plugin1_path = File.expand_path("./plugin1.rb")
-        File.write(plugin1_path, <<-RUBY)
-          Neovim.plugin do |plug|
-            plug.command(:SyncAdd, :args => 2, :sync => true) do |nvim, x, y|
-              x + y
-            end
-          end
-        RUBY
-
-        plugin2_path = File.expand_path("./plugin2.rb")
-        File.write(plugin2_path, <<-RUBY)
-          Neovim.plugin do |plug|
-            plug.command(:AsyncSetLine, :args => 1) do |nvim, str|
-              nvim.current.line = str
-            end
-          end
-        RUBY
-
-        nvim = Neovim.attach_child(["--headless", "-u", "NONE", "-N", "-n"])
-
-        host_exe = File.expand_path("../../../bin/neovim-ruby-host", __FILE__)
-        nvim.command("let host = rpcstart('#{host_exe}', ['#{plugin1_path}', '#{plugin2_path}'])")
-
-        expect(nvim.eval("rpcrequest(host, 'poll')")).to eq("ok")
-        expect(nvim.eval("rpcrequest(host, '#{plugin1_path}:command:SyncAdd', 1, 2)")).to eq(3)
-
-        expect {
-          nvim.eval("rpcnotify(host, '#{plugin2_path}:command:AsyncSetLine', 'foo')")
-          nvim.eval("rpcrequest(host, 'poll')")
-        }.to change { nvim.current.buffer.lines.to_a }.from([""]).to(["foo"])
-
-        expect {
-          nvim.eval("rpcnotify(host, 'Unknown')")
-        }.not_to raise_error
-
-        expect {
-          nvim.eval("call rpcrequest(host, 'Unknown')")
-        }.to raise_error(ArgumentError)
+    plugin1_path = Support.file_path("plugin1.rb")
+    File.write(plugin1_path, <<-RUBY)
+      Neovim.plugin do |plug|
+        plug.command(:SyncAdd, :args => 2, :sync => true) do |nvim, x, y|
+          x + y
+        end
       end
-    end
+    RUBY
+
+    plugin2_path = Support.file_path("plugin2.rb")
+    File.write(plugin2_path, <<-RUBY)
+      Neovim.plugin do |plug|
+        plug.command(:AsyncSetLine, :args => 1) do |nvim, str|
+          nvim.current.line = str
+        end
+      end
+    RUBY
+
+    nvim = Neovim.attach_child(["--headless", "-u", "NONE", "-N", "-n"])
+
+    host_exe = File.expand_path("../../../bin/neovim-ruby-host", __FILE__)
+    nvim.command("let host = rpcstart('#{host_exe}', ['#{plugin1_path}', '#{plugin2_path}'])")
+
+    expect(nvim.eval("rpcrequest(host, 'poll')")).to eq("ok")
+    expect(nvim.eval("rpcrequest(host, '#{plugin1_path}:command:SyncAdd', [1, 2])")).to eq(3)
+
+    expect {
+      nvim.eval("rpcnotify(host, '#{plugin2_path}:command:AsyncSetLine', ['foo'])")
+      nvim.eval("rpcrequest(host, 'poll')")
+    }.to change { nvim.current.buffer.lines.to_a }.from([""]).to(["foo"])
+
+    expect {
+      nvim.eval("rpcnotify(host, 'Unknown')")
+    }.not_to raise_error
+
+    expect {
+      nvim.eval("call rpcrequest(host, 'Unknown')")
+    }.to raise_error(ArgumentError)
   end
 end

data/spec/helper.rb

@@ -1,8 +1,11 @@
 require "bundler/setup"
+require "logger"
 require "neovim"
 require "pry"
 require "timeout"
 
+require File.expand_path("../support.rb", __FILE__)
+
 if ENV["REPORT_COVERAGE"]
   require "coveralls"
   Coveralls.wear!
@@ -12,6 +15,10 @@ Thread.abort_on_exception = true
 
 ENV["NVIM_EXECUTABLE"] = File.expand_path("../../vendor/neovim/build/bin/nvim", __FILE__)
 
+Neovim.logger = Logger.new(STDERR).tap do |logger|
+  logger.level = ENV.fetch("NVIM_RUBY_LOG_LEVEL", Logger::WARN).to_i
+end
+
 RSpec.configure do |config|
   config.expect_with :rspec do |exp|
     exp.syntax = :expect
@@ -22,7 +29,12 @@ RSpec.configure do |config|
 
   Kernel.srand config.seed
 
-  config.around do |spec|
-    Timeout.timeout(5) { spec.run }
+  config.around(:example) do |spec|
+    Support.clean_workspace
+    Timeout.timeout(2) { spec.run }
+  end
+
+  config.after(:suite) do
+    Support.remove_workspace
   end
 end

data/spec/neovim/async_session_spec.rb

@@ -7,7 +7,7 @@ module Neovim
         stream = MsgpackStream.new(event_loop)
         async = AsyncSession.new(stream)
 
-        srv_thr = Thread.new do
+        server_thread = Thread.new do
           client = server.accept
           IO.select(nil, [client])
           client.write(MessagePack.pack(
@@ -25,7 +25,7 @@ module Neovim
 
         request = fiber.resume
 
-        srv_thr.join
+        server_thread.join
 
         expect(request).to be_a(Request)
         expect(request.method_name).to eq("func")
@@ -36,7 +36,7 @@ module Neovim
         stream = MsgpackStream.new(event_loop)
         async = AsyncSession.new(stream)
 
-        srv_thr = Thread.new do
+        server_thread = Thread.new do
           client = server.accept
           IO.select(nil, [client])
           client.write(MessagePack.pack(
@@ -54,7 +54,7 @@ module Neovim
 
         notification = fiber.resume
 
-        srv_thr.join
+        server_thread.join
 
         expect(notification).to be_a(Notification)
         expect(notification.method_name).to eq("func")
@@ -66,7 +66,7 @@ module Neovim
         async = AsyncSession.new(stream)
         messages = []
 
-        srv_thr = Thread.new do
+        server_thread = Thread.new do
           client = server.accept
           messages << client.readpartial(1024)
 
@@ -83,7 +83,7 @@ module Neovim
 
         expect(fiber.resume).to eq(["error", "result"])
 
-        srv_thr.join
+        server_thread.join
 
         expect(messages).to eq(
           [MessagePack.pack([0, 0, "func", [1, 2, 3]])]
@@ -99,10 +99,8 @@ module Neovim
     end
 
     context "unix" do
-      before { FileUtils.rm_f("/tmp/#$$.sock") }
-      after { FileUtils.rm_f("/tmp/#$$.sock") }
-      let!(:server) { UNIXServer.new("/tmp/#$$.sock") }
-      let!(:event_loop) { EventLoop.unix("/tmp/#$$.sock") }
+      let!(:server) { UNIXServer.new(Support.socket_path) }
+      let!(:event_loop) { EventLoop.unix(Support.socket_path) }
 
       include_context "async session behavior"
     end

data/spec/neovim/buffer_spec.rb

@@ -12,10 +12,24 @@ module Neovim
     end
 
     describe "#lines=" do
-      it "updates the buffers lines" do
+      it "updates the buffer's lines" do
         buffer.lines = ["one", "two"]
         expect(buffer.lines.to_a).to eq(["one", "two"])
       end
     end
+
+    describe "#range" do
+      it "returns a LineRange" do
+        expect(buffer.range).to be_a(LineRange)
+      end
+    end
+
+    describe "#range=" do
+      it "updates the buffer's range" do
+        buffer.lines = ["one", "two", "three"]
+        buffer.range = (0..1)
+        expect(buffer.range.to_a).to eq(["one", "two"])
+      end
+    end
   end
 end

data/spec/neovim/current_spec.rb

@@ -74,19 +74,5 @@ module Neovim
         }.to change { current.tabpage.index }.to(initial_index)
       end
     end
-
-    describe "#range" do
-      it "returns the current range" do
-        expect(current.range).to be_a(LineRange)
-      end
-    end
-
-    describe "#range=" do
-      it "sets the current range" do
-        current.buffer.lines = ["1", "2", "3"]
-        current.range = (1..2)
-        expect(current.range.to_a).to eq(["2", "3"])
-      end
-    end
   end
 end

data/spec/neovim/event_loop_spec.rb

@@ -22,7 +22,7 @@ module Neovim
       it "sends and receives data" do
         messages = []
 
-        srv_thr = Thread.new do
+        server_thread = Thread.new do
           client = server.accept
           messages << client.readpartial(1024)
 
@@ -37,7 +37,7 @@ module Neovim
         end
 
         expect(fiber.resume).to eq("OK")
-        srv_thr.join
+        server_thread.join
         expect(messages).to eq(["data"])
       end
     end
@@ -50,10 +50,8 @@ module Neovim
     end
 
     context "unix" do
-      before { FileUtils.rm_f("/tmp/#$$.sock") }
-      after { FileUtils.rm_f("/tmp/#$$.sock") }
-      let!(:server) { UNIXServer.new("/tmp/#$$.sock") }
-      let!(:event_loop) { EventLoop.unix("/tmp/#$$.sock") }
+      let!(:server) { UNIXServer.new(Support.socket_path) }
+      let!(:event_loop) { EventLoop.unix(Support.socket_path) }
 
       include_context "socket behavior"
     end
@@ -73,7 +71,7 @@ module Neovim
           event_loop = EventLoop.stdio
           messages = []
 
-          srv_thr = Thread.new do
+          server_thread = Thread.new do
             messages << srv_stdout.readpartial(1024)
             srv_stdin.write("OK")
           end
@@ -84,7 +82,7 @@ module Neovim
           end
 
           expect(fiber.resume).to eq("OK")
-          srv_thr.join
+          server_thread.join
           expect(messages).to eq(["data"])
         ensure
           STDOUT.reopen(old_stdout)

data/spec/neovim/host_spec.rb

@@ -1,19 +1,14 @@
 require "helper"
-require "tempfile"
 
 module Neovim
   RSpec.describe Host do
     describe ".load_from_files" do
       it "loads the defined plugins into a manifest" do
-        plug1 = Tempfile.open("plug1") do |f|
-          f.write("Neovim.plugin")
-          f.path
-        end
+        plug1 = Support.file_path("plug1.rb")
+        plug2 = Support.file_path("plug2.rb")
 
-        plug2 = Tempfile.open("plug2") do |f|
-          f.write("Neovim.plugin; Neovim.plugin")
-          f.path
-        end
+        File.write(plug1, "Neovim.plugin")
+        File.write(plug2, "Neovim.plugin; Neovim.plugin")
 
         manifest = Manifest.new
 
@@ -23,10 +18,8 @@ module Neovim
       end
 
       it "doesn't load plugin code into the global namespace" do
-        plug = Tempfile.open("plug") do |f|
-          f.write("class FooClass; end")
-          f.path
-        end
+        plug = Support.file_path("plug.rb")
+        File.write(plug, "class FooClass; end")
 
         host = Host.load_from_files([plug])
         expect(Kernel.const_defined?("FooClass")).to be(false)

data/spec/neovim/msgpack_stream_spec.rb

@@ -6,11 +6,11 @@ module Neovim
     shared_context "msgpack stream behavior" do
       it "sends and receives data" do
         stream = MsgpackStream.new(event_loop)
-        messages = []
+        client_messages = []
 
-        srv_thr = Thread.new do
+        server_thread = Thread.new do
           client = server.accept
-          messages << client.readpartial(1024)
+          client_messages << client.readpartial(1024)
 
           client.write(MessagePack.pack([2]))
           client.close
@@ -22,8 +22,11 @@ module Neovim
           stream.send([1]).run(msg_cb)
         end
 
-        expect(fiber.resume).to eq([2])
-        expect(messages).to eq([MessagePack.pack([1])])
+        server_message = fiber.resume
+        server_thread.join
+
+        expect(server_message).to eq([2])
+        expect(client_messages).to eq([MessagePack.pack([1])])
       end
     end
 
@@ -35,10 +38,8 @@ module Neovim
     end
 
     context "unix" do
-      before { FileUtils.rm_f("/tmp/#$$.sock") }
-      after { FileUtils.rm_f("/tmp/#$$.sock") }
-      let!(:server) { UNIXServer.new("/tmp/#$$.sock") }
-      let!(:event_loop) { EventLoop.unix("/tmp/#$$.sock") }
+      let!(:server) { UNIXServer.new(Support.socket_path) }
+      let!(:event_loop) { EventLoop.unix(Support.socket_path) }
 
       include_context "msgpack stream behavior"
     end

data/spec/neovim/session_spec.rb

@@ -34,23 +34,21 @@ module Neovim
     end
 
     context "tcp" do
-      let!(:nvim_port) do
-        server = TCPServer.new("0.0.0.0", 0)
-        server.addr[1].tap { server.close }
-      end
-
+      let!(:nvim_port) { Support.port }
       let!(:nvim_pid) do
-        Process.spawn(
+        pid = Process.spawn(
           {"NVIM_LISTEN_ADDRESS" => "0.0.0.0:#{nvim_port}"},
           "#{ENV.fetch("NVIM_EXECUTABLE")} --headless -n -u NONE",
           [:out, :err] => "/dev/null"
-        ).tap do
-          begin
-            TCPSocket.open("0.0.0.0", nvim_port).close
-          rescue Errno::ECONNREFUSED
-            retry
-          end
+        )
+
+        begin
+          TCPSocket.open("0.0.0.0", nvim_port).close
+        rescue Errno::ECONNREFUSED
+          retry
         end
+
+        pid
       end
 
       after do
@@ -69,27 +67,30 @@ module Neovim
     end
 
     context "unix" do
+      let!(:socket_path) { Support.socket_path }
       let!(:nvim_pid) do
-        FileUtils.rm_f("/tmp/nvim-#$$.sock")
-        Process.spawn(
-          {"NVIM_LISTEN_ADDRESS" => "/tmp/nvim-#$$.sock"},
+        pid = Process.spawn(
+          {"NVIM_LISTEN_ADDRESS" => socket_path},
           "#{ENV.fetch("NVIM_EXECUTABLE")} --headless -n -u NONE",
           [:out, :err] => "/dev/null"
-        ).tap do
-          loop do
-            break if File.exists?("/tmp/nvim-#$$.sock")
-          end
+        )
+
+        begin
+          UNIXSocket.new(socket_path).close
+        rescue Errno::ENOENT, Errno::ECONNREFUSED
+          retry
         end
+
+        pid
       end
 
       after do
         Process.kill(:TERM, nvim_pid)
         Process.waitpid(nvim_pid)
-        FileUtils.rm_f("/tmp/nvim-#$$.sock")
       end
 
       let(:session) do
-        event_loop = EventLoop.unix("/tmp/nvim-#$$.sock")
+        event_loop = EventLoop.unix(socket_path)
         stream = MsgpackStream.new(event_loop)
         async = AsyncSession.new(stream)
         Session.new(async)

data/spec/neovim_spec.rb

@@ -8,19 +8,15 @@ RSpec.describe Neovim do
 
   describe ".attach_tcp" do
     it "attaches to a TCP socket" do
-      srv = TCPServer.new("0.0.0.0", 0)
-      port = srv.addr[1]
-      srv.close
-
+      port = Support.port
       env = {"NVIM_LISTEN_ADDRESS" => "0.0.0.0:#{port}"}
       pid = Process.spawn(env, nvim_exe, *nvim_argv, [:out, :err] => "/dev/null")
 
       begin
-        wait_socket = TCPSocket.open("0.0.0.0", port)
+        TCPSocket.open("0.0.0.0", port).close
       rescue Errno::ECONNREFUSED
         retry
       end
-      wait_socket.close
 
       begin
         expect(Neovim.attach_tcp("0.0.0.0", port).strwidth("hi")).to eq(2)
@@ -32,16 +28,21 @@ RSpec.describe Neovim do
 
   describe ".attach_unix" do
     it "attaches to a UNIX socket" do
-      FileUtils.rm_f("/tmp/#$$.sock")
-      env = {"NVIM_LISTEN_ADDRESS" => "/tmp/#$$.sock"}
+      socket_path = Support.socket_path
+      env = {"NVIM_LISTEN_ADDRESS" => socket_path}
       pid = Process.spawn(env, nvim_exe, *nvim_argv, [:out, :err] => "/dev/null")
 
-      loop { break if File.exists?("/tmp/#$$.sock") }
+      begin
+        UNIXSocket.new(socket_path).close
+      rescue Errno::ENOENT, Errno::ECONNREFUSED
+        retry
+      end
 
       begin
-        expect(Neovim.attach_unix("/tmp/#$$.sock").strwidth("hi")).to eq(2)
+        expect(Neovim.attach_unix(socket_path).strwidth("hi")).to eq(2)
       ensure
         Process.kill(:TERM, pid)
+        Process.waitpid(pid)
       end
     end
   end

data/spec/support.rb

@@ -0,0 +1,29 @@
+require "fileutils"
+
+module Support
+  def self.workspace
+    File.expand_path("../workspace/#$$", __FILE__)
+  end
+
+  def self.socket_path
+    file_path("nvim.sock")
+  end
+
+  def self.port
+    server = TCPServer.new("0.0.0.0", 0)
+    server.addr[1].tap { server.close }
+  end
+
+  def self.file_path(name)
+    File.join(workspace, name)
+  end
+
+  def self.remove_workspace
+    FileUtils.rm_rf(workspace)
+  end
+
+  def self.clean_workspace
+    remove_workspace
+    FileUtils.mkdir_p(workspace)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neovim
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Alex Genco
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-09 00:00:00.000000000 Z
+date: 2016-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -121,6 +121,7 @@ files:
 - lib/neovim/event_loop.rb
 - lib/neovim/host.rb
 - lib/neovim/line_range.rb
+- lib/neovim/logging.rb
 - lib/neovim/manifest.rb
 - lib/neovim/msgpack_stream.rb
 - lib/neovim/notification.rb
@@ -148,6 +149,7 @@ files:
 - spec/neovim/session_spec.rb
 - spec/neovim/window_spec.rb
 - spec/neovim_spec.rb
+- spec/support.rb
 homepage: https://github.com/alexgenco/neovim-ruby
 licenses:
 - MIT
@@ -168,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A Ruby client for Neovim
@@ -189,3 +191,4 @@ test_files:
 - spec/neovim/session_spec.rb
 - spec/neovim/window_spec.rb
 - spec/neovim_spec.rb
+- spec/support.rb