neovim 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 94299b85fc9c539d812062822342c89a47b0d829
-  data.tar.gz: 225a197bab993d300596743292de0823ee994e9a
+  metadata.gz: e51184d65bdcfaf91be38f7ed8f794d1971e2bcd
+  data.tar.gz: e5900e2d8a0849a2b7c195a701d07b4270ccf4e0
 SHA512:
-  metadata.gz: c641e29939e3f02a8e788cbf88e7b6eb4c4310a19b0825f86cebef93a33bbe62658fa48518c46c3d43a8d270eda169ec3e45355fc7becd38235189d637c18b0b
-  data.tar.gz: 83d1e66f8ff9fa729223a12a063e3b3268894d7a1d004b2bedb0c9da8e416cb7043f955f5d1bfc8c05ccf88e6a88c10567949f237c7fb3f5f127d37f74289f6f
+  metadata.gz: 908119d756874c8d76e42056e2a99e009c0dc19dde6c865e9d0cbee9e33b4b1c485d08e9bf54fbfdf374f00518461122c3fe66b5119612b56afb6383319e5a9b
+  data.tar.gz: 097c4a2565b01b6b6cb785601de2f526ec3c7b091f7fcd054b2ab87ea5d05acb27815f8abda84b665bcbc9e1ba4dde1883ed4fc88249d34cbafd2f26eab09f5a

data/.travis.yml

@@ -10,6 +10,7 @@ rvm:
   - 2.1.0
   - 2.2.0
   - 2.3.0
+  - ruby-head
 
 before_install:
   - eval "$(curl -Ss https://raw.githubusercontent.com/neovim/bot-ci/master/scripts/travis-setup.sh) nightly-x64"

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+# 0.3.0
+- Mark `Plugin::DSL#rpc` private
+- Rename Session constants:
+  - `Neovim::EventLoop` -> `Neovim::Session::EventLoop`
+  - `Neovim::MsgpackStream` -> `Neovim::Session::Serializer`
+  - `Neovim::AsyncSession` -> `Neovim::Session::RPC`
+  - `Neovim::API` -> `Neovim::Session::API`
+  - `Neovim::Request` -> `Neovim::Session::Request`
+  - `Neovim::Notification` -> `Neovim::Session::Notification`
+
 # 0.2.5
 - Optimize remote function lookup
 - Fix bug where $curbuf and $curwin weren't persisting instance state between

data/lib/neovim/current.rb

@@ -3,27 +3,32 @@ require "neovim/tabpage"
 require "neovim/window"
 
 module Neovim
-  # Support for +client.current+ chaining.
+  # Support for +Client#current+ chaining.
   #
   # @see Client#current
-  # @api private
   class Current
     def initialize(session)
       @session = session
       @range = (0..-1)
     end
 
+    # Get the line under the cursor.
+    #
     # @return [String]
     def line
       @session.request(:vim_get_current_line)
     end
 
+    # Set the line under the cursor.
+    #
     # @param line [String] The target line contents.
     # @return [String]
     def line=(line)
       @session.request(:vim_set_current_line, line)
     end
 
+    # Get the active buffer.
+    #
     # @return [Buffer]
     def buffer
       @session.request(:vim_get_current_buffer).tap do |buf|
@@ -31,34 +36,46 @@ module Neovim
       end
     end
 
+    # Set the active buffer.
+    #
     # @param buffer [Buffer, Fixnum] The target buffer or index.
     # @return [Buffer, Fixnum]
     def buffer=(buffer)
       @session.request(:vim_set_current_buffer, buffer)
     end
 
+    # Get the active window.
+    #
     # @return [Window]
     def window
       @session.request(:vim_get_current_window)
     end
 
+    # Set the active window.
+    #
     # @param window [Window, Fixnum] The target window or index.
     # @return [Window, Fixnum]
     def window=(window)
       @session.request(:vim_set_current_window, window)
     end
 
+    # Get the active tabpage.
+    #
     # @return [Tabpage]
     def tabpage
       @session.request(:vim_get_current_tabpage)
     end
 
+    # Set the active tabpage.
+    #
     # @param tabpage [Tabpage, Fixnum] The target tabpage or index.
     # @return [Tabpage, Fixnum]
     def tabpage=(tabpage)
       @session.request(:vim_set_current_tabpage, tabpage)
     end
 
+    # Set the current line range of the current buffer.
+    #
     # @param range [Range] The target range
     def range=(range)
       @range = range

data/lib/neovim/host.rb

@@ -9,10 +9,6 @@ module Neovim
     attr_reader :handlers, :specs
 
     # Initialize and populate a +Host+ from a list of plugin paths.
-    #
-    # @param rplugin_paths [Array<String>]
-    # @return [Host]
-    # @see Loader#load
     def self.load_from_files(rplugin_paths, options={})
       session = options.fetch(:session) { Session.stdio }
       client = options.fetch(:client) { Client.new(session) }
