neovim 0.0.5 → 0.0.6

data/neovim.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables   = ["neovim-ruby-host"]
   spec.test_files    = spec.files.grep(%r{^spec/})
   spec.require_paths = ["lib"]
 

data/spec/acceptance/neovim-ruby-host_spec.rb

@@ -1,14 +1,17 @@
 require "helper"
-require "tmpdir"
 
 RSpec.describe "neovim-ruby-host" do
   it "loads and runs plugins from Ruby source files" do
     plugin1_path = Support.file_path("plugin1.rb")
     File.write(plugin1_path, <<-RUBY)
       Neovim.plugin do |plug|
-        plug.command(:SyncAdd, :args => 2, :sync => true) do |nvim, x, y|
+        plug.function(:SyncAdd, :args => 2, :sync => true) do |nvim, x, y|
           x + y
         end
+
+        plug.autocmd(:BufEnter, :pattern => "*.rb") do |nvim|
+          nvim.current.line = "Ruby file, eh?"
+        end
       end
     RUBY
 
@@ -27,19 +30,24 @@ RSpec.describe "neovim-ruby-host" do
     nvim.command("let host = rpcstart('#{host_exe}', ['#{plugin1_path}', '#{plugin2_path}'])")
 
     expect(nvim.eval("rpcrequest(host, 'poll')")).to eq("ok")
-    expect(nvim.eval("rpcrequest(host, '#{plugin1_path}:command:SyncAdd', [1, 2])")).to eq(3)
+    expect(nvim.eval("rpcrequest(host, '#{plugin1_path}:function:SyncAdd', [1, 2])")).to eq(3)
+
+    expect {
+      nvim.command("call rpcnotify(host, '#{plugin1_path}:autocmd:BufEnter:*.rb')")
+      sleep 0.1
+    }.to change { nvim.current.buffer.lines.to_a }.from([""]).to(["Ruby file, eh?"])
 
     expect {
-      nvim.eval("rpcnotify(host, '#{plugin2_path}:command:AsyncSetLine', ['foo'])")
-      nvim.eval("rpcrequest(host, 'poll')")
-    }.to change { nvim.current.buffer.lines.to_a }.from([""]).to(["foo"])
+      nvim.command("call rpcnotify(host, '#{plugin2_path}:command:AsyncSetLine', ['foo'])")
+      sleep 0.1
+    }.to change { nvim.current.buffer.lines.to_a }.from(["Ruby file, eh?"]).to(["foo"])
 
     expect {
-      nvim.eval("rpcnotify(host, 'Unknown')")
+      nvim.command("call rpcnotify(host, 'Unknown')")
     }.not_to raise_error
 
     expect {
-      nvim.eval("call rpcrequest(host, 'Unknown')")
+      nvim.command("call rpcrequest(host, 'Unknown')")
     }.to raise_error(ArgumentError)
   end
 end

data/spec/helper.rb

@@ -13,7 +13,14 @@ end
 
 Thread.abort_on_exception = true
 
-ENV["NVIM_EXECUTABLE"] = File.expand_path("../../vendor/neovim/build/bin/nvim", __FILE__)
+nvim_bin = File.expand_path("../../vendor/neovim/build/bin/nvim", __FILE__)
+
+if File.exists?(nvim_bin)
+  ENV["NVIM_EXECUTABLE"] = nvim_bin
+else
+  warn("Can't find vendored `nvim` executable. Build it with `rake neovim:build`")
+  exit(1)
+end
 
 Neovim.logger = Logger.new(STDERR).tap do |logger|
   logger.level = ENV.fetch("NVIM_RUBY_LOG_LEVEL", Logger::WARN).to_i
@@ -26,15 +33,16 @@ RSpec.configure do |config|
 
   config.disable_monkey_patching!
   config.order = :random
+  config.color = true
 
   Kernel.srand config.seed
 
   config.around(:example) do |spec|
-    Support.clean_workspace
+    Support.setup_workspace
     Timeout.timeout(2) { spec.run }
   end
 
   config.after(:suite) do
-    Support.remove_workspace
+    Support.teardown_workspace
   end
 end

data/spec/neovim/api_spec.rb

@@ -0,0 +1,40 @@
+require "helper"
+
+module Neovim
+  RSpec.describe API do
+    describe ".null" do
+      it "returns an empty API object" do
+        api = API.null
+
+        expect(api.types).to eq([])
+        expect(api.functions).to eq([])
+      end
+    end
+
+    describe "#function" do
+      it "returns a corresponding Function object" do
+        api = API.new(
+          [nil, {"functions" => [
+            {"name" => "vim_strwidth", "async" => false}
+          ]}]
+        )
+
+        function = api.function("vim_strwidth")
+        expect(function).to be_a(API::Function)
+        expect(function.name).to eq("vim_strwidth")
+        expect(function.async).to be(false)
+      end
+    end
+
+    describe "#functions_with_prefix" do
+      it "returns relevant functions" do
+        api = API.new(
+          [nil, {"functions" => [{"name" => "vim_strwidth"}]}]
+        )
+
+        functions = api.functions_with_prefix("vim_")
+        expect(functions.first.name).to eq("vim_strwidth")
+      end
+    end
+  end
+end

