neovim 0.7.1 → 0.9.0

data/spec/neovim/connection_spec.rb

@@ -7,11 +7,31 @@ module Neovim
     describe "#write" do
       it "writes msgpack to the underlying file descriptor" do
         rd, wr = IO.pipe
-        connection = Connection.new(nil_io, wr)
-        connection.write("some data")
+        Connection.new(nil_io, wr).write("some data").flush
+        data = rd.readpartial(1024)
+
+        expect(MessagePack.unpack(data)).to eq("some data")
+      end
+    end
+
+    describe "#flush" do
+      it "flushes writes to the underlying file descriptor" do
+        rd, wr = IO.pipe
+        connection = Connection.new(nil_io, wr).write("some data")
+
+        expect { rd.read_nonblock(16) }.to raise_error(IO::WaitReadable)
+
+        connection.flush
+
+        expect(rd.read_nonblock(16)).to eq(MessagePack.pack("some data"))
+      end
+
+      it "throws an exception when the file is closed" do
+        _, wr = IO.pipe
+        connection = Connection.new(nil_io, wr).write("some data")
         wr.close
 
-        expect(MessagePack.unpack(rd.read)).to eq("some data")
+        expect { connection.flush }.to raise_error(IOError)
       end
     end
 
@@ -19,11 +39,19 @@ module Neovim
       it "reads msgpack from the underlying file descriptor" do
         rd, wr = IO.pipe
         wr.write(MessagePack.pack("some data"))
-        wr.close
+        wr.flush
 
         connection = Connection.new(rd, nil_io)
         expect(connection.read).to eq("some data")
       end
+
+      it "throws an exception when the file is closed" do
+        rd, wr = IO.pipe
+        wr.close
+
+        connection = Connection.new(rd, nil_io)
+        expect { connection.read }.to raise_error(EOFError)
+      end
     end
 
     describe "#register_type" do

data/spec/neovim/current_spec.rb

@@ -2,9 +2,8 @@ require "helper"
 
 module Neovim
   RSpec.describe Current do
-    let(:client) { Neovim.attach_child(Support.child_argv) }
+    let(:client) { Support.persistent_client }
     let(:current) { client.current }
-    after { client.shutdown }
 
     describe "#line" do
       it "returns an empty string if the current line is empty" do

data/spec/neovim/event_loop_spec.rb

@@ -16,7 +16,9 @@ module Neovim
     describe "#request" do
       it "writes a msgpack request" do
         event_loop.request(1, :method, 1, 2)
+        connection.flush
         message = server_rd.readpartial(1024)
+
         expect(message).to eq(MessagePack.pack([0, 1, "method", [1, 2]]))
       end
     end
@@ -24,7 +26,9 @@ module Neovim
     describe "#respond" do
       it "writes a msgpack response" do
         event_loop.respond(2, "value", "error")
+        connection.flush
         message = server_rd.readpartial(1024)
+
         expect(message).to eq(MessagePack.pack([1, 2, "error", "value"]))
       end
     end
@@ -32,7 +36,9 @@ module Neovim
     describe "#notify" do
       it "writes a msgpack notification" do
         event_loop.notify(:method, 1, 2)
+        connection.flush
         message = server_rd.readpartial(1024)
+
         expect(message).to eq(MessagePack.pack([2, "method", [1, 2]]))
       end
     end
@@ -52,6 +58,16 @@ module Neovim
         expect(message.method_name).to eq("foo_method")
       end
 
+      it "returns the last message received" do
+        server_wr.write(MessagePack.pack([0, 1, :foo_method, []]))
+        server_wr.flush
+
+        message = event_loop.run { |req| event_loop.stop; req }
+
+        expect(message.sync?).to eq(true)
+        expect(message.method_name).to eq("foo_method")
+      end
+
       it "shuts down after receiving EOFError" do
         run_thread = Thread.new do
           event_loop.run

data/spec/neovim/host/cli_spec.rb

