neovim 0.5.1 → 0.6.0

data/lib/neovim/event_loop/connection.rb

@@ -0,0 +1,78 @@
+require "neovim/logging"
+require "socket"
+
+module Neovim
+  class EventLoop
+    # The lowest level interface to reading from and writing to +nvim+.
+    #
+    # @api private
+    class Connection
+      include Logging
+
+      def self.tcp(host, port)
+        socket = Socket.tcp(host, port)
+        new(socket)
+      end
+
+      def self.unix(path)
+        socket = Socket.unix(path)
+        new(socket)
+      end
+
+      def self.child(_argv)
+        argv = _argv.include?("--embed") ? _argv : _argv + ["--embed"]
+
+        io = ::IO.popen(argv, "rb+").tap do |_io|
+          Process.detach(_io.pid)
+        end
+
+        new(io)
+      end
+
+      def self.stdio
+        new(STDIN, STDOUT)
+      end
+
+      def initialize(rd, wr=rd)
+        @rd, @wr = rd, wr
+        @running = false
+      end
+
+      # Write data to the underlying +IO+. This will block until all the
+      # data has been written.
+      def write(data)
+        written = 0
+        total = data.bytesize
+        log(:debug) { {:bytes => total} }
+
+        begin
+          while written < total
+            written += @wr.write_nonblock(data[written..-1])
+          end
+        rescue ::IO::WaitWritable
+          ::IO.select(nil, [@wr], nil, 1)
+          retry
+        ensure
+          @wr.flush
+        end
+      end
+
+      def read
+        @rd.readpartial(1024 * 16).tap do |bytes|
+          log(:debug) { {:bytes => bytes.bytesize} }
+          yield bytes
+        end
+      end
+
+      # Close underlying +IO+s.
+      def close
+        [@rd, @wr].each do |io|
+          begin
+            io.close
+          rescue ::IOError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neovim/event_loop/message_builder.rb

@@ -0,0 +1,127 @@
+require "neovim/logging"
+
+module Neovim
+  class EventLoop
+    # Handles formatting RPC messages and registering response callbacks for
+    # requests.
+    #
+    # @api private
+    class MessageBuilder
+      module StructToH
+        def to_h
+          each_pair.inject({}) { |acc, (k, v)| acc.merge(k => v) }
+        end
+      end
+
+      class Request < Struct.new(:id, :method_name, :arguments)
+        include StructToH
+
+        def sync?
+          true
+        end
+
+        def to_h
+          super.merge(:type => :request)
+        end
+      end
+
+      class Notification < Struct.new(:method_name, :arguments)
+        include StructToH
+
+        def sync?
+          false
+        end
+
+        def to_h
+          super.merge(:type => :notification)
+        end
+      end
+
+      class Response < Struct.new(:request_id, :value, :error)
+        include StructToH
+
+        def value!
+          error ? raise(error) : value
+        end
+
+        def to_h
+          super.merge(:type => :response)
+        end
+      end
+
+      include Logging
+
+      def initialize
+        @request_id = 0
+        @pending_requests = {}
+      end
+
+      def write(type, *write_args)
+        case type
+        when :request
+          method, args, response_handler = write_args
+
+          @request_id += 1
+          @pending_requests[@request_id] = response_handler
+
+          log(:debug) do
+            {
+              :type => type,
+              :request_id => @request_id,
+              :method_name => method,
+              :arguments => args,
+            }
+          end
+
+          yield [0, @request_id, method, args]
+        when :response
+          reqid, value, error = write_args
+
+          log(:debug) do
+            {
+              :type => type,
+              :request_id => reqid,
+              :value => value,
+              :error => error,
+            }
+          end
+
+          yield [1, reqid, error, value]
+        when :notification
+          method, args = write_args
+
+          log(:debug) do
+            {
+              :type => type,
+              :method_name => method,
+              :arguments => args,
+            }
+          end
+
+          yield [2, method, args]
+        else
+          raise "Unknown RPC message type #{type}"
+        end
+      end
+
+      def read((kind, *payload))
+        case kind
+        when 0
+          message = Request.new(*payload)
+          log(:debug) { message.to_h }
+          yield message
+        when 2
+          message = Notification.new(*payload)
+          log(:debug) { message.to_h }
+          yield message
+        when 1
+          reqid, (_, error), result = payload
+          handler = @pending_requests.delete(reqid) || Proc.new {}
+          message = Response.new(reqid, result, error)
+          log(:debug) { message.to_h }
+          handler.call(message)
+        end
+      end
+    end
+  end
+end

data/lib/neovim/event_loop/serializer.rb

@@ -0,0 +1,37 @@
+require "neovim/logging"
+require "msgpack"
+
+module Neovim
+  class EventLoop
+    # Handles serializing RPC messages to and from MessagePack
+    #
+    # @api private
+    class Serializer
+      include Logging
+
+      def initialize(unpacker = MessagePack::Unpacker.new)
+        @unpacker = unpacker
+      end
+
+      # Serialize an RPC message
+      def write(obj)
+        log(:debug) { {:object => obj} }
+        yield MessagePack.pack(obj)
+      end
+
+      def read(bytes)
+        @unpacker.feed_each(bytes) do |obj|
+          log(:debug) { {:object => obj} }
+          yield obj
+        end
+      end
+
+      def register_type(id, &block)
+        @unpacker.register_type(id) do |data|
+          index = MessagePack.unpack(data)
+          block.call(index)
+        end
+      end
+    end
+  end
+end

data/lib/neovim/host.rb

@@ -1,4 +1,6 @@
 require "neovim"
+require "neovim/client"
+require "neovim/event_loop"
 require "neovim/host/loader"
 
 module Neovim
