neovim 0.2.2 → 0.2.3

data/lib/neovim/line_range.rb

@@ -1,5 +1,7 @@
 module Neovim
   # Provide an enumerable interface for dealing with ranges of lines.
+  #
+  # @api private
   class LineRange
     include Enumerable
 
@@ -111,6 +113,12 @@ module Neovim
       self
     end
 
+    # @param index [Fixnum]
+    # @param line [String]
+    def insert(index, lines)
+      @buffer.insert(index, Array(lines))
+    end
+
     # @param index [Fixnum]
     def delete(index)
       @buffer.del_line(abs_line(index))

data/lib/neovim/logging.rb

@@ -2,6 +2,7 @@ require "logger"
 
 module Neovim
   # Mixed into classes for unified logging helper methods.
+  # @api private
   module Logging
     class << self
       attr_writer :logger

data/lib/neovim/msgpack_stream.rb

@@ -3,7 +3,9 @@ require "msgpack"
 
 module Neovim
   # Handles serializing RPC messages to MessagePack and passing them to
-  # the event loop
+  # the event loop.
+  #
+  # @api private
   class MsgpackStream
     include Logging
 
@@ -40,7 +42,7 @@ module Neovim
         end
       end
     rescue => e
-      fatal("got unexpected error #{e}")
+      fatal("got unexpected error #{e.inspect}")
       debug(e.backtrace.join("\n"))
     end
 

data/lib/neovim/notification.rb

@@ -1,5 +1,6 @@
 module Neovim
   # An asynchronous message from +nvim+.
+  #
   # @api private
   class Notification
     attr_reader :method_name, :arguments

data/lib/neovim/plugin.rb

@@ -1,6 +1,7 @@
 require "neovim/plugin/dsl"
 
 module Neovim
+  # @api private
   class Plugin
     attr_accessor :handlers
     attr_reader :source

data/lib/neovim/request.rb

@@ -1,5 +1,6 @@
 module Neovim
   # A synchronous message from +nvim+.
+  #
   # @api private
   class Request
     attr_reader :method_name, :arguments

data/lib/neovim/ruby_provider.rb

@@ -6,6 +6,8 @@ module Neovim
   # This class is used to define a +Neovim::Plugin+ to act as a backend for the
   # legacy +:ruby+, +:rubyfile+, and +:rubydo+ Vim commands. It is autoloaded
   # from +nvim+ and not intended to be loaded directly.
+  #
+  # @api private
   module RubyProvider
     def self.__define_plugin!
       Thread.abort_on_exception = true

data/lib/neovim/session.rb

@@ -7,6 +7,8 @@ require "fiber"
 
 module Neovim
   # Wraps an +AsyncSession+ in a synchronous API using +Fiber+s.
+  #
+  # @api private
   class Session
     include Logging
 
@@ -99,7 +101,7 @@ module Neovim
         Fiber.new { yield message if block_given? }.resume
       end
     ensure
-      stop
+      shutdown
     end
 
     # Make an RPC request and return its response.

data/lib/neovim/version.rb

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

data/spec/helper.rb

@@ -38,4 +38,5 @@ RSpec.configure do |config|
   Kernel.srand config.seed
 end
 
+Neovim.logger.level = Logger::FATAL
 Thread.abort_on_exception = true

data/spec/neovim/buffer_spec.rb

@@ -4,6 +4,7 @@ module Neovim
   RSpec.describe Buffer do
     let(:client) { Neovim.attach_child(["nvim", "-n", "-u", "NONE"]) }
     let(:buffer) { client.current.buffer }
+    after { client.shutdown }
 
     describe "#lines" do
       it "returns a LineRange" do
@@ -108,6 +109,25 @@ module Neovim
           }.to change { buffer.lines.to_a }.to(["one", "two"])
         end
 
+        it "unshifts buffer lines using index 0" do
+          buffer.lines = []
+
+          expect {
+            buffer.append(0, "two")
+            buffer.append(0, "one")
+          }.to change { buffer.lines.to_a }.to(["one", "two", ""])
+        end
+
+        it "raises for out of bounds indexes" do
+          expect {
+            buffer.append(-1, "err")
+          }.to raise_error(/out of bounds/i)
+
+          expect {
+            buffer.append(10, "err")
+          }.to raise_error(/out of bounds/i)
+        end
+
         it "returns the appended line" do
           expect(buffer.append(0, "two")).to eq("two")
         end

