neovim 0.6.2 → 0.7.0

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,96 @@ module Neovim
         end
       end
 
-      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.kill while host_thread.alive?
         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
+      context "poll" do
+        it "initializes a client and responds 'ok'" do
+          nvim_wr.write([0, 1, :poll, []]).flush
+          type, reqid, method = nvim_rd.read
 
-        response = MessagePack.unpack(nvim_rd.readpartial(1024))
-        expect(response).to eq([1, 0, nil, "ok"])
-      end
+          expect(type).to eq(0)
+          expect(reqid).to eq(2)
+          expect(method).to eq("nvim_get_api_info")
 
-      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" => {},
-              },
-            ],
-          ],
-        )
+          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
 
-      it "delegates to plugin handlers" do
-        message = MessagePack.pack([0, 0, "#{plugin_path}:command:StrWidth", ["hi"]])
-        nvim_wr.write(message)
-        nvim_wr.flush
+      context "after poll" do
+        before do
+          nvim_wr.write([0, 1, :poll, []]).flush
+          _, reqid, _ = nvim_rd.read
 
-        response = MessagePack.unpack(nvim_rd.readpartial(1024))
-        expect(response).to eq([1, 0, nil, 2])
-      end
+          session = Session.new(EventLoop.child(Support.child_argv))
+          api_info = session.request(:nvim_get_api_info)
+          session.shutdown
 
-      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
+          nvim_wr.write([1, reqid, nil, api_info]).flush
+          nvim_rd.read
+        end
 
-        response = MessagePack.unpack(nvim_rd.readpartial(1024))
-        expect(response).to eq([1, 0, "BOOM", nil])
-      end
+        it "responds with specs to the 'specs' request" do
+          nvim_wr.write([0, 2, :specs, [plugin_path]]).flush
 
-      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
+          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 "handles unknown requests" do
-        message = MessagePack.pack([0, 0, "foobar", []])
-        nvim_wr.write(message)
-        nvim_wr.flush
+        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

data/spec/neovim/logging_spec.rb

@@ -16,21 +16,21 @@ module Neovim
 
     describe ".logger" do
       it "fetches the output from $NVIM_RUBY_LOG_FILE" do
-        logger = instance_double(Logger, :level= => nil, :formatter= => nil)
+        logger = instance_double(Logger, "level=": nil, "formatter=": nil)
         expect(Logger).to receive(:new).with("/tmp/nvim.log").and_return(logger)
         Logging.logger("NVIM_RUBY_LOG_FILE" => "/tmp/nvim.log")
         expect(Logging.logger).to be(logger)
       end
 
       it "defaults the output to STDERR" do
-        logger = instance_double(Logger, :level= => nil, :formatter= => nil)
+        logger = instance_double(Logger, "level=": nil, "formatter=": nil)
         expect(Logger).to receive(:new).with(STDERR).and_return(logger)
         Logging.logger({})
         expect(Logging.logger).to be(logger)
       end
 
       it "fetches the level from $NVIM_RUBY_LOG_LEVEL as a string" do
-        logger = instance_double(Logger, :formatter= => nil)
+        logger = instance_double(Logger, "formatter=": nil)
         expect(Logger).to receive(:new).and_return(logger)
         expect(logger).to receive(:level=).with(Logger::DEBUG)
         Logging.logger("NVIM_RUBY_LOG_LEVEL" => "DEBUG")
@@ -38,7 +38,7 @@ module Neovim
       end
 
       it "fetches the level from $NVIM_RUBY_LOG_LEVEL as an integer" do
-        logger = instance_double(Logger, :formatter= => nil)
+        logger = instance_double(Logger, "formatter=": nil)
         expect(Logger).to receive(:new).and_return(logger)
         expect(logger).to receive(:level=).with(0)
         Logging.logger("NVIM_RUBY_LOG_LEVEL" => "0")
@@ -46,7 +46,7 @@ module Neovim
       end
 
       it "defaults the level to WARN" do
-        logger = instance_double(Logger, :formatter= => nil)
+        logger = instance_double(Logger, "formatter=": nil)
         expect(Logger).to receive(:new).and_return(logger)
         expect(logger).to receive(:level=).with(Logger::WARN)
         Logging.logger({})
@@ -81,7 +81,7 @@ module Neovim
 
       describe "#log" do
         it "logs JSON at the specified level" do