@@ -6,23 +8,20 @@ module Neovim
   class Host
     include Logging
 
-    attr_reader :handlers, :specs
-
     # 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, options={})
-      session = options.fetch(:session) { Session.stdio }
-      client = options.fetch(:client) { Client.new(session) }
+    def self.run(rplugin_paths, event_loop=EventLoop.stdio)
+      client = Client.from_event_loop(event_loop)
 
-      new(session, client).tap do |host|
+      new(client).tap do |host|
         Loader.new(host).load(rplugin_paths)
       end.run
     end
 
-    def initialize(session, client)
-      @session = session
+    def initialize(client)
       @client = client
+      @session = client.session
       @handlers = {"poll" => poll_handler, "specs" => specs_handler}
       @specs = {}
     end
@@ -40,67 +39,68 @@ module Neovim
     # Run the event loop, passing received messages to the appropriate handler.
     def run
       @session.run { |msg| handle(msg) }
-    rescue => e
-      fatal("got unexpected error #{e.inspect}")
-      debug(e.backtrace.join("\n"))
+    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)
-      debug("received #{message.inspect}")
+      log(:debug) { message.to_h }
 
       @handlers.
         fetch(message.method_name, default_handler).
         call(@client, message)
-    rescue => e
-      fatal("got unexpected error #{e.inspect}")
-      debug(e.backtrace.join("\n"))
+    rescue SignalException => ex
+      log_exception(:debug, ex, __method__)
+      raise ex
+    rescue => ex
+      log_exception(:fatal, ex, __method__)
     end
 
     private
 
     def poll_handler
       @poll_handler ||= Proc.new do |_, req|
-        debug("received 'poll' request #{req.inspect}")
-        req.respond("ok")
+        @session.respond(req.id, "ok")
       end
     end
 
     def specs_handler
       @specs_handler ||= Proc.new do |_, req|
-        debug("received 'specs' request #{req.inspect}")
         source = req.arguments.fetch(0)
 
         if @specs.key?(source)
-          req.respond(@specs.fetch(source))
+          @session.respond(req.id, @specs.fetch(source))
         else
-          req.error("Unknown plugin #{source}")
+          @session.respond(req.id, nil, "Unknown plugin #{source}")
         end
       end
     end
 
     def default_handler
       @default_handler ||= Proc.new do |_, message|
-        if message.sync?
-          message.error("Unknown request #{message.method_name}")
-        end
+        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
-          debug("received #{message.inspect}")
           args = message.arguments.flatten(1)
           result = handler.call(client, *args)
 
-          message.respond(result) if message.sync?
+          @session.respond(message.id, result) if message.sync?
         rescue => e
-          warn("got unexpected error #{e.inspect}")
-          debug(e.backtrace.join("\n"))
+          log_exception(:error, e, __method__)
 
-          message.error(e.message) if message.sync?
+          if message.sync?
+            @session.respond(message.id, nil, e.message)
+          else
+            client.err_writeln("#{handler.qualified_name}: (#{e.class}) #{e.message}")
+          end
         end
       end
     end

data/lib/neovim/logging.rb

@@ -1,17 +1,16 @@
 require "logger"
+require "json"
 
 module Neovim
   # Mixed into classes for unified logging helper methods.
   #
   # @api private
   module Logging
-    class << self
-      attr_writer :logger
-    end
+    TIMESTAMP_FORMAT = "%Y-%m-%dT%H:%M:%S.%6N".freeze
 
     # Return the value of @logger, or construct it from the environment.
     # $NVIM_RUBY_LOG_FILE specifies a file to log to (default +STDERR+), while
-    # NVIM_RUBY_LOG_LEVEL specifies the level (default +WARN+)
+    # $NVIM_RUBY_LOG_LEVEL specifies the level (default +WARN+)
     def self.logger(env=ENV)
       return @logger if instance_variable_defined?(:@logger)
 
@@ -31,34 +30,57 @@ module Neovim
         @logger.level = Logger::WARN
       end
 
+      @logger.formatter = json_formatter
       @logger
     end
 
+    def self.logger=(logger)
+      logger.formatter = json_formatter
+      @logger = logger
+    end
+
     def self.included(base)
       base.send(:include, Helpers)
     end
 
-    module Helpers
-      private
-
-      def fatal(msg)
-        logger.fatal(self.class) { msg }
+    def self.json_formatter
+      Proc.new do |level, time, _, fields|
+        JSON.generate(
+          {
+            :_level => level,
+            :_time => time.strftime(TIMESTAMP_FORMAT)
+          }.merge!(fields)
+        ) << "\n"
       end
+    end
+    private_class_method :json_formatter
 
-      def warn(msg)
-        logger.warn(self.class) { msg }
-      end
+    module Helpers
+      private
 
-      def info(msg)
-        logger.info(self.class) { msg }
+      def log(level, _method=nil, &block)
+        begin
+          Logging.logger.public_send(level) do
+            {
+              :_class => self.class,
+              :_method => _method || block.binding.eval("__method__"),
+            }.merge!(block.call)
+          end
+        rescue => ex
+          Logging.logger.error("failed to log: #{ex.inspect}")
+        end
+      rescue
+        # Inability to log shouldn't abort process
       end
 
-      def debug(msg)
-        logger.debug(self.class) { msg }
-      end
+      def log_exception(level, ex, _method)
+        log(level, _method) do
+          {:exception => ex.class, :message => ex.message}
+        end
 
-      def logger
-        Logging.logger
+        log(:debug, _method) do
+          {:exception => ex.class, :message => ex.message, :backtrace => ex.backtrace}
+        end
       end
     end
   end