@@ -30,8 +26,6 @@ module Neovim
     end
 
     # Register a +Plugin+ to receive +Host+ messages.
-    #
-    # @param plugin [Plugin]
     def register(plugin)
       plugin.handlers.each do |handler|
         @handlers[handler.qualified_name] = wrap_plugin_handler(handler)
@@ -41,8 +35,6 @@ module Neovim
     end
 
     # Run the event loop, passing received messages to the appropriate handler.
-    #
-    # @return [void]
     def run
       @session.run { |msg| handle(msg) }
     rescue => e
@@ -52,9 +44,6 @@ module Neovim
 
     # Handle messages received from the host. Sends a +Neovim::Client+ along
     # with the message to be used in plugin callbacks.
-    #
-    # @param message [Neovim::Request, Neovim::Notification]
-    # @param client [Neovim::Client]
     def handle(message)
       debug("received #{message.inspect}")
 
@@ -102,9 +91,12 @@ module Neovim
           debug("received #{message.inspect}")
           args = message.arguments.flatten(1)
           result = handler.call(client, *args)
+
           message.respond(result) if message.sync?
         rescue => e
           warn("got unexpected error #{e.inspect}")
+          debug(e.backtrace.join("\n"))
+
           message.error(e.message) if message.sync?
         end
       end

data/lib/neovim/host/loader.rb

@@ -9,8 +9,6 @@ module Neovim
       # Load the provided Ruby files while temporarily overriding
       # +Neovim.plugin+ to expose the remote plugin DSL and register the result
       # to the host.
-      #
-      # @param paths [Array<String>]
       def load(paths)
         paths.each do |path|
           override_plugin_method(path) do

data/lib/neovim/line_range.rb

@@ -1,7 +1,5 @@
 module Neovim
   # Provide an enumerable interface for dealing with ranges of lines.
-  #
-  # @api private
   class LineRange
     include Enumerable
 
@@ -11,17 +9,23 @@ module Neovim
       @end = _end
     end
 
+    # Resolve to an array of lines as strings.
+    #
     # @return [Array<String>]
     def to_a
       @buffer.get_line_slice(@begin, @end, true, true)
     end
 
+    # Yield each line in the range.
+    #
     # @yield [String] The current line
     # @return [Array<String>]
     def each(&block)
       to_a.each(&block)
     end
 
+    # Access the line at the given index within the range.
+    #
     # @overload [](index)
     #   @param index [Fixnum]
     #
@@ -60,6 +64,8 @@ module Neovim
     end
     alias_method :slice, :[]
 
+    # Set the line at the given index within the range.
+    #
     # @overload []=(index, string)
     #   @param index [Fixnum]
     #   @param string [String]
@@ -107,18 +113,24 @@ module Neovim
       end
     end
 
+    # Replace the range of lines.
+    #
     # @param other [Array] The replacement lines
     def replace(other)
       self[0..-1] = other
       self
     end
 
+    # Insert line(s) at the given index within the range.
+    #
     # @param index [Fixnum]
     # @param lines [String]
     def insert(index, lines)
       @buffer.insert(index, Array(lines))
     end
 
+    # Delete the line at the given index within the range.
+    #
     # @param index [Fixnum]
     def delete(index)
       @buffer.del_line(abs_line(index))

data/lib/neovim/plugin.rb

@@ -7,9 +7,6 @@ module Neovim
     attr_reader :source
 
     # Entrypoint to the +Neovim.plugin+ DSL.
-    #
-    # @param source [String] The path of the plugin file.
-    # @yield [DSL] The receiver of DSL methods.
     def self.from_config_block(source)
       new(source).tap do |instance|
         yield DSL.new(instance) if block_given?
@@ -21,7 +18,7 @@ module Neovim
       @source = source
     end
 
-    # @return [Array] Handler specs used by +nvim+ to register plugins.
+    # Return specs used by +nvim+ to register plugins.
     def specs
       @handlers.inject([]) do |acc, handler|
         handler.qualified? ? acc + [handler.to_spec] : acc

data/lib/neovim/plugin/dsl.rb

@@ -66,23 +66,15 @@ module Neovim
         register_handler(:autocmd, event, options, block)
       end
 
-      # Register a top-level remote procedure call (RPC).
-      #
-      # This can be used to directly expose an RPC call without a namespace.
-      # This is used primarily for exposing legacy ruby provider calls.
-      #
-      # @option options [Boolean] :sync (false) Whether +nvim+ should receive
-      #   the return value of the block.
-      def rpc(name, options={}, &block)
-        sync = options.delete(:sync)
+      private
 
