neovim 0.2.5 → 0.3.0

data/lib/neovim/session/api.rb

@@ -0,0 +1,61 @@
+module Neovim
+  class Session
+    # @api private
+    class API
+      attr_reader :channel_id
+
+      # Represents an unknown API. Used as a stand-in when the API hasn't been
+      # discovered yet via the +vim_get_api_info+ RPC call.
+      def self.null
+        new([nil, {"functions" => [], "types" => []}])
+      end
+
+      def initialize(payload)
+        @channel_id, @api_info = payload
+      end
+
+      # Return all functions defined by the API.
+      def functions
+        @functions ||= @api_info.fetch("functions").inject({}) do |acc, func|
+          name, async = func.values_at("name", "async")
+          acc.merge(name => Function.new(name, async))
+        end
+      end
+
+      # Return information about +nvim+ types. Used for registering MessagePack
+      # +ext+ types.
+      def types
+        @types ||= @api_info.fetch("types")
+      end
+
+      # Return a list of functions with the given name prefix.
+      def functions_with_prefix(prefix)
+        functions.inject([]) do |acc, (name, function)|
+          name =~ /\A#{prefix}/ ? acc.push(function) : acc
+        end
+      end
+
+      # Find a function with the given name.
+      def function(name)
+        functions[name.to_s]
+      end
+
+      # Truncate the output of inspect so console sessions are more pleasant.
+      def inspect
+        "#<#{self.class}:0x%x @types={...} @functions={...}>" % (object_id << 1)
+      end
+
+      class Function < Struct.new(:name, :async)
+        # Apply this function to a running RPC session. Sends either a request if
+        # +async+ is +false+ or a notification if +async+ is +true+.
+        def call(session, *args)
+          if async
+            session.notify(name, *args)
+          else
+            session.request(name, *args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neovim/session/event_loop.rb

@@ -0,0 +1,108 @@
+require "neovim/logging"
+require "socket"
+
+module Neovim
+  class Session
+    # The lowest level interface to reading from and writing to +nvim+.
+    #
+    # @api private
+    class EventLoop
+      include Logging
+
+      private_class_method :new
+
+      # Connect to a TCP socket.
+      def self.tcp(host, port)
+        socket = TCPSocket.new(host, port)
+        new(socket)
+      end
+
+      # Connect to a UNIX domain socket.
+      def self.unix(path)
+        socket = UNIXSocket.new(path)
+        new(socket)
+      end
+
+      # Spawn and connect to a child +nvim+ process.
+      def self.child(argv)
+        io = IO.popen(argv | ["--embed"], "rb+").tap do |_io|
+          Process.detach(_io.pid)
+        end
+
+        new(io)
+      end
+
+      # Connect to the current process's standard streams. This is used to
+      # promote the current process to a Ruby plugin host.
+      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)
+        start = 0
+        size = data.size
+        debug("writing #{data.inspect}")
+
+        begin
+          while start < size
+            start += @wr.write_nonblock(data[start..-1])
+          end
+          self
+        rescue IO::WaitWritable
+          IO.select(nil, [@wr], nil, 1)
+          retry
+        end
+      end
+
+      # Run the event loop, reading from the underlying +IO+ and yielding
+      # received messages to the block.
+      def run
+        @running = true
+
+        loop do
+          break unless @running
+          message = @rd.readpartial(1024 * 16)
+          debug("received #{message.inspect}")
+          yield message if block_given?
+        end
+      rescue EOFError
+        info("got EOFError")
+      rescue => e
+        fatal("got unexpected error #{e.inspect}")
+        debug(e.backtrace.join("\n"))
+      end
+
+      # Stop the event loop.
+      def stop
+        @running = false
+      end
+
+      # Stop the event loop and close underlying +IO+s.
+      def shutdown
+        stop
+
+        [@rd, @wr].each do |io|
+          begin
+            io.close
+          rescue IOError
+          end
+
+          begin
+            if pid = io.pid
+              Process.kill(:TERM, pid)
+              Process.waitpid(pid)
+            end
+          rescue IOError, Errno::ESRCH, Errno::ECHILD
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neovim/session/notification.rb