@@ -0,0 +1,94 @@
+require "helper"
+require "neovim/host/cli"
+
+begin
+  require "pty"
+rescue LoadError
+  # Not available on Windows
+end
+
+module Neovim
+  class Host
+    RSpec.describe CLI do
+      let(:stdin) { StringIO.new }
+      let(:stdout) { StringIO.new }
+      let(:stderr) { StringIO.new }
+
+      specify "-V" do
+        expect do
+          CLI.run("/exe/nv-rb-host", ["-V"], stdin, stdout, stderr)
+        end.to raise_error(SystemExit) { |e| expect(e.status).to eq(0) }
+
+        expect(stderr.string).to be_empty
+        expect(stdout.string).to eq(Neovim::VERSION.to_s + "\n")
+      end
+
+      specify "-h" do
+        expect do
+          CLI.run("/exe/nv-rb-host", ["-h"], stdin, stdout, stderr)
+        end.to raise_error(SystemExit) { |e| expect(e.status).to eq(0) }
+
+        expect(stderr.string).to be_empty
+        expect(stdout.string).to eq("Usage: nv-rb-host [-hV] rplugin_path ...\n")
+      end
+
+      it "fails with invalid arguments" do
+        expect do
+          CLI.run("/exe/nv-rb-host", ["-x"], stdin, stdout, stderr)
+        end.to raise_error(SystemExit) { |e| expect(e.status).to eq(1) }
+
+        expect(stdout.string).to be_empty
+        expect(stderr.string).to eq("invalid option: -x\n")
+      end
+
+      it "fails when run interactively" do
+        if !defined?(PTY)
+          skip "Skipping without `pty` library."
+        end
+
+        PTY.open do |tty,|
+          expect do
+            CLI.run("/exe/nv-rb-host", ["plugin.rb"], tty, stdout, stderr)
+          end.to raise_error(SystemExit) { |e| expect(e.status).to eq(1) }
+
+          expect(stdout.string).to be_empty
+          expect(stderr.string).to eq("Can't run nv-rb-host interactively.\n")
+        end
+      end
+
+      it "starts a stdio host" do
+        nvim_r, host_w = IO.pipe
+        host_r, nvim_w = IO.pipe
+
+        nvim_u = MessagePack::Unpacker.new(nvim_r)
+        nvim_p = MessagePack::Packer.new(nvim_w)
+
+        Support.file_path("plugin").tap do |path|
+          File.write(path, "Neovim.plugin { |p| p.function('Foo') }")
+
+          thr = Thread.new do
+            CLI.run("/exe/nv-rb-host", [path], host_r, host_w, stderr)
+          end
+
+          begin
+            nvim_p.write([0, 1, :poll, []]).flush
+
+            expect(nvim_u.read[0..1]).to eq([2, "nvim_set_client_info"])
+            expect(nvim_u.read[0..2]).to eq([0, 2, "nvim_get_api_info"])
+
+            nvim_p.write([1, 2, nil, [10, {"functions" => {}, "types" => {}}]]).flush
+            expect(nvim_u.read).to eq([1, 1, nil, "ok"])
+
+            nvim_p.write([0, 3, :specs, [path]]).flush
+            *prefix, (payload, *) = nvim_u.read
+
+            expect(prefix).to eq([1, 3, nil])
+            expect(payload["name"]).to eq("Foo")
+          ensure
+            thr.kill.join
+          end
+        end
+      end
+    end
+  end
+end

data/spec/neovim/host_spec.rb

@@ -41,22 +41,20 @@ module Neovim
         end
       end
 
-      after do
-        host_thread.kill while host_thread.alive?
-        host_thread.join
-      end
+      after { host_thread.kill.join }
 
       context "poll" do
-        it "initializes a client and responds 'ok'" do
+        it "initializes a client, sets client info, and responds 'ok'" do
           nvim_wr.write([0, 1, :poll, []]).flush
-          type, reqid, method = nvim_rd.read
 
-          expect(type).to eq(0)
-          expect(reqid).to eq(2)
-          expect(method).to eq("nvim_get_api_info")
+          expect(nvim_rd.read).to match([2, "nvim_set_client_info", duck_type(:to_ary)])
+
+          type, reqid, method = nvim_rd.read
+          expect([type, reqid, method]).to match([0, duck_type(:to_int), "nvim_get_api_info"])
 
           api_info = [0, {"types" => {}, "functions" => {}}]
           nvim_wr.write([1, reqid, nil, api_info]).flush
