neovim 0.0.3 → 0.0.4

data/spec/neovim/host_spec.rb

@@ -4,7 +4,7 @@ require "tempfile"
 module Neovim
   RSpec.describe Host do
     describe ".load_from_files" do
-      it "loads the defined plugins" do
+      it "loads the defined plugins into a manifest" do
         plug1 = Tempfile.open("plug1") do |f|
           f.write("Neovim.plugin")
           f.path
@@ -15,8 +15,11 @@ module Neovim
           f.path
         end
 
-        host = Host.load_from_files([plug1, plug2])
-        expect(host.plugins.size).to eq(3)
+        manifest = Manifest.new
+
+        expect(manifest).to receive(:register).exactly(3).times
+        host = Host.load_from_files([plug1, plug2], manifest)
+        expect(host.manifest).to eq(manifest)
       end
 
       it "doesn't load plugin code into the global namespace" do
@@ -31,49 +34,7 @@ module Neovim
     end
 
     describe "#run" do
-      it "runs an async client with the plugins as callbacks" do
-        sync_cb = lambda { |nvim, x, y| [nvim, x, y] }
-        async_cb = lambda { |nvim, x, y| [nvim, x, y] }
-
-        plugin = Plugin.from_config_block do |plug|
-          plug.command(:Sync, :nargs => 2, :sync => true, &sync_cb)
-          plug.command(:Async, :nargs => 2, &async_cb)
-        end
-
-        mock_async_session = double(:async_session, :request => nil)
-        expect(AsyncSession).to receive(:new) { mock_async_session }
-
-        mock_client = double(:client)
-        expect(Client).to receive(:new) { mock_client }
-
-        expect(EventLoop).to receive(:stdio) { double(:event_loop) }
-        expect(MsgpackStream).to receive(:new) { double(:msgpack_stream) }
-        expect(Session).to receive(:new) { double(:session) }
-
-        expect(mock_async_session).to receive(:run) do |req_cb, not_cb|
-          mock_request = double(
-            :request,
-            :method_name => :Sync,
-            :arguments => [1, 2]
-          )
-
-          mock_notification = double(
-            :notification,
-            :method_name => :Async,
-            :arguments => [3, 4]
-          )
-
-          expect(sync_cb).to receive(:call).with(mock_client, 1, 2).and_call_original
-          expect(mock_request).to receive(:respond).with([mock_client, 1, 2])
-          req_cb.call(mock_request)
-
-          expect(async_cb).to receive(:call).with(mock_client, 3, 4).and_call_original
-          not_cb.call(mock_notification)
-        end
-
-        host = Host.new([plugin])
-        host.run
-      end
+      # TODO: Find a way to test this without excessive mocking
     end
   end
 end

data/spec/neovim/line_range_spec.rb

@@ -0,0 +1,68 @@
+require "helper"
+
+module Neovim
+  RSpec.describe LineRange do
+    let(:client) { Neovim.attach_child(["--headless", "-n", "-u", "NONE"]) }
+    let(:buffer) { client.current.buffer }
+    let(:line_range) { LineRange.new(buffer, 0, -1) }
+
+    before do
+      client.command("normal i1")
+      client.command("normal o2")
+      client.command("normal o3")
+    end
+
+    it "is enumerable" do
+      expect(line_range).to be_an(Enumerable)
+      expect(line_range).to respond_to(:each)
+    end
+
+    describe "#to_a" do
+      it "returns lines as an array" do
+        expect(line_range.to_a).to eq(["1", "2", "3"])
+      end
+    end
+
+    describe "#[]" do
+      it "accepts a single index" do
+        expect(line_range[1]).to eq("2")
+      end
+
+      it "accepts an index and length" do
+        expect(line_range[0, 2].to_a).to eq(["1", "2"])
+      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
+    end
+
+    describe "#[]=" do
+      it "accepts a single index" do
+        line_range[0] = "foo"
+        expect(line_range.to_a).to eq(["foo", "2", "3"])
+      end
+
+      it "accepts an index and length" do
+        line_range[0, 2] = ["foo"]
+        expect(line_range.to_a).to eq(["foo", "3"])
+      end
+
+      it "accepts a range" do
+        line_range[0..1] = ["foo"]
+        expect(line_range.to_a).to eq(["foo", "3"])
+
+        line_range[0...1] = ["bar"]
+        expect(line_range.to_a).to eq(["bar", "3"])
+      end
+    end
+
+    describe "#replace" do
+      it "replaces all lines" do
+        line_range.replace(["5", "6"])
+        expect(line_range.to_a).to eq(["5", "6"])
+      end
+    end
+  end
+end

data/spec/neovim/manifest_spec.rb

