neovim 0.6.2 → 0.9.0.pre.1

data/spec/neovim/event_loop_spec.rb

@@ -10,71 +10,73 @@ module Neovim
     let(:server_rd) { pull_pipe[0] }
     let(:server_wr) { push_pipe[1] }
 
-    let(:connection) { EventLoop::Connection.new(client_rd, client_wr) }
+    let(:connection) { Connection.new(client_rd, client_wr) }
     let(:event_loop) { EventLoop.new(connection) }
 
-    describe "#run" do
-      it "reads requests" do
-        server_wr.write(MessagePack.pack([0, 1, :foo_method, []]))
-        server_wr.flush
+    describe "#request" do
+      it "writes a msgpack request" do
+        event_loop.request(1, :method, 1, 2)
+        connection.flush
+        message = server_rd.readpartial(1024)
 
-        request = nil
-        event_loop.run do |req|
-          request = req
-          event_loop.stop
-        end
-        expect(request.method_name).to eq("foo_method")
+        expect(message).to eq(MessagePack.pack([0, 1, "method", [1, 2]]))
       end
+    end
 
-      it "writes requests" do
-        response = nil
-
-        event_loop.request(:foo_method) do |res|
-          response = res
-          event_loop.stop
-        end
+    describe "#respond" do
+      it "writes a msgpack response" do
+        event_loop.respond(2, "value", "error")
+        connection.flush
+        message = server_rd.readpartial(1024)
 
-        server_wr.write(MessagePack.pack([1, 1, nil, :value]))
-        server_wr.flush
-
-        event_loop.run
-        expect(response.value!).to eq("value")
+        expect(message).to eq(MessagePack.pack([1, 2, "error", "value"]))
       end
+    end
 
-      it "writes responses" do
-        event_loop.respond(1, :foo_response, nil)
+    describe "#notify" do
+      it "writes a msgpack notification" do
+        event_loop.notify(:method, 1, 2)
+        connection.flush
+        message = server_rd.readpartial(1024)
 
-        server_wr.write(MessagePack.pack([2, :noop, []]))
-        server_wr.flush
-
-        event_loop.run { event_loop.stop }
-        expect(server_rd.readpartial(1024)).to eq(
-          MessagePack.pack([1, 1, nil, :foo_response])
-        )
+        expect(message).to eq(MessagePack.pack([2, "method", [1, 2]]))
       end
+    end
 
-      it "reads notifications" do
-        server_wr.write(MessagePack.pack([2, :foo_notification, []]))
+    describe "#run" do
+      it "yields received messages to the block" do
+        server_wr.write(MessagePack.pack([0, 1, :foo_method, []]))
         server_wr.flush
 
-        notification = nil
-        event_loop.run do |ntf|
-          notification = ntf
+        message = nil
+        event_loop.run do |req|
+          message = req
           event_loop.stop
         end
-        expect(notification.method_name).to eq("foo_notification")
-      end
 
-      it "writes notifications" do
-        event_loop.notify(:foo_notification)
+        expect(message.sync?).to eq(true)
+        expect(message.method_name).to eq("foo_method")
+      end
 
-        server_wr.write(MessagePack.pack([2, :noop, []]))
+      it "returns the last message received" do
+        server_wr.write(MessagePack.pack([0, 1, :foo_method, []]))
         server_wr.flush
 
-        event_loop.run { event_loop.stop }
-        expect(server_rd.readpartial(1024)).to eq(
-          MessagePack.pack([2, :foo_notification, []])
-        )
+        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
+        end
+
+        server_wr.close
+        run_thread.join
+        expect(client_rd).to be_closed
+        expect(client_wr).to be_closed
       end
     end
   end

data/spec/neovim/executable_spec.rb

@@ -23,9 +23,9 @@ module Neovim
       it "raises with an invalid executable path" do
         executable = Executable.new(File::NULL)
 
-        expect {
+        expect do
           executable.version
-        }.to raise_error(Executable::Error, Regexp.new(File::NULL))
+        end.to raise_error(Executable::Error, Regexp.new(File::NULL))
       end
     end
   end

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/loader_spec.rb

@@ -6,7 +6,7 @@ module Neovim
     RSpec.describe Loader do
       describe "#load" do
         let(:plugin_path) { Support.file_path("plug.rb") }
-        let(:host) { instance_double(Host, :register => nil) }
+        let(:host) { instance_double(Host, plugins: []) }
         let(:loader) { Loader.new(host) }
 
         before do
@@ -14,33 +14,40 @@ module Neovim
         end
 
         it "registers plugins defined in the provided files" do
