neovim 0.6.2 → 0.7.0

data/lib/neovim/version.rb

@@ -1,3 +1,3 @@
 module Neovim
-  VERSION = Gem::Version.new("0.6.2")
+  VERSION = Gem::Version.new("0.7.0")
 end

data/neovim.gemspec

@@ -17,11 +17,15 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^spec/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.2.0")
+
   spec.add_dependency "msgpack", "~> 1.1"
   spec.add_dependency "multi_json", "~> 1.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "coveralls"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

data/spec/acceptance/runtime/rplugin/ruby/autocmds.rb

@@ -1,9 +1,9 @@
 Neovim.plugin do |plug|
-  plug.autocmd(:BufEnter, :pattern => "*.rb") do |nvim|
+  plug.autocmd(:BufEnter, pattern: "*.rb") do |nvim|
     nvim.get_current_buf.set_var("rplugin_autocmd_BufEnter", true)
   end
 
-  plug.autocmd(:BufEnter, :pattern => "*.c", :eval => "g:to_eval") do |nvim, to_eval|
-    nvim.set_var("rplugin_autocmd_BufEnter_eval", to_eval.merge(:b => 43))
+  plug.autocmd(:BufEnter, pattern: "*.c", eval: "g:to_eval") do |nvim, to_eval|
+    nvim.set_var("rplugin_autocmd_BufEnter_eval", to_eval.merge(b: 43))
   end
 end

data/spec/acceptance/runtime/rplugin/ruby/commands.rb

@@ -3,61 +3,61 @@ Neovim.plugin do |plug|
     nvim.set_var("rplugin_command_nargs_0", true)
   end
 
-  plug.command(:RPluginCommandNargs1, :nargs => 1) do |nvim, arg|
+  plug.command(:RPluginCommandNargs1, nargs: 1) do |nvim, arg|
     nvim.set_var("rplugin_command_nargs_1", arg)
   end
 
-  plug.command(:RPluginCommandNargsN, :nargs => "*") do |nvim, *args|
+  plug.command(:RPluginCommandNargsN, nargs: "*") do |nvim, *args|
     nvim.set_var("rplugin_command_nargs_n", args)
   end
 
-  plug.command(:RPluginCommandNargsQ, :nargs => "?") do |nvim, arg|
+  plug.command(:RPluginCommandNargsQ, nargs: "?") do |nvim, arg|
     nvim.set_var("rplugin_command_nargs_q", arg)
   end
 
-  plug.command(:RPluginCommandNargsP, :nargs => "+") do |nvim, *args|
+  plug.command(:RPluginCommandNargsP, nargs: "+") do |nvim, *args|
     nvim.set_var("rplugin_command_nargs_p", args)
   end
 
-  plug.command(:RPluginCommandRange, :range => true) do |nvim, *range|
+  plug.command(:RPluginCommandRange, range: true) do |nvim, *range|
     nvim.set_var("rplugin_command_range", range)
   end
 
-  plug.command(:RPluginCommandRangeP, :range => "%") do |nvim, *range|
+  plug.command(:RPluginCommandRangeP, range: "%") do |nvim, *range|
     nvim.set_var("rplugin_command_range_p", range)
   end
 
-  plug.command(:RPluginCommandRangeN, :range => 1) do |nvim, *range|
+  plug.command(:RPluginCommandRangeN, range: 1) do |nvim, *range|
     nvim.set_var("rplugin_command_range_n", range)
   end
 
-  plug.command(:RPluginCommandCountN, :count => 1) do |nvim, *count|
+  plug.command(:RPluginCommandCountN, count: 1) do |nvim, *count|
     nvim.set_var("rplugin_command_count_n", count)
   end
 
-  plug.command(:RPluginCommandBang, :bang => true) do |nvim, bang|
+  plug.command(:RPluginCommandBang, bang: true) do |nvim, bang|
     nvim.set_var("rplugin_command_bang", bang)
   end
 
-  plug.command(:RPluginCommandRegister, :register => true) do |nvim, reg|
+  plug.command(:RPluginCommandRegister, register: true) do |nvim, reg|
     nvim.set_var("rplugin_command_register", reg)
   end
 