+
           expect(nvim_rd.read).to eq([1, 1, nil, "ok"])
         end
       end
@@ -64,14 +62,18 @@ module Neovim
       context "after poll" do
         before do
           nvim_wr.write([0, 1, :poll, []]).flush
-          _, reqid, = nvim_rd.read
 
-          session = Session.new(EventLoop.child(Support.child_argv))
-          api_info = session.request(:nvim_get_api_info)
-          session.shutdown
+          expect(nvim_rd.read[1]).to eq("nvim_set_client_info")
+
+          _, reqid, method = nvim_rd.read
+
+          expect(method).to eq("nvim_get_api_info")
+
+          api_info = Support.persistent_client.get_api_info
 
           nvim_wr.write([1, reqid, nil, api_info]).flush
-          nvim_rd.read
+
+          expect(nvim_rd.read[3]).to eq("ok")
         end
 
         it "responds with specs to the 'specs' request" do

data/spec/neovim/line_range_spec.rb

@@ -2,7 +2,7 @@ require "helper"
 
 module Neovim
   RSpec.describe LineRange do
-    let(:client) { Neovim.attach_child(Support.child_argv) }
+    let(:client) { Support.persistent_client }
     let(:buffer) { client.current.buffer }
     let(:line_range) { LineRange.new(buffer) }
 
@@ -10,8 +10,6 @@ module Neovim
       buffer.set_lines(0, -1, true, ["1", "2", "3", "4"])
     end
 
-    after { client.shutdown }
-
     describe "#each" do
       it "yields each line" do
         yielded = []

data/spec/neovim/remote_object_spec.rb

@@ -2,8 +2,7 @@ require "helper"
 
 module Neovim
   RSpec.describe RemoteObject do
-    let(:client) { Neovim.attach_child(Support.child_argv) }
-    after { client.shutdown }
+    let(:client) { Support.persistent_client }
 
     context Window do
       let(:window) { client.current.window }

data/spec/neovim/ruby_provider/buffer_ext_spec.rb

@@ -4,13 +4,11 @@ require "neovim/ruby_provider/buffer_ext"
 module Neovim
   RSpec.describe Buffer do
     let!(:nvim) do
-      Neovim.attach_child(Support.child_argv).tap do |nvim|
-        stub_const("::Vim", nvim)
+      Support.persistent_client.tap do |client|
+        stub_const("::Vim", client)
       end
     end
 
-    after { nvim.shutdown }
-
     describe ".current" do
       it "returns the current buffer from the global Vim client" do
         expect(Buffer.current).to eq(nvim.get_current_buf)
@@ -27,9 +25,10 @@ module Neovim
 
     describe ".[]" do
       it "returns the buffer from the global Vim client at the given index" do
-        expect(Buffer[0]).to eq(nvim.get_current_buf)
-        nvim.command("new")
-        expect(Buffer[1]).to eq(nvim.get_current_buf)
+        buffer = Buffer[0]
+
+        expect(buffer).to be_a(Buffer)
+        expect(buffer).to eq(nvim.list_bufs[0])
       end
     end
   end

data/spec/neovim/ruby_provider/object_ext_spec.rb

@@ -0,0 +1,10 @@
+require "helper"
+require "neovim/ruby_provider/object_ext"
+
+RSpec.describe Object do
+  describe "#to_msgpack" do
+    it "converts classes to strings" do
+      expect(MessagePack.pack(String)).to eq(MessagePack.pack("String"))
+    end
+  end
+end

data/spec/neovim/ruby_provider/vim_spec.rb

@@ -52,7 +52,7 @@ RSpec.describe Vim do
     end
 
     it "refreshes global variables" do
-      client = Neovim.attach_child(Support.child_argv)
+      client = Support.persistent_client
       client.command("vs foo")
 
       Vim.__client = client

data/spec/neovim/ruby_provider/window_ext_spec.rb

@@ -4,13 +4,11 @@ require "neovim/ruby_provider/window_ext"
 module Neovim
   RSpec.describe Window do
     let!(:nvim) do
