neovim 0.3.0 → 0.3.1

data/lib/neovim/host.rb

@@ -1,4 +1,4 @@
-require "neovim/logging"
+require "neovim"
 require "neovim/host/loader"
 
 module Neovim
@@ -8,14 +8,16 @@ module Neovim
 
     attr_reader :handlers, :specs
 
-    # Initialize and populate a +Host+ from a list of plugin paths.
-    def self.load_from_files(rplugin_paths, options={})
+    # 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) }
 
       new(session, client).tap do |host|
         Loader.new(host).load(rplugin_paths)
-      end
+      end.run
     end
 
     def initialize(session, client)

data/lib/neovim/host/loader.rb

@@ -1,3 +1,5 @@
+require "neovim/plugin"
+
 module Neovim
   class Host
     # @api private

data/lib/neovim/line_range.rb

@@ -55,7 +55,7 @@ module Neovim
           LineRange.new(
             @buffer,
             abs_line(pos),
-            abs_line(pos + len -1)
+            abs_line(pos + len - 1)
           )
         else
           @buffer.get_line(abs_line(pos))

data/lib/neovim/logging.rb

@@ -2,6 +2,7 @@ require "logger"
 
 module Neovim
   # Mixed into classes for unified logging helper methods.
+  #
   # @api private
   module Logging
     class << self
@@ -9,22 +10,22 @@ module Neovim
     end
 
     # Return the value of @logger, or construct it from the environment.
-    # $NVIM_RUBY_LOG_FILE specifies a file to log to (default +STDOUT+), while
+    # $NVIM_RUBY_LOG_FILE specifies a file to log to (default +STDERR+), while
     # NVIM_RUBY_LOG_LEVEL specifies the level (default +WARN+)
-    def self.logger
+    def self.logger(env=ENV)
       return @logger if instance_variable_defined?(:@logger)
 
-      if env_file = ENV["NVIM_RUBY_LOG_FILE"]
+      if env_file = env["NVIM_RUBY_LOG_FILE"]
         @logger = Logger.new(env_file)
       else
         @logger = Logger.new(STDERR)
       end
 
-      if env_level = ENV["NVIM_RUBY_LOG_LEVEL"]
-        if Logger.const_defined?(env_level.upcase)
-          @logger.level = Logger.const_get(env_level.upcase)
-        else
+      if env_level = env["NVIM_RUBY_LOG_LEVEL"]
+        begin
           @logger.level = Integer(env_level)
+        rescue ArgumentError
+          @logger.level = Logger.const_get(env_level.upcase)
         end
       else
         @logger.level = Logger::WARN

data/lib/neovim/plugin/dsl.rb

@@ -42,7 +42,7 @@ module Neovim
       # @param options [Hash] Function options.
       # @param &block [Proc, nil] The body of the function.
       #
-      # @option options [String, Boolean] :range The range argument. 
+      # @option options [String, Boolean] :range The range argument.
       #   See +:h command-range+.
       # @option options [String] :eval An +nvim+ expression. Gets evaluated and
       #   passed as an argument to the block.

data/lib/neovim/ruby_provider.rb

@@ -9,6 +9,8 @@ module Neovim
   #
   # @api private
   module RubyProvider
+    @__buffer_cache = {}
+
     def self.__define_plugin!
       Thread.abort_on_exception = true
 
@@ -19,7 +21,7 @@ module Neovim
       end
     end
 
-    # Evaluate the provided Ruby code, exposing the +VIM+ constant for
+    # Evaluate the provided Ruby code, exposing the +Vim+ constant for
     # interactions with the editor.
     #
     # This is used by the +:ruby+ command.
@@ -32,7 +34,7 @@ module Neovim
     end
     private_class_method :__define_ruby_execute
 
-    # Evaluate the provided Ruby file, exposing the +VIM+ constant for
+    # Evaluate the provided Ruby file, exposing the +Vim+ constant for
     # interactions with the editor.
     #
     # This is used by the +:rubyfile+ command.
@@ -82,25 +84,20 @@ module Neovim
     private_class_method :__wrap_client
 
     def self.__with_globals(client)
-      @__buffer_cache ||= {}
-      @__window_cache ||= {}
-
-      bufnr, winnr = client.evaluate("[bufnr('%'), winnr()]")
+      bufnr = client.evaluate("bufnr('%')")
 
       $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
-      end
+      $curwin = client.get_current_window
 
       yield
     end
     private_class_method :__with_globals
 
     def self.__with_vim_constant(client)
-      ::VIM.__client = client
+      ::Vim.__client = client
       yield
     end
     private_class_method :__with_vim_constant

data/lib/neovim/ruby_provider/buffer_ext.rb

@@ -3,15 +3,15 @@ require "neovim/ruby_provider/vim"
 module Neovim
   class Buffer
     def self.current
