neovim 0.0.6 → 0.1.0

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

@@ -21,16 +21,21 @@ RSpec.describe "neovim-ruby-host" do
         plug.command(:AsyncSetLine, :args => 1) do |nvim, str|
           nvim.current.line = str
         end
+
+        plug.rpc(:TopLevelAdd, :nargs => 2, :sync => true) do |nvim, x, y|
+          x + y
+        end
       end
     RUBY
 
-    nvim = Neovim.attach_child(["--headless", "-u", "NONE", "-N", "-n"])
+    nvim = Neovim.attach_child(["nvim", "--headless", "-u", "NONE", "-N", "-n"])
 
     host_exe = File.expand_path("../../../bin/neovim-ruby-host", __FILE__)
     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}:function:SyncAdd', [1, 2])")).to eq(3)
+    expect(nvim.eval("rpcrequest(host, 'TopLevelAdd', 1, 2)")).to eq(3)
 
     expect {
       nvim.command("call rpcnotify(host, '#{plugin1_path}:autocmd:BufEnter:*.rb')")

data/spec/acceptance/ruby_provider_spec.rb

@@ -0,0 +1,76 @@
+require "helper"
+
+RSpec.describe "ruby_provider" do
+  let(:nvim) do
+    Neovim.attach_child(["nvim", "--headless", "-u", "NONE", "-N", "-n"])
+  end
+
+  before do
+    provider_path = Support.file_path("provider.rb")
+    File.write(provider_path, "require 'neovim/ruby_provider'")
+    host_exe = File.expand_path("../../../bin/neovim-ruby-host", __FILE__)
+    nvim.current.buffer.lines = ["line1", "line2"]
+    nvim.command("let host = rpcstart('#{host_exe}', ['#{provider_path}'])")
+  end
+
+  describe "ruby_execute" do
+    it "runs ruby directly" do
+      ruby = "VIM.command('let myvar = [1, 2]')".inspect
+      nvim.eval("rpcrequest(host, 'ruby_execute', #{ruby})")
+      expect(nvim.eval("g:myvar")).to eq([1, 2])
+    end
+
+    it "exposes the $curwin variable" do
+      nvim.command("vsplit")
+
+      expect {
+        ruby = "$curwin.width -= 1".inspect
+        nvim.eval("rpcrequest(host, 'ruby_execute', #{ruby})")
+      }.to change { nvim.current.window.width }.by(-1)
+    end
+
+    it "exposes the $curbuf variable" do
+      expect {
+        ruby = "$curbuf.lines = ['line']".inspect
+        nvim.eval("rpcrequest(host, 'ruby_execute', #{ruby})")
+      }.to change { nvim.current.buffer.lines.to_a }.to(["line"])
+    end
+  end
+
+  describe "ruby_execute_file" do
+    let(:script_path) { Support.file_path("script.rb") }
+
+    it "runs ruby from a file" do
+      File.write(script_path, "VIM.command('let myvar = [1, 2]')")
+      nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')")
+      expect(nvim.eval("g:myvar")).to eq([1, 2])
+    end
+
+    it "exposes the $curwin variable" do
+      File.write(script_path, "$curwin.width -= 1")
+      nvim.command("vsplit")
+
+      expect {
+        nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')")
+      }.to change { nvim.current.window.width }.by(-1)
+    end
+
+    it "exposes the $curbuf variable" do
+      File.write(script_path, "$curbuf.lines = ['line']")
+
+      expect {
+        nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')")
+      }.to change { nvim.current.buffer.lines.to_a }.to(["line"])
+    end
+  end
+
+  describe "ruby_do_range" do
+    it "mutates lines via the $_ variable" do
+      nvim.current.buffer.lines = ["a", "b", "c", "d"]
+
+      expect {
+        nvim.eval("rpcrequest(host, 'ruby_do_range', 2, 3, '$_.upcase!; 42')")
+      }.to change { nvim.current.buffer.lines.to_a }.to(["a", "B", "C", "d"])
+    end
+  end
+end

data/spec/helper.rb

@@ -1,5 +1,5 @@
 require "bundler/setup"
-require "logger"
+require "mkmf"
 require "neovim"
 require "pry"
 require "timeout"
@@ -11,21 +11,12 @@ if ENV["REPORT_COVERAGE"]
   Coveralls.wear!
 end
 
-Thread.abort_on_exception = true
-
-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`")
+unless find_executable0("nvim")
+  warn("Can't find `nvim` executable. See installation instructions:")
+  warn("https://github.com/neovim/neovim/wiki/Installing-Neovim")
   exit(1)
 end
 
-Neovim.logger = Logger.new(STDERR).tap do |logger|
-  logger.level = ENV.fetch("NVIM_RUBY_LOG_LEVEL", Logger::WARN).to_i
-end
-
 RSpec.configure do |config|
   config.expect_with :rspec do |exp|
     exp.syntax = :expect
@@ -35,14 +26,17 @@ RSpec.configure do |config|
   config.order = :random
   config.color = true
 
-  Kernel.srand config.seed
-
   config.around(:example) do |spec|
     Support.setup_workspace
-    Timeout.timeout(2) { spec.run }
-  end
 
-  config.after(:suite) do
-    Support.teardown_workspace
+    begin
+      Timeout.timeout(5) { spec.run }
+    ensure
+      Support.teardown_workspace
+    end
   end
+
+  Kernel.srand config.seed
 end
+
+Thread.abort_on_exception = true

data/spec/neovim/async_session_spec.rb

@@ -9,10 +9,11 @@ module Neovim
 
         server_thread = Thread.new do
           client = server.accept
-          IO.select(nil, [client])
-          client.write(MessagePack.pack(
-            [0, 123, "func", [1, 2, 3]]
-          ))
+          client.write(
+            MessagePack.pack(
+              [0, 123, "func", [1, 2, 3]]
+            )
+          )
         end
 
         request = nil
@@ -34,10 +35,11 @@ module Neovim
 
         server_thread = Thread.new do
           client = server.accept
-          IO.select(nil, [client])
-          client.write(MessagePack.pack(
-            [2, "func", [1, 2, 3]]
-          ))
+          client.write(
+            MessagePack.pack(
+              [2, "func", [1, 2, 3]]
+            )
+          )
         end
 
         notification = nil
@@ -56,15 +58,17 @@ module Neovim
       it "receives responses to requests" do
         stream = MsgpackStream.new(event_loop)
         async_session = AsyncSession.new(stream)
-        messages = []
+        request = nil
 
         server_thread = Thread.new do
           client = server.accept
-          messages << client.readpartial(1024)
+          request = client.readpartial(1024)
 
-          client.write(MessagePack.pack(
-            [1, 0, [0, "error"], "result"]
-          ))
+          client.write(
+            MessagePack.pack(
+              [1, 0, [0, "error"], "result"]
+            )
+          )
         end
 
         error, result = nil
@@ -79,8 +83,8 @@ module Neovim
         server_thread.join
         async_session.shutdown
 
-        expect(messages).to eq(
-          [MessagePack.pack([0, 0, "func", [1, 2, 3]])]
+        expect(request).to eq(
+          MessagePack.pack([0, 0, "func", [1, 2, 3]])
         )
       end
     end

data/spec/neovim/buffer_spec.rb

@@ -2,7 +2,7 @@ require "helper"
 
 module Neovim
   RSpec.describe Buffer do
-    let(:client) { Neovim.attach_child(["--headless", "-n", "-u", "NONE"]) }
+    let(:client) { Neovim.attach_child(["nvim", "--headless", "-n", "-u", "NONE"]) }
     let(:buffer) { client.current.buffer }
 
     describe "#lines" do
@@ -31,5 +31,131 @@ module Neovim
         expect(buffer.range.to_a).to eq(["one", "two"])
       end
     end
+
+    describe "if_ruby compatibility" do
+      describe "#name" do
+        it "returns the buffer path as a string" do
+          buffer.set_name("test_buf")
+
+          expect(File.basename(buffer.name)).
+            to end_with("test_buf")
+        end
+      end
+
+      describe "#number" do
+        it "returns the buffer index" do
+          expect(buffer.number).to be(1)
+        end
+      end
+
+      describe "#count" do
+        it "returns the number of lines" do
+          buffer.lines = ["one", "two", "three"]
+          expect(buffer.count).to be(3)
+        end
+      end
+
+      describe "#length" do
+        it "returns the number of lines" do
+          buffer.lines = ["one", "two", "three"]
+          expect(buffer.length).to be(3)
+        end
+      end
+
+      describe "#[]" do
+        it "returns the line at the given index" do
+          buffer.lines = ["one", "two", "three"]
+          expect(buffer[1]).to eq("two")
+        end
+      end
+
+      describe "#[]=" do
+        it "sets the line at the given index" do
+          buffer.lines = ["one", "two"]
+
+          expect {
+            buffer[0] = "first"
+          }.to change { buffer.lines }.to(["first", "two"])
+        end
+
+        it "returns the line" do
+          expect(buffer[0] = "first").to eq("first")
+        end
+
+        it "raises an out of bounds exception" do
+          expect {
+            buffer[10] = "line"
+          }.to raise_error(/out of bounds/)
+        end
+      end
+
+      describe "#delete" do
+        it "deletes the line at the given index" do
+          buffer.lines = ["one", "two"]
+
+          expect {
+            buffer.delete(0)
+          }.to change { buffer.lines }.to(["two"])
+        end
+      end
+
+      describe "#append" do
+        it "adds a line after the given index" do
+          buffer.lines = ["one"]
+
+          expect {
+            buffer.append(0, "two")
+          }.to change { buffer.lines.to_a }.to(["one", "two"])
+        end
+
+        it "returns the appended line" do
+          expect(buffer.append(0, "two")).to eq("two")
+        end
+      end
+
+      describe "#line" do
+        it "returns the current line on an active buffer" do
+          buffer.lines = ["one", "two"]
+          expect(buffer.line).to eq("one")
+        end
+
+        it "returns nil on an inactive buffer" do
+          original = buffer
+          client.command("vnew")
+          expect(original.line).to be(nil)
+        end
+      end
+
+      describe "#line=" do
+        it "sets the current line on an active buffer" do
+          expect {
+            buffer.line = "line"
+          }.to change { buffer.lines }.to(["line"])
+        end
+
+        it "has no effect when called on an inactive buffer" do
+          original = buffer
+          client.command("vnew")
+          original.line = "line"
+
+          expect(original.lines.to_a).to eq([""])
+          expect(client.current.buffer.lines.to_a).to eq([""])
+        end
+      end
+
+      describe "#line_number" do
+        it "returns the current line number on an active buffer" do
+          client.command("normal oone")
+          expect(buffer.line_number).to be(2)
+        end
+
+        it "returns nil on an inactive buffer" do
+          original = buffer
+          client.command("vnew")
+
+          expect(original.line_number).to be(nil)
+        end
+      end
+    end
   end
 end

data/spec/neovim/client_spec.rb

@@ -2,7 +2,7 @@ require "helper"
 
 module Neovim
   RSpec.describe Client do
-    let(:client) { Neovim.attach_child(["-n", "-u", "NONE"]) }
+    let(:client) { Neovim.attach_child(["nvim", "-n", "-u", "NONE"]) }
 
     describe "#respond_to?" do
       it "returns true for vim functions" do

data/spec/neovim/current_spec.rb

@@ -2,7 +2,7 @@ require "helper"
 
 module Neovim
   RSpec.describe Current do
-    let(:client) { Neovim.attach_child(["-n", "-u", "NONE"]) }
+    let(:client) { Neovim.attach_child(["nvim", "-n", "-u", "NONE"]) }
     let(:current) { client.current }
 
     describe "#line" do
@@ -134,5 +134,13 @@ module Neovim
         expect(current.tabpage = tp0).to eq(tp0)
       end
     end
+
+    describe "#range=" do
+      it "sets the line range of the current buffer" do
+        current.buffer.lines = ["one", "two", "three", "four"]
+        current.range = (1..2)
+        expect(current.buffer.range.to_a).to eq(["two", "three"])
+      end
+    end
   end
 end

data/spec/neovim/event_loop_spec.rb

@@ -1,32 +1,31 @@
 require "helper"
 require "socket"
-require "fileutils"
 
 module Neovim
   RSpec.describe EventLoop do
     shared_context "socket behavior" do
       it "sends and receives data" do
-        messages = []
+        request = nil
 
         server_thread = Thread.new do
           client = server.accept
-          messages << client.readpartial(1024)
+          request = client.readpartial(1024)
 
-          client.write("OK")
+          client.write("res")
           client.close
           server.close
         end
 
-        message = nil
-        event_loop.write("data").run do |msg|
-          message = msg
+        response = nil
+        event_loop.write("req").run do |msg|
+          response = msg
           event_loop.stop
         end
 
         server_thread.join
         event_loop.shutdown
-        expect(message).to eq("OK")
-        expect(messages).to eq(["data"])
+        expect(request).to eq("req")
+        expect(response).to eq("res")
       end
     end
 
@@ -57,22 +56,22 @@ module Neovim
           STDIN.reopen(cl_stdin)
 
           event_loop = EventLoop.stdio
-          messages = []
+          request = nil
 
           server_thread = Thread.new do
-            messages << srv_stdout.readpartial(1024)
-            srv_stdin.write("OK")
+            request = srv_stdout.readpartial(1024)
+            srv_stdin.write("res")
           end
 
-          message = nil
-          event_loop.write("data").run do |msg|
-            message = msg
+          response = nil
+          event_loop.write("req").run do |msg|
+            response = msg
             event_loop.stop
           end
 
           server_thread.join
-          expect(message).to eq("OK")
-          expect(messages).to eq(["data"])
+          expect(request).to eq("req")
+          expect(response).to eq("res")
         ensure
           STDOUT.reopen(old_stdout)
           STDIN.reopen(old_stdin)
@@ -82,17 +81,17 @@ module Neovim
 
     context "child" do
       it "sends and receives data" do
-        event_loop = EventLoop.child(["-n", "-u", "NONE"])
+        event_loop = EventLoop.child(["nvim", "-n", "-u", "NONE"])
         input = MessagePack.pack([0, 0, :vim_strwidth, ["hi"]])
 
-        message = nil
+        response = nil
         event_loop.write(input).run do |msg|
-          message = msg
+          response = msg
           event_loop.stop
         end
 
         event_loop.shutdown
-        expect(message).to eq(MessagePack.pack([1, 0, nil, 2]))
+        expect(response).to eq(MessagePack.pack([1, 0, nil, 2]))
       end
     end
   end