neovim 0.0.6 → 0.1.0

data/spec/neovim/host_spec.rb

@@ -30,7 +30,7 @@ module Neovim
       it "delegates messages to the manifest" do
         messages = []
         manifest = instance_double(Manifest)
-        session = Session.child(["-n", "-u", "NONE"])
+        session = Session.child(["nvim", "-n", "-u", "NONE"])
 
         host = Host.new(manifest, session)
 

data/spec/neovim/line_range_spec.rb

@@ -2,14 +2,16 @@ require "helper"
 
 module Neovim
   RSpec.describe LineRange 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 }
-    let(:line_range) { LineRange.new(buffer, 0, -1) }
+    let(:line_range) { LineRange.new(buffer, 0, 3) }
+    let(:sub_range) { LineRange.new(buffer, 1, 2) }
 
     before do
       client.command("normal i1")
       client.command("normal o2")
       client.command("normal o3")
+      client.command("normal o4")
     end
 
     it "is enumerable" do
@@ -19,7 +21,11 @@ module Neovim
 
     describe "#to_a" do
       it "returns lines as an array" do
-        expect(line_range.to_a).to eq(["1", "2", "3"])
+        expect(line_range.to_a).to eq(["1", "2", "3", "4"])
+      end
+
+      it "returns a subset of lines as an array" do
+        expect(sub_range.to_a).to eq(["2", "3"])
       end
     end
 
@@ -28,40 +34,98 @@ module Neovim
         expect(line_range[1]).to eq("2")
       end
 
+      it "returns lines at an offset from the index" do
+        expect(sub_range[0]).to eq("2")
+      end
+
+      it "allows indexes beyond the bounds of a sub range" do
+        expect(sub_range[2]).to eq("4")
+      end
+
+      it "returns lines at an offset with a negative index" do
+        expect(sub_range[-1]).to eq("3")
+      end
+
       it "accepts an index and length" do
         expect(line_range[0, 2].to_a).to eq(["1", "2"])
       end
 
+      it "returns lines at an offset from an index and length" do
+        expect(sub_range[0, 2].to_a).to eq(["2", "3"])
+      end
+
       it "accepts a range" do
         expect(line_range[0..1].to_a).to eq(["1", "2"])
         expect(line_range[0...1].to_a).to eq(["1"])
       end
+
+      it "accepts a range with a negative end" do
+        expect(line_range[0..-1].to_a).to eq(["1", "2", "3", "4"])
+      end
+
+      it "returns lines at an offset from a range" do
+        expect(sub_range[0..1].to_a).to eq(["2", "3"])
+      end
     end
 
     describe "#[]=" do
       it "accepts a single index" do
         line_range[0] = "foo"
-        expect(line_range.to_a).to eq(["foo", "2", "3"])
+        expect(line_range.to_a).to eq(["foo", "2", "3", "4"])
+      end
+
+      it "accepts a single index at an offset" do
+        sub_range[0] = "foo"
+        expect(buffer.lines.to_a).to eq(["1", "foo", "3", "4"])
       end
 
       it "accepts an index and length" do
         line_range[0, 2] = ["foo"]
-        expect(line_range.to_a).to eq(["foo", "3"])
+        expect(line_range.to_a).to eq(["foo", "3", "4"])
+      end
+
+      it "accepts an index and length at an offset" do
+        sub_range[0, 2] = ["foo"]
+        expect(buffer.lines.to_a).to eq(["1", "foo", "4"])
       end
 
       it "accepts a range" do
         line_range[0..1] = ["foo"]
-        expect(line_range.to_a).to eq(["foo", "3"])
+        expect(line_range.to_a).to eq(["foo", "3", "4"])
 
         line_range[0...1] = ["bar"]
-        expect(line_range.to_a).to eq(["bar", "3"])
+        expect(line_range.to_a).to eq(["bar", "3", "4"])
+      end
+
+      it "accepts a range at an offset" do
+        sub_range[0..1] = ["foo"]
+        expect(buffer.lines.to_a).to eq(["1", "foo", "4"])
       end
     end
 
     describe "#replace" do
       it "replaces all lines" do