-      ::VIM.get_current_buffer
+      ::Vim.get_current_buffer
     end
 
     def self.count
-      ::VIM.get_buffers.size
+      ::Vim.get_buffers.size
     end
 
     def self.[](index)
-      ::VIM.get_buffers[index]
+      ::Vim.get_buffers[index]
     end
   end
 end

data/lib/neovim/ruby_provider/vim.rb

@@ -1,7 +1,9 @@
 require "neovim/buffer"
 require "neovim/window"
 
-module VIM
+# The VIM module provides backwards compatibility for the legacy +:ruby+,
+# +:rubyfile+, and +:rubydo+ +vim+ functions.
+module Vim
   Buffer = ::Neovim::Buffer
   Window = ::Neovim::Window
 
@@ -9,7 +11,10 @@ module VIM
     @__client = client
   end
 
+  # Delegate all method calls to the underlying +Neovim::Client+ object.
   def self.method_missing(method, *args, &block)
     @__client.public_send(method, *args, &block)
   end
 end
+
+VIM = Vim

data/lib/neovim/ruby_provider/window_ext.rb

@@ -3,15 +3,15 @@ require "neovim/ruby_provider/vim"
 module Neovim
   class Window
     def self.current
-      ::VIM.get_current_window
+      ::Vim.get_current_window
     end
 
     def self.count
-      ::VIM.get_windows.size
+      ::Vim.get_current_tabpage.get_windows.size
     end
 
     def self.[](index)
-      ::VIM.get_windows[index]
+      ::Vim.get_current_tabpage.get_windows[index]
     end
   end
 end

data/lib/neovim/session.rb

@@ -66,8 +66,8 @@ module Neovim
     def run
       @running = true
 
-      while message = @pending_messages.shift
-        Fiber.new { yield message if block_given? }.resume
+      while pending = @pending_messages.shift
+        Fiber.new { yield pending if block_given? }.resume
       end
 
       return unless @running

data/lib/neovim/session/api.rb

@@ -45,7 +45,13 @@ module Neovim
         "#<#{self.class}:0x%x @types={...} @functions={...}>" % (object_id << 1)
       end
 
-      class Function < Struct.new(:name, :async)
+      class Function
+        attr_reader :name, :async
+
+        def initialize(name, async)
+          @name, @async = name, async
+        end
+
         # 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)

data/lib/neovim/session/event_loop.rb

@@ -9,8 +9,6 @@ module Neovim
     class EventLoop
       include Logging
 
-      private_class_method :new
-
       # Connect to a TCP socket.
       def self.tcp(host, port)
         socket = TCPSocket.new(host, port)
@@ -24,8 +22,10 @@ module Neovim
       end
 
       # Spawn and connect to a child +nvim+ process.
-      def self.child(argv)
-        io = IO.popen(argv | ["--embed"], "rb+").tap do |_io|
+      def self.child(_argv)
+        argv = _argv.include?("--embed") ? _argv : _argv + ["--embed"]
+
+        io = IO.popen(argv, "rb+").tap do |_io|
           Process.detach(_io.pid)
         end
 
@@ -93,14 +93,6 @@ module Neovim
             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

data/lib/neovim/session/serializer.rb

@@ -10,9 +10,9 @@ module Neovim
     class Serializer
       include Logging
 
-      def initialize(event_loop)
+      def initialize(event_loop, unpacker=nil)
         @event_loop = event_loop
-        @unpacker = MessagePack::Unpacker.new
+        @unpacker = unpacker || MessagePack::Unpacker.new
       end
 
       # Serialize an RPC message to and write it to the event loop.

data/lib/neovim/tabpage.rb

@@ -6,25 +6,31 @@ module Neovim
 # The following methods are dynamically generated.
 =begin
 @method get_windows
+  Send the +tabpage_get_windows+ RPC to +nvim+
   @return [Array<Window>]
 
 @method get_var(name)
+  Send the +tabpage_get_var+ RPC to +nvim+
   @param [String] name
   @return [Object]
 
 @method set_var(name, value)
+  Send the +tabpage_set_var+ RPC to +nvim+
   @param [String] name
   @param [Object] value
   @return [Object]
 
 @method del_var(name)
+  Send the +tabpage_del_var+ RPC to +nvim+
   @param [String] name
   @return [Object]
 
 @method get_window
+  Send the +tabpage_get_window+ RPC to +nvim+
   @return [Window]
 
 @method is_valid
+  Send the +tabpage_is_valid+ RPC to +nvim+
   @return [Boolean]
 
 =end

data/lib/neovim/version.rb

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

data/lib/neovim/window.rb

@@ -53,64 +53,82 @@ module Neovim
     # @param coords [Array(Fixnum, Fixnum)]
     # @return [Array(Fixnum, Fixnum)]
     def cursor=(coords)
