neovim 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c69f05bcd8852ed00d741fa9c86b4453a34acea8
-  data.tar.gz: fdf05283ab34d8f5692dc8cb95d3335d2b105bda
+  metadata.gz: ff45b0d6aaf7cab8f5c5092d9865c05d08d65dd4
+  data.tar.gz: 37296e52f00a0f027edb8035c7d35e869782cf65
 SHA512:
-  metadata.gz: 3f6d303d8fd49a35c9ba809e0be985533a80e26a20940e565797821a3eefe968e3c579a3ae760f0f739eadf478ae7325e720553e60dcfd059bf470b82b2d0803
-  data.tar.gz: 14a9f4aa0be233fedac15c11e1064d8c54903fed3d868472c600063be30f7f8a692db1993da8ac0b77bc5622ccc848c99f39ac9a7d808cbd47b8c382d71f0929
+  metadata.gz: d09d6c4f10345ebaa35d9d1e3eef431dab85d827c7a4045bcbbce56437b03a0598e5c4b683051b3fd992ccd902deb820500ee1101b7de0fddd2e3738daeede7a
+  data.tar.gz: bc3e6b3734c26b344a88b38fae3c12063fe5e3418c0e23142b226f8c1da6f7a0dee93526a3a77400208a915264365479a8597c8a02fa72416babdc44bc95b0a3

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# 0.0.2
+
+- Add Neovim.plugin DSL for defining plugins
+- Add neovim-ruby-host executable for spawning plugins

data/README.md

@@ -1,5 +1,6 @@
 # Neovim Ruby
 
