neovim 0.5.1 → 0.6.0

data/spec/neovim/client_spec.rb

@@ -5,10 +5,24 @@ module Neovim
     let(:client) { Neovim.attach_child(Support.child_argv) }
     after { client.shutdown }
 
-    specify do
-      client.strwidth("foo")
-      client.strwidth("bar")
-      client.command("echom 'hi'")
+    describe "#set_option" do
+      it "sets an option from two arguments" do
+        expect {
+          client.set_option("makeprg", "rake")
+        }.to change { client.evaluate("&makeprg") }.to("rake")
+      end
+
+      it "sets an option from a string" do
+        expect {
+          client.set_option("timeoutlen=0")
+        }.to change { client.evaluate("&timeoutlen") }.to(0)
+      end
+
+      it "sets a boolean option" do
+        expect {
+          client.set_option("expandtab")
+        }.to change { client.evaluate("&expandtab") }.to(1)
+      end
     end
 
     describe "#respond_to?" do

data/spec/neovim/event_loop/connection_spec.rb

@@ -0,0 +1,63 @@
+require "helper"
+
+module Neovim
+  class EventLoop
+    RSpec.describe Connection do
+      describe "#write" do
+        it "writes to the underlying file descriptor" do
+          rd, wr = IO.pipe
+          connection = Connection.new(nil, wr)
+          connection.write("some data")
+          wr.close
+
+          expect(rd.read).to eq("some data")
+        end
+
+        it "writes large amounts of data" do
+          File.open(Support.file_path("io"), "w+") do |io|
+            connection = Connection.new(nil, io)
+            big_data = Array.new(1024 * 16) { SecureRandom.hex(4) }.join
+
+            connection = Connection.new(nil, io)
+            connection.write(big_data)
+
+            expect(File.read(io.path)).to eq(big_data)
+          end
+        end
+      end
+
+      describe "#read" do
+        it "yields data from the underlying file descriptor" do
+          rd, wr = IO.pipe
+          wr.write("some data")
+          wr.close
+
+          connection = Connection.new(rd, nil)
+
+          expect do |y|
+            connection.read(&y)
+          end.to yield_with_args("some data")
+        end
+      end
+
+      describe "#close" do
+        it "closes IO handles" do
+          rd, wr = ::IO.pipe
+          Connection.new(rd, wr).close
+
+          expect(rd).to be_closed
+          expect(wr).to be_closed
+        end
+
+        it "kills spawned processes" do
+          io = ::IO.popen("cat", "rb+")
+          pid = io.pid
+          expect(pid).to respond_to(:to_int)
+
+          Connection.new(io).close
+          expect { Process.kill(0, pid) }.to raise_error(Errno::ESRCH)
+        end
+      end
+    end
+  end
+end

data/spec/neovim/event_loop/message_builder_spec.rb