data/spec/neovim/client_spec.rb

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

data/spec/neovim/current_spec.rb

@@ -4,6 +4,7 @@ module Neovim
   RSpec.describe Current do
     let(:client) { Neovim.attach_child(["nvim", "-n", "-u", "NONE"]) }
     let(:current) { client.current }
+    after { client.shutdown }
 
     describe "#line" do
       it "returns an empty string if the current line is empty" do

data/spec/neovim/host/loader_spec.rb

@@ -0,0 +1,47 @@
+require "helper"
+
+module Neovim
+  class Host
+    RSpec.describe Loader do
+      describe "#load" do
+        let(:plugin_path) { Support.file_path("plug.rb") }
+        let(:host) { instance_double(Host, :register => nil) }
+        let(:loader) { Loader.new(host) }
+
+        before do
+          File.write(plugin_path, "Neovim.plugin")
+        end
+
+        it "registers plugins defined in the provided files" do
+          expect(host).to receive(:register).with(kind_of(Plugin))
+          loader.load([plugin_path])
+        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])
+        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])
+        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)
+        end
+
+        it "doesn't leak the overidden Neovim.plugin method" do
+          loader.load([plugin_path])
+          expect {
+            Neovim.plugin
+          }.to raise_error(/outside of a plugin host/)
+        end
+      end
+    end
+  end
+end

data/spec/neovim/host_spec.rb

@@ -2,50 +2,138 @@ require "helper"
 
 module Neovim
   RSpec.describe Host do
+    let(:session) { instance_double(Session) }
+    let(:client) { instance_double(Client) }
+    let(:host) { Host.new(session, client) }
+
     describe ".load_from_files" do
-      it "loads the defined plugins into a manifest" do
-        plug1 = Support.file_path("plug1.rb")
-        plug2 = Support.file_path("plug2.rb")
+      it "instantiates with a session and loads plugins" do
+        paths = ["/foo", "/bar"]
+        loader = instance_double(Host::Loader)
 
-        File.write(plug1, "Neovim.plugin")
-        File.write(plug2, "Neovim.plugin; Neovim.plugin")
+        expect(Host::Loader).to receive(:new).
+          with(kind_of(Host)).
+          and_return(loader)
+        expect(loader).to receive(:load).with(paths)
 
-        manifest = Manifest.new
+        Host.load_from_files(paths, :session => session, :client => client)
+      end
+    end
+
+    describe "#handlers" do
+      it "has a default poll handler" do
+        expect(host.handlers["poll"]).to respond_to(:call)
+      end
+    end
 
-        expect(manifest).to receive(:register).exactly(3).times
-        host = Host.load_from_files([plug1, plug2], manifest)
-        expect(host.manifest).to eq(manifest)
+    describe "#specs" do
+      it "has default specs" do
+        expect(host.specs).to eq({})
       end
+    end
 
-      it "doesn't load plugin code into the global namespace" do
-        plug = Support.file_path("plug.rb")
-        File.write(plug, "class FooClass; end")
+    describe "#register" do
+      it "adds specs" do
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.command(:Foo)
+        end
 
-        host = Host.load_from_files([plug])
-        expect(Kernel.const_defined?("FooClass")).to be(false)
+        expect {
+          host.register(plugin)
+        }.to change { host.specs }.from({}).to("source" => plugin.specs)
+      end
+
+      it "adds plugin handlers" do
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.command(:Foo)
+        end
+
+        expect {
+          host.register(plugin)
+        }.to change {
+          host.handlers["source:command:Foo"]
+        }.from(nil).to(kind_of(Proc))
+      end
+
+      it "doesn't add top-level RPCs to specs" do
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.rpc(:Foo)
+        end
+
+        expect {
+          host.register(plugin)
+        }.to change { host.specs }.from({}).to("source" => [])
       end
     end
 
-    describe "#run" do
-      it "delegates messages to the manifest" do
-        messages = []
-        manifest = instance_double(Manifest)
-        session = Session.child(["nvim", "-n", "-u", "NONE"])
+    describe "#handle" do
+      it "calls the poll handler" do
+        message = double(:message, :method_name => "poll", :sync? => true)
+
+        expect(message).to receive(:respond).with("ok")
+        host.handle(message)
+      end
 
