neovim 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 39cfc5e3df7a8ab166fc8b036f9bb73dee269d39
-  data.tar.gz: 2ffff11255346e889b896afb1ec90444553c0472
+  metadata.gz: 6d788e73532acb46ec8b33b5391fb1a1077bd69d
+  data.tar.gz: 3456c2d23d5f98802b0bbb2ac29612e20a51e11c
 SHA512:
-  metadata.gz: 442348e1633ac14d7185fabb38be72f1df180893b87db118609e265e4f059b4153c1b08aec61b74b031d5a79ef8aa4e4db151316629ecf164931fdb9645ada89
-  data.tar.gz: b01ba2a5a77b93d8c59481d293602df43574b7724d0bda3fa384fa4ea2f23b2bab51a1aa8539173c2243d756990b6b831d54784d7c709756474974f3cb74d204
+  metadata.gz: fa3098403bd3e78a7b56eaf21f8810190d1cb34b17fd8365cfe424537294440b99351d67b33408e3d1f4b094cd2013f193be87b1eb66db6f4d4c6b59cb9e084a
+  data.tar.gz: 5a12541cec062aa8643decc49b580aa76c562f734d1319ce77e8284a503b2b37a6afa9eb075abbe9e2d97278a003a301ea2d51dc469bc05713f1bc121b25e3e1

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 0.0.4
+- Add support for loading Ruby remote plugins from nvim
+- Add Current#range to return a LineRange enumerable object
+- Support sending large messages
+- Remove unecessary #stop methods
+- Add setup callback support to event loop
+
 # 0.0.3
 
 - Add Buffer#lines enumerable interface

data/bin/neovim-ruby-host

@@ -1,8 +1,7 @@
 #!/usr/bin/env ruby
-
 require "neovim"
 
-if $stdin.tty?
+if STDIN.tty?
   abort("Can't run neovim-ruby-host interactively.")
 else
   Neovim.start_host(ARGV)

data/lib/neovim.rb

@@ -7,7 +7,9 @@ require "neovim/session"
 require "neovim/plugin"
 
 module Neovim
-  @__configured_plugins = []
+  class << self
+    attr_accessor :__configured_plugin_manifest, :__configured_plugin_path
+  end
 
   def self.attach_tcp(host, port)
     attach_event_loop(EventLoop.tcp(host, port))
@@ -26,22 +28,21 @@ module Neovim
   end
 
   def self.plugin(&block)
-    Plugin.from_config_block(&block).tap do |plugin|
-      @__configured_plugins << plugin
+    Plugin.from_config_block(__configured_plugin_path, &block).tap do |plugin|
+      if __configured_plugin_manifest.respond_to?(:register)
+        __configured_plugin_manifest.register(plugin)
+      end
     end
   end
 
-  class << self
-    attr_accessor :__configured_plugins
 
-    private
 
-    def attach_event_loop(event_loop)
-      msgpack_stream = MsgpackStream.new(event_loop)
-      async_session = AsyncSession.new(msgpack_stream)
-      session = Session.new(async_session)
+  def self.attach_event_loop(event_loop)
+    msgpack_stream = MsgpackStream.new(event_loop)
+    async_session = AsyncSession.new(msgpack_stream)
+    session = Session.new(async_session)
 
-      Client.new(session)
-    end
+    Client.new(session)
   end
+  private_class_method :attach_event_loop
 end

data/lib/neovim/api_info.rb

@@ -21,7 +21,7 @@ module Neovim
     end
 
     def inspect
-      "#<#{self.class}:0x%x @channel_id=#{@channel_id.inspect} @types={...} @functions={...}>" % (object_id << 1)
+      "#<#{self.class}:0x%x @types={...} @functions={...}>" % (object_id << 1)
     end
   end
 end

data/lib/neovim/async_session.rb

@@ -27,11 +27,12 @@ module Neovim
       self
     end
 
-    def run(request_cb=nil, notification_cb=nil)
+    def run(request_cb=nil, notification_cb=nil, setup_cb=nil)
       request_cb ||= Proc.new {}
       notification_cb ||= Proc.new {}
+      setup_cb ||= Proc.new {}
 
-      @msgpack_stream.run do |msg|
+      msg_cb = Proc.new do |msg|
         kind, *rest = msg
 
         case kind
@@ -46,11 +47,8 @@ module Neovim
           notification_cb.call(Notification.new(method, args))
         end
       end
-    end
 
-    def stop
-      @msgpack_stream.stop
-      self
+      @msgpack_stream.run(msg_cb, setup_cb)
     end
   end
 end

data/lib/neovim/buffer.rb

@@ -1,74 +1,14 @@
 require "neovim/object"
