neovim 0.3.0 → 0.3.1

data/spec/neovim/remote_object_spec.rb

@@ -2,7 +2,7 @@ require "helper"
 
 module Neovim
   RSpec.describe RemoteObject do
-    let(:client) { Neovim.attach_child(["nvim", "-n", "-u", "NONE"]) }
+    let(:client) { Neovim.attach_child(Support.child_argv) }
     after { client.shutdown }
 
     context Window do
@@ -26,6 +26,10 @@ module Neovim
         it "enables window_* function calls" do
           expect(window.get_cursor).to eq([1, 0])
         end
+
+        it "falls back to super" do
+          expect { window.foobar }.to raise_error(NoMethodError)
+        end
       end
 
       describe "#methods" do

data/spec/neovim/ruby_provider/buffer_ext_spec.rb

@@ -4,21 +4,21 @@ require "neovim/ruby_provider/buffer_ext"
 module Neovim
   RSpec.describe Buffer do
     let!(:nvim) do
-      Neovim.attach_child(["nvim", "-u", "NONE", "-n"]).tap do |nvim|
-        stub_const("::VIM", nvim)
+      Neovim.attach_child(Support.child_argv).tap do |nvim|
+        stub_const("::Vim", nvim)
       end
     end
 
     after { nvim.shutdown }
 
     describe ".current" do
-      it "returns the current buffer from the global VIM client" do
+      it "returns the current buffer from the global Vim client" do
         expect(Buffer.current).to eq(nvim.get_current_buffer)
       end
     end
 
     describe ".count" do
-      it "returns the current buffer count from the global VIM client" do
+      it "returns the current buffer count from the global Vim client" do
         expect {
           nvim.command("new")
         }.to change { Buffer.count }.by(1)
@@ -26,7 +26,7 @@ module Neovim
     end
 
     describe ".[]" do
-      it "returns the buffer from the global VIM client at the given index" do
+      it "returns the buffer from the global Vim client at the given index" do
         expect(Buffer[0]).to eq(nvim.get_current_buffer)
         nvim.command("new")
         expect(Buffer[1]).to eq(nvim.get_current_buffer)

data/spec/neovim/ruby_provider/vim_spec.rb

@@ -0,0 +1,32 @@
+require "helper"
+require "neovim/ruby_provider/vim"
+
+RSpec.describe Vim do
+  describe Vim::Buffer do
+    it "refers to Neovim::Buffer" do
+      expect(Vim::Buffer).to be(Neovim::Buffer)
+    end
+  end
+
+  describe Vim::Window do
+    it "refers to Neovim::Window" do
+      expect(Vim::Window).to be(Neovim::Window)
+    end
+  end
+
+  describe VIM do
+    it "is an alias for the Vim module" do
+      expect(VIM).to be(Vim)
+    end
+  end
+
+  describe "#method_missing" do
+    it "delegates method calls to @__client" do
+      client = double(:client)
+      expect(client).to receive(:foo).with(1, 2)
+
+      Vim.__client = client
+      Vim.foo(1, 2)
+    end
+  end
+end

data/spec/neovim/ruby_provider/window_ext_spec.rb

@@ -4,32 +4,46 @@ require "neovim/ruby_provider/window_ext"
 module Neovim
   RSpec.describe Window do
     let!(:nvim) do
-      Neovim.attach_child(["nvim", "-u", "NONE", "-n"]).tap do |nvim|
-        stub_const("::VIM", nvim)
+      Neovim.attach_child(Support.child_argv).tap do |nvim|
+        stub_const("::Vim", nvim)
       end
     end
 
     after { nvim.shutdown }
 
     describe ".current" do
-      it "returns the current window from the global VIM client" do
+      it "returns the current window from the global Vim client" do
         expect(Window.current).to eq(nvim.get_current_window)
       end
     end
 
     describe ".count" do
-      it "returns the current window count from the global VIM client" do
+      it "returns the current window count from the global Vim client" do
         expect {
           nvim.command("new")
         }.to change { Window.count }.by(1)
       end
+
+      it "only includes windows within a tabpage" do
+        expect {
+          nvim.command("tabnew")
+        }.not_to change { Window.count }.from(1)
+      end
     end
 
     describe ".[]" do
-      it "returns the window from the global VIM client at the given index" do
-        expect(Window[0]).to eq(nvim.get_current_window)
-        nvim.command("tabnew")
-        expect(Window[1]).to eq(nvim.get_current_window)
+      it "returns the window at the given index" do
+        expect {
+          nvim.command("new")
+        }.to change { Window[1] }.from(nil).to(kind_of(Window))
+      end
+
+      it "only includes windows within a tabpage" do
+        nvim.command("new")
+
+        expect {
+          nvim.command("tabnew")
+        }.to change { Window[1] }.from(kind_of(Window)).to(nil)
       end
     end
   end

data/spec/neovim/session/api_spec.rb

@@ -13,17 +13,36 @@ module Neovim
       end
 
       describe "#function" do
