neovim 0.6.2 → 0.7.0

data/lib/neovim/host.rb

@@ -8,67 +8,57 @@ module Neovim
   class Host
     include Logging
 
-    # Start a plugin host. This is called by the +nvim-ruby-host+ executable,
-    # which is spawned by +nvim+ to discover and run Ruby plugins, and acts as
-    # the bridge between +nvim+ and the plugin.
-    def self.run(rplugin_paths, event_loop=EventLoop.stdio)
-      client = Client.from_event_loop(event_loop)
+    attr_reader :plugins
 
-      new(client).tap do |host|
+    def self.run(rplugin_paths, event_loop=EventLoop.stdio)
+      new(event_loop).tap do |host|
         Loader.new(host).load(rplugin_paths)
       end.run
     end
 
-    def initialize(client)
-      @client = client
-      @session = client.session
+    def initialize(event_loop)
+      @event_loop = event_loop
+      @session = Session.new(event_loop)
       @handlers = {"poll" => poll_handler, "specs" => specs_handler}
+      @plugins = []
       @specs = {}
     end
 
-    # Register a +Plugin+ to receive +Host+ messages.
-    def register(plugin)
-      plugin.handlers.each do |handler|
-        @handlers[handler.qualified_name] = wrap_plugin_handler(handler)
-      end
-
-      plugin.setup(@client)
-      @specs[plugin.source] = plugin.specs
-    end
-
-    # Run the event loop, passing received messages to the appropriate handler.
     def run
       @session.run { |msg| handle(msg) }
-    ensure
-      @client.shutdown
-      @session.shutdown
     end
 
-    # Handle messages received from the host. Sends a +Neovim::Client+ along
-    # with the message to be used in plugin callbacks.
     def handle(message)
       log(:debug) { message.to_h }
 
       @handlers.
         fetch(message.method_name, default_handler).
         call(@client, message)
-    rescue SignalException => ex
-      log_exception(:debug, ex, __method__)
-      raise ex
-    rescue => ex
-      log_exception(:fatal, ex, __method__)
+    rescue Exception => e
+      log_exception(:error, e, __method__)
+
+      if message.sync?
+        @session.respond(message.id, nil, e.message)
+      else
+        @client.err_writeln("Exception handling #{message.method_name}: (#{e.class}) #{e.message}")
+      end
+
+      raise unless StandardError === e
     end
 
     private
 
     def poll_handler
-      @poll_handler ||= Proc.new do |_, req|
+      @poll_handler ||= -> (_, req) {
+        initialize_client(req.id)
+        initialize_plugins
+
         @session.respond(req.id, "ok")
-      end
+      }
     end
 
     def specs_handler
-      @specs_handler ||= Proc.new do |_, req|
+      @specs_handler ||= -> (_, req) {
         source = req.arguments.fetch(0)
 
         if @specs.key?(source)
@@ -76,33 +66,39 @@ module Neovim
         else
           @session.respond(req.id, nil, "Unknown plugin #{source}")
         end
-      end
+      }
     end
 
     def default_handler
-      @default_handler ||= Proc.new do |_, message|
+      @default_handler ||= -> (_, message) {
         next unless message.sync?
         @session.respond(message.id, nil, "Unknown request #{message.method_name}")
-      end
+      }
     end
 
-    def wrap_plugin_handler(handler)
-      Proc.new do |client, message|
-        begin
-          args = message.arguments.flatten(1)
-          result = handler.call(client, *args)
-
-          @session.respond(message.id, result) if message.sync?
-        rescue => e
-          log_exception(:error, e, __method__)
-
-          if message.sync?
-            @session.respond(message.id, nil, e.message)
-          else
-            client.err_writeln("#{handler.qualified_name}: (#{e.class}) #{e.message}")
-          end
+    def initialize_client(request_id)
+      @session.request_id = request_id
+      @client = Client.from_event_loop(@event_loop, @session)
+    end
+
+    def initialize_plugins
+      @plugins.each do |plugin|
+        plugin.handlers.each do |handler|
+          @handlers[handler.qualified_name] = wrap_plugin_handler(handler)
         end
+
+        plugin.setup(@client)
+        @specs[plugin.source] = plugin.specs
       end
     end
+
+    def wrap_plugin_handler(handler)
+      -> (client, message) {
+        args = message.arguments.flatten(1)
+        result = handler.call(client, *args)
+
+        @session.respond(message.id, result) if message.sync?
+      }
+    end
   end
 end

data/lib/neovim/host/loader.rb

@@ -8,9 +8,6 @@ module Neovim
         @host = host
       end
 
-      # Load the provided Ruby files while temporarily overriding
-      # +Neovim.plugin+ to expose the remote plugin DSL and register the result
-      # to the host.
       def load(paths)
         paths.each do |path|
           override_plugin_method(path) do
@@ -27,7 +24,7 @@ module Neovim
 
         Neovim.define_singleton_method(:plugin) do |&block|
           plugin = Plugin.from_config_block(path, &block)
-          at_host.register(plugin)
+          at_host.plugins << plugin
         end
 
         yield