@@ -0,0 +1,19 @@
+module Neovim
+  class Session
+    # An asynchronous message from +nvim+.
+    #
+    # @api private
+    class Notification
+      attr_reader :method_name, :arguments
+
+      def initialize(method_name, args)
+        @method_name = method_name.to_s
+        @arguments = args
+      end
+
+      def sync?
+        false
+      end
+    end
+  end
+end

data/lib/neovim/session/request.rb

@@ -0,0 +1,31 @@
+module Neovim
+  class Session
+    # A synchronous message from +nvim+.
+    #
+    # @api private
+    class Request
+      attr_reader :method_name, :arguments
+
+      def initialize(method_name, args, serializer, request_id)
+        @method_name = method_name.to_s
+        @arguments = args
+        @serializer = serializer
+        @request_id = request_id
+      end
+
+      def sync?
+        true
+      end
+
+      def respond(value)
+        @serializer.write([1, @request_id, nil, value])
+        self
+      end
+
+      def error(message)
+        @serializer.write([1, @request_id, message, nil])
+        self
+      end
+    end
+  end
+end

data/lib/neovim/session/rpc.rb

@@ -0,0 +1,95 @@
+require "neovim/logging"
+require "neovim/session/request"
+require "neovim/session/notification"
+
+module Neovim
+  class Session
+    # Handles formatting RPC requests and writing them to the +Serializer+.
+    # This exposes an asynchronous API, in which responses are handled in
+    # callbacks.
+    #
+    # @api private
+    class RPC
+      include Logging
+
+      attr_reader :serializer
+
+      def initialize(serializer)
+        @serializer = serializer
+        @request_id = 0
+        @pending_requests = {}
+      end
+
+      # Send an RPC request and enqueue it's callback to be called when a
+      # response is received.
+      def request(method, *args, &response_cb)
+        reqid = @request_id
+        @request_id += 1
+
+        @serializer.write([0, reqid, method, args])
+        @pending_requests[reqid] = response_cb || Proc.new {}
+        self
+      end
+
+      # Send an RPC notification. Notifications don't receive a response
+      # from +nvim+.
+      def notify(method, *args)
+        @serializer.write([2, method, args])
+        self
+      end
+
+      # Run the event loop, yielding received RPC messages to the block. RPC
+      # requests and notifications from +nvim+ will be wrapped in +Request+
+      # and +Notification+ objects, respectively, and responses will be
+      # passed to their callbacks with optional errors.
+      def run(&callback)
+        @serializer.run do |msg|
+          debug("received #{msg.inspect}")
+          kind, *payload = msg
+
+          case kind
+          when 0
+            handle_request(payload, callback)
+          when 1
+            handle_response(payload)
+          when 2
+            handle_notification(payload, callback)
+          end
+        end
+      rescue => e
+        fatal("got unexpected error #{e.inspect}")
+        debug(e.backtrace.join("\n"))
+      end
+
+      # Stop the event loop.
+      def stop
+        @serializer.stop
+      end
+
+      # Shut down the event loop.
+      def shutdown
+        @serializer.shutdown
+      end
+
+      private
+
+      def handle_request(payload, callback)
+        callback ||= Proc.new {}
+        reqid, method, args = payload
+        callback.call(Request.new(method, args, @serializer, reqid))
+      end
+
+      def handle_response(payload)
+        reqid, (_, error), result = payload
+        callback = @pending_requests.delete(reqid) || Proc.new {}
+        callback.call(error, result)
+      end
+
+      def handle_notification(payload, callback)
+        callback ||= Proc.new {}
+        method, args = payload
+        callback.call(Notification.new(method, args))
+      end
+    end
+  end
+end

data/lib/neovim/session/serializer.rb