-        it "returns a corresponding Function object" do
+        it "returns a sync function object" do
           api = API.new(
             [nil, {"functions" => [
-              {"name" => "vim_strwidth", "async" => false}
+              {"name" => "vim_sync", "async" => false}
             ]}]
           )
 
-          function = api.function("vim_strwidth")
-          expect(function).to be_a(API::Function)
-          expect(function.name).to eq("vim_strwidth")
+          function = api.function("vim_sync")
+          expect(function.name).to eq("vim_sync")
           expect(function.async).to be(false)
+
+          session = instance_double(Session)
+          expect(session).to receive(:request).with("vim_sync", "msg")
+          function.call(session, "msg")
+        end
+
+        it "returns an async function object" do
+          api = API.new(
+            [nil, {"functions" => [
+              {"name" => "vim_async", "async" => true}
+            ]}]
+          )
+
+          function = api.function("vim_async")
+          expect(function.name).to eq("vim_async")
+          expect(function.async).to be(true)
+
+          session = instance_double(Session)
+          expect(session).to receive(:notify).with("vim_async", "msg")
+          function.call(session, "msg")
         end
       end
 

data/spec/neovim/session/event_loop_spec.rb

@@ -82,7 +82,7 @@ module Neovim
 
       context "child" do
         it "sends and receives data" do
-          event_loop = EventLoop.child(["nvim", "-n", "-u", "NONE"])
+          event_loop = EventLoop.child(Support.child_argv)
           input = MessagePack.pack([0, 0, :vim_strwidth, ["hi"]])
 
           response = nil
@@ -94,6 +94,59 @@ module Neovim
           expect(response).to eq(MessagePack.pack([1, 0, nil, 2]))
         end
       end
+
+      describe "#run" do
+        it "handles EOF" do
+          rd, wr = IO.pipe
+          wr.close
+          event_loop = EventLoop.new(rd, wr)
+          expect(event_loop).to receive(:info).with(/EOFError/)
+
+          event_loop.run
+        end
+
+        it "handles other errors" do
+          rd, wr = IO.pipe
+          rd.close
+          event_loop = EventLoop.new(rd, wr)
+          expect(event_loop).to receive(:fatal).with(/IOError/)
+
+          event_loop.run
+        end
+      end
+
+      describe "#write" do
+        it "retries when writes would block" do
+          rd, wr = IO.pipe
+          event_loop = EventLoop.new(rd, wr)
+          err_class = Class.new(RuntimeError) { include IO::WaitWritable }
+
+          expect(wr).to receive(:write_nonblock).and_raise(err_class)
+          expect(wr).to receive(:write_nonblock).and_call_original
+
+          event_loop.write("a")
+          expect(rd.readpartial(1)).to eq("a")
+        end
+      end
+
+      describe "#shutdown" do
+        it "closes IO handles" do
+          rd, wr = IO.pipe
+          EventLoop.new(rd, wr).shutdown
+
+          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)
+
+          EventLoop.new(io).shutdown
+          expect { Process.kill(0, pid) }.to raise_error(Errno::ESRCH)
+        end
+      end
     end
   end
 end

data/spec/neovim/session/notification_spec.rb

@@ -0,0 +1,20 @@
+require "helper"
+
+module Neovim
+  class Session
+    RSpec.describe Notification do
+      let(:notification) { Notification.new(:method, ["arg"]) }
+
+      it "has readers" do
+        expect(notification.method_name).to eq("method")
+        expect(notification.arguments).to eq(["arg"])
+      end
+
+      describe "#sync?" do
+        it "is false" do
+          expect(notification.sync?).to be(false)
+        end
+      end
+    end
+  end
+end

data/spec/neovim/session/request_spec.rb

@@ -0,0 +1,36 @@
+require "helper"
+
+module Neovim
+  class Session
+    RSpec.describe Request do
+      let(:serializer) { double(:serializer) }
+      let(:reqid) { 1 }
+      let(:request) { Request.new(:method, ["arg"], serializer, reqid) }
+
+      it "has readers" do
+        expect(request.method_name).to eq("method")
+        expect(request.arguments).to eq(["arg"])
+      end
+
+      describe "#sync?" do
+        it "is true" do
+          expect(request.sync?).to be(true)
+        end
+      end
+
+      describe "#respond" do
+        it "writes an RPC response to serializer" do
+          expect(serializer).to receive(:write).with([1, reqid, nil, "val"])
+          request.respond("val")
+        end
+      end
+
+      describe "#error" do
+        it "writes an RPC error response to serializer" do
+          expect(serializer).to receive(:write).with([1, reqid, "err", nil])
+          request.error("err")
+        end
+      end
+    end
+  end
+end

data/spec/neovim/session/rpc_spec.rb

@@ -103,6 +103,18 @@ module Neovim
 
         include_context "rpc behavior"
       end
+
+      describe "#run" do
+        it "logs exceptions" do
+          serializer = instance_double(Serializer)
+          rpc = RPC.new(serializer)
+
+          expect(serializer).to receive(:run).and_raise("BOOM")
+          expect(rpc).to receive(:fatal).with(/BOOM/)
+
+          rpc.run
+        end
+      end
     end
   end
 end