data/spec/neovim/async_session_spec.rb

@@ -5,7 +5,7 @@ module Neovim
     shared_context "async session behavior" do
       it "receives requests" do
         stream = MsgpackStream.new(event_loop)
-        async = AsyncSession.new(stream)
+        async_session = AsyncSession.new(stream)
 
         server_thread = Thread.new do
           client = server.accept
@@ -15,16 +15,12 @@ module Neovim
           ))
         end
 
-        req_cb = Proc.new do |request|
-          Fiber.yield(request)
+        request = nil
+        async_session.run do |msg|
+          request = msg
+          async_session.shutdown
         end
 
-        fiber = Fiber.new do
-          async.run(req_cb)
-        end
-
-        request = fiber.resume
-
         server_thread.join
 
         expect(request).to be_a(Request)
@@ -34,7 +30,7 @@ module Neovim
 
       it "receives notifications" do
         stream = MsgpackStream.new(event_loop)
-        async = AsyncSession.new(stream)
+        async_session = AsyncSession.new(stream)
 
         server_thread = Thread.new do
           client = server.accept
@@ -44,16 +40,12 @@ module Neovim
           ))
         end
 
-        not_cb = Proc.new do |notification|
-          Fiber.yield(notification)
+        notification = nil
+        async_session.run do |message|
+          notification = message
+          async_session.shutdown
         end
 
-        fiber = Fiber.new do
-          async.run(nil, not_cb)
-        end
-
-        notification = fiber.resume
-
         server_thread.join
 
         expect(notification).to be_a(Notification)
@@ -63,7 +55,7 @@ module Neovim
 
       it "receives responses to requests" do
         stream = MsgpackStream.new(event_loop)
-        async = AsyncSession.new(stream)
+        async_session = AsyncSession.new(stream)
         messages = []
 
         server_thread = Thread.new do
@@ -75,15 +67,17 @@ module Neovim
           ))
         end
 
-        fiber = Fiber.new do
-          async.request("func", 1, 2, 3) do |error, result|
-            Fiber.yield(error, result)
-          end.run
-        end
+        error, result = nil
+        async_session.request("func", 1, 2, 3) do |err, res|
+          error, result = err, res
+          async_session.shutdown
+        end.run
 
-        expect(fiber.resume).to eq(["error", "result"])
+        expect(error).to eq("error")
+        expect(result).to eq("result")
 
         server_thread.join
+        async_session.shutdown
 
         expect(messages).to eq(
           [MessagePack.pack([0, 0, "func", [1, 2, 3]])]

data/spec/neovim/current_spec.rb

@@ -30,13 +30,33 @@ module Neovim
     end
 
     describe "#buffer=" do
-      it "sets the current buffer" do
+      it "sets the current buffer from an integer" do
         initial_index = current.buffer.index
         client.command("vnew")
 
         expect {
           current.buffer = initial_index
-        }.to change { current.buffer.index }
+        }.to change { current.buffer.index }.to(initial_index)
+      end
+
+      it "sets the current buffer from a Buffer" do
+        b0 = current.buffer
+        client.command("vnew")
+        b1 = current.buffer
+
+        expect {
+          current.buffer = b0
+        }.to change { current.buffer }.from(b1).to(b0)
+      end
+
+      it "returns an integer" do
+        index = current.buffer.index
+        expect(current.buffer = index).to eq(index)
+      end
+
+      it "returns a Buffer" do
+        buffer = current.buffer
+        expect(current.buffer = buffer).to eq(buffer)
       end
     end
 
@@ -47,7 +67,7 @@ module Neovim
     end
 
     describe "#window=" do
-      it "sets the current window" do
+      it "sets the current window from an integer" do
         client.command("vsp")
         expect(current.window.index).not_to eq(1)
 
@@ -55,6 +75,26 @@ module Neovim
           current.window = 1
         }.to change { current.window.index }.to(1)
       end
+
+      it "sets the current window from a Window" do
+        w0 = current.window
+        client.command("vsp")
+        w1 = current.window
+
+        expect {
+          current.window = w0
+        }.to change { current.window }.from(w1).to(w0)
+      end
+
+      it "returns an integer" do
+        index = current.window.index
+        expect(current.window = index).to eq(index)
+      end
+
+      it "returns a Window" do
+        w0 = current.window
+        expect(current.window = w0).to eq(w0)
+      end
     end
 
     describe "#tabpage" do