-      set_cursor(coords)
+      _x, _y = coords
+      x = [_x, 1].max
+      y = [_y, 0].max + 1
+      @session.request(:vim_eval, "cursor(#{x}, #{y})")
     end
 
 # The following methods are dynamically generated.
 =begin
 @method get_buffer
+  Send the +window_get_buffer+ RPC to +nvim+
   @return [Buffer]
 
 @method get_cursor
+  Send the +window_get_cursor+ RPC to +nvim+
   @return [Array<Fixnum>]
 
 @method set_cursor(pos)
+  Send the +window_set_cursor+ RPC to +nvim+
   @param [Array<Fixnum>] pos
   @return [void]
 
 @method get_height
+  Send the +window_get_height+ RPC to +nvim+
   @return [Fixnum]
 
 @method set_height(height)
+  Send the +window_set_height+ RPC to +nvim+
   @param [Fixnum] height
   @return [void]
 
 @method get_width
+  Send the +window_get_width+ RPC to +nvim+
   @return [Fixnum]
 
 @method set_width(width)
+  Send the +window_set_width+ RPC to +nvim+
   @param [Fixnum] width
   @return [void]
 
 @method get_var(name)
+  Send the +window_get_var+ RPC to +nvim+
   @param [String] name
   @return [Object]
 
 @method set_var(name, value)
+  Send the +window_set_var+ RPC to +nvim+
   @param [String] name
   @param [Object] value
   @return [Object]
 
 @method del_var(name)
+  Send the +window_del_var+ RPC to +nvim+
   @param [String] name
   @return [Object]
 
 @method get_option(name)
+  Send the +window_get_option+ RPC to +nvim+
   @param [String] name
   @return [Object]
 
 @method set_option(name, value)
+  Send the +window_set_option+ RPC to +nvim+
   @param [String] name
   @param [Object] value
   @return [void]
 
 @method get_position
+  Send the +window_get_position+ RPC to +nvim+
   @return [Array<Fixnum>]
 
 @method get_tabpage
+  Send the +window_get_tabpage+ RPC to +nvim+
   @return [Tabpage]
 
 @method is_valid
+  Send the +window_is_valid+ RPC to +nvim+
   @return [Boolean]
 
 =end

data/script/generate_docs

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require "neovim"
+require "pathname"
+
+vim_docs = []
+buffer_docs = []
+window_docs = []
+tabpage_docs = []
+session = Neovim::Session.child(%w(nvim -u NONE -n))
+vim_defs = Neovim::Client.instance_methods(false)
+buffer_defs = Neovim::Buffer.instance_methods(false)
+tabpage_defs = Neovim::Tabpage.instance_methods(false)
+window_defs = Neovim::Window.instance_methods(false)
+
+session.request(:vim_get_api_info)[1]["functions"].each do |func|
+  prefix, method_name = func["name"].split("_", 2)
+
+  case prefix
+  when "vim"
+    next if vim_defs.include?(method_name.to_sym)
+  when "buffer"
+    next if buffer_defs.include?(method_name.to_sym)
+  when "tabpage"
+    next if tabpage_defs.include?(method_name.to_sym)
+  when "window"
+    next if window_defs.include?(method_name.to_sym)
+  end
+
+  return_type = func["return_type"]
+  params = func["parameters"]
+  params.shift unless prefix == "vim"
+  param_names = params.map(&:last)
+  param_str = params.empty? ? "" : "(#{param_names.join(", ")})"
+  method_decl = "@method #{method_name}#{param_str}"
+  method_desc = "  Send the +#{prefix}_#{method_name}+ RPC to +nvim+"
+  param_docs = params.map do |type, name|
+    "  @param [#{type}] #{name}"
+  end
+  return_doc = "  @return [#{return_type}]\n"
+  method_doc = [method_decl, method_desc, *param_docs, return_doc].join("\n")
+  method_doc.gsub!(/ArrayOf\((\w+)[^)]*\)/, 'Array<\1>')
+  method_doc.gsub!(/Integer/, "Fixnum")
+
+  case prefix
+  when "vim"
+    vim_docs << method_doc
+  when "buffer"
+    buffer_docs << method_doc
+  when "tabpage"
+    tabpage_docs << method_doc
+  when "window"
+    window_docs << method_doc
+  end
+end
+
+lib_dir = Pathname.new(File.expand_path("../../lib/neovim", __FILE__))
+{
+  "client.rb" => vim_docs,
+  "buffer.rb" => buffer_docs,
+  "tabpage.rb" => tabpage_docs,
+  "window.rb" => window_docs,
+}.each do |filename, docs|
+  path = lib_dir.join(filename)
+  contents = File.read(path)
+  doc_str = ["=begin", *docs, "=end"].join("\n")
+
+  File.write(path, contents.sub(/=begin.+=end/m, doc_str))
+end