-        line_range.replace(["5", "6"])
-        expect(line_range.to_a).to eq(["5", "6"])
+        line_range.replace(["4", "5"])
+        expect(line_range.to_a).to eq(["4", "5"])
+      end
+
+      it "replaces a subset of lines" do
+        sub_range.replace(["5", "6"])
+        expect(buffer.lines.to_a).to eq(["1", "5", "6", "4"])
+      end
+    end
+
+    describe "#delete" do
+      it "deletes the line at the given index" do
+        expect {
+          line_range.delete(0)
+        }.to change { line_range.to_a }.to(["2", "3", "4"])
+      end
+
+      it "deletes the line at an offset" do
+        expect {
+          sub_range.delete(0)
+        }.to change { buffer.lines.to_a }.to(["1", "3", "4"])
       end
     end
   end

data/spec/neovim/manifest_spec.rb

@@ -38,6 +38,18 @@ module Neovim
           manifest.handlers["source:command:Foo"]
         }.from(nil).to(kind_of(Proc))
       end
+
+      it "doesn't add top-level RPCs to specs" do
+        manifest = Manifest.new
+
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.rpc(:Foo)
+        end
+
+        expect {
+          manifest.register(plugin)
+        }.to change { manifest.specs }.from({}).to("source" => [])
+      end
     end
 
     describe "#handle" do
@@ -77,6 +89,20 @@ module Neovim
         manifest.handle(message, client)
       end
 
+      it "rescues plugin sync handler exceptions" do
+        manifest = Manifest.new
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.command(:Foo, :sync => true) { raise "BOOM" }
+        end
+        manifest.register(plugin)
+
+        message = double(:message, :method_name => "source:command:Foo", :sync? => true, :arguments => [])
+        client = double(:client)
+
+        expect(message).to receive(:error).with("BOOM")
+        manifest.handle(message, client)
+      end
+
       it "calls a plugin async handler" do
         manifest = Manifest.new
         async_proc = Proc.new {}

data/spec/neovim/msgpack_stream_spec.rb

@@ -6,26 +6,26 @@ module Neovim
     shared_context "msgpack stream behavior" do
       it "sends and receives data" do
         msgpack_stream = MsgpackStream.new(event_loop)
-        client_messages = []
+        request = nil
 
         server_thread = Thread.new do
           client = server.accept
-          client_messages << client.readpartial(1024)
+          request = client.readpartial(1024)
 
-          client.write(MessagePack.pack([2]))
+          client.write(MessagePack.pack(["res"]))
           client.close
           server.close
         end
 
-        server_message = nil
-        msgpack_stream.write([1]).run do |message|
-          server_message = message
+        response = nil
+        msgpack_stream.write(["req"]).run do |message|
+          response = message
           msgpack_stream.shutdown
         end
 
         server_thread.join
-        expect(server_message).to eq([2])
-        expect(client_messages).to eq([MessagePack.pack([1])])
+        expect(request).to eq(MessagePack.pack(["req"]))
+        expect(response).to eq(["res"])
       end
     end
 

data/spec/neovim/plugin_spec.rb

@@ -62,6 +62,47 @@ module Neovim
           :opts => {:range => "", :nargs => 1},
         )
       end
+
+      it "registers a top level RPC" do
+        cmd_block = Proc.new {}
+
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.rpc("Foo", :sync => true, &cmd_block)
+        end
+
+        expect(plugin.handlers.size).to be(1)
+        handler = plugin.handlers.first
+
+        expect(handler.block).to eq(cmd_block)
+        expect(handler.qualified_name).to eq("Foo")
+      end
+    end
+
+    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)
+        end
+
+        expect(plugin.specs).to eq(
+          [
+            {
+              :type => :command,
+              :name => "Foo",
+              :sync => true,
+              :opts=> {:nargs => 2}
+            }
+          ]
+        )
+      end
+
+      it "doesn't include specs for top-level RPCs" do
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.rpc("Foo", :sync => true)
+        end
+
+        expect(plugin.specs).to eq([])
+      end
     end
   end
 end

data/spec/neovim/remote_object_spec.rb

@@ -3,7 +3,7 @@ require "helper"
 module Neovim
   RSpec.describe RemoteObject do
     context Window do
-      let(:window) { Neovim.attach_child(["-n", "-u", "NONE"]).current.window }
+      let(:window) { Neovim.attach_child(["nvim", "-n", "-u", "NONE"]).current.window }
 
       describe "#respond_to?" do
         it "returns true for Window functions" do
