neovim 0.6.2 → 0.9.0.pre.1

data/lib/neovim/host/loader.rb

@@ -8,9 +8,6 @@ module Neovim
         @host = host
       end
 
-      # Load the provided Ruby files while temporarily overriding
-      # +Neovim.plugin+ to expose the remote plugin DSL and register the result
-      # to the host.
       def load(paths)
         paths.each do |path|
           override_plugin_method(path) do
@@ -27,7 +24,7 @@ module Neovim
 
         Neovim.define_singleton_method(:plugin) do |&block|
           plugin = Plugin.from_config_block(path, &block)
-          at_host.register(plugin)
+          at_host.plugins << plugin
         end
 
         yield

data/lib/neovim/line_range.rb

@@ -12,8 +12,8 @@ module Neovim
     # @yieldparam line [String]
     def each(&block)
       (0...@buffer.count).each_slice(5000) do |linenos|
-        _start, _stop = linenos[0], linenos[-1] + 1
-        @buffer.get_lines(_start, _stop, true).each(&block)
+        start, stop = linenos[0], linenos[-1] + 1
+        @buffer.get_lines(start, stop, true).each(&block)
       end
     end
 
@@ -50,15 +50,15 @@ module Neovim
     # @example Get the first two lines using an index and length
     #   line_range[0, 2] # => ["first", "second"]
     def [](pos, len=nil)
-      if Range === pos
+      if pos.is_a?(Range)
         @buffer.get_lines(*range_indices(pos), true)
       else
-        _begin, _end = length_indices(pos, len || 1)
-        lines = @buffer.get_lines(_begin, _end, true)
+        start, stop = length_indices(pos, len || 1)
+        lines = @buffer.get_lines(start, stop, true)
         len ? lines : lines.first
       end
     end
-    alias_method :slice, :[]
+    alias slice []
 
     # Set a line or line range.
     #
@@ -85,11 +85,11 @@ module Neovim
       *target, val = args
       pos, len = target
 
-      if Range === pos
+      if pos.is_a?(Range)
         @buffer.set_lines(*range_indices(pos), true, Array(val))
       else
-        _begin, _end = length_indices(pos, len || 1)
-        @buffer.set_lines(_begin, _end, true, Array(val))
+        start, stop = length_indices(pos, len || 1)
+        @buffer.set_lines(start, stop, true, Array(val))
       end
     end
 
@@ -113,18 +113,18 @@ module Neovim
     private
 
     def range_indices(range)
-      _begin = adjust_index(range.begin)
-      _end = adjust_index(range.end)
-      _end += 1 unless range.exclude_end?
+      start = adjust_index(range.begin)
+      stop = adjust_index(range.end)
+      stop += 1 unless range.exclude_end?
 
-      [_begin, _end]
+      [start, stop]
     end
 
     def length_indices(index, len)
-      _begin = adjust_index(index)
-      _end = _begin < 0 ? [_begin + len, -1].min : _begin + len
+      start = adjust_index(index)
+      stop = start < 0 ? [start + len, -1].min : start + len
 
-      [_begin, _end]
+      [start, stop]
     end
 
     def adjust_index(i)

data/lib/neovim/logging.rb

@@ -13,13 +13,12 @@ module Neovim
     def self.logger(env=ENV)
       return @logger if instance_variable_defined?(:@logger)
 
-      if env_file = env["NVIM_RUBY_LOG_FILE"]
-        @logger = Logger.new(env_file)
-      else
-        @logger = Logger.new(STDERR)
-      end
+      env_file, env_level =
+        env.values_at("NVIM_RUBY_LOG_FILE", "NVIM_RUBY_LOG_LEVEL")
+
+      @logger = Logger.new(env_file || STDERR)
 
-      if env_level = env["NVIM_RUBY_LOG_LEVEL"]
+      if /\S+/.match?(env_level)
         begin
           @logger.level = Integer(env_level)
         rescue ArgumentError
@@ -43,29 +42,30 @@ module Neovim
     end
 
     def self.json_formatter