@@ -0,0 +1,113 @@
+require "helper"
+require "neovim/manifest"
+require "neovim/plugin"
+
+module Neovim
+  RSpec.describe Manifest do
+    it "has a default poll handler" do
+      manifest = Manifest.new
+      expect(manifest.handlers["poll"]).to respond_to(:call)
+    end
+
+    it "has default specs" do
+      manifest = Manifest.new
+      expect(manifest.specs).to eq({})
+    end
+
+    describe "#register" do
+      it "adds specs" do
+        manifest = Manifest.new
+
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.command(:Foo)
+        end
+
+        expect {
+          manifest.register(plugin)
+        }.to change { manifest.specs }.from({}).to("source" => plugin.specs)
+      end
+
+      it "adds plugin handlers" do
+        manifest = Manifest.new
+
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.command(:Foo)
+        end
+
+        expect {
+          manifest.register(plugin)
+        }.to change {
+          manifest.handlers["source:command:Foo"]
+        }.from(nil).to(kind_of(Proc))
+      end
+    end
+
+    describe "#handle" do
+      it "calls the poll handler" do
+        manifest = Manifest.new
+        message = double(:message, :method_name => "poll", :sync? => true)
+        client = double(:client)
+
+        expect(message).to receive(:respond).with("ok")
+        manifest.handle(message, client)
+      end
+
+      it "calls the specs handler" do
+        manifest = Manifest.new
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.command(:Foo)
+        end
+        manifest.register(plugin)
+
+        message = double(:message, :method_name => "specs", :sync? => true, :arguments => ["source"])
+
+        expect(message).to receive(:respond).with(plugin.specs)
+        manifest.handle(message, double(:client))
+      end
+
+      it "calls a plugin sync handler" do
+        manifest = Manifest.new
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.command(:Foo, :sync => true) { |client, arg| [client, arg] }
+        end
+        manifest.register(plugin)
+
+        message = double(:message, :method_name => "source:command:Foo", :sync? => true, :arguments => [:arg])
+        client = double(:client)
+
+        expect(message).to receive(:respond).with([client, :arg])
+        manifest.handle(message, client)
+      end
+
+      it "calls a plugin async handler" do
+        manifest = Manifest.new
+        async_proc = Proc.new {}
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.command(:Foo, &async_proc)
+        end
+        manifest.register(plugin)
+
+        message = double(:message, :method_name => "source:command:Foo", :sync? => false, :arguments => [:arg])
+        client = double(:client)
+
+        expect(async_proc).to receive(:call).with(client, :arg)
+        manifest.handle(message, client)
+      end
+
+      it "calls a default sync handler" do
+        manifest = Manifest.new
+        message = double(:message, :method_name => "foobar", :sync? => true)
+
+        expect(message).to receive(:error).with("Unknown request foobar")
+        manifest.handle(message, double(:client))
+      end
+
+      it "calls a default async handler" do
+        manifest = Manifest.new
+        message = double(:message, :method_name => "foobar", :sync? => false)
+
+        manifest.handle(message, double(:client))
+      end
+    end
+  end
+end

data/spec/neovim/msgpack_stream_spec.rb

@@ -11,13 +11,15 @@ module Neovim
         srv_thr = Thread.new do
           client = server.accept
           messages << client.readpartial(1024)
+
           client.write(MessagePack.pack([2]))
+          client.close
+          server.close
         end
 
         fiber = Fiber.new do
-          stream.send([1]).run do |msg|
-            Fiber.yield(msg)
-          end
+          msg_cb = Proc.new { |msg| Fiber.yield(msg) }
+          stream.send([1]).run(msg_cb)
         end
 
         expect(fiber.resume).to eq([2])

data/spec/neovim/plugin_spec.rb

@@ -6,60 +6,60 @@ module Neovim
       it "registers a command" do
         cmd_block = Proc.new {}
 
-        plugin = Plugin.from_config_block do |plug|
+        plugin = Plugin.from_config_block("source") do |plug|
           plug.command("Foo", :range => true, :nargs => 1, &cmd_block)
         end
 