-      Neovim.attach_child(Support.child_argv).tap do |nvim|
-        stub_const("::Vim", nvim)
+      Support.persistent_client.tap do |client|
+        stub_const("::Vim", client)
       end
     end
 
-    after { nvim.shutdown }
-
     describe ".current" do
       it "returns the current window from the global Vim client" do
         expect(Window.current).to eq(nvim.get_current_win)
@@ -33,17 +31,16 @@ module Neovim
 
     describe ".[]" do
       it "returns the window at the given index" do
-        expect do
-          nvim.command("new")
-        end.to change { Window[1] }.from(nil).to(kind_of(Window))
+        window = Window[0]
+
+        expect(window).to be_a(Window)
+        expect(window).to eq(nvim.list_wins[0])
       end
 
       it "only includes windows within a tabpage" do
-        nvim.command("new")
-
         expect do
           nvim.command("tabnew")
-        end.to change { Window[1] }.from(kind_of(Window)).to(nil)
+        end.to change { Window[0] }
       end
     end
   end

data/spec/neovim/session_spec.rb

@@ -2,10 +2,8 @@ require "helper"
 
 module Neovim
   RSpec.describe Session do
-    let(:event_loop) { EventLoop.child(Support.child_argv) }
-    let!(:session) { Session.new(event_loop) }
-
-    after { session.shutdown }
+    let(:client) { Support.persistent_client }
+    let(:session) { client.session }
 
     describe "#request" do
       it "synchronously returns a result" do
@@ -18,12 +16,6 @@ module Neovim
         end.to raise_error(/wrong number of arguments/i)
       end
 
-      it "handles large data" do
-        large_str = Array.new(1024 * 17) { SecureRandom.hex(1) }.join
-        session.request(:nvim_set_current_line, large_str)
-        expect(session.request(:nvim_get_current_line)).to eq(large_str)
-      end
-
       it "fails outside of the main thread", :silence_thread_exceptions do
         expect do
           Thread.new { session.request(:nvim_strwidth, "foo") }.join
@@ -32,18 +24,6 @@ module Neovim
     end
 
     describe "#notify" do
-      it "doesn't raise exceptions" do
-        expect do
-          session.notify(:nvim_strwidth, "too", "many")
-        end.not_to raise_error
-      end
-
-      it "handles large data" do
-        large_str = Array.new(1024 * 17) { SecureRandom.hex(1) }.join
-        session.notify(:nvim_set_current_line, large_str)
-        expect(session.request(:nvim_get_current_line)).to eq(large_str)
-      end
-
       it "succeeds outside of the main thread" do
         expect do
           Thread.new { session.notify(:nvim_set_current_line, "foo") }.join
@@ -51,33 +31,26 @@ module Neovim
       end
     end
 
-    describe "#run" do
-      it "enqueues messages received during blocking requests" do
-        session.request(:nvim_subscribe, "my_event")
-        session.request(:nvim_command, "call rpcnotify(0, 'my_event', 'foo')")
+    describe "#next" do
+      it "returns the next message from the event loop" do
+        cid, = session.request(:nvim_get_api_info)
+        session.request(:nvim_command, "call rpcnotify(#{cid}, 'my_event', 'foo')")
 
-        message = nil
-        session.run do |msg|
-          message = msg
-          session.shutdown
-        end
+        message = session.next
 
         expect(message.sync?).to eq(false)
         expect(message.method_name).to eq("my_event")
         expect(message.arguments).to eq(["foo"])
       end
 
-      it "supports requests within callbacks" do
-        session.request(:nvim_subscribe, "my_event")
-        session.request(:nvim_command, "call rpcnotify(0, 'my_event', 'foo')")
+      it "returns asynchronous notification errors", nvim_version: ">= 0.4.pre.dev" do
+        session.notify(:nvim_set_current_line, "too", "many", "args")
 
-        result = nil
-        session.run do |msg|
-          result = session.request(:nvim_strwidth, msg.arguments.first)
-          session.shutdown
-        end
+        message = session.next
 
-        expect(result).to be(3)
+        expect(message.sync?).to eq(false)
+        expect(message.method_name).to eq("nvim_error_event")
+        expect(message.arguments).to eq([0, "Wrong number of arguments: expecting 1 but got 3"])
       end
     end
   end