-      Proc.new do |level, time, _, fields|
+      lambda do |level, time, _, fields|
         require "multi_json"
 
         MultiJson.encode(
           {
-            :_level => level,
-            :_time => time.strftime(TIMESTAMP_FORMAT)
+            _level: level,
+            _time: time.strftime(TIMESTAMP_FORMAT)
           }.merge!(fields)
         ) << "\n"
       end
     end
     private_class_method :json_formatter
 
+    # @api private
     module Helpers
       private
 
-      def log(level, _method=nil, &block)
+      def log(level, method=nil, &block)
         begin
           Logging.logger.public_send(level) do
             {
-              :_class => self.class,
-              :_method => _method || block.binding.eval("__method__"),
-            }.merge!(block.call)
+              _class: self.class,
+              _method: method || block.binding.eval("__method__")
+            }.merge!(yield)
           end
         rescue => ex
           Logging.logger.error("failed to log: #{ex.inspect}")
@@ -74,13 +74,13 @@ module Neovim
         # Inability to log shouldn't abort process
       end
 
-      def log_exception(level, ex, _method)
-        log(level, _method) do
-          {:exception => ex.class, :message => ex.message}
+      def log_exception(level, ex, method)
+        log(level, method) do
+          {exception: ex.class, message: ex.message}
         end
 
-        log(:debug, _method) do
-          {:exception => ex.class, :message => ex.message, :backtrace => ex.backtrace}
+        log(:debug, method) do
+          {exception: ex.class, message: ex.message, backtrace: ex.backtrace}
         end
       end
     end

data/lib/neovim/message.rb

@@ -0,0 +1,70 @@
+require "neovim/logging"
+
+module Neovim
+  # @api private
+  class Message
+    def self.from_array((kind, *payload))
+      case kind
+      when 0
+        request(*payload)
+      when 1
+        reqid, (_, error), value = payload
+        response(reqid, error, value)
+      when 2
+        notification(*payload)
+      else
+        raise "Unknown message type #{kind.inspect}"
+      end
+    end
+
+    def self.request(id, method, args)
+      Request.new(id, method, args)
+    end
+
+    def self.response(request_id, error, value)
+      Response.new(request_id, error, value)
+    end
+
+    def self.notification(method, args)
+      Notification.new(method, args)
+    end
+
+    Request = Struct.new(:id, :method_name, :arguments) do
+      def to_a
+        [0, id, method_name, arguments]
+      end
+
+      def received(_)
+        yield self
+      end
+
+      def sync?
+        true
+      end
+    end
+
+    Response = Struct.new(:request_id, :error, :value) do
+      def to_a
+        [1, request_id, error, value]
+      end
+
+      def received(handlers)
+        handlers.delete(request_id).call(self)
+      end
+    end
+
+    Notification = Struct.new(:method_name, :arguments) do
+      def to_a
+        [2, method_name, arguments]
+      end
+
+      def received(_)
+        yield self
+      end
+
+      def sync?
+        false
+      end
+    end
+  end
+end

data/lib/neovim/plugin.rb

@@ -3,10 +3,9 @@ require "neovim/plugin/dsl"
 module Neovim
   # @api private
   class Plugin
-    attr_accessor :handlers, :setup_blocks
+    attr_accessor :handlers, :setup_blocks, :script_host
     attr_reader :source
 
-    # Entrypoint to the +Neovim.plugin+ DSL.
     def self.from_config_block(source)
       new(source).tap do |instance|
         yield DSL.new(instance) if block_given?
@@ -14,21 +13,24 @@ module Neovim
     end
 
     def initialize(source)
-      @handlers = []
       @source = source
+      @handlers = []
       @setup_blocks = []
+      @script_host = false
     end
 
-    # Return specs used by +nvim+ to register plugins.
     def specs
       @handlers.inject([]) do |acc, handler|
         handler.qualified? ? acc + [handler.to_spec] : acc
       end
     end
 
-    # Run all registered setup blocks.
     def setup(client)
       @setup_blocks.each { |bl| bl.call(client) }
     end
+
+    def script_host?
+      !!@script_host
+    end
   end
 end

data/lib/neovim/plugin/dsl.rb

@@ -68,6 +68,12 @@ module Neovim
 
       private
 
+      # Mark this plugin as the Ruby script host started by nvim. Should only
+      # be used in +Neovim::RubyProvider+.
+      def script_host!
+        @plugin.script_host = true
+      end
+
       # Register a setup block to run once before the host starts. The block
       # should expect to receive a single argument, a +Neovim::Client+.
       #