@@ -37,7 +37,7 @@ module Neovim
     end
 
     context Tabpage do
-      let(:tabpage) { Neovim.attach_child(["-n", "-u", "NONE"]).current.tabpage }
+      let(:tabpage) { Neovim.attach_child(["nvim", "-n", "-u", "NONE"]).current.tabpage }
 
       describe "#respond_to?" do
         it "returns true for Tabpage functions" do
@@ -71,7 +71,7 @@ module Neovim
     end
 
     context Buffer do
-      let(:buffer) { Neovim.attach_child(["-n", "-u", "NONE"]).current.buffer }
+      let(:buffer) { Neovim.attach_child(["nvim", "-n", "-u", "NONE"]).current.buffer }
 
       describe "#respond_to?" do
         it "returns true for Buffer functions" do

data/spec/neovim/session_spec.rb

@@ -1,43 +1,84 @@
 require "helper"
 require "securerandom"
-require "fileutils"
 
 module Neovim
   RSpec.describe Session do
     shared_context "session behavior" do
-      it "supports requests" do
-        expect(session.request(:vim_strwidth, "foobar")).to be(6)
-      end
+      describe "#channel_id" do
+        it "returns nil when the API hasn't been discovered" do
+          expect(session.channel_id).to be(nil)
+        end
 
-      it "supports notifications" do
-        expect(session.notify(:vim_input, "jk")).to be(nil)
+        it "returns the channel_id when the API has been discovered" do
+          session.discover_api
+          expect(session.channel_id).to respond_to(:to_int)
+        end
       end
 
-      it "raises an exception when there are errors" do
-        expect {
-          session.request(:vim_strwidth, "too", "many")
-        }.to raise_error(/wrong number of arguments/i)
+      describe "#request" do
+        it "synchronously returns a result" do
+          expect(session.request(:vim_strwidth, "foobar")).to be(6)
+        end
+
+        it "raises an exception when there are errors" do
+          expect {
+            session.request(:vim_strwidth, "too", "many")
+          }.to raise_error(/wrong number of arguments/i)
+        end
+
+        it "handles large data" do
+          large_str = Array.new(1024 * 17) { SecureRandom.hex(1) }.join
+          session.request(:vim_set_current_line, large_str)
+          expect(session.request(:vim_get_current_line)).to eq(large_str)
+        end
       end
 
-      it "handles large data" do
-        large_str = Array.new(1024 * 16) { SecureRandom.hex(1) }.join
-        session.request(:vim_set_current_line, large_str)
-        expect(session.request(:vim_get_current_line)).to eq(large_str)
+      describe "#notify" do
+        it "returns nil" do
+          expect(session.notify(:vim_input, "jk")).to be(nil)
+        end
+
+        it "doesn't raise exceptions" do
+          expect {
+            session.notify(:vim_strwidth, "too", "many")
+          }.not_to raise_error
+        end
+
+        it "handles large data" do
+          large_str = Array.new(1024 * 17) { SecureRandom.hex(1) }.join
+          session.notify(:vim_set_current_line, large_str)
+          expect(session.request(:vim_get_current_line)).to eq(large_str)
+        end
       end
 
-      it "subscribes to events" do
-        session.request(:vim_subscribe, "my_event")
-        session.request(:vim_command, "call rpcnotify(0, 'my_event', 'foo')")
+      describe "#run" do
+        it "enqueues messages received during blocking requests" do
+          session.request(:vim_subscribe, "my_event")
+          session.request(:vim_command, "call rpcnotify(0, 'my_event', 'foo')")
 
-        messages = []
-        session.run do |msg|
-          messages << msg
-          session.shutdown
+          message = nil
+          session.run do |msg|
+            message = msg
+            session.shutdown
+          end
+
+          expect(message).to be_a(Notification)
+          expect(message.method_name).to eq("my_event")
+          expect(message.arguments).to eq(["foo"])
         end
 
-        expect(messages.first).to be_a(Notification)
-        expect(messages.first.method_name).to eq("my_event")
-        expect(messages.first.arguments).to eq(["foo"])
+        it "supports requests within callbacks" do
+          session.request(:vim_subscribe, "my_event")
+          session.request(:vim_command, "call rpcnotify(0, 'my_event', 'foo')")
+
+          result = nil
+          session.run do |msg|
+            result = session.request(:vim_strwidth, msg.arguments.first)
+            session.shutdown
+          end
+
+          expect(result).to be(3)
+        end
       end
     end
 