-          expect(host).to receive(:register).with(kind_of(Plugin))
-          loader.load([plugin_path])
+          expect do
+            loader.load([plugin_path])
+          end.to change { host.plugins.size }.by(1)
         end
 
         it "registers multiple plugins defined in the provided files" do
           File.write(plugin_path, "Neovim.plugin; Neovim.plugin")
-          expect(host).to receive(:register).with(kind_of(Plugin)).twice
-          loader.load([plugin_path])
+
+          expect do
+            loader.load([plugin_path])
+          end.to change { host.plugins.size }.by(2)
         end
 
         it "doesn't register plugins when none are defined" do
           File.write(plugin_path, "class FooClass; end")
-          expect(host).not_to receive(:register)
-          loader.load([plugin_path])
+
+          expect do
+            loader.load([plugin_path])
+          end.not_to change { host.plugins.size }
         end
 
         it "doesn't leak constants defined in plugins" do
           File.write(plugin_path, "class FooClass; end")
-          loader.load([plugin_path])
-          expect(Kernel.const_defined?(:FooClass)).to be(false)
+
+          expect do
+            loader.load([plugin_path])
+          end.not_to change { Kernel.const_defined?(:FooClass) }.from(false)
         end
 
         it "doesn't leak the overidden Neovim.plugin method" do
           loader.load([plugin_path])
-          expect {
+          expect do
             Neovim.plugin
-          }.to raise_error(/outside of a plugin host/)
+          end.to raise_error(/outside of a plugin host/)
         end
       end
     end

data/spec/neovim/host_spec.rb

@@ -9,18 +9,18 @@ module Neovim
 
       let(:host_rd) { push_pipe[0] }
       let(:host_wr) { pull_pipe[1] }
-      let(:nvim_rd) { pull_pipe[0] }
-      let(:nvim_wr) { push_pipe[1] }
+      let(:nvim_rd) { MessagePack::Unpacker.new(pull_pipe[0]) }
+      let(:nvim_wr) { MessagePack::Packer.new(push_pipe[1]) }
 
       let(:plugin_path) do
         Support.file_path("my_plugin").tap do |path|
           File.write(path, <<-PLUGIN)
             Neovim.plugin do |plug|
-              plug.command(:StrWidth, :nargs => 1, :sync => true) do |client, arg|
-                arg.bytesize
+              plug.command(:Echo, nargs: 1, sync: true) do |client, arg|
+                arg
               end
 
-              plug.command(:Boom, :sync => true) do |client|
+              plug.command(:Boom, sync: true) do |client|
                 raise "BOOM"
               end
 
@@ -33,7 +33,7 @@ module Neovim
       end
 
       let!(:host_thread) do
-        connection = EventLoop::Connection.new(host_rd, host_wr)
+        connection = Connection.new(host_rd, host_wr)
         event_loop = EventLoop.new(connection)
 
         Thread.new do
@@ -41,106 +41,98 @@ module Neovim
         end
       end
 
-      before do
-        _, reqid, method = MessagePack.unpack(nvim_rd.readpartial(1024))
-        expect(method).to eq("nvim_get_api_info")
+      after { host_thread.kill.join }
 
-        session = Session.new(EventLoop.child(Support.child_argv))
-        api_info = session.request(:nvim_get_api_info)
-        session.shutdown
+      context "poll" do
+        it "initializes a client, sets client info, and responds 'ok'" do
+          nvim_wr.write([0, 1, :poll, []]).flush
 
-        nvim_wr.write(MessagePack.pack([1, reqid, nil, api_info]))
-        nvim_wr.flush
-      end
+          expect(nvim_rd.read).to match([2, "nvim_set_client_info", duck_type(:to_ary)])
 
-      after do
-        host_thread.kill
-        host_thread.join
-      end
+          type, reqid, method = nvim_rd.read
+          expect([type, reqid, method]).to match([0, duck_type(:to_int), "nvim_get_api_info"])
 
-      it "responds 'ok' to the 'poll' request" do
-        message = MessagePack.pack([0, 0, :poll, []])
-        nvim_wr.write(message)
-        nvim_wr.flush
+          api_info = [0, {"types" => {}, "functions" => {}}]
+          nvim_wr.write([1, reqid, nil, api_info]).flush
 
-        response = MessagePack.unpack(nvim_rd.readpartial(1024))
-        expect(response).to eq([1, 0, nil, "ok"])
+          expect(nvim_rd.read).to eq([1, 1, nil, "ok"])
+        end
       end
 