-          obj.public_log(:info, :foo => "bar")
+          obj.public_log(:info, foo: "bar")
           logged = MultiJson.decode(log.string)
 
           expect(logged).to match(

data/spec/neovim/message_spec.rb

@@ -0,0 +1,119 @@
+require "helper"
+
+module Neovim
+  RSpec.describe Message do
+    describe ".request" do
+      it "builds a request" do
+        request = Message.request(1, :method, [1, 2])
+
+        expect(request).to be_a(Message::Request)
+        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
+
+    describe ".response" do
+      it "builds a response" do
+        response = Message.response(1, "error", "value")
+
+        expect(response).to be_a(Message::Response)
+        expect(response.request_id).to eq(1)
+        expect(response.error).to eq("error")
+        expect(response.value).to eq("value")
+      end
+    end
+
+    describe ".notification" do
+      it "builds a notification" do
+        notification = Message.notification(:method, [1, 2])
+
+        expect(notification).to be_a(Message::Notification)
+        expect(notification.sync?).to eq(false)
+        expect(notification.method_name).to eq(:method)
+        expect(notification.arguments).to eq([1, 2])
+      end
+    end
+
+    describe ".from_array" do
+      it "returns a request" do
+        request = Message.from_array([0, 1, :method, [1, 2]])
+
+        expect(request).to be_a(Message::Request)
+        expect(request.id).to eq(1)
+        expect(request.method_name).to eq(:method)
+        expect(request.arguments).to eq([1, 2])
+      end
+
+      it "returns a response" do
+        response = Message.from_array([1, 1, [1, "error"], "value"])
+
+        expect(response).to be_a(Message::Response)
+        expect(response.request_id).to eq(1)
+        expect(response.error).to eq("error")
+        expect(response.value).to eq("value")
+      end
+
+      it "returns a notification" do
+        notification = Message.from_array([2, :method, [1, 2]])
+
+        expect(notification).to be_a(Message::Notification)
+        expect(notification.method_name).to eq(:method)
+        expect(notification.arguments).to eq([1, 2])
+      end
+    end
+
+    describe Message::Request do
+      subject { described_class.new(1, :method, [1, 2]) }
+
+      specify "#to_a" do
+        expect(subject.to_a).to eq([0, 1, :method, [1, 2]])
+      end
+
+      describe "#received" do
+        it "yields itself to the block" do
+          request = Message::Request.new(1, :method, [1, 2])
+
+          expect do |block|
+            request.received({}, &block)
+          end.to yield_with_args(request)
+        end
+      end
+    end
+
+    describe Message::Response do
+      subject { described_class.new(2, "error", "result") }
+
+      specify "#to_a" do
+        expect(subject.to_a).to eq([1, 2, "error", "result"])
+      end
+
+      describe "#received" do
+        it "yields itself to the response handler" do
+          response = Message::Response.new(1, nil, "value")
+
+          expect do |block|
+            response.received(1 => block.to_proc)
+          end.to yield_with_args(response)
+        end
+      end
+    end
+
+    describe Message::Notification do
+      subject { described_class.new(:method, [1, 2]) }
+
+      specify "#to_a" do
+        expect(subject.to_a).to eq([2, :method, [1, 2]])
+      end
+
+      describe "#received" do
+        it "yields itself to the block" do
+          expect do |block|
+            subject.received({}, &block)
+          end.to yield_with_args(subject)
+        end
+      end
+    end
+  end
+end

data/spec/neovim/plugin_spec.rb

@@ -5,15 +5,15 @@ module Neovim
   RSpec.describe Plugin do
     describe ".from_config_block" do
       it "registers a command" do
-        cmd_block = Proc.new {}
+        cmd_block = -> {}
 
         plugin = Plugin.from_config_block("source") do |plug|
           plug.command(
             "Foo",
-            :nargs => 1,
-            :range => true,
-            :bang => true,
-            :register => true,
+            nargs: 1,
+            range: true,
+            bang: true,
+            register: true,
             &cmd_block
           )
         end
@@ -26,23 +26,23 @@ module Neovim
         expect(handler.block).to eq(cmd_block)
         expect(handler.qualified_name).to eq("source:command:Foo")
         expect(handler.to_spec).to eq(
-          :type => :command,
-          :name => "Foo",
-          :sync => false,
-          :opts => {
-            :nargs => 1,
-            :range => "",
-            :bang => "",
-            :register => "",
+          type: :command,
+          name: "Foo",
+          sync: false,
+          opts: {
+            nargs: 1,
+            range: "",
+            bang: "",
+            register: "",
           },
         )
       end
 
       it "registers an autocmd" do
-        au_block = Proc.new {}
+        au_block = -> {}
 
         plugin = Plugin.from_config_block("source") do |plug|
-          plug.autocmd("BufEnter", :pattern => "*.rb", &au_block)
+          plug.autocmd("BufEnter", pattern: "*.rb", &au_block)
         end
 
         expect(plugin.handlers.size).to be(1)
@@ -53,18 +53,18 @@ module Neovim
         expect(handler.block).to eq(au_block)
         expect(handler.qualified_name).to eq("source:autocmd:BufEnter:*.rb")
         expect(handler.to_spec).to eq(
-          :type => :autocmd,
-          :name => "BufEnter",
-          :sync => false,
-          :opts => {:pattern => "*.rb"},
+          type: :autocmd,
+          name: "BufEnter",
+          sync: false,
+          opts: {pattern: "*.rb"},
         )
       end
 
       it "registers a function" do
-        fun_block = Proc.new {}
+        fun_block = -> {}
 
         plugin = Plugin.from_config_block("source") do |plug|
-          plug.function("Foo", :range => true, :nargs => 1, &fun_block)
+          plug.function("Foo", range: true, nargs: 1, &fun_block)
         end
 
         expect(plugin.handlers.size).to be(1)
@@ -75,10 +75,10 @@ module Neovim
         expect(handler.block).to eq(fun_block)
         expect(handler.qualified_name).to eq("source:function:Foo")
         expect(handler.to_spec).to eq(
-          :type => :function,
-          :name => "Foo",
-          :sync => false,
-          :opts => {:range => "", :nargs => 1},
+          type: :function,
+          name: "Foo",
+          sync: false,
+          opts: {range: "", nargs: 1},
         )
       end
 
@@ -101,7 +101,7 @@ module Neovim
       end
 
       it "registers a top level RPC" do
-        cmd_block = Proc.new {}
+        cmd_block = -> {}
 
         plugin = Plugin.from_config_block("source") do |plug|
           plug.__send__(:rpc, "Foo", &cmd_block)
@@ -120,16 +120,16 @@ module Neovim
     describe "#specs" do
       it "returns specs for plugin handlers" do
         plugin = Plugin.from_config_block("source") do |plug|
-          plug.command("Foo", :sync => true, :nargs => 2)
+          plug.command("Foo", sync: true, nargs: 2)
         end
 
         expect(plugin.specs).to eq(
           [
             {
-              :type => :command,
-              :name => "Foo",
-              :sync => true,
-              :opts=> {:nargs => 2}
+              type: :command,
+              name: "Foo",
+              sync: true,
+              opts: {nargs: 2}
             }
           ]
         )