@@ -64,7 +104,7 @@ module Neovim
     end
 
     describe "#tabpage=" do
-      it "sets the current tabpage" do
+      it "sets the current tabpage from an integer" do
         initial_index = current.tabpage.index
         client.command("tabnew")
         expect(current.tabpage.index).not_to eq(initial_index)
@@ -73,6 +113,26 @@ module Neovim
           current.tabpage = initial_index
         }.to change { current.tabpage.index }.to(initial_index)
       end
+
+      it "sets the current tabpage from a Tabpage" do
+        tp0 = current.tabpage
+        client.command("tabnew")
+        tp1 = current.tabpage
+
+        expect {
+          current.tabpage = tp0
+        }.to change { current.tabpage }.from(tp1).to(tp0)
+      end
+
+      it "returns an integer" do
+        index = current.tabpage.index
+        expect(current.tabpage = index).to eq(index)
+      end
+
+      it "returns a Tabpage" do
+        tp0 = current.tabpage
+        expect(current.tabpage = tp0).to eq(tp0)
+      end
     end
   end
 end

data/spec/neovim/event_loop_spec.rb

@@ -1,23 +1,9 @@
 require "helper"
 require "socket"
-require "msgpack"
 require "fileutils"
 
 module Neovim
   RSpec.describe EventLoop do
-    it "calls the setup callback" do
-      messages = []
-      rd, wr = IO.pipe
-      event_loop = EventLoop.new(rd, wr)
-
-      fiber = Fiber.new do
-        setup_cb = Proc.new { Fiber.yield(:setup) }
-        event_loop.run(nil, setup_cb)
-      end
-
-      expect(fiber.resume).to eq(:setup)
-    end
-
     shared_context "socket behavior" do
       it "sends and receives data" do
         messages = []
@@ -31,13 +17,15 @@ module Neovim
           server.close
         end
 
-        fiber = Fiber.new do
-          msg_cb = Proc.new { |msg| Fiber.yield(msg) }
-          event_loop.send("data").run(msg_cb)
+        message = nil
+        event_loop.write("data").run do |msg|
+          message = msg
+          event_loop.stop
         end
 
-        expect(fiber.resume).to eq("OK")
         server_thread.join
+        event_loop.shutdown
+        expect(message).to eq("OK")
         expect(messages).to eq(["data"])
       end
     end
@@ -76,13 +64,14 @@ module Neovim
             srv_stdin.write("OK")
           end
 
-          fiber = Fiber.new do
-            msg_cb = Proc.new { |msg| Fiber.yield(msg) }
-            event_loop.send("data").run(msg_cb)
+          message = nil
+          event_loop.write("data").run do |msg|
+            message = msg
+            event_loop.stop
           end
 
-          expect(fiber.resume).to eq("OK")
           server_thread.join
+          expect(message).to eq("OK")
           expect(messages).to eq(["data"])
         ensure
           STDOUT.reopen(old_stdout)
@@ -94,14 +83,16 @@ module Neovim
     context "child" do
       it "sends and receives data" do
         event_loop = EventLoop.child(["-n", "-u", "NONE"])
-        message = MessagePack.pack([0, 0, :vim_strwidth, ["hi"]])
+        input = MessagePack.pack([0, 0, :vim_strwidth, ["hi"]])
 
-        fiber = Fiber.new do
-          msg_cb = Proc.new { |msg| Fiber.yield(msg) }
-          event_loop.send(message).run(msg_cb)
+        message = nil
+        event_loop.write(input).run do |msg|
+          message = msg
+          event_loop.stop
         end
 
-        expect(fiber.resume).to eq(MessagePack.pack([1, 0, nil, 2]))
+        event_loop.shutdown
+        expect(message).to eq(MessagePack.pack([1, 0, nil, 2]))
       end
     end
   end

data/spec/neovim/host_spec.rb

@@ -27,7 +27,26 @@ module Neovim
     end
 
     describe "#run" do
-      # TODO: Find a way to test this without excessive mocking
+      it "delegates messages to the manifest" do
+        messages = []
+        manifest = instance_double(Manifest)
+        session = Session.child(["-n", "-u", "NONE"])
+
+        host = Host.new(manifest, session)
+
+        expect(manifest).to receive(:handle) do |msg, client|
+          expect(msg.method_name).to eq("my_event")
+          expect(msg.arguments).to eq(["arg"])
+          expect(client).to be_a(Client)
+
+          session.stop
+        end
+
+        session.request(:vim_subscribe, "my_event")
+        session.request(:vim_command, "call rpcnotify(0, 'my_event', 'arg')")
+
+        host.run
+      end
     end
   end
 end

data/spec/neovim/manifest_spec.rb

@@ -1,6 +1,4 @@
 require "helper"
-require "neovim/manifest"
-require "neovim/plugin"
 
 module Neovim
   RSpec.describe Manifest do