-      it "responds with specs to the 'specs' request" do
-        message = MessagePack.pack([0, 0, :specs, [plugin_path]])
-        nvim_wr.write(message)
-        nvim_wr.flush
-
-        response = MessagePack.unpack(nvim_rd.readpartial(1024))
-        expect(response).to eq(
-          [
-            1,
-            0,
-            nil,
-            [
-              {
-                "type" => "command",
-                "name" => "StrWidth",
-                "sync" => true,
-                "opts" => {"nargs" => 1},
-              },
-              {
-                "type" => "command",
-                "name" => "Boom",
-                "sync" => true,
-                "opts" => {},
-              },
-              {
-                "type" => "command",
-                "name" => "BoomAsync",
-                "sync" => false,
-                "opts" => {},
-              },
-            ],
-          ],
-        )
-      end
+      context "after poll" do
+        before do
+          nvim_wr.write([0, 1, :poll, []]).flush
 
-      it "delegates to plugin handlers" do
-        message = MessagePack.pack([0, 0, "#{plugin_path}:command:StrWidth", ["hi"]])
-        nvim_wr.write(message)
-        nvim_wr.flush
+          expect(nvim_rd.read[1]).to eq("nvim_set_client_info")
 
-        response = MessagePack.unpack(nvim_rd.readpartial(1024))
-        expect(response).to eq([1, 0, nil, 2])
-      end
+          _, reqid, method = nvim_rd.read
 
-      it "handles exceptions in sync plugin handlers" do
-        message = MessagePack.pack([0, 0, "#{plugin_path}:command:Boom", ["hi"]])
-        nvim_wr.write(message)
-        nvim_wr.flush
+          expect(method).to eq("nvim_get_api_info")
 
-        response = MessagePack.unpack(nvim_rd.readpartial(1024))
-        expect(response).to eq([1, 0, "BOOM", nil])
-      end
+          api_info = Support.persistent_client.get_api_info
 
-      it "handles exceptions in async plugin handlers" do
-        message = MessagePack.pack([2, "#{plugin_path}:command:BoomAsync", ["hi"]])
-        nvim_wr.write(message)
-        nvim_wr.flush
-
-        message = MessagePack.unpack(nvim_rd.readpartial(1024))
-        expect(message).to match_array(
-          [
-            0, duck_type(:to_int), "nvim_err_writeln",
-            [/my_plugin:command:BoomAsync: \(RuntimeError\) BOOM ASYNC/]
-          ]
-        )
-      end
+          nvim_wr.write([1, reqid, nil, api_info]).flush
+
+          expect(nvim_rd.read[3]).to eq("ok")
+        end
+
+        it "responds with specs to the 'specs' request" do
+          nvim_wr.write([0, 2, :specs, [plugin_path]]).flush
 
-      it "handles unknown requests" do
-        message = MessagePack.pack([0, 0, "foobar", []])
-        nvim_wr.write(message)
-        nvim_wr.flush
+          expect(nvim_rd.read).to eq(
+            [
+              1,
+              2,
+              nil,
+              [
+                {
+                  "type" => "command",
+                  "name" => "Echo",
+                  "sync" => true,
+                  "opts" => {"nargs" => 1}
+                },
+                {
+                  "type" => "command",
+                  "name" => "Boom",
+                  "sync" => true,
+                  "opts" => {}
+                },
+                {
+                  "type" => "command",
+                  "name" => "BoomAsync",
+                  "sync" => false,
+                  "opts" => {}
+                }
+              ]
+            ]
+          )
+        end
+
+        it "delegates to plugin handlers" do
+          nvim_wr.write([0, 0, "#{plugin_path}:command:Echo", ["hi"]]).flush
+          expect(nvim_rd.read).to eq([1, 0, nil, "hi"])
+        end
+
+        it "handles exceptions in sync plugin handlers" do
+          nvim_wr.write([0, 0, "#{plugin_path}:command:Boom", ["hi"]]).flush
+          expect(nvim_rd.read).to eq([1, 0, "BOOM", nil])
+        end
 
-        response = MessagePack.unpack(nvim_rd.readpartial(1024))
-        expect(response).to eq([1, 0, "Unknown request foobar", nil])
+        it "handles exceptions in async plugin handlers" do
+          nvim_wr.write([2, "#{plugin_path}:command:BoomAsync", ["hi"]]).flush
+
+          expect(nvim_rd.read).to match_array(
+            [
+              0, duck_type(:to_int), "nvim_err_writeln",
+              [/my_plugin:command:BoomAsync: \(RuntimeError\) BOOM ASYNC/]
+            ]
+          )
+        end
+
+        it "handles unknown requests" do
+          nvim_wr.write([0, 0, "foobar", []]).flush
+          expect(nvim_rd.read).to eq([1, 0, "Unknown request foobar", nil])
+        end
       end
     end
   end