-        expect(plugin.specs).to eq(
-          [
-            {
-              :type => :command,
-              :name => :Foo,
-              :sync => false,
-              :opts => {:range => "", :nargs => 1},
-              :proc => cmd_block
-            }
-          ]
+        expect(plugin.handlers.size).to be(1)
+        handler = plugin.handlers.first
+
+        expect(handler.block).to eq(cmd_block)
+        expect(handler.qualified_name).to eq("source:command:Foo")
+        expect(handler.to_spec).to eq(
+          :type => :command,
+          :name => "Foo",
+          :sync => false,
+          :opts => {:range => "", :nargs => 1},
         )
       end
 
       it "registers an autocmd" do
         au_block = Proc.new {}
 
-        plugin = Plugin.from_config_block do |plug|
+        plugin = Plugin.from_config_block("source") do |plug|
           plug.autocmd("BufEnter", :pattern => "*.rb", &au_block)
         end
 
-        expect(plugin.specs).to eq(
-          [
-            {
-              :type => :autocmd,
-              :name => :BufEnter,
-              :sync => false,
-              :opts => {:pattern => "*.rb"},
-              :proc => au_block
-            }
-          ]
+        expect(plugin.handlers.size).to be(1)
+        handler = plugin.handlers.first
+
+        expect(handler.block).to eq(au_block)
+        expect(handler.qualified_name).to eq("source:autocmd:BufEnter:*.rb")
+        expect(handler.to_spec).to eq(
+          :type => :autocmd,
+          :name => "BufEnter",
+          :sync => false,
+          :opts => {:pattern => "*.rb"},
         )
       end
 
       it "registers a function" do
         fun_block = Proc.new {}
 
-        plugin = Plugin.from_config_block do |plug|
+        plugin = Plugin.from_config_block("source") do |plug|
           plug.function("Foo", :range => true, :nargs => 1, &fun_block)
         end
 
-        expect(plugin.specs).to eq(
-          [
-            {
-              :type => :function,
-              :name => :Foo,
-              :sync => false,
-              :opts => {:range => "", :nargs => 1},
-              :proc => fun_block
-            }
-          ]
+        expect(plugin.handlers.size).to be(1)
+        handler = plugin.handlers.first
+
+        expect(handler.block).to eq(fun_block)
+        expect(handler.qualified_name).to eq("source:function:Foo")
+        expect(handler.to_spec).to eq(
+          :type => :function,
+          :name => "Foo",
+          :sync => false,
+          :opts => {:range => "", :nargs => 1},
         )
       end
     end

data/spec/neovim/session_spec.rb

@@ -1,33 +1,112 @@
 require "helper"
+require "securerandom"
+require "fileutils"
 
 module Neovim
   RSpec.describe Session do
-    let(:session) do
-      event_loop = EventLoop.child(["-n", "-u", "NONE"])
-      stream = MsgpackStream.new(event_loop)
-      async = AsyncSession.new(stream)
-      Session.new(async)
-    end
+    shared_context "session behavior" do
+      it "supports functions with async=false" do
+        expect(session.request(:vim_strwidth, "foobar")).to be(6)
+      end
+
+      it "supports functions with async=true" do
+        expect(session.request(:vim_input, "jk")).to be(2)
+      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 "supports functions with async=false" do
-      expect(session.request(:vim_strwidth, "foobar")).to be(6)
+      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)
+      end
+
+      describe "#api_methods_for_prefix" do
+        it "returns relevant functions without a prefix" do
+          methods = session.api_methods_for_prefix("vim_")
+          expect(methods).to include(:strwidth)
+        end
+      end
     end
 
-    it "supports functions with async=true" do
-      expect(session.request(:vim_input, "jk")).to be(2)
+    context "tcp" do
+      let!(:nvim_port) do
+        server = TCPServer.new("0.0.0.0", 0)
+        server.addr[1].tap { server.close }
+      end
+
+      let!(:nvim_pid) do
+        Process.spawn(
+          {"NVIM_LISTEN_ADDRESS" => "0.0.0.0:#{nvim_port}"},
+          "#{ENV.fetch("NVIM_EXECUTABLE")} --headless -n -u NONE",
+          [:out, :err] => "/dev/null"
+        ).tap do
+          begin
+            TCPSocket.open("0.0.0.0", nvim_port).close
+          rescue Errno::ECONNREFUSED
+            retry
+          end
+        end
+      end
+
+      after do
+        Process.kill(:TERM, nvim_pid)
+        Process.waitpid(nvim_pid)
+      end
+
+      let(:session) do
+        event_loop = EventLoop.tcp("0.0.0.0", nvim_port)
+        stream = MsgpackStream.new(event_loop)
+        async = AsyncSession.new(stream)
+        Session.new(async)
+      end
+
+      include_context "session behavior"
     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)
+    context "unix" do
+      let!(:nvim_pid) do
+        FileUtils.rm_f("/tmp/nvim-#$$.sock")
+        Process.spawn(
+          {"NVIM_LISTEN_ADDRESS" => "/tmp/nvim-#$$.sock"},
+          "#{ENV.fetch("NVIM_EXECUTABLE")} --headless -n -u NONE",
+          [:out, :err] => "/dev/null"
+        ).tap do
+          loop do
+            break if File.exists?("/tmp/nvim-#$$.sock")
+          end
+        end
+      end
+
+      after do
+        Process.kill(:TERM, nvim_pid)
+        Process.waitpid(nvim_pid)
+        FileUtils.rm_f("/tmp/nvim-#$$.sock")
+      end
+
+      let(:session) do
+        event_loop = EventLoop.unix("/tmp/nvim-#$$.sock")
+        stream = MsgpackStream.new(event_loop)
+        async = AsyncSession.new(stream)
+        Session.new(async)
+      end
+
+      include_context "session behavior"
     end
 
-    describe "#api_methods_for_prefix" do
-      it "returns relevant functions without a prefix" do
-        methods = session.api_methods_for_prefix("vim_")
-        expect(methods).to include(:strwidth)
+    context "child" do
+      let(:session) do
+        event_loop = EventLoop.child(["-n", "-u", "NONE"])
+        stream = MsgpackStream.new(event_loop)
+        async = AsyncSession.new(stream)
+        Session.new(async)
       end
+
+      include_context "session behavior"
     end
   end
 end