-        host = Host.new(manifest, session)
+      it "calls the specs handler" do
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.command(:Foo)
+        end
+        host.register(plugin)
 
-        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)
+        message = double(:message, :method_name => "specs", :sync? => true, :arguments => ["source"])
 
-          session.stop
+        expect(message).to receive(:respond).with(plugin.specs)
+        host.handle(message)
+      end
+
+      it "calls a plugin sync handler" do
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.command(:Foo, :sync => true) { |client, arg| [client, arg] }
+        end
+        host.register(plugin)
+
+        message = double(:message, :method_name => "source:command:Foo", :sync? => true, :arguments => [:arg])
+
+        expect(message).to receive(:respond).with([client, :arg])
+        host.handle(message)
+      end
+
+      it "rescues plugin sync handler exceptions" do
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.command(:Foo, :sync => true) { raise "BOOM" }
+        end
+        host.register(plugin)
+
+        message = double(:message, :method_name => "source:command:Foo", :sync? => true, :arguments => [])
+
+        expect(message).to receive(:error).with("BOOM")
+        host.handle(message)
+      end
+
+      it "calls a plugin async handler" do
+        async_proc = Proc.new {}
+        plugin = Plugin.from_config_block("source") do |plug|
+          plug.command(:Foo, &async_proc)
         end
+        host.register(plugin)
+
+        message = double(:message, :method_name => "source:command:Foo", :sync? => false, :arguments => [:arg])
+
+        expect(async_proc).to receive(:call).with(client, :arg)
+        host.handle(message)
+      end
+
+      it "calls a default sync handler" do
+        message = double(:message, :method_name => "foobar", :sync? => true)
+
+        expect(message).to receive(:error).with("Unknown request foobar")
+        host.handle(message)
+      end
 
-        session.request(:vim_subscribe, "my_event")
-        session.request(:vim_command, "call rpcnotify(0, 'my_event', 'arg')")
+      it "calls a default async handler" do
+        message = double(:message, :method_name => "foobar", :sync? => false)
 
-        host.run
+        host.handle(message)
       end
     end
   end

data/spec/neovim/line_range_spec.rb

@@ -4,7 +4,7 @@ module Neovim
   RSpec.describe LineRange do
     let(:client) { Neovim.attach_child(["nvim", "-n", "-u", "NONE"]) }
     let(:buffer) { client.current.buffer }
-    let(:line_range) { LineRange.new(buffer, 0, 3) }
+    let(:line_range) { LineRange.new(buffer, 0, -1) }
     let(:sub_range) { LineRange.new(buffer, 1, 2) }
 
     before do
@@ -14,6 +14,8 @@ module Neovim
       client.command("normal o4")
     end
 
+    after { client.shutdown }
+
     it "is enumerable" do
       expect(line_range).to be_an(Enumerable)
       expect(line_range).to respond_to(:each)
@@ -115,6 +117,46 @@ module Neovim
       end
     end
 
+    describe "#insert" do
+      before { line_range.replace(["1", "2"]) }
+
+      it "inserts lines at the beginning" do
+        expect {
+          line_range.insert(0, "z")
+        }.to change { line_range.to_a }.to(["z", "1", "2"])
+
+        expect {
+          line_range.insert(0, ["x", "y"])
+        }.to change { line_range.to_a }.to(["x", "y", "z", "1", "2"])
+      end
+
+      it "inserts lines in the middle" do
+        expect {
+          line_range.insert(1, "z")
+        }.to change { line_range.to_a }.to(["1", "z", "2"])
+
+        expect {
+          line_range.insert(1, ["x", "y"])
+        }.to change { line_range.to_a }.to(["1", "x", "y", "z", "2"])
+      end
+
+      it "inserts lines at the end" do
+        expect {
+          line_range.insert(-1, "x")
+        }.to change { line_range.to_a }.to(["1", "2", "x"])
+
+        expect {
+          line_range.insert(-1, ["y", "z"])
+        }.to change { line_range.to_a }.to(["1", "2", "x", "y", "z"])
+      end
+
+      it "raises on out of bounds indexes" do
+        expect {
+          line_range.insert(10, "x")
+        }.to raise_error(/out of bounds/i)
+      end
+    end
+
     describe "#delete" do
       it "deletes the line at the given index" do
         expect {

data/spec/neovim/remote_object_spec.rb

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