-  plug.command(:RPluginCommandCompletion, :complete => "buffer") do |nvim|
+  plug.command(:RPluginCommandCompletion, complete: "buffer") do |nvim|
     attrs = nvim.command_output("silent command RPluginCommandCompletion")
     compl = attrs.split($/).last.split[2]
     nvim.set_var("rplugin_command_completion", compl)
   end
 
-  plug.command(:RPluginCommandEval, :eval => "g:to_eval") do |nvim, to_eval|
-    nvim.set_var("rplugin_command_eval", to_eval.merge(:b => 43))
+  plug.command(:RPluginCommandEval, eval: "g:to_eval") do |nvim, to_eval|
+    nvim.set_var("rplugin_command_eval", to_eval.merge(b: 43))
   end
 
-  plug.command(:RPluginCommandSync, :sync => true) do |nvim|
+  plug.command(:RPluginCommandSync, sync: true) do |nvim|
     nvim.set_var("rplugin_command_sync", true)
   end
 
-  plug.command(:RPluginCommandRecursive, :sync => true, :nargs => 1) do |nvim, n|
+  plug.command(:RPluginCommandRecursive, sync: true, nargs: 1) do |nvim, n|
     if Integer(n) >= 10
       nvim.set_var("rplugin_command_recursive", n)
     else

data/spec/acceptance/runtime/rplugin/ruby/functions.rb

@@ -3,19 +3,19 @@ Neovim.plugin do |plug|
     nvim.set_var("rplugin_function_args", args)
   end
 
-  plug.function(:RPluginFunctionRange, :range => true) do |nvim, *range|
+  plug.function(:RPluginFunctionRange, range: true) do |nvim, *range|
     nvim.set_var("rplugin_function_range", range)
   end
 
-  plug.function(:RPluginFunctionEval, :eval => "g:to_eval") do |nvim, to_eval|
-    nvim.set_var("rplugin_function_eval", to_eval.merge(:b => 43))
+  plug.function(:RPluginFunctionEval, eval: "g:to_eval") do |nvim, to_eval|
+    nvim.set_var("rplugin_function_eval", to_eval.merge(b: 43))
   end
 
-  plug.function(:RPluginFunctionSync, :sync => true) do |nvim|
+  plug.function(:RPluginFunctionSync, sync: true) do |nvim|
     true
   end
 
-  plug.function(:RPluginFunctionRecursive, :sync => true, :nargs => 1) do |nvim, n|
+  plug.function(:RPluginFunctionRecursive, sync: true, nargs: 1) do |nvim, n|
     if n >= 10
       n
     else

data/spec/acceptance_spec.rb

@@ -3,10 +3,11 @@ ENV.delete("VIMRUNTIME")
 
 require "json"
 require "net/http"
+require "openssl"
 require "open-uri"
 require "tempfile"
 
-RSpec.describe "Acceptance", :timeout => 10 do
+RSpec.describe "Acceptance", timeout: 10 do
   let(:root) { File.expand_path("../acceptance", __FILE__) }
   let(:init) { File.join(root, "runtime/init.vim") }
   let(:manifest) { File.join(root, "runtime/rplugin.vim") }
@@ -19,7 +20,7 @@ RSpec.describe "Acceptance", :timeout => 10 do
     ["ruby", "rubyfile", "rubydo"].each do |feature|
       specify ":#{feature}" do
         run_vader("#{feature}_spec.vim") do |status, output|
-          expect(status).to be_success, lambda { output.read }
+          expect(status).to be_success, -> { output.read }
         end
       end
     end
@@ -36,7 +37,7 @@ RSpec.describe "Acceptance", :timeout => 10 do
     ["command", "function", "autocmd"].each do |feature|
       specify "##{feature}" do
         run_vader("rplugin_#{feature}_spec.vim") do |status, output|
-          expect(status).to be_success, lambda { output.read }
+          expect(status).to be_success, -> { output.read }
         end
       end
     end
@@ -44,23 +45,25 @@ RSpec.describe "Acceptance", :timeout => 10 do
 
   describe "Generated documentation" do
     it "is up to date" do
+      url = "https://api.github.com/repos/neovim/neovim/releases/latest"
+
       begin
-        url = "https://api.github.com/repos/neovim/neovim/releases/latest"
         response = open(url) { |json| JSON.load(json) }
