neovim 0.0.3 → 0.0.4

data/lib/neovim/msgpack_stream.rb

@@ -23,17 +23,14 @@ module Neovim
       self
     end
 
-    def run(&message_cb)
-      @event_loop.run do |data|
+    def run(message_cb, setup_cb=nil)
+      data_cb = Proc.new do |data|
         @unpacker.feed_each(data) do |msg|
           message_cb.call(msg)
         end
       end
-    end
 
-    def stop
-      @event_loop.stop
-      self
+      @event_loop.run(data_cb, setup_cb)
     end
   end
 end

data/lib/neovim/notification.rb

@@ -3,8 +3,12 @@ module Neovim
     attr_reader :method_name, :arguments
 
     def initialize(method_name, args)
-      @method_name = method_name.to_sym
+      @method_name = method_name.to_s
       @arguments = args
     end
+
+    def sync?
+      false
+    end
   end
 end

data/lib/neovim/plugin.rb

@@ -1,15 +1,60 @@
 module Neovim
   class Plugin
-    def self.from_config_block(&block)
-      new.tap do |instance|
+    def self.from_config_block(source, &block)
+      new(source).tap do |instance|
         block.call(DSL.new(instance)) if block
       end
     end
 
-    attr_accessor :specs
+    attr_accessor :handlers
+    attr_reader :source
 
-    def initialize
-      @specs = []
+    def initialize(source)
+      @handlers = []
+      @source = source
+    end
+
+    def specs
+      @handlers.map(&:to_spec)
+    end
+
+    class Handler
+      attr_reader :block
+
+      def initialize(source, type, name, sync, options, block)
+        @source = source
+        @type = type.to_sym
+        @name = name.to_s
+        @sync = !!sync
+        @options = options
+        @block = block || ::Proc.new {}
+      end
+
+      def qualified_name
+        if @type == :autocmd
+          pattern = @options.fetch(:pattern, "*")
+          "#{@source}:#{@type}:#{@name}:#{pattern}"
+        else
+          "#{@source}:#{@type}:#{@name}"
+        end
+      end
+
+      def sync?
+        @sync
+      end
+
+      def to_spec
+        {
+          :type => @type,
+          :name => @name,
+          :sync => @sync,
+          :opts => @options,
+        }
+      end
+
+      def call(*args)
+        @block.call(*args)
+      end
     end
 
     class DSL < BasicObject
@@ -17,44 +62,41 @@ module Neovim
         @plugin = plugin
       end
 
-      def command(name, _options={}, &block)
-        options = _options.dup
-        options[:range] = "" if options[:range] == true
-        options[:range] = ::Kernel.String(options[:range])
+      def command(name, options={}, &block)
+        register_handler(:command, name, options, block)
+      end
 
-        @plugin.specs.push(
-          :type => :command,
-          :name => name.to_sym,
-          :sync => !!options.delete(:sync),
-          :opts => options,
-          :proc => block || ::Proc.new {}
-        )
+      def function(name, options={}, &block)
+        register_handler(:function, name, options, block)
       end
 
-      def function(name, _options, &block)
-        options = _options.dup
-        options[:range] = "" if options[:range] == true
-        options[:range] = ::Kernel.String(options[:range])
+      def autocmd(name, options={}, &block)
+        register_handler(:autocmd, name, options, block)
+      end
+
+      private
+
+      def register_handler(type, name, _options, block)
+        if type == :autocmd
+          options = _options.dup
+        else
+          options = standardize_range(_options.dup)
+        end
 