@@ -0,0 +1,105 @@
+require "helper"
+
+module Neovim
+  class EventLoop
+    RSpec.describe MessageBuilder do
+      let(:message_builder) { MessageBuilder.new }
+
+      describe "#write" do
+        context "requests" do
+          it "yields a valid request message" do
+            expect do |y|
+              message_builder.write(:request, :method, [1, 2], Proc.new {}, &y)
+            end.to yield_with_args([0, 1, :method, [1, 2]])
+          end
+
+          it "increments the request id" do
+            expect do |y|
+              message_builder.write(:request, :method, [], Proc.new {}, &y)
+              message_builder.write(:request, :method, [], Proc.new {}, &y)
+            end.to yield_successive_args(
+              [0, 1, :method, []],
+              [0, 2, :method, []]
+            )
+          end
+        end
+
+        context "responses" do
+          it "yields a valid response message" do
+            expect do |y|
+              message_builder.write(:response, 2, :value, "error msg", &y)
+            end.to yield_with_args([1, 2, "error msg", :value])
+          end
+        end
+
+        context "notifications" do
+          it "yields a valid notification message" do
+            expect do |y|
+              message_builder.write(:notification, :method, [1, 2], &y)
+            end.to yield_with_args([2, :method, [1, 2]])
+          end
+        end
+      end
+
+      describe "#read" do
+        context "requests" do
+          it "yields a request object" do
+            request = nil
+            message_builder.read([0, 1, :method, [1, 2]]) do |req|
+              request = req
+            end
+
+            expect(request.sync?).to eq(true)
+            expect(request.id).to eq(1)
+            expect(request.method_name).to eq(:method)
+            expect(request.arguments).to eq([1, 2])
+          end
+        end
+
+        context "responses" do
+          it "calls the registered handler with a success response" do
+            response = nil
+            handler = Proc.new { |res| response = res }
+
+            message_builder.write(:request, :method, [1, 2], handler) {}
+            message_builder.read([1, 1, [nil, nil], :result])
+
+            expect(response.request_id).to eq(1)
+            expect(response.value).to eq(:result)
+            expect(response.value!).to eq(:result)
+            expect(response.error).to eq(nil)
+          end
+
+          it "calls the registered handler with an error response" do
+            response = nil
+
+            handler = Proc.new do |res|
+              response = res
+            end
+
+            message_builder.write(:request, :method, [1, 2], handler) {}
+            message_builder.read([1, 1, [:some_err, "BOOM"], nil])
+
+            expect(response.request_id).to eq(1)
+            expect(response.error).to eq("BOOM")
+            expect(response.value).to eq(nil)
+            expect { response.value! }.to raise_error("BOOM")
+          end
+        end
+
+        context "notifications" do
+          it "yields a notification object" do
+            notification = nil
+            message_builder.read([2, :method, [1, 2]]) do |ntf|
+              notification = ntf
+            end
+
+            expect(notification.sync?).to eq(false)
+            expect(notification.method_name).to eq(:method)
+            expect(notification.arguments).to eq([1, 2])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/neovim/event_loop/serializer_spec.rb

@@ -0,0 +1,63 @@
+require "helper"
+
+module Neovim
+  class EventLoop
+    RSpec.describe Serializer do
+      let(:serializer) { Serializer.new }
+
+      describe "write" do
+        it "yields msgpack" do
+          expect do |y|
+            serializer.write([1, :foo], &y)
+          end.to yield_with_args(MessagePack.pack([1, :foo]))
+        end
+      end
+
+      describe "read" do
+        it "yields an unpacked object" do
+          expect do |y|
+            serializer.read(MessagePack.pack([1, :foo]), &y)
+          end.to yield_with_args([1, "foo"])
+        end
+
+        it "accumulates chunks of data and yields a single object" do
+          object = Array.new(16) { SecureRandom.hex(4) }
+          msgpack = MessagePack.pack(object)
+
+          expect do |y|
+            msgpack.chars.each_slice(10) do |chunk|
+              serializer.read(chunk.join, &y)
+            end
+          end.to yield_with_args(object)
+        end
+      end
+
+      describe "#register_type" do
+        it "registers a msgpack ext type" do
+          ext_class = Struct.new(:id) do
+            def self.from_msgpack_ext(data)
+              new(data.unpack('N')[0])
+            end
+
+            def to_msgpack_ext
+              [self.id].pack('C')
+            end
+          end
+
+          serializer.register_type(42) do |id|
+            ext_class.new(id)
+          end
+
+          factory = MessagePack::Factory.new
+          factory.register_type(42, ext_class)
+          obj = ext_class.new(1)
+          msgpack = factory.packer.write(obj).flush.to_str
+
+          expect do |y|
+            serializer.read(msgpack, &y)
+          end.to yield_with_args(obj)
+        end
+      end
+    end
+  end
+end

data/spec/neovim/event_loop_spec.rb

@@ -0,0 +1,81 @@
+require "helper"
+
+module Neovim
+  RSpec.describe EventLoop do
+    let!(:push_pipe) { IO.pipe }
+    let!(:pull_pipe) { IO.pipe }
+
+    let(:client_rd) { push_pipe[0] }
+    let(:client_wr) { pull_pipe[1] }
+    let(:server_rd) { pull_pipe[0] }
+    let(:server_wr) { push_pipe[1] }
+
+    let(:connection) { EventLoop::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
+
+        request = nil
+        event_loop.run do |req|
+          request = req
+          event_loop.stop
+        end
+        expect(request.method_name).to eq("foo_method")
+      end
+
+      it "writes requests" do
+        response = nil
+
+        event_loop.request(:foo_method) do |res|
+          response = res
+          event_loop.stop
+        end
+
+        server_wr.write(MessagePack.pack([1, 1, nil, :value]))
+        server_wr.flush
+
+        event_loop.run
+        expect(response.value!).to eq("value")
+      end
+
+      it "writes responses" do
+        event_loop.respond(1, :foo_response, nil)
+
+        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])
+        )
+      end
+
+      it "reads notifications" do
+        server_wr.write(MessagePack.pack([2, :foo_notification, []]))
+        server_wr.flush
+
+        notification = nil
+        event_loop.run do |ntf|
+          notification = ntf
+          event_loop.stop
+        end
+        expect(notification.method_name).to eq("foo_notification")
+      end
+
+      it "writes notifications" do
+        event_loop.notify(:foo_notification)
+
+        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([2, :foo_notification, []])
+        )
+      end
+    end
+  end
+end