data/spec/neovim/session/serializer_spec.rb

@@ -43,6 +43,20 @@ module Neovim
 
         include_context "serializer behavior"
       end
+
+      describe "#run" do
+        it "logs exceptions" do
+          unpacker = instance_double(MessagePack::Unpacker)
+          event_loop = instance_double(EventLoop)
+          serializer = Serializer.new(event_loop, unpacker)
+
+          expect(event_loop).to receive(:run).and_yield("data")
+          expect(unpacker).to receive(:feed_each).with("data").and_raise("BOOM")
+          expect(serializer).to receive(:fatal).with(/BOOM/)
+
+          serializer.run
+        end
+      end
     end
   end
 end

data/spec/neovim/session_spec.rb

@@ -95,11 +95,11 @@ module Neovim
     end
 
     context "tcp" do
-      let!(:nvim_port) { Support.port }
+      let!(:nvim_port) { Support.tcp_port }
       let!(:nvim_pid) do
         pid = Process.spawn(
           {"NVIM_LISTEN_ADDRESS" => "0.0.0.0:#{nvim_port}"},
-          "nvim --headless -n -u NONE",
+          Support.child_argv.join(" "),
           [:out, :err] => "/dev/null"
         )
 
@@ -126,7 +126,7 @@ module Neovim
       let!(:nvim_pid) do
         pid = Process.spawn(
           {"NVIM_LISTEN_ADDRESS" => socket_path},
-          "nvim --headless -n -u NONE",
+          Support.child_argv.join(" "),
           [:out, :err] => "/dev/null"
         )
 
@@ -149,7 +149,7 @@ module Neovim
     end
 
     context "child" do
-      let!(:session) { Session.child(["nvim", "-n", "-u", "NONE"]) }
+      let!(:session) { Session.child(Support.child_argv) }
       include_context "session behavior"
       after { session.shutdown }
     end

data/spec/neovim/window_spec.rb

@@ -2,7 +2,7 @@ require "helper"
 
 module Neovim
   RSpec.describe Window do
-    let(:client) { Neovim.attach_child(["nvim", "-n", "-u", "NONE"]) }
+    let(:client) { Neovim.attach_child(Support.child_argv) }
     let(:window) { client.current.window }
     after { client.shutdown }
 
@@ -69,6 +69,22 @@ module Neovim
             client.command("normal ix")
           }.to change { client.current.line }.to("oxne")
         end
+
+        it "supports out of range indexes" do
+          window.buffer.lines = ["x", "xx"]
+
+          expect {
+            window.cursor = [10, 10]
+          }.to change { window.cursor }.to([2, 1])
+
+          expect {
+            window.cursor = [0, -1]
+          }.to change { window.cursor }.to([1, 0])
+        end
+
+        it "returns the cursor array" do
+          expect(window.cursor = [10, 10]).to eq([10, 10])
+        end
       end
     end
   end

data/spec/neovim_spec.rb

@@ -1,13 +1,11 @@
 require "helper"
 
 RSpec.describe Neovim do
-  let(:nvim_argv) { %w(nvim --headless -u NONE -i NONE -n) }
-
   describe ".attach_tcp" do
     it "attaches to a TCP socket" do
-      port = Support.port
+      port = Support.tcp_port
       env = {"NVIM_LISTEN_ADDRESS" => "0.0.0.0:#{port}"}
-      pid = Process.spawn(env, *nvim_argv, [:out, :err] => "/dev/null")
+      pid = Process.spawn(env, *Support.child_argv, [:out, :err] => "/dev/null")
 
       begin
         client = Neovim.attach_tcp("0.0.0.0", port)
@@ -28,7 +26,7 @@ RSpec.describe Neovim do
     it "attaches to a UNIX socket" do
       socket_path = Support.socket_path
       env = {"NVIM_LISTEN_ADDRESS" => socket_path}
-      pid = Process.spawn(env, *nvim_argv, [:out, :err] => "/dev/null")
+      pid = Process.spawn(env, *Support.child_argv, [:out, :err] => "/dev/null")
 
       begin
         client = Neovim.attach_unix(socket_path)
@@ -48,25 +46,11 @@ RSpec.describe Neovim do
   describe ".attach_child" do
     it "spawns and attaches to a child process" do
       begin
-        client = Neovim.attach_child(nvim_argv)
+        client = Neovim.attach_child(Support.child_argv)
         expect(client.strwidth("hi")).to eq(2)
       ensure
         client.shutdown
       end
     end
   end
-
-  describe ".start_host" do
-    it "loads and runs a Host" do
-      paths = ["/foo", "/bar"]
-      host = double(:host)
-
-      expect(Neovim::Host).to receive(:load_from_files).
-        with(paths).
-        and_return(host)
-
-      expect(host).to receive(:run)
-      Neovim.start_host(paths)
-    end
-  end
 end