neovim 0.0.6 → 0.1.0

data/lib/neovim/logging.rb

@@ -1,5 +1,4 @@
 require "logger"
-require "stringio"
 
 module Neovim
   # Mixed into classes for unified logging helper methods.
@@ -14,14 +13,18 @@ module Neovim
     def self.logger
       return @logger if instance_variable_defined?(:@logger)
 
-      if ENV["NVIM_RUBY_LOG_FILE"]
-        @logger = Logger.new(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["NVIM_RUBY_LOG_LEVEL"]
-        @logger.level = Integer(ENV["NVIM_RUBY_LOG_LEVEL"])
+      if env_level = ENV["NVIM_RUBY_LOG_LEVEL"]
+        if Logger.const_defined?(env_level.upcase)
+          @logger.level = Logger.const_get(env_level.upcase)
+        else
+          @logger.level = Integer(env_level)
+        end
       else
         @logger.level = Logger::WARN
       end
@@ -29,26 +32,32 @@ module Neovim
       @logger
     end
 
-    private
-
-    def fatal(msg)
-      logger.fatal(self.class) { msg }
+    def self.included(base)
+      base.send(:include, Helpers)
     end
 
-    def warn(msg)
-      logger.warn(self.class) { msg }
-    end
+    module Helpers
+      private
 
-    def info(msg)
-      logger.info(self.class) { msg }
-    end
+      def fatal(msg)
+        logger.fatal(self.class) { msg }
+      end
 
-    def debug(msg)
-      logger.debug(self.class) { msg }
-    end
+      def warn(msg)
+        logger.warn(self.class) { msg }
+      end
 
-    def logger
-      Logging.logger
+      def info(msg)
+        logger.info(self.class) { msg }
+      end
+
+      def debug(msg)
+        logger.debug(self.class) { msg }
+      end
+
+      def logger
+        Logging.logger
+      end
     end
   end
 end

data/lib/neovim/manifest.rb

@@ -68,15 +68,21 @@ module Neovim
 
     def wrap_sync(handler)
       Proc.new do |client, request|
-        debug("received #{request.inspect}")
-        request.respond(handler.call(client, *request.arguments[0]))
+        begin
+          debug("received #{request.inspect}")
+          args = request.arguments.flatten(1)
+          request.respond(handler.call(client, *args))
+        rescue => e
+          request.error(e.message)
+        end
       end
     end
 
     def wrap_async(handler)
       Proc.new do |client, notification|
         debug("received #{notification.inspect}")
-        handler.call(client, *notification.arguments[0])
+        args = notification.arguments.flatten(1)
+        handler.call(client, *args)
       end
     end
   end

data/lib/neovim/plugin.rb

@@ -22,7 +22,9 @@ module Neovim
 
     # @return [Array] Handler specs used by +nvim+ to register plugins.
     def specs
-      @handlers.map(&:to_spec)
+      @handlers.inject([]) do |acc, handler|
+        handler.qualified? ? acc + [handler.to_spec] : acc
+      end
     end
   end
 end

data/lib/neovim/plugin/dsl.rb

@@ -52,6 +52,20 @@ 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)
+      def rpc(name, options={}, &block)
+        sync = options.delete(:sync)
+
+        @plugin.handlers.push(
+          Handler.unqualified(name, sync, options, block)
+        )
+      end
+
       private
 
       def register_handler(type, name, _options, block)

data/lib/neovim/plugin/handler.rb

@@ -4,16 +4,39 @@ module Neovim
     class Handler
       attr_reader :block
 
+      def self.unqualified(name, sync, options, block)
+        new(
+          nil,
+          nil,
+          name,
+          sync,
+          options.merge(:qualified => false),
+          block
+        )
+      end
+
       def initialize(source, type, name, sync, options, block)
         @source = source
-        @type = type.to_sym
+        @type = type.to_sym if type.respond_to?(:to_sym)
         @name = name.to_s
         @sync = !!sync
         @options = options
         @block = block || Proc.new {}
+        @qualified =
+          options.key?(:qualified) ? options.delete(:qualified) : true
+      end
+
+      def sync?
+        @sync
+      end
+
+      def qualified?
+        @qualified
       end
 
       def qualified_name