-        @plugin.specs.push(
-          :type => :function,
-          :name => name.to_sym,
-          :sync => !!options.delete(:sync),
-          :opts => options,
-          :proc => block || ::Proc.new {}
+        sync = options.delete(:sync)
+
+        @plugin.handlers.push(
+          Handler.new(@plugin.source, type, name, sync, options, block)
         )
       end
 
-      def autocmd(name, _options={}, &block)
-        options = _options.dup
+      def standardize_range(options)
+        if options.key?(:range)
+          options[:range] = "" if options[:range] == true
+          options[:range] = ::Kernel.String(options[:range])
+        end
 
-        @plugin.specs.push(
-          :type => :autocmd,
-          :name => name.to_sym,
-          :sync => !!options.delete(:sync),
-          :opts => options,
-          :proc => block || ::Proc.new {}
-        )
+        options
       end
     end
   end

data/lib/neovim/request.rb

@@ -3,12 +3,16 @@ module Neovim
     attr_reader :method_name, :arguments
 
     def initialize(method_name, args, msgpack_stream, request_id)
-      @method_name = method_name.to_sym
+      @method_name = method_name.to_s
       @arguments = args
       @msgpack_stream = msgpack_stream
       @request_id = request_id
     end
 
+    def sync?
+      true
+    end
+
     def respond(value)
       @msgpack_stream.send([1, @request_id, nil, value])
       self

data/lib/neovim/version.rb

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

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

@@ -2,10 +2,11 @@ require "helper"
 require "tmpdir"
 
 RSpec.describe "neovim-ruby-host" do
-  specify do
+  it "loads and runs plugins from Ruby source files" do
     Dir.mktmpdir do |pwd|
       Dir.chdir(pwd) do
-        File.write("./plugin1.rb", <<-RUBY)
+        plugin1_path = File.expand_path("./plugin1.rb")
+        File.write(plugin1_path, <<-RUBY)
           Neovim.plugin do |plug|
             plug.command(:SyncAdd, :args => 2, :sync => true) do |nvim, x, y|
               x + y
@@ -13,7 +14,8 @@ RSpec.describe "neovim-ruby-host" do
           end
         RUBY
 
-        File.write("./plugin2.rb", <<-RUBY)
+        plugin2_path = File.expand_path("./plugin2.rb")
+        File.write(plugin2_path, <<-RUBY)
           Neovim.plugin do |plug|
             plug.command(:AsyncSetLine, :args => 1) do |nvim, str|
               nvim.current.line = str
@@ -23,35 +25,24 @@ RSpec.describe "neovim-ruby-host" do
 
         nvim = Neovim.attach_child(["--headless", "-u", "NONE", "-N", "-n"])
 
-        # Start the remote host
         host_exe = File.expand_path("../../../bin/neovim-ruby-host", __FILE__)
-        nvim.command(%{let host = rpcstart("#{host_exe}", ["./plugin1.rb", "./plugin2.rb"])})
+        nvim.command("let host = rpcstart('#{host_exe}', ['#{plugin1_path}', '#{plugin2_path}'])")
 
-        # Send a "poll" request
-        expect(nvim.eval(%{rpcrequest(host, "poll")})).to eq("ok")
+        expect(nvim.eval("rpcrequest(host, 'poll')")).to eq("ok")
+        expect(nvim.eval("rpcrequest(host, '#{plugin1_path}:command:SyncAdd', 1, 2)")).to eq(3)
 
-        # Make a request to the synchronous SyncAdd method and store the result
-        nvim.command(%{let result = rpcrequest(host, "SyncAdd", 1, 2)})
-
-        # Write the result to the buffer
-        nvim.command("put =result")
-        nvim.command("normal o")
-
-        # Set the current line via the AsyncSetLine method
-        nvim.command(%{call rpcnotify(host, "AsyncSetLine", "foo")})
+        expect {
+          nvim.eval("rpcnotify(host, '#{plugin2_path}:command:AsyncSetLine', 'foo')")
+          nvim.eval("rpcrequest(host, 'poll')")
+        }.to change { nvim.current.buffer.lines.to_a }.from([""]).to(["foo"])
 
-        # Make an unknown notification
         expect {
-          nvim.command(%{call rpcnotify(host, "Unknown")})
+          nvim.eval("rpcnotify(host, 'Unknown')")
         }.not_to raise_error
 
-        # Make an unknown request
         expect {
-          nvim.command(%{call rpcrequest(host, "Unknown")})
-        }.to raise_error(ArgumentError, /unknown request/i)
-
-        # Assert the contents of the buffer
-        expect(nvim.current.buffer.lines).to eq(["", "3", "foo"])
+          nvim.eval("call rpcrequest(host, 'Unknown')")
+        }.to raise_error(ArgumentError)
       end
     end
   end

data/spec/helper.rb

@@ -8,6 +8,8 @@ if ENV["REPORT_COVERAGE"]
   Coveralls.wear!
 end
 
+Thread.abort_on_exception = true
+
 ENV["NVIM_EXECUTABLE"] = File.expand_path("../../vendor/neovim/build/bin/nvim", __FILE__)
 
 RSpec.configure do |config|

data/spec/neovim/async_session_spec.rb

@@ -28,7 +28,7 @@ module Neovim
         srv_thr.join
 
         expect(request).to be_a(Request)
-        expect(request.method_name).to eq(:func)
+        expect(request.method_name).to eq("func")
         expect(request.arguments).to eq([1, 2, 3])
       end
 
@@ -57,7 +57,7 @@ module Neovim
         srv_thr.join
 
         expect(notification).to be_a(Notification)
-        expect(notification.method_name).to eq(:func)
+        expect(notification.method_name).to eq("func")
         expect(notification.arguments).to eq([1, 2, 3])
       end
 

data/spec/neovim/buffer_spec.rb

@@ -6,53 +6,15 @@ module Neovim
     let(:buffer) { client.current.buffer }
 
     describe "#lines" do
