neovim 0.5.1 → 0.6.0

data/lib/neovim/plugin/dsl.rb

@@ -26,8 +26,8 @@ module Neovim
       #   modifier. See +:h command-bang+.
       # @option options [Boolean] :register Whether the command can accept a
       #   register name. See +:h command-register+.
-      # @option options [Boolean] :complete Set the completion attributes of
-      #   the command. See +:h command-completion+.
+      # @option options [String] :complete Set the completion attributes of the
+      #   command. See +:h command-completion+.
       # @option options [String] :eval An +nvim+ expression. Gets evaluated and
       #   passed as an argument to the block.
       # @option options [Boolean] :sync (false) Whether +nvim+ should receive
@@ -71,16 +71,16 @@ module Neovim
       # Register a setup block to run once before the host starts. The block
       # should expect to receive a single argument, a +Neovim::Client+.
       #
-      # This is used for bootstrapping the legacy ruby provider, and not meant
-      # to be used publicly in plugin definitions.
+      # This is used for bootstrapping the ruby provider, and not meant to be
+      # used publicly in plugin definitions.
       def setup(&block)
         @plugin.setup_blocks << block
       end
 
       # Directly define a synchronous RPC call without a namespace.
       #
-      # This is used for exposing legacy ruby provider calls, and not meant to
-      # be used publicly in plugin definitions.
+      # This is used for exposing ruby provider calls, and not meant to be used
+      # publicly in plugin definitions.
       def rpc(name, &block)
         @plugin.handlers.push(Handler.unqualified(name, block))
       end

data/lib/neovim/remote_object.rb

@@ -7,10 +7,10 @@ module Neovim
   class RemoteObject
     attr_reader :index
 
-    def initialize(index, session)
+    def initialize(index, session, api)
       @index = index
       @session = session
-      @api = session.api
+      @api = api
     end
 
     # Serialize object to MessagePack.

data/lib/neovim/ruby_provider.rb

@@ -4,8 +4,8 @@ require "neovim/ruby_provider/window_ext"
 
 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 required directly.
+  # +:ruby+, +:rubyfile+, and +:rubydo+ Vim commands. It is autoloaded from
+  # +nvim+ and not intended to be required directly.
   #
   # @api private
   module RubyProvider
@@ -28,7 +28,7 @@ module Neovim
     def self.__define_setup(plug)
       plug.__send__(:setup) do |client|
         $stdout.define_singleton_method(:write) do |string|
-          client.out_write(string)
+          client.out_write(string + "\n")
         end
 
         $stderr.define_singleton_method(:write) do |string|
@@ -36,7 +36,7 @@ module Neovim
         end
 
         begin
-          cid = client.channel_id
+          cid = client.api.channel_id
           client.command("au DirChanged * call rpcrequest(#{cid}, 'ruby_chdir', v:event)")
         rescue ArgumentError
           # Swallow this exception for now. This means the nvim installation is
@@ -116,8 +116,10 @@ module Neovim
     def self.__with_exception_handling(client)
       begin
         yield
-      rescue SyntaxError, LoadError, StandardError => e
-        msg = [e.class, e.message].join(": ")
+      rescue SignalException => sig
+        raise sig
+      rescue Exception => e
+        msg = [e.class, e.message.gsub("\n", " ")].join(": ")
         client.err_writeln(msg.lines.first.strip)
       end
     end

data/lib/neovim/ruby_provider/vim.rb

@@ -1,8 +1,8 @@
 require "neovim/buffer"
 require "neovim/window"
 
-# The VIM module provides backwards compatibility for the legacy +:ruby+,
-# +:rubyfile+, and +:rubydo+ +vim+ functions.
+# The VIM module provides backwards compatibility for the +:ruby+, +:rubyfile+,
+# and +:rubydo+ +vim+ functions.
 module Vim
   Buffer = ::Neovim::Buffer
   Window = ::Neovim::Window

data/lib/neovim/session.rb

@@ -1,65 +1,18 @@
 require "neovim/logging"
-require "neovim/session/api"
-require "neovim/session/event_loop"
-require "neovim/session/rpc"
-require "neovim/session/serializer"
 require "fiber"
 
 module Neovim
-  # Wraps a +Session::RPC+ in a synchronous API using +Fiber+s.
+  # Wraps an event loop in a synchronous API using +Fiber+s.
   #
   # @api private
   class Session
     include Logging
 
-    # Connect to a TCP socket.
-    def self.tcp(host, port)
-      from_event_loop(EventLoop.tcp(host, port))
-    end
-
-    # Connect to a UNIX domain socket.
-    def self.unix(socket_path)
-      from_event_loop(EventLoop.unix(socket_path))
-    end
-
-    # Spawn and connect to a child +nvim+ process.
-    def self.child(argv)
-      from_event_loop(EventLoop.child(argv))
-    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
-      from_event_loop(EventLoop.stdio)
-    end
-
-    def self.from_event_loop(event_loop)
-      serializer = Serializer.new(event_loop)
-      rpc = RPC.new(serializer)
-      new(rpc)
-    end
-    private_class_method :from_event_loop
-
-    def initialize(rpc)
-      @rpc = rpc
+    def initialize(event_loop)
+      @event_loop = event_loop
       @pending_messages = []
       @main_thread = Thread.current
       @main_fiber = Fiber.current