+require "neovim/line_range"
 
 module Neovim
   class Buffer < Neovim::Object
     def lines
-      @lines ||= Lines.new(self)
+      @lines ||= LineRange.new(self, 0, -1)
     end
 
     def lines=(arr)
       lines[0..-1] = arr
     end
-
-    class Lines
-      include Enumerable
-
-      def initialize(buffer)
-        @buffer = buffer
-      end
-
-      def ==(other)
-        case other
-        when Array
-          to_a == other
-        else
-          super
-        end
-      end
-
-      def to_a
-        self[0..-1]
-      end
-
-      def each(&block)
-        to_a.each(&block)
-      end
-
-      def [](idx, len=nil)
-        case idx
-        when Range
-          @buffer.get_line_slice(idx.begin, idx.end, true, !idx.exclude_end?)
-        else
-          if len
-            @buffer.get_line_slice(idx, idx + len, true, false)
-          else
-            @buffer.get_line(idx)
-          end
-        end
-      end
-      alias_method :slice, :[]
-
-      def []=(*args)
-        *target, val = args
-        idx, len = target
-
-        case idx
-        when Range
-          @buffer.set_line_slice(
-            idx.begin,
-            idx.end,
-            true,
-            !idx.exclude_end?,
-            val
-          )
-        else
-          if len
-            @buffer.set_line_slice(idx, idx + len, true, false, val)
-          else
-            @buffer.set_line(idx, val)
-          end
-        end
-      end
-    end
   end
 end

data/lib/neovim/client.rb

@@ -27,9 +27,5 @@ module Neovim
     def current
       Current.new(@session)
     end
-
-    def stop
-      @session.stop
-    end
   end
 end

data/lib/neovim/current.rb

@@ -42,5 +42,14 @@ module Neovim
       tabpage = Tabpage.new(tabpage_index, @session)
       @session.request(:vim_set_current_tabpage, tabpage)
     end
+
+    def range
+      @range ||= LineRange.new(buffer, 0, -1)
+    end
+
+    def range=(_range)
+      _end = _range.exclude_end? ? _range.end - 1 : _range.end
+      @range = LineRange.new(buffer, _range.begin, _end)
+    end
   end
 end

data/lib/neovim/event_loop.rb

@@ -28,28 +28,29 @@ module Neovim
     end
 
     def send(data)
-      @wr.write_nonblock(data)
-      self
-    rescue IO::WaitWritable
-      IO.select(nil, [@wr])
-      retry
+      start = 0
+      size = data.size
+
+      begin
+        while start < size
+          start += @wr.write_nonblock(data[start..-1])
+        end
+        self
+      rescue IO::WaitWritable
+        IO.select(nil, [@wr])
+        retry
+      end
     end
 
-    def run(&message_callback)
+    def run(message_callback, setup_callback=nil)
       @running = true
-      message_callback ||= Proc.new {}
+      setup_callback.call if setup_callback.respond_to?(:call)
 
       loop do
         break unless @running
         message_callback.call(@rd.readpartial(1024 * 16))
       end
     rescue EOFError
-      stop
-    end
-
-    def stop
-      @running = false
-      self
     end
   end
 end

data/lib/neovim/host.rb

@@ -1,85 +1,47 @@
+require "neovim/manifest"
+
 module Neovim
   class Host
-    def self.load_from_files(rplugin_paths)
-      plugins_before = Neovim.__configured_plugins
-      captured_plugins = []
+    def self.load_from_files(rplugin_paths, target_manifest=Manifest.new)
+      old_manifest = Neovim.__configured_plugin_manifest
+      old_path = Neovim.__configured_plugin_path
 
       begin
-        Neovim.__configured_plugins = captured_plugins
+        Neovim.__configured_plugin_manifest = target_manifest
 
         rplugin_paths.each do |rplugin_path|
+          Neovim.__configured_plugin_path = rplugin_path
           Kernel.load(rplugin_path, true)
         end
 
-        new(captured_plugins)
+        new(target_manifest)
       ensure
-        Neovim.__configured_plugins = plugins_before
+        Neovim.__configured_plugin_manifest = old_manifest
+        Neovim.__configured_plugin_path = old_path
       end
     end
 
-    attr_reader :plugins
+    attr_reader :manifest
 
-    def initialize(plugins)
-      @plugins = plugins
-      @handlers = compile_handlers(plugins)
+    def initialize(manifest)
+      @manifest = manifest
       @event_loop = EventLoop.stdio
       @msgpack_stream = MsgpackStream.new(@event_loop)
       @async_session = AsyncSession.new(@msgpack_stream)
     end
 
     def run