+[![Gem Version](https://badge.fury.io/rb/neovim.svg)](https://badge.fury.io/rb/neovim)
 [![Travis](https://travis-ci.org/alexgenco/neovim-ruby.svg?branch=master)](https://travis-ci.org/alexgenco/neovim-ruby)
 [![Coverage Status](https://coveralls.io/repos/alexgenco/neovim-ruby/badge.png)](https://coveralls.io/r/alexgenco/neovim-ruby)
 
@@ -38,6 +39,38 @@ client = Neovim.attach_unix("/tmp/nvim.sock")
 
 The interface of the client is generated at runtime from the `vim_get_api_info` RPC call. For now, you can refer to the Node client's auto-generated [API description](https://github.com/neovim/node-client/blob/master/index.d.ts). Note that methods will be in `snake_case` rather than `camelCase`.
 
+The `neovim-ruby-host` executable can be used to spawn Ruby plugins via the `rpcstart` command. A plugin can be defined like this:
+
+```ruby
+# my_plugin.rb
+
+Neovim.plugin do |plug|
+  # Define a command called "Add" which returns the sum of two numbers
+  # The `:sync => true` option tells nvim to wait for a response.
+  # The result of the block will be returned to nvim.
+  plug.command(:Add, :nargs => 2, :sync => true) do |nvim, x, y|
+    x + y
+  end
+  
+  # Define a command called "SetLine" which sets the current line
+  # This command is asynchronous, so nvim won't wait for a response.
+  plug.command(:SetLine, :nargs => 1) do |nvim, str|
+    nvim.current.line = str
+  end
+end
+```
+
+In your `nvim`, you can start this plugin by running `let host = rpcstart("neovim-ruby-host", ["./my_plugin.rb"])`. You can use this channel id to communicate with the host, e.g.
+```viml
+let result = rpcrequest(host, "Add", 1, 2)
+let result " # => 3
+
+call rpcnotify(host, "SetLine", "Foo")
+" Current line is set to "Foo"
+```
+
+Plugin functionality is very limited right now. Besides `command`, the plugin DSL exposes the `function` and `autocmd` directives, however they are functionally identical to `command`. Their purpose is to define a manifest that nvim can load via the `UpdateRemotePlugins` command, which will generate the actual `command`, `function`, and `autocmd` definitions. This piece has not yet been implemented.
+
 ## Contributing
 
 1. Fork it (http://github.com/alexgenco/neovim-ruby/fork)

data/bin/neovim-ruby-host

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require "neovim"
+Neovim.start_host(ARGV)

data/lib/neovim.rb

@@ -1,10 +1,14 @@
 require "neovim/async_session"
 require "neovim/client"
 require "neovim/event_loop"
+require "neovim/host"
 require "neovim/msgpack_stream"
 require "neovim/session"
+require "neovim/plugin"
 
 module Neovim
+  @__configured_plugins = []
+
   def self.attach_tcp(host, port)
     attach_event_loop(EventLoop.tcp(host, port))
   end
@@ -17,7 +21,19 @@ module Neovim
     attach_event_loop(EventLoop.child(argv))
   end
 
+  def self.start_host(rplugin_paths)
+    Host.load_from_files(rplugin_paths).run
+  end
+
+  def self.plugin(&block)
+    Plugin.from_config_block(&block).tap do |plugin|
+      __configured_plugins << plugin
+    end
+  end
+
   class << self
+    attr_accessor :__configured_plugins
+
     private
 
     def attach_event_loop(event_loop)

data/lib/neovim/async_session.rb

@@ -1,3 +1,6 @@
+require "neovim/request"
+require "neovim/notification"
+
 module Neovim
   class AsyncSession
     def initialize(msgpack_stream)
@@ -34,13 +37,13 @@ module Neovim
         case kind
         when 0
           reqid, method, args = rest
-          request_cb.call(method, args, Responder.new(@msgpack_stream, reqid))
+          request_cb.call(Request.new(method, args, @msgpack_stream, reqid))
         when 1
           reqid, (_, error), result = rest
           @pending_requests.fetch(reqid).call(error, result)
         when 2
-          event, args = rest
-          notification_cb.call(event, args)
+          method, args = rest
+          notification_cb.call(Notification.new(method, args))
         end
       end
     end
@@ -49,27 +52,5 @@ module Neovim
       @msgpack_stream.stop
       self
     end
-
-    def shutdown
-      @msgpack_stream.shutdown
-      self
-    end
-
-    class Responder
-      def initialize(msgpack_stream, request_id)
-        @msgpack_stream = msgpack_stream
-        @request_id = request_id
-      end
-
-      def send(value)
-        @msgpack_stream.send([1, @request_id, nil, value])
-        self
-      end
-
-      def error(value)
-        @msgpack_stream.send([1, @request_id, value, nil])
-        self
-      end
-    end
   end
 end

data/lib/neovim/client.rb

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

data/lib/neovim/event_loop.rb

@@ -1,4 +1,3 @@
-require "eventmachine"
 require "socket"
 
 module Neovim
@@ -24,52 +23,33 @@ module Neovim
     end
 
     def initialize(rd, wr)
-      @read_stream, @write_stream = rd, wr
+      @rd, @wr = rd, wr
+      @running = false
     end
 
     def send(data)
-      EM.schedule do
-        @write_conn.send_data(data)
-      end
+      @wr.write_nonblock(data)
       self
+    rescue IO::WaitWritable
+      IO.select(nil, [@wr])
+      retry
     end
 
     def run(&message_callback)
+      @running = true
       message_callback ||= Proc.new {}
 
-      EM.run do
-        @read_conn = EM.watch(@read_stream, Connection)
-        @write_conn = EM.watch(@write_stream, Connection) unless @write_stream == @read_stream
-        @write_conn ||= @read_conn
-
-        @read_conn.notify_readable = true
-        @read_conn.message_callback = message_callback
+      loop do
+        break unless @running
+        message_callback.call(@rd.readpartial(1024 * 16))
       end
+    rescue EOFError
+      stop
     end
 
     def stop
-      EM.stop_event_loop
-      self
-    end
-
-    def shutdown
-      stop
+      @running = false
       self
-    ensure
-      @read_conn.close if @read_conn.respond_to?(:close)
-      @write_conn.close if @write_conn.respond_to?(:close)
-    end
-
-    class Connection < EM::Connection
-      attr_writer :message_callback
-
-      def send_data(data)
-        @io.write_nonblock(data)
-      end
-
-      def notify_readable
-        @message_callback.call(@io.readpartial(1024 * 16))
-      end
     end
   end
 end

data/lib/neovim/host.rb

@@ -0,0 +1,70 @@
+module Neovim
+  class Host
+    def self.load_from_files(rplugin_paths)
+      plugins_before = Neovim.__configured_plugins
+      captured_plugins = []
+
+      begin
+        Neovim.__configured_plugins = captured_plugins
+
+        rplugin_paths.each do |rplugin_path|
+          Kernel.load(rplugin_path, true)
+        end
+
+        new(captured_plugins)
+      ensure
+        Neovim.__configured_plugins = plugins_before
+      end
+    end
+
+    attr_reader :plugins
+
+    def initialize(plugins)
+      @plugins = plugins
+      @handlers = compile_handlers(plugins)
+    end
+
+    def run
+      event_loop = EventLoop.stdio
+      msgpack_stream = MsgpackStream.new(event_loop)
+      async_session = AsyncSession.new(msgpack_stream)
+      session = Session.new(async_session)
+      client = Client.new(session)
+
+      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)
+      end
+
+      async_session.run(request_callback, notification_callback)
+    end
+
+    private
+
+    def compile_handlers(plugins)
+      base = {
+        :request => Hash.new(Proc.new {}),
+        :notification => Hash.new(Proc.new {})
+      }
+
+      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
+    end
+  end
+end

data/lib/neovim/msgpack_stream.rb

@@ -35,10 +35,5 @@ module Neovim
       @event_loop.stop
       self
     end
-
-    def shutdown
-      @event_loop.shutdown
-      self
-    end
   end
 end

data/lib/neovim/notification.rb

@@ -0,0 +1,10 @@
+module Neovim
+  class Notification
+    attr_reader :method_name, :arguments
+
+    def initialize(method_name, args)
+      @method_name = method_name.to_sym
+      @arguments = args
+    end
+  end
+end

data/lib/neovim/plugin.rb

@@ -0,0 +1,61 @@
+module Neovim
+  class Plugin
+    def self.from_config_block(&block)
+      new.tap do |instance|
+        block.call(DSL.new(instance)) if block
+      end
+    end
+
+    attr_accessor :specs
+
+    def initialize
+      @specs = []
+    end
+
+    class DSL < BasicObject
+      def initialize(plugin)
+        @plugin = plugin
+      end
+
+      def command(name, _options={}, &block)
+        options = _options.dup
+        options[:range] = "" if options[:range] == true
+        options[:range] = ::Kernel.String(options[:range])
+
+        @plugin.specs.push(
+          :type => :command,
+          :name => name.to_sym,
+          :sync => !!options.delete(:sync),
+          :opts => options,
+          :proc => block || ::Proc.new {}
+        )
+      end
+
+      def function(name, _options, &block)
+        options = _options.dup
+        options[:range] = "" if options[:range] == true
+        options[:range] = ::Kernel.String(options[:range])
+
+        @plugin.specs.push(
+          :type => :function,
+          :name => name.to_sym,
+          :sync => !!options.delete(:sync),
+          :opts => options,
+          :proc => block || ::Proc.new {}
+        )
+      end
+
+      def autocmd(name, _options={}, &block)
+        options = _options.dup
+
+        @plugin.specs.push(
+          :type => :autocmd,
+          :name => name.to_sym,
+          :sync => !!options.delete(:sync),
+          :opts => options,
+          :proc => block || ::Proc.new {}
+        )
+      end
+    end
+  end
+end

data/lib/neovim/request.rb

@@ -0,0 +1,22 @@
+module Neovim
+  class Request
+    attr_reader :method_name, :arguments
+
+    def initialize(method_name, args, msgpack_stream, request_id)
+      @method_name = method_name.to_sym
+      @arguments = args
+      @msgpack_stream = msgpack_stream
+      @request_id = request_id
+    end
+
+    def respond(value)
+      @msgpack_stream.send([1, @request_id, nil, value])
+      self
+    end
+
+    def error(message)
+      @msgpack_stream.send([1, @request_id, message, nil])
+      self
+    end
+  end
+end

data/lib/neovim/session.rb

@@ -12,14 +12,14 @@ module Neovim
     end
 
     def request(method, *args)
-      err = res = nil
-
-      @async_session.request(method, *args) do |error, response|
-        err, res = error, response
-        @async_session.stop
-      end.run
+      fiber = Fiber.new do
+        @async_session.request(method, *args) do |err, res|
+          Fiber.yield(err, res)
+        end.run
+      end
 
-      err ? raise(ArgumentError, err) : res
+      error, response = fiber.resume
+      error ? raise(ArgumentError, error) : response
     end
 
     def api_methods_for_prefix(prefix)

data/lib/neovim/version.rb

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

data/neovim.gemspec

@@ -18,7 +18,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "msgpack", "0.7.0dev1"
-  spec.add_dependency "eventmachine", "~> 1.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

data/spec/acceptance/neovim-ruby-host_spec.rb

@@ -0,0 +1,57 @@
+require "helper"
+require "tempfile"
+
+RSpec.describe "neovim-ruby-host" do
+  let(:lib_path)  { File.expand_path("../../../lib", __FILE__) }
+  let(:bin_path)  { File.expand_path("../../../bin/neovim-ruby-host", __FILE__) }
+  let(:nvim_path) { File.expand_path("../../../vendor/neovim/build/bin/nvim", __FILE__) }
+
+  specify do
+    plugin1 = Tempfile.open("plug1") do |f|
+      f.write(<<-RUBY)
+        Neovim.plugin do |plug|
+          plug.command(:SyncAdd, :args => 2, :sync => true) do |nvim, x, y|
+            x + y
+          end
+        end
+      RUBY
+      f.path
+    end
+
+    plugin2 = Tempfile.open("plug2") do |f|
+      f.write(<<-RUBY)
+        Neovim.plugin do |plug|
+          plug.command(:AsyncSetLine, :args => 1) do |nvim, str|
+            nvim.current.line = str
+          end
+        end
+      RUBY
+      f.path
+    end
+
+    output = Tempfile.new("output").tap(&:close).path
+    host_nvim = Neovim.attach_child(["--headless", "-u", "NONE", "-N", "-n"])
+
+    # Start the remote host
+    host_nvim.command(%{let g:chan = rpcstart("#{bin_path}", ["#{plugin1}", "#{plugin2}"])})
+    sleep 0.4 # TODO figure out if/why this is necessary
+
+    # Make a request to the synchronous SyncAdd method and store the results
+    host_nvim.command(%{let g:res = rpcrequest(g:chan, "SyncAdd", 1, 2)})
+
+    # Write the results to the buffer
+    host_nvim.command("put =g:res")
+    host_nvim.command("normal o")
+
+    # Set the current line content via the AsyncSetLine method
+    host_nvim.command(%{call rpcnotify(g:chan, "AsyncSetLine", "foo")})
+
+    # Ensure notification callback has completed
+    host_nvim.eval("0")
+
+    # Save the contents of the buffer
+    host_nvim.command("write! #{output}")
+
+    expect(File.read(output)).to eq("\n3\nfoo\n")
+  end
+end

data/spec/helper.rb

@@ -21,6 +21,6 @@ RSpec.configure do |config|
   Kernel.srand config.seed
 
   config.around do |spec|
-    Timeout.timeout(1) { spec.run }
+    Timeout.timeout(5) { spec.run }
   end
 end

data/spec/neovim/async_session_spec.rb

@@ -2,95 +2,109 @@ require "helper"
 
 module Neovim
   RSpec.describe AsyncSession do
-    it "receives requests" do
-      server = TCPServer.new("0.0.0.0", 0)
-      event_loop = EventLoop.tcp("0.0.0.0", server.addr[1])
-      stream = MsgpackStream.new(event_loop)
-      async = AsyncSession.new(stream)
-      messages = []
-
-      srv_thr = Thread.new do
-        client = server.accept
-        client.write(MessagePack.pack(
-          [0, 123, "func", [1, 2, 3]]
-        ))
-
-        client.close
-        server.close
+    shared_context "async session behavior" do
+      it "receives requests" do
+        stream = MsgpackStream.new(event_loop)
+        async = AsyncSession.new(stream)
+
+        srv_thr = Thread.new do
+          client = server.accept
+          IO.select(nil, [client])
+          client.write(MessagePack.pack(
+            [0, 123, "func", [1, 2, 3]]
+          ))
+        end
+
+        req_cb = Proc.new do |request|
+          Fiber.yield(request)
+        end
+
+        fiber = Fiber.new do
+          async.run(req_cb)
+        end
+
+        request = fiber.resume
+
+        srv_thr.join
+
+        expect(request).to be_a(Request)
+        expect(request.method_name).to eq(:func)
+        expect(request.arguments).to eq([1, 2, 3])
       end
 
-      req_cb = Proc.new do |*payload|
-        messages << payload
-        async.shutdown
-      end
+      it "receives notifications" do
+        stream = MsgpackStream.new(event_loop)
+        async = AsyncSession.new(stream)
 
-      async.run(req_cb)
-      srv_thr.join
+        srv_thr = Thread.new do
+          client = server.accept
+          IO.select(nil, [client])
+          client.write(MessagePack.pack(
+            [2, "func", [1, 2, 3]]
+          ))
+        end
 
-      expect(messages.first.size).to eq(3)
-      expect(messages.first[0..1]).to eq(["func", [1, 2, 3]])
-      expect(messages.first[2]).to be_a(AsyncSession::Responder)
-    end
+        not_cb = Proc.new do |notification|
+          Fiber.yield(notification)
+        end
 
-    it "receives notifications" do
-      server = TCPServer.new("0.0.0.0", 0)
-      event_loop = EventLoop.tcp("0.0.0.0", server.addr[1])
-      stream = MsgpackStream.new(event_loop)
-      async = AsyncSession.new(stream)
-      messages = []
-
-      srv_thr = Thread.new do
-        client = server.accept
-        client.write(MessagePack.pack(
-          [2, "func", [1, 2, 3]]
-        ))
-
-        client.close
-        server.close
-      end
+        fiber = Fiber.new do
+          async.run(nil, not_cb)
+        end
 
-      not_cb = Proc.new do |*payload|
-        messages << payload
-        async.shutdown
+        notification = fiber.resume
+
+        srv_thr.join
+
+        expect(notification).to be_a(Notification)
+        expect(notification.method_name).to eq(:func)
+        expect(notification.arguments).to eq([1, 2, 3])
       end
 
-      async.run(nil, not_cb)
-      srv_thr.join
+      it "receives responses to requests" do
+        stream = MsgpackStream.new(event_loop)
+        async = AsyncSession.new(stream)
+        messages = []
 
-      expect(messages).to eq([["func", [1, 2, 3]]])
-    end
+        srv_thr = Thread.new do
+          client = server.accept
+          messages << client.readpartial(1024)
 
-    it "receives responses to requests" do
-      server = TCPServer.new("0.0.0.0", 0)
-      event_loop = EventLoop.tcp("0.0.0.0", server.addr[1])
-      stream = MsgpackStream.new(event_loop)
-      async = AsyncSession.new(stream)
-      messages = []
+          client.write(MessagePack.pack(
+            [1, 0, [0, "error"], "result"]
+          ))
+        end
 
-      srv_thr = Thread.new do
-        client = server.accept
-        messages << client.read_nonblock(1024)
+        fiber = Fiber.new do
+          async.request("func", 1, 2, 3) do |error, result|
+            Fiber.yield(error, result)
+          end.run
+        end
 
-        client.write(MessagePack.pack(
-          [1, 0, [0, "error"], "result"]
-        ))
+        expect(fiber.resume).to eq(["error", "result"])
 
-        client.close
-        server.close
-      end
+        srv_thr.join
 
-      async.request("func", 1, 2, 3) do |error, result|
-        expect(error).to eq("error")
-        expect(result).to eq("result")
-        async.shutdown
+        expect(messages).to eq(
+          [MessagePack.pack([0, 0, "func", [1, 2, 3]])]
+        )
       end
+    end
+
+    context "tcp" do
+      let!(:server) { TCPServer.new("0.0.0.0", 0) }
+      let!(:event_loop) { EventLoop.tcp("0.0.0.0", server.addr[1]) }
+
+      include_context "async session behavior"
+    end
 
-      async.run
-      srv_thr.join
+    context "unix" do
+      before { FileUtils.rm_f("/tmp/#$$.sock") }
+      after { FileUtils.rm_f("/tmp/#$$.sock") }
+      let!(:server) { UNIXServer.new("/tmp/#$$.sock") }
+      let!(:event_loop) { EventLoop.unix("/tmp/#$$.sock") }
 
-      expect(messages).to eq(
-        [MessagePack.pack([0, 0, "func", [1, 2, 3]])]
-      )
+      include_context "async session behavior"
     end
   end
 end

data/spec/neovim/event_loop_spec.rb

@@ -5,24 +5,24 @@ require "fileutils"
 
 module Neovim
   RSpec.describe EventLoop do
-    shared_context "socket behaviors" do
+    shared_context "socket behavior" do
       it "sends and receives data" do
         messages = []
 
         srv_thr = Thread.new do
           client = server.accept
-          messages << client.read_nonblock(1024)
+          messages << client.readpartial(1024)
 
-          client.write("from server")
-          client.close
-          server.close
+          client.write("OK")
         end
 
-        event_loop.send("data").run do |msg|
-          expect(msg).to eq("from server")
-          event_loop.shutdown
+        fiber = Fiber.new do
+          event_loop.send("data").run do |msg|
+            Fiber.yield(msg)
+          end
         end
 
+        expect(fiber.resume).to eq("OK")
         srv_thr.join
         expect(messages).to eq(["data"])
       end
@@ -32,15 +32,16 @@ module Neovim
       let!(:server) { TCPServer.new("0.0.0.0", 0) }
       let!(:event_loop) { EventLoop.tcp("0.0.0.0", server.addr[1]) }
 
-      include_context "socket behaviors"
+      include_context "socket behavior"
     end
 
     context "unix" do
       before { FileUtils.rm_f("/tmp/#$$.sock") }
+      after { FileUtils.rm_f("/tmp/#$$.sock") }
       let!(:server) { UNIXServer.new("/tmp/#$$.sock") }
       let!(:event_loop) { EventLoop.unix("/tmp/#$$.sock") }
 
-      include_context "socket behaviors"
+      include_context "socket behavior"
     end
 
     context "child" do
@@ -48,10 +49,13 @@ module Neovim
         event_loop = EventLoop.child(["-n", "-u", "NONE"])
         message = MessagePack.pack([0, 0, :vim_strwidth, ["hi"]])
 
-        event_loop.send(message).run do |msg|
-          expect(msg).to eq(MessagePack.pack([1, 0, nil, 2]))
-          event_loop.shutdown
+        fiber = Fiber.new do
+          event_loop.send(message).run do |msg|
+            Fiber.yield(msg)
+          end
         end
+
+        expect(fiber.resume).to eq(MessagePack.pack([1, 0, nil, 2]))
       end
     end
   end

data/spec/neovim/host_spec.rb

@@ -0,0 +1,80 @@
+require "helper"
+require "tempfile"
+
+module Neovim
+  RSpec.describe Host do
+    describe ".load_from_files" do
+      it "loads the defined plugins" do
+        plug1 = Tempfile.open("plug1") do |f|
+          f.write("Neovim.plugin")
+          f.path
+        end
+
+        plug2 = Tempfile.open("plug2") do |f|
+          f.write("Neovim.plugin; Neovim.plugin")
+          f.path
+        end
+
+        host = Host.load_from_files([plug1, plug2])
+        expect(host.plugins.size).to eq(3)
+      end
+
+      it "doesn't load plugin code into the global namespace" do
+        plug = Tempfile.open("plug") do |f|
+          f.write("class FooClass; end")
+          f.path
+        end
+
+        host = Host.load_from_files([plug])
+        expect(Kernel.const_defined?("FooClass")).to be(false)
+      end
+    end
+
+    describe "#run" do
+      it "runs an async client with the plugins as callbacks" do
+        sync_cb = lambda { |nvim, x, y| [nvim, x, y] }
+        async_cb = lambda { |nvim, x, y| [nvim, x, y] }
+
+        plugin = Plugin.from_config_block do |plug|
+          plug.command(:Sync, :nargs => 2, :sync => true, &sync_cb)
+          plug.command(:Async, :nargs => 2, &async_cb)
+        end
+
+        host = Host.new([plugin])
+
+        mock_async_session = double(:async_session, :request => nil)
+        expect(AsyncSession).to receive(:new) { mock_async_session }
+
+        mock_client = double(:client)
+        expect(Client).to receive(:new) { mock_client }
+
+        expect(EventLoop).to receive(:stdio) { double(:event_loop) }
+        expect(MsgpackStream).to receive(:new) { double(:msgpack_stream) }
+        expect(Session).to receive(:new) { double(:session) }
+
+        expect(mock_async_session).to receive(:run) do |req_cb, not_cb|
+          mock_request = double(
+            :request,
+            :method_name => :Sync,
+            :arguments => [1, 2]
+          )
+
+          mock_notification = double(
+            :notification,
+            :method_name => :Async,
+            :arguments => [3, 4]
+          )
+
+          expect(sync_cb).to receive(:call).with(mock_client, 1, 2).and_call_original
+          expect(mock_request).to receive(:respond).with([mock_client, 1, 2])
+          req_cb.call(mock_request)
+
+          expect(async_cb).to receive(:call).with(mock_client, 3, 4).and_call_original
+          not_cb.call(mock_notification)
+        end
+
+        host.run
+      end
+    end
+  end
+end

data/spec/neovim/msgpack_stream_spec.rb

@@ -3,27 +3,42 @@ require "helper"
 
 module Neovim
   RSpec.describe MsgpackStream do
-    it "sends and receives msgpack" do
-      server = TCPServer.new("0.0.0.0", 0)
-      event_loop = EventLoop.tcp("0.0.0.0", server.addr[1])
-      stream = MsgpackStream.new(event_loop)
-      messages = []
-
-      srv_thr = Thread.new do
-        client = server.accept
-        messages << client.read_nonblock(1024)
-
-        client.write(MessagePack.pack([2]))
-        client.close
-        server.close
-      end
+    shared_context "msgpack stream behavior" do
+      it "sends and receives data" do
+        stream = MsgpackStream.new(event_loop)
+        messages = []
+
+        srv_thr = Thread.new do
+          client = server.accept
+          messages << client.readpartial(1024)
+          client.write(MessagePack.pack([2]))
+        end
 
-      stream.send([1]).run do |msg|
-        expect(msg).to eq([2])
-        stream.shutdown
+        fiber = Fiber.new do
+          stream.send([1]).run do |msg|
+            Fiber.yield(msg)
+          end
+        end
+
+        expect(fiber.resume).to eq([2])
+        expect(messages).to eq([MessagePack.pack([1])])
       end
+    end
+
+    context "tcp" do
+      let!(:server) { TCPServer.new("0.0.0.0", 0) }
+      let!(:event_loop) { EventLoop.tcp("0.0.0.0", server.addr[1]) }
+
+      include_context "msgpack stream behavior"
+    end
+
+    context "unix" do
+      before { FileUtils.rm_f("/tmp/#$$.sock") }
+      after { FileUtils.rm_f("/tmp/#$$.sock") }
+      let!(:server) { UNIXServer.new("/tmp/#$$.sock") }
+      let!(:event_loop) { EventLoop.unix("/tmp/#$$.sock") }
 
-      expect(messages).to eq([MessagePack.pack([1])])
+      include_context "msgpack stream behavior"
     end
   end
 end

data/spec/neovim/object_spec.rb

@@ -0,0 +1,107 @@
+require "helper"
+
+module Neovim
+  RSpec.describe Object do
+    context Window do
+      let(:window) { Neovim.attach_child(["-n", "-u", "NONE"]).current.window }
+
+      describe "#respond_to?" do
+        it "returns true for Window functions" do
+          expect(window).to respond_to(:get_cursor)
+        end
+
+        it "returns true for Ruby functions" do
+          expect(window).to respond_to(:inspect)
+        end
+
+        it "returns false otherwise" do
+          expect(window).not_to respond_to(:foobar)
+        end
+      end
+
+      describe "#method_missing" do
+        it "enables window_* function calls" do
+          expect(window.get_cursor).to eq([1, 0])
+        end
+      end
+
+      describe "#methods" do
+        it "returns builtin methods" do
+          expect(window.methods).to include(:inspect)
+        end
+
+        it "returns api methods" do
+          expect(window.methods).to include(:get_height)
+        end
+      end
+    end
+
+    context Tabpage do
+      let(:tabpage) { Neovim.attach_child(["-n", "-u", "NONE"]).current.tabpage }
+
+      describe "#respond_to?" do
+        it "returns true for Tabpage functions" do
+          expect(tabpage).to respond_to(:is_valid)
+        end
+
+        it "returns true for Ruby functions" do
+          expect(tabpage).to respond_to(:inspect)
+        end
+
+        it "returns false otherwise" do
+          expect(tabpage).not_to respond_to(:foobar)
+        end
+      end
+
+      describe "#method_missing" do
+        it "enables tabpage_* function calls" do
+          expect(tabpage.is_valid).to be(true)
+        end
+      end
+
+      describe "#methods" do
+        it "returns builtin methods" do
+          expect(tabpage.methods).to include(:inspect)
+        end
+
+        it "returns api methods" do
+          expect(tabpage.methods).to include(:get_windows)
+        end
+      end
+    end
+
+    context Buffer do
+      let(:buffer) { Neovim.attach_child(["-n", "-u", "NONE"]).current.buffer }
+
+      describe "#respond_to?" do
+        it "returns true for Buffer functions" do
+          expect(buffer).to respond_to(:line_count)
+        end
+
+        it "returns true for Ruby functions" do
+          expect(buffer).to respond_to(:inspect)
+        end
+
+        it "returns false otherwise" do
+          expect(buffer).not_to respond_to(:foobar)
+        end
+      end
+
+      describe "#method_missing" do
+        it "enables buffer_* function calls" do
+          expect(buffer.line_count).to be(1)
+        end
+      end
+
+      describe "#methods" do
+        it "returns builtin methods" do
+          expect(buffer.methods).to include(:inspect)
+        end
+
+        it "returns api methods" do
+          expect(buffer.methods).to include(:get_mark)
+        end
+      end
+    end
+  end
+end

data/spec/neovim/plugin_spec.rb

@@ -0,0 +1,67 @@
+require "helper"
+
+module Neovim
+  RSpec.describe Plugin do
+    describe ".from_config_block" do
+      it "registers a command" do
+        cmd_block = Proc.new {}
+
+        plugin = Plugin.from_config_block do |plug|
+          plug.command("Foo", :range => true, :nargs => 1, &cmd_block)
+        end
+
+        expect(plugin.specs).to eq(
+          [
+            {
+              :type => :command,
+              :name => :Foo,
+              :sync => false,
+              :opts => {:range => "", :nargs => 1},
+              :proc => cmd_block
+            }
+          ]
+        )
+      end
+
+      it "registers an autocmd" do
+        au_block = Proc.new {}
+
+        plugin = Plugin.from_config_block do |plug|
+          plug.autocmd("BufEnter", :pattern => "*.rb", &au_block)
+        end
+
+        expect(plugin.specs).to eq(
+          [
+            {
+              :type => :autocmd,
+              :name => :BufEnter,
+              :sync => false,
+              :opts => {:pattern => "*.rb"},
+              :proc => au_block
+            }
+          ]
+        )
+      end
+
+      it "registers a function" do
+        fun_block = Proc.new {}
+
+        plugin = Plugin.from_config_block do |plug|
+          plug.function("Foo", :range => true, :nargs => 1, &fun_block)
+        end
+
+        expect(plugin.specs).to eq(
+          [
+            {
+              :type => :function,
+              :name => :Foo,
+              :sync => false,
+              :opts => {:range => "", :nargs => 1},
+              :proc => fun_block
+            }
+          ]
+        )
+      end
+    end
+  end
+end

data/spec/neovim_spec.rb

@@ -45,10 +45,18 @@ RSpec.describe Neovim do
     end
   end
 
-  describe "attach_child" do
+  describe ".attach_child" do
     it "spawns and attaches to a child process" do
       nvim = Neovim.attach_child(nvim_argv)
       expect(nvim.strwidth("hi")).to eq(2)
     end
   end
+
+  describe ".plugin" do
+    it "adds to Neovim.__configured_plugins" do
+      expect {
+        Neovim.plugin
+      }.to change { Neovim.__configured_plugins.size }.by(1)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neovim
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Alex Genco
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-16 00:00:00.000000000 Z
+date: 2015-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -24,20 +24,6 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.7.0dev1
-- !ruby/object:Gem::Dependency
-  name: eventmachine
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -97,7 +83,8 @@ dependencies:
 description: 
 email:
 - alexgenco@gmail.com
-executables: []
+executables:
+- neovim-ruby-host
 extensions: []
 extra_rdoc_files: []
 files:
@@ -105,31 +92,38 @@ files:
 - ".gitignore"
 - ".gitmodules"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/neovim-ruby-host
 - lib/neovim.rb
 - lib/neovim/api_info.rb
 - lib/neovim/async_session.rb
 - lib/neovim/client.rb
 - lib/neovim/current.rb
 - lib/neovim/event_loop.rb
+- lib/neovim/host.rb
 - lib/neovim/msgpack_stream.rb
+- lib/neovim/notification.rb
 - lib/neovim/object.rb
+- lib/neovim/plugin.rb
+- lib/neovim/request.rb
 - lib/neovim/session.rb
 - lib/neovim/version.rb
 - neovim.gemspec
+- spec/acceptance/neovim-ruby-host_spec.rb
 - spec/helper.rb
 - spec/neovim/async_session_spec.rb
-- spec/neovim/buffer_spec.rb
 - spec/neovim/client_spec.rb
 - spec/neovim/current_spec.rb
 - spec/neovim/event_loop_spec.rb
+- spec/neovim/host_spec.rb
 - spec/neovim/msgpack_stream_spec.rb
+- spec/neovim/object_spec.rb
+- spec/neovim/plugin_spec.rb
 - spec/neovim/session_spec.rb
-- spec/neovim/tabpage_spec.rb
-- spec/neovim/window_spec.rb
 - spec/neovim_spec.rb
 homepage: https://github.com/alexgenco/neovim-ruby
 licenses:
@@ -156,14 +150,15 @@ signing_key:
 specification_version: 4
 summary: A Ruby client for Neovim
 test_files:
+- spec/acceptance/neovim-ruby-host_spec.rb
 - spec/helper.rb
 - spec/neovim/async_session_spec.rb
-- spec/neovim/buffer_spec.rb
 - spec/neovim/client_spec.rb
 - spec/neovim/current_spec.rb
 - spec/neovim/event_loop_spec.rb
+- spec/neovim/host_spec.rb
 - spec/neovim/msgpack_stream_spec.rb
+- spec/neovim/object_spec.rb
+- spec/neovim/plugin_spec.rb
 - spec/neovim/session_spec.rb
-- spec/neovim/tabpage_spec.rb
-- spec/neovim/window_spec.rb
 - spec/neovim_spec.rb

data/spec/neovim/buffer_spec.rb

@@ -1,37 +0,0 @@
-require "helper"
-
-module Neovim
-  RSpec.describe Buffer do
-    let(:buffer) { Neovim.attach_child(["-n", "-u", "NONE"]).current.buffer }
-
-    describe "#respond_to?" do
-      it "returns true for Buffer functions" do
-        expect(buffer).to respond_to(:line_count)
-      end
-
-      it "returns true for Ruby functions" do
-        expect(buffer).to respond_to(:inspect)
-      end
-
-      it "returns false otherwise" do
-        expect(buffer).not_to respond_to(:foobar)
-      end
-    end
-
-    describe "#method_missing" do
-      it "enables buffer_* function calls" do
-        expect(buffer.line_count).to be(1)
-      end
-    end
-
-    describe "#methods" do
-      it "returns builtin methods" do
-        expect(buffer.methods).to include(:inspect)
-      end
-
-      it "returns api methods" do
-        expect(buffer.methods).to include(:get_mark)
-      end
-    end
-  end
-end

data/spec/neovim/tabpage_spec.rb

@@ -1,37 +0,0 @@
-require "helper"
-
-module Neovim
-  RSpec.describe Tabpage do
-    let(:tabpage) { Neovim.attach_child(["-n", "-u", "NONE"]).current.tabpage }
-
-    describe "#respond_to?" do
-      it "returns true for Tabpage functions" do
-        expect(tabpage).to respond_to(:is_valid)
-      end
-
-      it "returns true for Ruby functions" do
-        expect(tabpage).to respond_to(:inspect)
-      end
-
-      it "returns false otherwise" do
-        expect(tabpage).not_to respond_to(:foobar)
-      end
-    end
-
-    describe "#method_missing" do
-      it "enables tabpage_* function calls" do
-        expect(tabpage.is_valid).to be(true)
-      end
-    end
-
-    describe "#methods" do
-      it "returns builtin methods" do
-        expect(tabpage.methods).to include(:inspect)
-      end
-
-      it "returns api methods" do
-        expect(tabpage.methods).to include(:get_windows)
-      end
-    end
-  end
-end

data/spec/neovim/window_spec.rb

@@ -1,37 +0,0 @@
-require "helper"
-
-module Neovim
-  RSpec.describe Window do
-    let(:window) { Neovim.attach_child(["-n", "-u", "NONE"]).current.window }
-
-    describe "#respond_to?" do
-      it "returns true for Window functions" do
-        expect(window).to respond_to(:get_cursor)
-      end
-
-      it "returns true for Ruby functions" do
-        expect(window).to respond_to(:inspect)
-      end
-
-      it "returns false otherwise" do
-        expect(window).not_to respond_to(:foobar)
-      end
-    end
-
-    describe "#method_missing" do
-      it "enables window_* function calls" do
-        expect(window.get_cursor).to eq([1, 0])
-      end
-    end
-
-    describe "#methods" do
-      it "returns builtin methods" do
-        expect(window.methods).to include(:inspect)
-      end
-
-      it "returns api methods" do
-        expect(window.methods).to include(:get_height)
-      end
-    end
-  end
-end