@@ -46,7 +87,7 @@ module Neovim
       let!(:nvim_pid) do
         pid = Process.spawn(
           {"NVIM_LISTEN_ADDRESS" => "0.0.0.0:#{nvim_port}"},
-          "#{ENV.fetch("NVIM_EXECUTABLE")} --headless -n -u NONE",
+          "nvim --headless -n -u NONE",
           [:out, :err] => "/dev/null"
         )
 
@@ -65,7 +106,6 @@ module Neovim
       end
 
       let(:session) { Session.tcp("0.0.0.0", nvim_port) }
-
       include_context "session behavior"
     end
 
@@ -74,7 +114,7 @@ module Neovim
       let!(:nvim_pid) do
         pid = Process.spawn(
           {"NVIM_LISTEN_ADDRESS" => socket_path},
-          "#{ENV.fetch("NVIM_EXECUTABLE")} --headless -n -u NONE",
+          "nvim --headless -n -u NONE",
           [:out, :err] => "/dev/null"
         )
 
@@ -93,12 +133,11 @@ module Neovim
       end
 
       let(:session) { Session.unix(socket_path) }
-
       include_context "session behavior"
     end
 
     context "child" do
-      let(:session) { Session.child(["-n", "-u", "NONE"]) }
+      let(:session) { Session.child(["nvim", "-n", "-u", "NONE"]) }
       include_context "session behavior"
     end
   end

data/spec/neovim/window_spec.rb

@@ -2,39 +2,62 @@ require "helper"
 
 module Neovim
   RSpec.describe Window do
-    let(:client) { Neovim.attach_child(["--headless", "-n", "-u", "NONE"]) }
+    let(:client) { Neovim.attach_child(["nvim", "--headless", "-n", "-u", "NONE"]) }
     let(:window) { client.current.window }
 
-    before do
-      client.command("normal 3Oabc")
-      client.command("normal gg")
-    end
+    describe "if_ruby compatibility" do
+      describe "#buffer" do
+        it "returns the buffer displayed in the window" do
+          expect(window.buffer).to be_a(Buffer)
+        end
+      end
+
+      describe "#height" do
+        it "returns the height of the window" do
+          client.set_option("lines", 5)
+          expect(window.height).to be(3)
+        end
+      end
 
-    describe "#cursor" do
-      it "moves line-wise" do
-        expect {
-          window.cursor.line += 1
-        }.to change { window.cursor.coordinates }.from([1, 0]).to([2, 0])
+      describe "#height=" do
+        it "sets the height of the window" do
+          expect {
+            window.height = 5
+          }.to change { window.height }.to(5)
+        end
+      end
 
-        expect {
-          window.cursor.line -= 1
-        }.to change { window.cursor.coordinates }.from([2, 0]).to([1, 0])
+      describe "#width" do
+        it "returns the width of the window" do
+          client.set_option("columns", 20)
+          expect(window.width).to be(20)
+        end
       end
 
-      it "moves column-wise" do
-        expect {
-          window.cursor.column += 1
-        }.to change { window.cursor.coordinates }.from([1, 0]).to([1, 1])
+      describe "#width=" do
+        it "sets the width of a vertically split window" do
+          client.command("vsplit")
+
+          expect {
+            window.width += 1
+          }.to change { window.width }.by(1)
+        end
+      end
 
-        expect {
-          window.cursor.column -= 1
-        }.to change { window.cursor.coordinates }.from([1, 1]).to([1, 0])
+      describe "#cursor" do
+        it "returns the cursor coordinates" do
+          expect(window.cursor).to eq([1, 0])
+        end
       end
 
-      it "moves to an absolute position" do
-        expect {
-          window.cursor.coordinates = [1, 1]
-        }.to change { window.cursor.coordinates }.to([1, 1])
+      describe "#cursor=" do
+        it "sets the cursor coodinates" do
+          window.buffer.lines = ["one", "two"]
+
+          expect {
+            window.cursor = [2, 2]
+          }.to change { window.cursor }.to([2, 2])
+        end
       end
     end
   end