@@ -85,14 +91,14 @@ module Neovim
         @plugin.handlers.push(Handler.unqualified(name, block))
       end
 
-      def register_handler(type, name, _options, block)
+      def register_handler(type, name, options, block)
         if type == :autocmd
-          options = _options.dup
+          options = options.dup
         else
-          options = standardize(_options.dup)
+          options = standardize(options.dup)
         end
 
-        sync = options.delete(:sync)
+        sync = !!options.delete(:sync)
 
         @plugin.handlers.push(
           Handler.new(@plugin.source, type, name, sync, options, block)

data/lib/neovim/plugin/handler.rb

@@ -5,22 +5,22 @@ module Neovim
       attr_reader :block
 
       def self.unqualified(name, block)
-        new(nil, nil, name, true, {:qualified => false}, block)
+        new(nil, nil, name, true, {qualified: false}, block)
       end
 
       def initialize(source, type, name, sync, options, block)
         @source = source
         @type = type.to_sym if type.respond_to?(:to_sym)
         @name = name.to_s
-        @sync = !!sync
+        @sync = sync
         @options = options
-        @block = block || Proc.new {}
+        @block = block || -> {}
         @qualified =
           options.key?(:qualified) ? options.delete(:qualified) : true
       end
 
       def sync?
-        @sync
+        !!@sync
       end
 
       def qualified?
@@ -40,10 +40,10 @@ module Neovim
 
       def to_spec
         {
-          :type => @type,
-          :name => @name,
-          :sync => @sync,
-          :opts => @options,
+          type: @type,
+          name: @name,
+          sync: @sync,
+          opts: @options
         }
       end
 

data/lib/neovim/remote_object.rb

@@ -1,3 +1,5 @@
+require "set"
+
 module Neovim
   # @abstract Superclass for all +nvim+ remote objects.
   #
@@ -23,21 +25,21 @@ module Neovim
 
     # Intercept method calls and delegate to appropriate RPC methods.
     def method_missing(method_name, *args)
-      if func = @api.function_for_object_method(self, method_name)
+      if (func = @api.function_for_object_method(self, method_name))
         func.call(@session, @index, *args)
       else
         super
       end
     end
 
-    # Extend +respond_to?+ to support RPC methods.
-    def respond_to?(method_name)
+    # Extend +respond_to_missing?+ to support RPC methods.
+    def respond_to_missing?(method_name, *)
       super || rpc_methods.include?(method_name.to_sym)
     end
 
     # Extend +methods+ to include RPC methods
     def methods(*args)
-      super | rpc_methods
+      super | rpc_methods.to_a
     end
 
     # Extend +==+ to only look at class and index.
@@ -48,7 +50,8 @@ module Neovim
     private
 
     def rpc_methods
-      @api.functions_for_object(self).map(&:method_name)
+      @rpc_methods ||=
+        @api.functions_for_object(self).map(&:method_name).to_set
     end
   end
 end

data/lib/neovim/ruby_provider.rb

@@ -1,6 +1,8 @@
 require "neovim/ruby_provider/vim"
+require "neovim/ruby_provider/object_ext"
 require "neovim/ruby_provider/buffer_ext"
 require "neovim/ruby_provider/window_ext"
+require "stringio"
 
 module Neovim
   # This class is used to define a +Neovim::Plugin+ to act as a backend for the
@@ -13,28 +15,20 @@ module Neovim
       Thread.abort_on_exception = true
 
       Neovim.plugin do |plug|
+        plug.__send__(:script_host!)
+
         __define_setup(plug)
         __define_ruby_execute(plug)
+        __define_ruby_eval(plug)
         __define_ruby_execute_file(plug)
         __define_ruby_do_range(plug)
         __define_ruby_chdir(plug)
       end
     end
 
-    # Bootstrap the provider client:
-    #
-    # 1. Monkeypatch +$stdout+ and +$stderr+ to write to +nvim+.
-    # 2. Define the +DirChanged+ event to update the provider's pwd.
+    # Define the +DirChanged+ event to update the provider's pwd.
     def self.__define_setup(plug)
       plug.__send__(:setup) do |client|
-        $stdout.define_singleton_method(:write) do |string|
-          client.out_write(string + "\n")
-        end
-
-        $stderr.define_singleton_method(:write) do |string|
-          client.err_writeln(string)
-        end
-
         begin
           cid = client.api.channel_id
           client.command("au DirChanged * call rpcrequest(#{cid}, 'ruby_chdir', v:event)")
@@ -52,12 +46,26 @@ module Neovim
     def self.__define_ruby_execute(plug)
       plug.__send__(:rpc, :ruby_execute) do |nvim, ruby|
         __wrap_client(nvim) do
-          eval(ruby, TOPLEVEL_BINDING, "eval")
+          eval(ruby, TOPLEVEL_BINDING, "ruby_execute")
         end
+        nil
       end
     end
     private_class_method :__define_ruby_execute
 
+    # Evaluate the provided Ruby code, exposing the +Vim+ constant for
+    # interactions with the editor and returning the value.
+    #
+    # This is used by the +:rubyeval+ command.
+    def self.__define_ruby_eval(plug)
+      plug.__send__(:rpc, :ruby_eval) do |nvim, ruby|
+        __wrap_client(nvim) do
+          eval(ruby, TOPLEVEL_BINDING, "ruby_eval")
+        end
+      end
+    end
+    private_class_method :__define_ruby_eval
+
     # Evaluate the provided Ruby file, exposing the +Vim+ constant for
     # interactions with the editor.
     #
@@ -65,6 +73,7 @@ module Neovim
     def self.__define_ruby_execute_file(plug)
       plug.__send__(:rpc, :ruby_execute_file) do |nvim, path|
         __wrap_client(nvim) { load(path) }
+        nil
       end
     end
     private_class_method :__define_ruby_execute_file
@@ -83,14 +92,15 @@ module Neovim
           __start, __stop, __ruby = __args
           __buffer = __nvim.get_current_buf
 
-          __update_lines_in_chunks(__buffer, __start, __stop, 5000) do |__lines|
+          __update_lines_in_chunks(__buffer, __start, __stop, 1_000) do |__lines|
             __lines.map do |__line|
               $_ = __line
-              eval(__ruby, binding, "eval")
+              eval(__ruby, binding, "ruby_do_range")
               $_
             end
           end
         end
+        nil
       end
     end
     private_class_method :__define_ruby_do_range
@@ -107,29 +117,45 @@ module Neovim
       Vim.__refresh_globals(client)
 
       __with_exception_handling(client) do
-        yield
+        __with_std_streams(client) do
+          yield
+        end
       end
-      nil
     end
     private_class_method :__wrap_client
 
     def self.__with_exception_handling(client)
+      yield
+    rescue ScriptError, StandardError => e
+      msg = [e.class, e.message].join(": ")
+      client.err_writeln(msg)
+    end
+    private_class_method :__with_exception_handling
+
+    def self.__with_std_streams(client)
+      old_stdout = $stdout.dup
+      old_stderr = $stderr.dup
+
+      $stdout, $stderr = StringIO.new, StringIO.new
+
       begin
-        yield
-      rescue SignalException => sig
-        raise sig
-      rescue Exception => e
-        msg = [e.class, e.message.gsub("\n", " ")].join(": ")
-        client.err_writeln(msg.lines.first.strip)
+        yield.tap do
+          client.out_write($stdout.string + $/) if $stdout.size > 0
+          client.err_writeln($stderr.string) if $stderr.size > 0
+        end
+      ensure
+        $stdout = old_stdout
+        $stderr = old_stderr
       end
     end
+    private_class_method :__with_std_streams
 
     def self.__update_lines_in_chunks(buffer, start, stop, size)
       (start..stop).each_slice(size) do |linenos|
-        _start, _stop = linenos[0]-1, linenos[-1]
-        lines = buffer.get_lines(_start, _stop, true)
+        start, stop = linenos[0] - 1, linenos[-1]
+        lines = buffer.get_lines(start, stop, false)
 
-        buffer.set_lines(_start, _stop, true, yield(lines))
+        buffer.set_lines(start, stop, false, yield(lines))
       end
     end
     private_class_method :__update_lines_in_chunks