data/spec/neovim/host/loader_spec.rb

@@ -1,6 +1,5 @@
 require "helper"
 require "neovim/host"
-require "neovim/host/loader"
 
 module Neovim
   class Host

data/spec/neovim/host_spec.rb

@@ -3,175 +3,144 @@ require "neovim/host"
 
 module Neovim
   RSpec.describe Host do
-    let(:session) { instance_double(Session) }
-    let(:client) { instance_double(Client) }
-    let(:host) { Host.new(session, client) }
-
     describe ".run" do
-      it "loads plugins and runs the host event loop" do
-        paths = ["/foo", "/bar"]
-
-        expect(Host).to receive(:new).and_return(host)
-        expect(host).to receive(:run)
-
-        loader = instance_double(Host::Loader)
-
-        expect(loader).to receive(:load).with(paths)
-        expect(Host::Loader).to receive(:new).
-          with(host).
-          and_return(loader)
-
-        Host.run(paths, :session => session, :client => client)
-      end
-    end
-
-    describe "#run" do
-      it "runs the session event loop and handles messages" do
-        message = double(:message)
-        expect(session).to receive(:run).and_yield(message)
-        expect(host).to receive(:handle).with(message)
-
-        host.run
-      end
-
-      it "rescues session exceptions", :silence_warnings do
-        expect(session).to receive(:run).and_raise("BOOM")
-        expect { host.run }.not_to raise_error
-      end
-    end
-
-    describe "#handlers" do
-      it "has a default poll handler" do
-        expect(host.handlers["poll"]).to respond_to(:call)
-      end
-    end
-
-    describe "#specs" do
-      it "has default specs" do
-        expect(host.specs).to eq({})
-      end
-    end
-
-    describe "#register" do
-      it "adds specs" do
-        plugin = Plugin.from_config_block("source") do |plug|
-          plug.command(:Foo)
+      let!(:push_pipe) { IO.pipe }
+      let!(:pull_pipe) { IO.pipe }
+
+      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(: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
+              end
+
+              plug.command(:Boom, :sync => true) do |client|
+                raise "BOOM"
+              end
+
+              plug.command(:BoomAsync) do |client|
+                raise "BOOM ASYNC"
+              end
+            end
+          PLUGIN
         end
-
-        expect {
-          host.register(plugin)
-        }.to change { host.specs }.from({}).to("source" => plugin.specs)
       end
 
-      it "adds plugin handlers" do
-        plugin = Plugin.from_config_block("source") do |plug|
-          plug.command(:Foo)
-        end
+      let!(:host_thread) do
+        connection = EventLoop::Connection.new(host_rd, host_wr)
+        event_loop = EventLoop.new(connection)
 
-        expect {
-          host.register(plugin)
-        }.to change {
-          host.handlers["source:command:Foo"]
-        }.from(nil).to(kind_of(Proc))
-      end
-
-      it "yields a client to the plugin setup blocks" do
-        yielded = []
-
-        plugin = Plugin.from_config_block("source") do |plug|
-          plug.__send__(:setup) do |client|
-            yielded << client
-          end
-
-          plug.__send__(:setup) do |_|
-            yielded << :other
-          end
+        Thread.new do
+          Host.run([plugin_path], event_loop)
         end
-
-        expect {
-          host.register(plugin)
-        }.to change { yielded }.from([]).to([client, :other])
       end
 
-      it "doesn't add top-level RPCs to specs" do
-        plugin = Plugin.from_config_block("source") do |plug|
-          plug.__send__(:rpc, :Foo)
-        end
-
-        expect {
-          host.register(plugin)
-        }.to change { host.specs }.from({}).to("source" => [])
-      end
-    end
-
-    describe "#handle" do
-      it "calls the poll handler" do
-        message = double(:message, :method_name => "poll", :sync? => true)
-
-        expect(message).to receive(:respond).with("ok")
-        host.handle(message)
-      end
-
-      it "calls the specs handler" do
-        plugin = Plugin.from_config_block("source") do |plug|
-          plug.command(:Foo)
-        end
-        host.register(plugin)
-
-        message = double(:message, :method_name => "specs", :sync? => true, :arguments => ["source"])
-
-        expect(message).to receive(:respond).with(plugin.specs)
-        host.handle(message)
-      end
-
-      it "calls a plugin sync handler" do
-        plugin = Plugin.from_config_block("source") do |plug|
-          plug.command(:Foo, :sync => true) { |client, arg| [client, arg] }
-        end
-        host.register(plugin)
-
-        message = double(:message, :method_name => "source:command:Foo", :sync? => true, :arguments => [:arg])
-
-        expect(message).to receive(:respond).with([client, :arg])
-        host.handle(message)
-      end
-
-      it "rescues plugin sync handler exceptions", :silence_warnings do
-        plugin = Plugin.from_config_block("source") do |plug|
-          plug.command(:Foo, :sync => true) { raise "BOOM" }
-        end
-        host.register(plugin)
-
-        message = double(:message, :method_name => "source:command:Foo", :sync? => true, :arguments => [])
-
-        expect(message).to receive(:error).with("BOOM")
-        host.handle(message)
-      end
-
-      it "calls a plugin async handler" do
-        async_proc = Proc.new {}
-        plugin = Plugin.from_config_block("source") do |plug|
-          plug.command(:Foo, &async_proc)
-        end
-        host.register(plugin)
-
-        message = double(:message, :method_name => "source:command:Foo", :sync? => false, :arguments => [:arg])
-
-        expect(async_proc).to receive(:call).with(client, :arg)
-        host.handle(message)
-      end
-
-      it "calls a default sync handler" do
-        message = double(:message, :method_name => "foobar", :sync? => true)
-
-        expect(message).to receive(:error).with("Unknown request foobar")
-        host.handle(message)
-      end
-
-      it "calls a default async handler" do
-        message = double(:message, :method_name => "foobar", :sync? => false)
-
-        host.handle(message)
+      before do
+        _, reqid, method = MessagePack.unpack(nvim_rd.readpartial(1024))
+        expect(method).to eq("nvim_get_api_info")
+
+        session = Session.new(EventLoop.child(Support.child_argv))
+        api_info = session.request(:nvim_get_api_info)
+        session.shutdown
+
+        nvim_wr.write(MessagePack.pack([1, reqid, nil, api_info]))
+        nvim_wr.flush
+      end
+
+      after do
+        host_thread.kill
+        host_thread.join
+      end
+
+      it "responds 'ok' to the 'poll' request" do
+        message = MessagePack.pack([0, 0, :poll, []])
+        nvim_wr.write(message)
+        nvim_wr.flush
+
+        response = MessagePack.unpack(nvim_rd.readpartial(1024))
+        expect(response).to eq([1, 0, nil, "ok"])
+      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
+
+      it "delegates to plugin handlers" do
+        message = MessagePack.pack([0, 0, "#{plugin_path}:command:StrWidth", ["hi"]])
+        nvim_wr.write(message)
+        nvim_wr.flush
+
+        response = MessagePack.unpack(nvim_rd.readpartial(1024))
+        expect(response).to eq([1, 0, nil, 2])
+      end
+
+      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
+
+        response = MessagePack.unpack(nvim_rd.readpartial(1024))
+        expect(response).to eq([1, 0, "BOOM", nil])
+      end
+
+      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
+
+      it "handles unknown requests" do
+        message = MessagePack.pack([0, 0, "foobar", []])
+        nvim_wr.write(message)
+        nvim_wr.flush
+
+        response = MessagePack.unpack(nvim_rd.readpartial(1024))
+        expect(response).to eq([1, 0, "Unknown request foobar", nil])
       end
     end
   end