-      notification_callback = Proc.new do |notif|
-        @handlers[:notification][notif.method_name].call(client, notif)
-      end
-
-      request_callback = Proc.new do |request|
-        @handlers[:request][request.method_name].call(client, request)
+      callback = Proc.new do |msg|
+        @manifest.handle(msg, client)
       end
 
-      @async_session.run(request_callback, notification_callback)
+      @async_session.run(callback, callback)
     end
 
     private
 
     def client
-      @client ||= Client.new(session)
-    end
-
-    def session
-      @session ||= Session.new(@async_session)
-    end
-
-    def compile_handlers(plugins)
-      default_req_handler = Proc.new do |_, request|
-        request.error("Unknown request #{request.method_name.inspect}")
-      end
-
-      default_ntf_handler = Proc.new {}
-
-      base = {
-        :request => Hash.new(default_req_handler),
-        :notification => Hash.new(default_ntf_handler)
-      }
-
-      base[:request][:poll] = lambda do |_, request|
-        request.respond("ok")
-      end
-
-      plugins.inject(base) do |handlers, plugin|
-        plugin.specs.each do |spec|
-          if spec[:sync]
-            handlers[:request][spec[:name]] = lambda do |client, request|
-              request.respond(spec[:proc].call(client, *request.arguments))
-            end
-          else
-            handlers[:notification][spec[:name]] = lambda do |client, notification|
-              spec[:proc].call(client, *notification.arguments)
-            end
-          end
-        end
-
-        handlers
-      end
+      @client ||= Client.new(Session.new(@async_session))
     end
   end
 end

data/lib/neovim/line_range.rb

@@ -0,0 +1,61 @@
+module Neovim
+  class LineRange
+    include Enumerable
+
+    def initialize(buffer, _begin, _end)
+      @buffer = buffer
+      @begin = _begin
+      @end = _end
+    end
+
+    def to_a
+      @buffer.get_line_slice(@begin, @end, true, true)
+    end
+
+    def each(&block)
+      to_a.each(&block)
+    end
+
+    def [](idx, len=nil)
+      case idx
+      when ::Range
+        _end = idx.exclude_end? ? idx.end - 1 : idx.end
+        LineRange.new(@buffer, idx.begin, _end)
+      else
+        if len
+          LineRange.new(@buffer, idx, idx + len - 1)
+        else
+          @buffer.get_line(idx)
+        end
+      end
+    end
+    alias_method :slice, :[]
+
+    def []=(*args)
+      *target, val = args
+      idx, len = target
+
+      case idx
+      when ::Range
+        @buffer.set_line_slice(
+          idx.begin,
+          idx.end,
+          true,
+          !idx.exclude_end?,
+          val
+        )
+      else
+        if len
+          @buffer.set_line_slice(idx, idx + len, true, false, val)
+        else
+          @buffer.set_line(idx, val)
+        end
+      end
+    end
+
+    def replace(other_ary)
+      self[0..-1] = other_ary
+      self
+    end
+  end
+end

data/lib/neovim/manifest.rb

@@ -0,0 +1,62 @@
+module Neovim
+  class Manifest
+    attr_reader :handlers, :specs
+
+    def initialize
+      @handlers = {"poll" => poll_handler, "specs" => specs_handler}
+      @specs = {}
+    end
+
+    def register(plugin)
+      plugin.handlers.each do |handler|
+        wrapped_handler = handler.sync? ? wrap_sync(handler) : wrap_async(handler)
+        @handlers[handler.qualified_name] = wrapped_handler
+      end
+
+      @specs[plugin.source] = plugin.specs
+    end
+
+    def handle(msg, client)
+      default_handler = msg.sync? ? default_sync_handler : default_async_handler
+      @handlers.fetch(msg.method_name, default_handler).call(client, msg)
+    end
+
+    private
+
+    def poll_handler
+      @poll_handler ||= Proc.new { |_, req| req.respond("ok") }
+    end
+
+    def specs_handler
+      @specs_handler ||= Proc.new do |_, req|
+        source = req.arguments.fetch(0)
+
+        if @specs.key?(source)
+          req.respond(@specs.fetch(source))
+        else
+          req.error("Unknown plugin #{source}")
+        end
+      end
+    end
+
+    def default_sync_handler
+      @default_sync_handler ||= Proc.new { |_, req| req.error("Unknown request #{req.method_name}") }
+    end
+
+    def default_async_handler
+      @default_async_handler ||= Proc.new {}
+    end
+
+    def wrap_sync(handler)
+      Proc.new do |client, request|
+        request.respond(handler.call(client, *request.arguments))
+      end
+    end
+
+    def wrap_async(handler)
+      Proc.new do |client, notification|
+        handler.call(client, *notification.arguments)
+      end
+    end
+  end
+end