-        release_version = response["name"][/NVIM v?(.+)$/, 1]
-
-        client_file = File.read(
-          File.expand_path("../../lib/neovim/client.rb", __FILE__)
-        )
-        docs_version = client_file[
-          /The methods documented here were generated using NVIM v?(.+)$/,
-          1
-        ]
-
-        expect(docs_version).to eq(release_version)
-      rescue SocketError, OpenURI::HTTPError => e
+      rescue SocketError, OpenURI::HTTPError, OpenSSL::SSL::SSLError => e
         skip "Skipping: #{e}"
       end
+
+      release_version = response["name"][/NVIM v?(.+)$/, 1]
+
+      client_file = File.read(
+        File.expand_path("../../lib/neovim/client.rb", __FILE__)
+      )
+      docs_version = client_file[
+        /The methods documented here were generated using NVIM v?(.+)$/,
+        1
+      ]
+
+      expect(docs_version).to eq(release_version)
     end
   end
 

data/spec/helper.rb

@@ -25,6 +25,21 @@ RSpec.configure do |config|
   config.order = :random
   config.color = true
 
+  config.around(:example, :silence_thread_exceptions) do |spec|
+    if Thread.respond_to?(:report_on_exception)
+      original = Thread.report_on_exception
+
+      begin
+        Thread.report_on_exception = false
+        spec.run
+      ensure
+        Thread.report_on_exception = original
+      end
+    else
+      spec.run
+    end
+  end
+
   config.around(:example) do |spec|
     Support.setup_workspace
     timeout = spec.metadata.fetch(:timeout, 3)

data/spec/neovim/connection_spec.rb

@@ -0,0 +1,79 @@
+require "helper"
+
+module Neovim
+  RSpec.describe Connection do
+    let(:nil_io) { StringIO.new }
+
+    describe "#write" do
+      it "writes msgpack to the underlying file descriptor" do
+        rd, wr = IO.pipe
+        connection = Connection.new(nil_io, wr)
+        connection.write("some data")
+        wr.close
+
+        expect(MessagePack.unpack(rd.read)).to eq("some data")
+      end
+    end
+
+    describe "#read" do
+      it "reads msgpack from the underlying file descriptor" do
+        rd, wr = IO.pipe
+        wr.write(MessagePack.pack("some data"))
+        wr.close
+
+        connection = Connection.new(rd, nil_io)
+        expect(connection.read).to eq("some data")
+      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
+
+        client_rd, server_wr = IO.pipe
+        server_rd, client_wr = IO.pipe
+
+        connection = Connection.new(client_rd, client_wr)
+
+        connection.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)
+        factory.packer(server_wr).write(obj).flush
+
+        expect(connection.read).to eq(obj)
+      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, nil_io).close
+        expect { Process.kill(0, pid) }.to raise_error(Errno::ESRCH)
+      end
+    end
+  end
+end

data/spec/neovim/event_loop_spec.rb

@@ -10,71 +10,57 @@ 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
-
-        request = nil
-        event_loop.run do |req|
-          request = req
-          event_loop.stop
-        end
-        expect(request.method_name).to eq("foo_method")
+    describe "#request" do
+      it "writes a msgpack request" do
+        event_loop.request(1, :method, 1, 2)
+        message = server_rd.readpartial(1024)
+        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
-
-        server_wr.write(MessagePack.pack([1, 1, nil, :value]))
-        server_wr.flush
-
-        event_loop.run
-        expect(response.value!).to eq("value")
+    describe "#respond" do
+      it "writes a msgpack response" do
+        event_loop.respond(2, "value", "error")
+        message = server_rd.readpartial(1024)
+        expect(message).to eq(MessagePack.pack([1, 2, "error", "value"]))
       end
+    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])
-        )
+    describe "#notify" do
+      it "writes a msgpack notification" do
+        event_loop.notify(:method, 1, 2)
+        message = server_rd.readpartial(1024)
+        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, []]))
-        server_wr.flush
+      it "shuts down after receiving EOFError" do
+        run_thread = Thread.new do
+          event_loop.run
+        end
 
-        event_loop.run { event_loop.stop }
-        expect(server_rd.readpartial(1024)).to eq(
-          MessagePack.pack([2, :foo_notification, []])
-        )
+        server_wr.close
+        run_thread.join
+        expect(client_rd).to be_closed
+        expect(client_wr).to be_closed
       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,26 +14,33 @@ 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