-      before do
-        client.command("normal i1")
-        client.command("normal o2")
-        client.command("normal o3")
-      end
-
-      it "returns the buffer's lines as an array" do
-        expect(buffer.lines).to eq(["1", "2", "3"])
-      end
-
-      it "can be indexed into" do
-        expect(buffer.lines[1]).to eq("2")
-      end
-
-      it "can be sliced with a length" do
-        expect(buffer.lines[0, 2]).to eq(["1", "2"])
-      end
-
-      it "can be sliced with a range" do
-        expect(buffer.lines[0..1]).to eq(["1", "2"])
-      end
-
-      it "can be updated at an index" do
-        buffer.lines[0] = "foo"
-        expect(buffer.lines).to eq(["foo", "2", "3"])
-      end
-
-      it "can be updated with a length" do
-        buffer.lines[0, 2] = ["foo"]
-        expect(buffer.lines).to eq(["foo", "3"])
-      end
-
-      it "can be updated with a range" do
-        buffer.lines[0..1] = ["foo"]
-        expect(buffer.lines).to eq(["foo", "3"])
-      end
-
-      it "exposes the Enumerable interface" do
-        succ_lines = buffer.lines.collect(&:succ)
-        expect(succ_lines).to eq(["2", "3", "4"])
+      it "returns a LineRange" do
+        expect(buffer.lines).to be_a(LineRange)
       end
     end
 
     describe "#lines=" do
       it "updates the buffers lines" do
         buffer.lines = ["one", "two"]
-        expect(buffer.lines).to eq(["one", "two"])
+        expect(buffer.lines.to_a).to eq(["one", "two"])
       end
     end
   end

data/spec/neovim/current_spec.rb

@@ -74,5 +74,19 @@ module Neovim
         }.to change { current.tabpage.index }.to(initial_index)
       end
     end
+
+    describe "#range" do
+      it "returns the current range" do
+        expect(current.range).to be_a(LineRange)
+      end
+    end
+
+    describe "#range=" do
+      it "sets the current range" do
+        current.buffer.lines = ["1", "2", "3"]
+        current.range = (1..2)
+        expect(current.range.to_a).to eq(["2", "3"])
+      end
+    end
   end
 end

data/spec/neovim/event_loop_spec.rb

@@ -5,6 +5,19 @@ require "fileutils"
 
 module Neovim
   RSpec.describe EventLoop do
+    it "calls the setup callback" do
+      messages = []
+      rd, wr = IO.pipe
+      event_loop = EventLoop.new(rd, wr)
+
+      fiber = Fiber.new do
+        setup_cb = Proc.new { Fiber.yield(:setup) }
+        event_loop.run(nil, setup_cb)
+      end
+
+      expect(fiber.resume).to eq(:setup)
+    end
+
     shared_context "socket behavior" do
       it "sends and receives data" do
         messages = []
@@ -14,12 +27,13 @@ module Neovim
           messages << client.readpartial(1024)
 
           client.write("OK")
+          client.close
+          server.close
         end
 
         fiber = Fiber.new do
-          event_loop.send("data").run do |msg|
-            Fiber.yield(msg)
-          end
+          msg_cb = Proc.new { |msg| Fiber.yield(msg) }
+          event_loop.send("data").run(msg_cb)
         end
 
         expect(fiber.resume).to eq("OK")
@@ -44,15 +58,49 @@ module Neovim
       include_context "socket behavior"
     end
 
+    context "stdio" do
+      it "sends and receives data" do
+        old_stdout = STDOUT.dup
+        old_stdin = STDIN.dup
+
+        begin
+          srv_stdout, cl_stdout = IO.pipe
+          cl_stdin, srv_stdin = IO.pipe
+
+          STDOUT.reopen(cl_stdout)
+          STDIN.reopen(cl_stdin)
+
+          event_loop = EventLoop.stdio
+          messages = []
+
+          srv_thr = Thread.new do
+            messages << srv_stdout.readpartial(1024)
+            srv_stdin.write("OK")
+          end
+
+          fiber = Fiber.new do
+            msg_cb = Proc.new { |msg| Fiber.yield(msg) }
+            event_loop.send("data").run(msg_cb)
+          end
+
+          expect(fiber.resume).to eq("OK")
+          srv_thr.join
+          expect(messages).to eq(["data"])
+        ensure
+          STDOUT.reopen(old_stdout)
+          STDIN.reopen(old_stdin)
+        end
+      end
+    end
+
     context "child" do
       it "sends and receives data" do
         event_loop = EventLoop.child(["-n", "-u", "NONE"])
         message = MessagePack.pack([0, 0, :vim_strwidth, ["hi"]])
 
         fiber = Fiber.new do
-          event_loop.send(message).run do |msg|
-            Fiber.yield(msg)
-          end
+          msg_cb = Proc.new { |msg| Fiber.yield(msg) }
+          event_loop.send(message).run(msg_cb)
         end
 
         expect(fiber.resume).to eq(MessagePack.pack([1, 0, nil, 2]))