-        @plugin.handlers.push(
-          Handler.unqualified(name, sync, options, block)
-        )
+      # 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.
+      def rpc(name, &block)
+        @plugin.handlers.push(Handler.unqualified(name, block))
       end
 
-      private
-
       def register_handler(type, name, _options, block)
         if type == :autocmd
           options = _options.dup

data/lib/neovim/plugin/handler.rb

@@ -4,15 +4,8 @@ module Neovim
     class Handler
       attr_reader :block
 
-      def self.unqualified(name, sync, options, block)
-        new(
-          nil,
-          nil,
-          name,
-          sync,
-          options.merge(:qualified => false),
-          block
-        )
+      def self.unqualified(name, block)
+        new(nil, nil, name, true, {:qualified => false}, block)
       end
 
       def initialize(source, type, name, sync, options, block)

data/lib/neovim/ruby_provider.rb

@@ -5,7 +5,7 @@ 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 loaded directly.
+  # from +nvim+ and not intended to be required directly.
   #
   # @api private
   module RubyProvider
@@ -24,7 +24,7 @@ module Neovim
     #
     # This is used by the +:ruby+ command.
     def self.__define_ruby_execute(plug)
-      plug.rpc(:ruby_execute, sync: true) do |nvim, ruby|
+      plug.__send__(:rpc, :ruby_execute) do |nvim, ruby|
         __wrap_client(nvim) do
           eval(ruby, TOPLEVEL_BINDING, __FILE__, __LINE__)
         end
@@ -37,7 +37,7 @@ module Neovim
     #
     # This is used by the +:rubyfile+ command.
     def self.__define_ruby_execute_file(plug)
-      plug.rpc(:ruby_execute_file, sync: true) do |nvim, path|
+      plug.__send__(:rpc, :ruby_execute_file) do |nvim, path|
         __wrap_client(nvim) { load(path) }
       end
     end
@@ -52,7 +52,7 @@ module Neovim
     #
     # This is used by the +:rubydo+ command.
     def self.__define_ruby_do_range(__plug)
-      __plug.rpc(:ruby_do_range, sync: true) do |__nvim, *__args|
+      __plug.__send__(:rpc, :ruby_do_range) do |__nvim, *__args|
         __wrap_client(__nvim) do
           __start, __stop, __ruby = __args
           __buffer = __nvim.get_current_buffer
@@ -69,7 +69,6 @@ module Neovim
     end
     private_class_method :__define_ruby_do_range
 
-    # @api private
     def self.__wrap_client(client)
       __with_globals(client) do
         __with_vim_constant(client) do
@@ -82,34 +81,30 @@ module Neovim
     end
     private_class_method :__wrap_client
 
-    # @api private
     def self.__with_globals(client)
       @__buffer_cache ||= {}
       @__window_cache ||= {}
 
-      __bufnr = client.evaluate("bufnr('%')")
-      __winnr = client.evaluate("winnr()")
+      bufnr, winnr = client.evaluate("[bufnr('%'), winnr()]")
 
-      $curbuf = @__buffer_cache.fetch(__bufnr) do
-        @__buffer_cache[__bufnr] = client.get_current_buffer
+      $curbuf = @__buffer_cache.fetch(bufnr) do
+        @__buffer_cache[bufnr] = client.get_current_buffer
       end
 
-      $curwin = @__window_cache.fetch(__winnr) do
-        @__window_cache[__winnr] = client.get_current_window
+      $curwin = @__window_cache.fetch(winnr) do
+        @__window_cache[winnr] = client.get_current_window
       end
 
       yield
     end
     private_class_method :__with_globals
 
-    # @api private
     def self.__with_vim_constant(client)
       ::VIM.__client = client
       yield
     end
     private_class_method :__with_vim_constant
 
-    # @api private
     def self.__with_redirect_streams(client)
       @__with_redirect_streams ||= begin
         $stdout.define_singleton_method(:write) do |string|
@@ -127,7 +122,6 @@ module Neovim
     end
     private_class_method :__with_redirect_streams
 
-    # @api private
     def self.__update_lines_in_chunks(buffer, start, stop, size)
       (start..stop).each_slice(size) do |linenos|
         _start, _stop = linenos[0]-1, linenos[-1]

data/lib/neovim/session.rb

@@ -1,63 +1,47 @@
-require "neovim/api"
-require "neovim/async_session"
-require "neovim/event_loop"
 require "neovim/logging"
-require "neovim/msgpack_stream"
+require "neovim/session/api"
+require "neovim/session/event_loop"
+require "neovim/session/rpc"
+require "neovim/session/serializer"
 require "fiber"
 
 module Neovim
-  # Wraps an +AsyncSession+ in a synchronous API using +Fiber+s.
+  # Wraps a +Session::RPC+ in a synchronous API using +Fiber+s.
   #
   # @api private
   class Session
     include Logging
 
     # Connect to a TCP socket.