data/lib/neovim/logging.rb

@@ -43,16 +43,16 @@ module Neovim
     end
 
     def self.json_formatter
-      Proc.new do |level, time, _, fields|
+      -> (level, time, _, fields) {
         require "multi_json"
 
         MultiJson.encode(
           {
-            :_level => level,
-            :_time => time.strftime(TIMESTAMP_FORMAT)
+            _level: level,
+            _time: time.strftime(TIMESTAMP_FORMAT)
           }.merge!(fields)
         ) << "\n"
-      end
+      }
     end
     private_class_method :json_formatter
 
@@ -63,8 +63,8 @@ module Neovim
         begin
           Logging.logger.public_send(level) do
             {
-              :_class => self.class,
-              :_method => _method || block.binding.eval("__method__"),
+              _class: self.class,
+              _method: _method || block.binding.eval("__method__"),
             }.merge!(block.call)
           end
         rescue => ex
@@ -76,11 +76,11 @@ module Neovim
 
       def log_exception(level, ex, _method)
         log(level, _method) do
-          {:exception => ex.class, :message => ex.message}
+          {exception: ex.class, message: ex.message}
         end
 
         log(:debug, _method) do
-          {:exception => ex.class, :message => ex.message, :backtrace => ex.backtrace}
+          {exception: ex.class, message: ex.message, backtrace: ex.backtrace}
         end
       end
     end

data/lib/neovim/message.rb

@@ -0,0 +1,70 @@
+require "neovim/logging"
+
+module Neovim
+  # @api private
+  class Message
+    def self.from_array((kind, *payload))
+      case kind
+      when 0
+        request(*payload)
+      when 1
+        reqid, (_, error), value = payload
+        response(reqid, error, value)
+      when 2
+        notification(*payload)
+      else
+        raise "Unknown message type #{kind.inspect}"
+      end
+    end
+
+    def self.request(id, method, args)
+      Request.new(id, method, args)
+    end
+
+    def self.response(request_id, error, value)
+      Response.new(request_id, error, value)
+    end
+
+    def self.notification(method, args)
+      Notification.new(method, args)
+    end
+
+    class Request < Struct.new(:id, :method_name, :arguments)
+      def to_a
+        [0, id, method_name, arguments]
+      end
+
+      def received(_, &block)
+        block.call(self)
+      end
+
+      def sync?
+        true
+      end
+    end
+
+    class Response < Struct.new(:request_id, :error, :value)
+      def to_a
+        [1, request_id, error, value]
+      end
+
+      def received(handlers)
+        handlers[request_id].call(self)
+      end
+    end
+
+    class Notification < Struct.new(:method_name, :arguments)
+      def to_a
+        [2, method_name, arguments]
+      end
+
+      def received(_, &block)
+        block.call(self)
+      end
+
+      def sync?
+        false
+      end
+    end
+  end
+end

data/lib/neovim/plugin.rb

@@ -6,7 +6,6 @@ module Neovim
     attr_accessor :handlers, :setup_blocks
     attr_reader :source
 
-    # Entrypoint to the +Neovim.plugin+ DSL.
     def self.from_config_block(source)
       new(source).tap do |instance|
         yield DSL.new(instance) if block_given?
@@ -19,14 +18,12 @@ module Neovim
       @setup_blocks = []
     end
 
-    # Return specs used by +nvim+ to register plugins.
     def specs
       @handlers.inject([]) do |acc, handler|
         handler.qualified? ? acc + [handler.to_spec] : acc
       end
     end
 
-    # Run all registered setup blocks.
     def setup(client)
       @setup_blocks.each { |bl| bl.call(client) }
     end

data/lib/neovim/plugin/handler.rb

@@ -5,7 +5,7 @@ module Neovim
       attr_reader :block
 
       def self.unqualified(name, block)
-        new(nil, nil, name, true, {:qualified => false}, block)
+        new(nil, nil, name, true, {qualified: false}, block)
       end
 
       def initialize(source, type, name, sync, options, block)
@@ -14,7 +14,7 @@ module Neovim
         @name = name.to_s
         @sync = !!sync
         @options = options
-        @block = block || Proc.new {}
+        @block = block || -> {}
         @qualified =
           options.key?(:qualified) ? options.delete(:qualified) : true
       end
@@ -40,10 +40,10 @@ module Neovim
 
       def to_spec
         {
-          :type => @type,
-          :name => @name,
-          :sync => @sync,
-          :opts => @options,
+          type: @type,
+          name: @name,
+          sync: @sync,
+          opts: @options,
         }
       end
 

data/lib/neovim/remote_object.rb

@@ -31,7 +31,7 @@ module Neovim
     end
 
     # Extend +respond_to?+ to support RPC methods.
-    def respond_to?(method_name)
+    def respond_to?(method_name, *)
       super || rpc_methods.include?(method_name.to_sym)
     end
 

data/lib/neovim/ruby_provider.rb