@@ -0,0 +1,62 @@
+require "neovim/logging"
+require "msgpack"
+
+module Neovim
+  class Session
+    # Handles serializing RPC messages to MessagePack and passing them to
+    # the event loop.
+    #
+    # @api private
+    class Serializer
+      include Logging
+
+      def initialize(event_loop)
+        @event_loop = event_loop
+        @unpacker = MessagePack::Unpacker.new
+      end
+
+      # Serialize an RPC message to and write it to the event loop.
+      def write(msg)
+        debug("writing #{msg.inspect}")
+        @event_loop.write(MessagePack.pack(msg))
+        self
+      end
+
+      # Run the event loop, yielding deserialized messages to the block.
+      def run
+        @event_loop.run do |data|
+          @unpacker.feed_each(data) do |msg|
+            debug("received #{msg.inspect}")
+            yield msg if block_given?
+          end
+        end
+      rescue => e
+        fatal("got unexpected error #{e.inspect}")
+        debug(e.backtrace.join("\n"))
+      end
+
+      # Stop the event loop.
+      def stop
+        @event_loop.stop
+      end
+
+      # Shut down the event loop.
+      def shutdown
+        @event_loop.shutdown
+      end
+
+      # Register msgpack ext types using the provided API and session
+      def register_types(api, session)
+        info("registering msgpack ext types")
+        api.types.each do |type, info|
+          klass = Neovim.const_get(type)
+          id = info.fetch("id")
+
+          @unpacker.register_type(id) do |data|
+            klass.new(MessagePack.unpack(data), session)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neovim/version.rb

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

data/neovim.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = Neovim::VERSION
   spec.authors       = ["Alex Genco"]
   spec.email         = ["alexgenco@gmail.com"]
-  spec.summary       = %q{A Ruby client for Neovim}
+  spec.summary       = "A Ruby client for Neovim"
   spec.homepage      = "https://github.com/alexgenco/neovim-ruby"
   spec.license       = "MIT"
 

data/spec/acceptance/neovim-ruby-host_spec.rb

@@ -43,10 +43,6 @@ RSpec.describe "neovim-ruby-host" do
         plug.autocmd(:BufEnter, :pattern => "*.rb") do |nvim|
           nvim.current.line = "Ruby file, eh?"
         end
-
-        plug.rpc(:TopLevelAdd, :nargs => 2, :sync => true) do |nvim, x, y|
-          x + y
-        end
       end
     RUBY
 
@@ -56,7 +52,6 @@ RSpec.describe "neovim-ruby-host" do
 
     expect(nvim.eval("rpcrequest(host, 'poll')")).to eq("ok")
     expect(nvim.eval("rpcrequest(host, '#{plugin_path}:function:SyncAdd', [1, 2])")).to eq(3)
-    expect(nvim.eval("rpcrequest(host, 'TopLevelAdd', 1, 2)")).to eq(3)
 
     expect {
       nvim.command("call rpcnotify(host, '#{plugin_path}:autocmd:BufEnter:*.rb')")

data/spec/acceptance/ruby_provider_spec.rb

@@ -56,10 +56,10 @@ RSpec.describe "ruby_provider" do
 
       expect(nvim.get_var("foo")).to be(123)
 
-      nvim.eval("rpcrequest(host, 'ruby_execute', '$curwin.instance_variable_set(:@foo, 456)')")
-      nvim.eval("rpcrequest(host, 'ruby_execute', 'VIM.command(\"let g:foo = \#{$curwin.instance_variable_get(:@foo)}\")')")
+      nvim.eval("rpcrequest(host, 'ruby_execute', '$curwin.instance_variable_set(:@bar, 456)')")
+      nvim.eval("rpcrequest(host, 'ruby_execute', 'VIM.command(\"let g:bar = \#{$curwin.instance_variable_get(:@bar)}\")')")
 
-      expect(nvim.get_var("foo")).to be(456)
+      expect(nvim.get_var("bar")).to be(456)
     end
   end
 
@@ -108,6 +108,38 @@ RSpec.describe "ruby_provider" do
       nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')")
       expect(nvim.get_var("called")).to be(2)
     end
+
+    it "persists instance state in globals" do
+      File.write(script_path, <<-RUBY)
+        def $curbuf.foo
+          @foo ||= 0
+          @foo += 1
+        end
+
+        VIM.command("let g:foo = \#{$curbuf.foo}")
+      RUBY
+
+      nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')")
+      expect(nvim.get_var("foo")).to be(1)
+
+      nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')")
+      expect(nvim.get_var("foo")).to be(2)
+
+      File.write(script_path, <<-RUBY)
+        def $curwin.bar
+          @bar ||= 0
+          @bar += 1
+        end
+
+        VIM.command("let g:bar = \#{$curwin.bar}")
+      RUBY
+
+      nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')")
+      expect(nvim.get_var("bar")).to be(1)
+
+      nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')")
+      expect(nvim.get_var("bar")).to be(2)
+    end
   end
 
   describe "ruby_do_range" do