-    #
-    # @param host [String] The hostname or IP address
-    # @param port [Fixnum] The port
-    # @return [Session]
-    # @see EventLoop.tcp
     def self.tcp(host, port)
       from_event_loop(EventLoop.tcp(host, port))
     end
 
     # Connect to a UNIX domain socket.
-    #
-    # @param socket_path [String] The socket path
-    # @return [Session]
-    # @see EventLoop.unix
     def self.unix(socket_path)
       from_event_loop(EventLoop.unix(socket_path))
     end
 
     # Spawn and connect to a child +nvim+ process.
-    #
-    # @param argv [Array] The arguments to pass to the spawned process
-    # @return [Session]
-    # @see EventLoop.child
     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.
-    #
-    # @return [Session]
-    # @see EventLoop.stdio
     def self.stdio
       from_event_loop(EventLoop.stdio)
     end
 
     def self.from_event_loop(event_loop)
-      msgpack_stream = MsgpackStream.new(event_loop)
-      async_session = AsyncSession.new(msgpack_stream)
-      new(async_session)
+      serializer = Serializer.new(event_loop)
+      rpc = RPC.new(serializer)
+      new(rpc)
     end
     private_class_method :from_event_loop
 
-    def initialize(async_session)
-      @async_session = async_session
+    def initialize(rpc)
+      @rpc = rpc
       @pending_messages = []
       @main_thread = Thread.current
       @main_fiber = Fiber.current
@@ -66,31 +50,19 @@ module Neovim
 
     # Return the +nvim+ API as described in the +vim_get_api_info+ call.
     # Defaults to empty API information.
-    #
-    # @return [API]
-    # @see API.null
     def api
       @api ||= API.null
     end
 
     # Discover the +nvim+ API as described in the +vim_get_api_info+ call,
     # propagating it down to lower layers of the stack.
-    #
-    # @return [API]
-    # @see API
     def discover_api
       @api = API.new(request(:vim_get_api_info)).tap do |api|
-        @async_session.msgpack_stream.register_types(api, self)
+        @rpc.serializer.register_types(api, self)
       end
     end
 
     # Run the event loop, handling messages in a +Fiber+.
-    #
-    # @yield [Object]
-    # @return [void]
-    # @see AsyncSession#run
-    # @see MsgpackStream#run
-    # @see EventLoop#run
     def run
       @running = true
 
@@ -100,7 +72,7 @@ module Neovim
 
       return unless @running
 
-      @async_session.run do |message|
+      @rpc.run do |message|
         Fiber.new { yield message if block_given? }.resume
       end
     ensure
@@ -117,11 +89,6 @@ module Neovim
     # If this method is called outside a callback, write to the stream and
     # run the event loop until a response is received. Messages received
     # in the meantime are enqueued to be handled later.
-    #
-    # @param method [String, Symbol] The RPC method name
-    # @param *args [Array] The RPC method arguments
-    # @return [Object] The response from the RPC call
-    # @raise [ArgumentError] An error returned from +nvim+
     def request(method, *args)
       main_thread_only do
         if Fiber.current == @main_fiber
@@ -136,48 +103,34 @@ module Neovim
       end
     end
 
-    # Make an RPC notification.
-    #
-    # @param method [String, Symbol] The RPC method name
-    # @param *args [Array] The RPC method arguments
-    # @return [nil]
+    # Make an RPC notification. +nvim+ will not block waiting for a response.
     def notify(method, *args)
       main_thread_only do
-        @async_session.notify(method, *args)
+        @rpc.notify(method, *args)
         nil
       end
     end
 
-    # Stop the event loop.
-    #
-    # @return [void]
-    # @see EventLoop#stop
+    # Return the channel ID if registered via +vim_get_api_info+.
+    def channel_id
+      api.channel_id
+    end
+
     def stop
       @running = false
-      @async_session.stop
+      @rpc.stop
     end
 
-    # Shut down the event loop.
-    #
-    # @return [void]
-    # @see EventLoop#shutdown
     def shutdown
       @running = false
-      @async_session.shutdown
-    end
-
-    # Return the channel ID if registered via +vim_get_api_info+.
-    #
-    # @return [Fixnum, nil]
-    def channel_id
-      api.channel_id
+      @rpc.shutdown
     end
 
     private
 
     def running_request(method, *args)
       fiber = Fiber.current
-      @async_session.request(method, *args) do |err, res|
+      @rpc.request(method, *args) do |err, res|
         fiber.resume(err, res)
       end
       Fiber.yield
@@ -186,7 +139,7 @@ module Neovim
     def stopped_request(method, *args)
       error, result = nil
 
-      @async_session.request(method, *args) do |err, res|
+      @rpc.request(method, *args) do |err, res|
         error, result = err, res
         stop
       end.run do |message|