-      @running = false
-    end
-
-    # Return the +nvim+ API as described in the +nvim_get_api_info+ call.
-    # Defaults to empty API information.
-    def api
-      @api ||= API.null
-    end
-
-    # Discover the +nvim+ API as described in the +nvim_get_api_info+ call,
-    # propagating it down to lower layers of the stack.
-    def discover_api
-      @api = API.new(request(:nvim_get_api_info)).tap do |api|
-        @rpc.serializer.register_types(api, self)
-      end
     end
 
     # Run the event loop, handling messages in a +Fiber+.
@@ -72,11 +25,11 @@ module Neovim
 
       return unless @running
 
-      @rpc.run do |message|
+      @event_loop.run do |message|
         Fiber.new { yield message if block_given? }.resume
       end
     ensure
-      shutdown
+      @event_loop.shutdown
     end
 
     # Make an RPC request and return its response.
@@ -92,61 +45,71 @@ module Neovim
     def request(method, *args)
       main_thread_only do
         if Fiber.current == @main_fiber
-          debug("handling blocking request")
-          err, res = stopped_request(method, *args)
+          response = blocking_request(method, *args)
         else
-          debug("yielding request to fiber")
-          err, res = running_request(method, *args)
+          response = yielding_request(method, *args)
         end
 
-        err ? raise(ArgumentError, err) : res
+        response.value!
       end
     end
 
-    # Make an RPC notification. +nvim+ will not block waiting for a response.
-    def notify(method, *args)
-      main_thread_only do
-        @rpc.notify(method, *args)
-        nil
-      end
+    def respond(request_id, value, error=nil)
+      @event_loop.respond(request_id, value, error)
     end
 
-    # Return the channel ID if registered via +nvim_get_api_info+.
-    def channel_id
-      api.channel_id
+    # Make an RPC notification. +nvim+ will not block waiting for a response.
+    def notify(method, *args)
+      @event_loop.notify(method, *args)
     end
 
-    def stop
+    def shutdown
       @running = false
-      @rpc.stop
+      @event_loop.shutdown
     end
 
-    def shutdown
+    def stop
       @running = false
-      @rpc.shutdown
+      @event_loop.stop
     end
 
     private
 
-    def running_request(method, *args)
+    def yielding_request(method, *args)
+      log(:debug) do
+        {
+          :method_name => method,
+          :arguments => args,
+        }
+      end
+
       fiber = Fiber.current
-      @rpc.request(method, *args) do |err, res|
-        fiber.resume(err, res)
+      @event_loop.request(method, *args) do |response|
+        fiber.resume(response)
       end
       Fiber.yield
     end
 
-    def stopped_request(method, *args)
-      error, result = nil
+    def blocking_request(method, *args)
+      log(:debug) do
+        {
+          :method_name => method,
+          :arguments => args,
+        }
+      end
+
+      response = nil
 
-      @rpc.request(method, *args) do |err, res|
-        error, result = err, res
+      @event_loop.request(method, *args) do |res|
+        response = res
         stop
-      end.run do |message|
+      end
+
+      @event_loop.run do |message|
         @pending_messages << message
       end
 
-      [error, result]
+      response
     end
 
     def main_thread_only

data/lib/neovim/tabpage.rb

@@ -3,7 +3,7 @@ require "neovim/remote_object"
 module Neovim
   # Class representing an +nvim+ tabpage.
   #
-  # The methods documented here were generated using NVIM v0.2.0
+  # The methods documented here were generated using NVIM v0.2.1
   class Tabpage < RemoteObject
 # The following methods are dynamically generated.
 =begin

data/lib/neovim/version.rb

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

data/lib/neovim/window.rb

@@ -3,7 +3,7 @@ require "neovim/remote_object"
 module Neovim
   # Class representing an +nvim+ window.
   #
-  # The methods documented here were generated using NVIM v0.2.0
+  # The methods documented here were generated using NVIM v0.2.1
   class Window < RemoteObject
     # Get the buffer displayed in the window
     #

data/script/dump_api

@@ -3,8 +3,10 @@
 $:.unshift File.expand_path("../../lib", __FILE__)
 
 require "neovim"
+require "json"
 require "pp"
 
 nvim_exe = ENV.fetch("NVIM_EXECUTABLE", "nvim")
-session = Neovim::Session.child([nvim_exe, "-u", "NONE", "-n"])
-pp session.request(:nvim_get_api_info)
+event_loop = Neovim::EventLoop.child([nvim_exe, "-u", "NONE", "-n"])
+session = Neovim::Session.new(event_loop)
+puts JSON.pretty_generate(session.request(:nvim_get_api_info))

data/script/generate_docs