+        return @name unless qualified?
+
         if @type == :autocmd
           pattern = @options.fetch(:pattern, "*")
           "#{@source}:#{@type}:#{@name}:#{pattern}"
@@ -22,10 +45,6 @@ module Neovim
         end
       end
 
-      def sync?
-        @sync
-      end
-
       def to_spec
         {
           :type => @type,

data/lib/neovim/ruby_provider.rb

@@ -0,0 +1,138 @@
+class VIM < BasicObject
+  class << self
+    attr_accessor :__client
+  end
+
+  Buffer = ::Neovim::Buffer
+  Window = ::Neovim::Window
+
+  def self.method_missing(method, *args, &block)
+    @__client.public_send(method, *args, &block)
+  end
+end
+
+module Neovim
+  # Make +VIM::Buffer.current+ return the current buffer.
+  class Buffer
+    def self.current
+      ::VIM.current.buffer
+    end
+  end
+
+  # Make +VIM::Window.current+ return the current buffer.
+  class Window
+    def self.current
+      ::VIM.current.window
+    end
+  end
+
+  module RubyProvider
+    def self.define_plugin!
+      Neovim.plugin do |plug|
+        define_ruby_execute(plug)
+        define_ruby_execute_file(plug)
+        define_ruby_do_range(plug)
+      end
+    end
+
+    def self.define_ruby_execute(plug)
+      plug.rpc(:ruby_execute, sync: true) do |nvim, ruby|
+        wrap_client(nvim) do
+          eval(ruby, binding, __FILE__, __LINE__)
+        end
+      end
+    end
+    private_class_method :define_ruby_execute
+
+    def self.define_ruby_execute_file(plug)
+      plug.rpc(:ruby_execute_file, sync: true) do |nvim, path|
+        wrap_client(nvim) do
+          eval(File.read(path), binding, __FILE__, __LINE__)
+        end
+      end
+    end
+    private_class_method :define_ruby_execute_file
+
+    def self.define_ruby_do_range(plug)
+      plug.rpc(:ruby_do_range, sync: true) do |nvim, *args|
+        begin
+          start, stop, ruby = args
+          buffer = nvim.current.buffer
+
+          (start..stop).each_slice(5000) do |linenos|
+            _start, _stop = linenos[0]-1, linenos[-1]
+            lines = buffer.get_lines(_start, _stop, true)
+
+            lines.map! do |line|
+              $_ = line
+              eval(ruby, binding, __FILE__, __LINE__)
+              String($_)
+            end
+
+            buffer.set_lines(_start, _stop, true, lines)
+          end
+        ensure
+          $_ = nil
+        end
+      end
+    end
+    private_class_method :define_ruby_do_range
+
+    def self.wrap_client(client)
+      with_globals(client) do
+        with_vim_constant(client) do
+          with_redirect_streams(client) do
+            yield
+          end
+        end
+      end
+    end
+    private_class_method :wrap_client
+
+    def self.with_globals(client)
+      $curwin = client.current.window
+      $curbuf = client.current.buffer
+
+      begin
+        yield
+      ensure
+        $curwin = $curbuf = nil
+      end
+    end
+    private_class_method :with_globals
+
+    def self.with_vim_constant(client)
+      ::VIM.__client = client
+
+      begin
+        yield
+      ensure
+        ::VIM.__client = nil
+      end
+    end
+    private_class_method :with_vim_constant
+
+    def self.with_redirect_streams(client)
+      old_out_write = $stdout.method(:write)
+      old_err_write = $stderr.method(:write)
+
+      $stdout.define_singleton_method(:write) do |string|
+        client.out_write(string)
+      end
+
+      $stderr.define_singleton_method(:write) do |string|
+        client.err_write(string)
+      end
+
+      begin
+        yield
+      ensure
+        $stdout.define_singleton_method(:write, &old_out_write)
+        $stderr.define_singleton_method(:write, &old_err_write)
+      end
+    end
+    private_class_method :with_redirect_streams
+  end
+end
+
+Neovim::RubyProvider.define_plugin!

data/lib/neovim/session.rb

@@ -1,4 +1,7 @@
 require "neovim/api"
+require "neovim/async_session"
+require "neovim/event_loop"
+require "neovim/msgpack_stream"
 require "fiber"
 
 module Neovim
@@ -66,11 +69,10 @@ module Neovim
 
     # Discover the +nvim+ API as described in the +vim_get_api_info+ call.
     #
-    # @return [self]
+    # @return [API]
     # @see API
     def discover_api
       @api = API.new(request(:vim_get_api_info))
-      self
     end
 
     # Run the event loop, handling messages in a +Fiber+.
@@ -121,7 +123,7 @@ module Neovim
       err ? raise(ArgumentError, err) : res
     end
 
-    # Make an RPC notification
+    # Make an RPC notification.
     #
     # @param method [String, Symbol] The RPC method name
     # @param *args [Array] The RPC method arguments
@@ -131,7 +133,7 @@ module Neovim
       nil
     end
 
-    # Stop the event loop
+    # Stop the event loop.
     #
     # @return [void]
     # @see EventLoop#stop
@@ -140,7 +142,7 @@ module Neovim
       @async_session.stop
     end
 
-    # Shut down the event loop
+    # Shut down the event loop.
     #
     # @return [void]
     # @see EventLoop#shutdown
@@ -149,6 +151,13 @@ module Neovim
       @async_session.shutdown
     end
 
+    # Return the channel ID if registered via +vim_get_api_info+.
+    #
+    # @return [Fixnum, nil]
+    def channel_id
+      api.channel_id
+    end
+
     private
 
     def in_handler_fiber(&block)

data/lib/neovim/version.rb

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

data/lib/neovim/window.rb

@@ -10,65 +10,58 @@ module Neovim
       @cursor ||= Cursor.new(self)
     end
 
-    class Cursor
-      def initialize(window)
-        @window = window
-      end
-
-      # Get the current coordinates of the cursor.
-      #
-      # @return [Array<Fixnum>]
-      # @note coordinates are 1-indexed
-      def coordinates
-        @window.get_cursor
-      end
-
-      # Set the coordinates of the cursor.
-      #
-      # @param coords [Array<Fixnum>] The coordinates as a pair of integers
-      # @return [Array<Fixnum>]
-      # @note coordinates are 1-indexed
-      # @example Move the cursor to line 1, column 2
-      #   window.cursor.coordinates = [1, 2]
-      def coordinates=(coords)
-        @window.set_cursor(coords)
-      end
-
-      # Get the cursor's line number.
-      #
-      # @return [Fixnum]
-      # @note Line numbers are 1-indexed
-      def line
-        coordinates[0]
-      end
-
-      # Set the cursor's line number.
-      #
-      # @param n [Fixnum]
-      # @return [Fixnum]
-      # @note Line numbers are 1-indexed
-      def line=(n)
-        self.coordinates = [n, column]
-        n
-      end
-
-      # Get the cursor's column number.
-      #
-      # @return [Fixnum]
-      # @note Column numbers are 1-indexed
-      def column
-        coordinates[1]
-      end
-
-      # Set the cursor's column number.
-      #
-      # @param n [Fixnum]
-      # @return [Fixnum]
-      # @note Column numbers are 1-indexed
-      def column=(n)
-        self.coordinates = [line, n]
-        n
-      end
+    # Get the buffer displayed in the window
+    #
+    # @return [Buffer]
+    def buffer
+      get_buffer
+    end
+
+    # Get the height of the window
+    #
+    # @return [Fixnum]
+    def height
+      get_height
+    end
+
+    # Set the height of the window
+    #
+    # @param height [Fixnum]
+    # @return [Fixnum]
+    def height=(height)
+      set_height(height)
+      height
+    end
+
+    # Get the width of the window
+    #
+    # @return [Fixnum]
+    def width
+      get_width
+    end
+
+    # Set the width of the window
+    #
+    # @param width [Fixnum]
+    # @return [Fixnum]
+    def width=(width)
+      set_width(width)
+      width
+    end
+
+    # Get the cursor coordinates
+    #
+    # @return [Array(Fixnum, Fixnum)]
+    def cursor
+      get_cursor
+    end
+
+    # Set the cursor coodinates
+    #
+    # @param coords [Array(Fixnum, Fixnum)]
+    # @return [Array(Fixnum, Fixnum)]
+    def cursor=(coords)
+      set_cursor(coords)
     end
 
 # The following methods are dynamically generated.