@@ -27,14 +27,6 @@ module Neovim
     # 2. Define the +DirChanged+ event to update the provider's pwd.
     def self.__define_setup(plug)
       plug.__send__(:setup) do |client|
-        $stdout.define_singleton_method(:write) do |string|
-          client.out_write(string + "\n")
-        end
-
-        $stderr.define_singleton_method(:write) do |string|
-          client.err_writeln(string)
-        end
-
         begin
           cid = client.api.channel_id
           client.command("au DirChanged * call rpcrequest(#{cid}, 'ruby_chdir', v:event)")
@@ -107,7 +99,9 @@ module Neovim
       Vim.__refresh_globals(client)
 
       __with_exception_handling(client) do
-        yield
+        __with_std_streams(client) do
+          yield
+        end
       end
       nil
     end
@@ -116,13 +110,30 @@ module Neovim
     def self.__with_exception_handling(client)
       begin
         yield
-      rescue SignalException => sig
-        raise sig
-      rescue Exception => e
-        msg = [e.class, e.message.gsub("\n", " ")].join(": ")
-        client.err_writeln(msg.lines.first.strip)
+      rescue ScriptError, StandardError => e
+        msg = [e.class, e.message].join(": ")
+        client.err_writeln(msg)
+      end
+    end
+    private_class_method :__with_exception_handling
+
+    def self.__with_std_streams(client)
+      old_stdout = $stdout.dup
+      old_stderr = $stderr.dup
+
+      $stdout, $stderr = StringIO.new, StringIO.new
+
+      begin
+        yield
+
+        client.out_write($stdout.string + $/) if $stdout.length > 0
+        client.err_writeln($stderr.string) if $stderr.length > 0
+      ensure
+        $stdout = old_stdout
+        $stderr = old_stderr
       end
     end
+    private_class_method :__with_std_streams
 
     def self.__update_lines_in_chunks(buffer, start, stop, size)
       (start..stop).each_slice(size) do |linenos|

data/lib/neovim/session.rb

@@ -8,28 +8,29 @@ module Neovim
   class Session
     include Logging
 
+    attr_writer :request_id
+
     def initialize(event_loop)
       @event_loop = event_loop
-      @pending_messages = []
       @main_thread = Thread.current
       @main_fiber = Fiber.current
+      @response_handlers = Hash.new(-> {})
+      @pending_messages = []
+      @request_id = 0
     end
 
-    # Run the event loop, handling messages in a +Fiber+.
-    def run
+    def run(&block)
       @running = true
 
-      while pending = @pending_messages.shift
-        Fiber.new { yield pending if block_given? }.resume
+      while message = @pending_messages.shift
+        Fiber.new { message.received(@response_handlers, &block) }.resume
       end
 
       return unless @running
 
       @event_loop.run do |message|
-        Fiber.new { yield message if block_given? }.resume
+        Fiber.new { message.received(@response_handlers, &block) }.resume
       end
-    ensure
-      @event_loop.shutdown
     end
 
     # Make an RPC request and return its response.
@@ -44,13 +45,21 @@ module Neovim
     # in the meantime are enqueued to be handled later.
     def request(method, *args)
       main_thread_only do
-        if Fiber.current == @main_fiber
-          response = blocking_request(method, *args)
-        else
-          response = yielding_request(method, *args)
+        @request_id += 1
+        blocking = Fiber.current == @main_fiber
+
+        log(:debug) do
+          {
+            method_name: method,
+            request_id: @request_id,
+            blocking: blocking,
+            arguments: args
+          }
         end
 
-        response.value!
+        @event_loop.request(@request_id, method, *args)
+        response = blocking ? blocking_response : yielding_response
+        response.error ? raise(response.error) : response.value
       end
     end
 
@@ -58,7 +67,6 @@ module Neovim
       @event_loop.respond(request_id, value, error)
     end
 
-    # Make an RPC notification. +nvim+ will not block waiting for a response.
     def notify(method, *args)
       @event_loop.notify(method, *args)
     end
@@ -75,43 +83,28 @@ module Neovim
 
     private
 
-    def yielding_request(method, *args)
-      log(:debug) do
-        {
-          :method_name => method,
-          :arguments => args,
-        }
-      end
-
-      fiber = Fiber.current
-      @event_loop.request(method, *args) do |response|
-        fiber.resume(response)
-      end
-      Fiber.yield
-    end
-
-    def blocking_request(method, *args)
-      log(:debug) do
-        {
-          :method_name => method,
-          :arguments => args,
-        }
-      end
-
+    def blocking_response
       response = nil
 
-      @event_loop.request(method, *args) do |res|
+      @response_handlers[@request_id] = -> (res) {
         response = res
         stop
-      end
-
-      @event_loop.run do |message|
-        @pending_messages << message
-      end
+      }
 
+      run { |message| @pending_messages << message }
       response
     end
 
+    def yielding_response
+      fiber = Fiber.current
+
+      @response_handlers[@request_id] = -> (response) {
+        fiber.resume(response)
+      }
+
+      Fiber.yield
+    end
+
     def main_thread_only
       if Thread.current == @main_thread
         yield if block_given?