@@ -12,7 +12,8 @@ tabpage_docs = []
 nvim_exe = ENV.fetch("NVIM_EXECUTABLE", "nvim")
 nvim_vrs = %x(#{nvim_exe} --version).split("\n").first
 
-session = Neovim::Session.child([nvim_exe, "-u", "NONE", "-n"])
+event_loop = Neovim::EventLoop.child([nvim_exe, "-u", "NONE", "-n"])
+session = Neovim::Session.new(event_loop)
 nvim_defs = Neovim::Client.instance_methods(false)
 buffer_defs = Neovim::Buffer.instance_methods(false)
 tabpage_defs = Neovim::Tabpage.instance_methods(false)

data/spec/{integration → acceptance}/rplugin_autocmd_spec.vim

@@ -15,4 +15,4 @@ Execute (Trigger event with eval):
   let g:to_eval = {'a': 42}
   silent split file.c
   sleep 50m
-  AssertEqual {'a': 42}, g:rplugin_autocmd_BufEnter_eval
+  AssertEqual {'a': 42, 'b': 43}, g:rplugin_autocmd_BufEnter_eval

data/spec/{integration → acceptance}/rplugin_command_spec.vim

@@ -87,11 +87,15 @@ Execute (Call rplugin commands with completion):
   AssertEqual "buffer", g:rplugin_command_completion
 
 Execute (Call rplugin commands with eval):
-  let g:to_eval = {'n': 42}
+  let g:to_eval = {'a': 42}
   RPluginCommandEval
   sleep 50m
-  AssertEqual {'n': 42}, g:rplugin_command_eval
+  AssertEqual {'a': 42, 'b': 43}, g:rplugin_command_eval
 
 Execute (Call synchronous rplugin commands):
   RPluginCommandSync
   AssertEqual v:true, g:rplugin_command_sync
+
+Execute (Call recursive rplugin commands):
+  RPluginCommandRecursive 0
+  AssertEqual "10", g:rplugin_command_recursive

data/spec/{integration → acceptance}/rplugin_function_spec.vim

@@ -17,10 +17,13 @@ Execute (Call rplugin functions with a range):
   AssertEqual [1, 2], g:rplugin_function_range
 
 Execute (Call rplugin functions with eval):
-  let g:to_eval = {'n': 42}
+  let g:to_eval = {'a': 42}
   call RPluginFunctionEval()
   sleep 50m
-  AssertEqual {'n': 42}, g:rplugin_function_eval
+  AssertEqual {'a': 42, 'b': 43}, g:rplugin_function_eval
 
 Execute (Call synchronous rplugin functions):
   AssertEqual v:true, RPluginFunctionSync()
+
+Execute (Call recursive rplugin functions):
+  AssertEqual 10, RPluginFunctionRecursive(0)

data/spec/{integration → acceptance}/ruby_spec.vim

@@ -47,6 +47,12 @@ Then:
     AssertNotEqual g:before_pwd, g:after_pwd
   endif
 
+Execute (Run nested Ruby commands):
+  ruby Vim.command("ruby Vim.command('let g:ruby_nested = 123')")
+
+Then:
+  AssertEqual 123, g:ruby_nested
+
 Execute (Raise a Ruby standard error):
   try
     ruby raise "BOOM"
@@ -72,3 +78,15 @@ Execute (Raise a Ruby syntax error):
 Expect:
   still works
   two
+
+Execute (Access Vim interface):
+  ruby expect(Vim).to eq(VIM)
+  ruby expect(Vim.strwidth("hi")).to eq(2)
+
+Execute (Access Vim::Buffer interface):
+  ruby expect($curbuf).to be_a(Neovim::Buffer)
+  ruby expect(Vim::Buffer.current).to eq($curbuf)
+
+Execute (Access Vim::Window interface):
+  ruby expect($curwin).to be_a(Neovim::Window)
+  ruby expect(Vim::Window.current).to eq($curwin)

data/spec/acceptance/rubyfile/nested.rb

@@ -0,0 +1 @@
+Vim.command("rubyfile ./rubyfile/nested_inner.rb")

data/spec/acceptance/rubyfile/nested_inner.rb

@@ -0,0 +1 @@
+Vim.command("let g:ruby_nested = 123")

data/spec/acceptance/rubyfile/ruby_interface.rb

@@ -0,0 +1,8 @@
+expect(Vim).to eq(VIM)
+expect(Vim.strwidth("hi")).to eq(2)
+
+expect($curbuf).to be_a(Neovim::Buffer)
+expect(Vim::Buffer.current).to eq($curbuf)
+
+expect($curwin).to be_a(Neovim::Window)
+expect(Vim::Window.current).to eq($curwin)

data/spec/{integration → acceptance}/rubyfile_spec.vim

@@ -53,6 +53,12 @@ Then:
     AssertNotEqual g:pwd_before, g:pwd_after
   endif
 
+Execute (Run nested Ruby files):
+  rubyfile ./rubyfile/nested.rb
+
+Then:
+  AssertEqual 123, g:ruby_nested
+
 Execute (Raise a Ruby load error):
   try
     rubyfile /foo/bar/baz
@@ -91,3 +97,6 @@ Execute (Raise a Ruby syntax error):
 Expect:
   still works
   two
+
+Execute (Access ruby interface):
+  rubyfile ./rubyfile/ruby_interface.rb