neovim 0.0.1

data/lib/neovim/msgpack_stream.rb

@@ -0,0 +1,44 @@
+require "msgpack"
+
+module Neovim
+  class MsgpackStream
+    def initialize(event_loop)
+      @event_loop = event_loop
+      @unpacker = MessagePack::Unpacker.new
+    end
+
+    def register_session(session)
+      session.api_info.types.each do |type, info|
+        klass = Neovim.const_get(type)
+        id = info.fetch("id")
+
+        @unpacker.register_type(id) do |data|
+          klass.new(MessagePack.unpack(data), session)
+        end
+      end
+    end
+
+    def send(msg)
+      @event_loop.send(MessagePack.pack(msg))
+      self
+    end
+
+    def run(&message_cb)
+      @event_loop.run do |data|
+        @unpacker.feed_each(data) do |msg|
+          message_cb.call(msg)
+        end
+      end
+    end
+
+    def stop
+      @event_loop.stop
+      self
+    end
+
+    def shutdown
+      @event_loop.shutdown
+      self
+    end
+  end
+end

data/lib/neovim/object.rb

@@ -0,0 +1,44 @@
+module Neovim
+  class Object
+    attr_reader :index
+
+    def initialize(index, session)
+      @index = index
+      @session = session
+    end
+
+    def respond_to?(method_name)
+      super || methods.include?(method_name.to_sym)
+    end
+
+    def method_missing(method_name, *args)
+      if methods.include?(method_name)
+        @session.request(qualify(method_name), @index, *args)
+      else
+        super
+      end
+    end
+
+    def to_msgpack(packer)
+      packer.pack(@index)
+    end
+
+    def methods
+      super | @session.api_methods_for_prefix(function_prefix)
+    end
+
+    private
+
+    def function_prefix
+      "#{self.class.to_s.split("::").last.downcase}_"
+    end
+
+    def qualify(method_name)
+      :"#{function_prefix}#{method_name}"
+    end
+  end
+
+  Buffer  = Class.new(Object)
+  Tabpage = Class.new(Object)
+  Window  = Class.new(Object)
+end

data/lib/neovim/session.rb

@@ -0,0 +1,35 @@
+require "neovim/api_info"
+
+module Neovim
+  class Session
+    attr_reader :api_info
+
+    def initialize(async_session)
+      @async_session = async_session
+
+      @api_info = APIInfo.new(request(:vim_get_api_info))
+      @async_session.register_session(self)
+    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
+
+      err ? raise(ArgumentError, err) : res
+    end
+
+    def api_methods_for_prefix(prefix)
+      @api_info.functions.inject([]) do |acc, function|
+        if function["name"] =~ /\A#{prefix}/
+          acc + [function["name"].sub(/\A#{prefix}/, "").to_sym]
+        else
+          acc
+        end
+      end
+    end
+  end
+end

data/lib/neovim/version.rb

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

data/neovim.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "neovim/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "neovim"
+  spec.version       = Neovim::VERSION
+  spec.authors       = ["Alex Genco"]
+  spec.email         = ["alexgenco@gmail.com"]
+  spec.summary       = %q{A Ruby client for Neovim}
+  spec.homepage      = "https://github.com/alexgenco/neovim-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^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"
+  spec.add_development_dependency "rspec",     "~> 3.0"
+  spec.add_development_dependency "coveralls", "~> 0.7.2"
+end

data/spec/helper.rb

@@ -0,0 +1,26 @@
+require "rubygems"
+require "bundler/setup"
+require "neovim"
+require "timeout"
+
+if ENV["REPORT_COVERAGE"]
+  require "coveralls"
+  Coveralls.wear!
+end
+
+ENV["NVIM_EXECUTABLE"] = File.expand_path("../../vendor/neovim/build/bin/nvim", __FILE__)
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |exp|
+    exp.syntax = :expect
+  end
+
+  config.disable_monkey_patching!
+  config.order = :random
+
+  Kernel.srand config.seed
+
+  config.around do |spec|
+    Timeout.timeout(1) { spec.run }
+  end
+end

data/spec/neovim/async_session_spec.rb

@@ -0,0 +1,96 @@
+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
+      end
+
+      req_cb = Proc.new do |*payload|
+        messages << payload
+        async.shutdown
+      end
+
+      async.run(req_cb)
+      srv_thr.join
+
+      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
+
+    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
+
+      not_cb = Proc.new do |*payload|
+        messages << payload
+        async.shutdown
+      end
+
+      async.run(nil, not_cb)
+      srv_thr.join
+
+      expect(messages).to eq([["func", [1, 2, 3]]])
+    end
+
+    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 = []
+
+      srv_thr = Thread.new do
+        client = server.accept
+        messages << client.read_nonblock(1024)
+
+        client.write(MessagePack.pack(
+          [1, 0, [0, "error"], "result"]
+        ))
+
+        client.close
+        server.close
+      end
+
+      async.request("func", 1, 2, 3) do |error, result|
+        expect(error).to eq("error")
+        expect(result).to eq("result")
+        async.shutdown
+      end
+
+      async.run
+      srv_thr.join
+
+      expect(messages).to eq(
+        [MessagePack.pack([0, 0, "func", [1, 2, 3]])]
+      )
+    end
+  end
+end

data/spec/neovim/buffer_spec.rb

@@ -0,0 +1,37 @@
+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/client_spec.rb

@@ -0,0 +1,57 @@
+require "helper"
+
+module Neovim
+  RSpec.describe Client do
+    let(:client) { Neovim.attach_child(["-n", "-u", "NONE"]) }
+
+    describe "#respond_to?" do
+      it "returns true for vim functions" do
+        expect(client).to respond_to(:strwidth)
+      end
+
+      it "returns true for Ruby functions" do
+        expect(client).to respond_to(:inspect)
+      end
+
+      it "returns false otherwise" do
+        expect(client).not_to respond_to(:foobar)
+      end
+    end
+
+    describe "#method_missing" do
+      it "enables vim_* function calls" do
+        expect(client.strwidth("hi")).to eq(2)
+      end
+
+      it "raises exceptions for unknown methods" do
+        expect {
+          client.foobar
+        }.to raise_error(NoMethodError)
+      end
+
+      it "raises exceptions for incorrect usage" do
+        expect {
+          client.strwidth("too", "many")
+        }.to raise_error("Wrong number of arguments: expecting 1 but got 2")
+      end
+    end
+
+    describe "#methods" do
+      it "includes builtin methods" do
+        expect(client.methods).to include(:inspect)
+      end
+
+      it "includes api methods" do
+        expect(client.methods).to include(:strwidth)
+      end
+    end
+
+    describe "#current" do
+      it "returns the target" do
+        expect(client.current.buffer).to be_a(Buffer)
+        expect(client.current.window).to be_a(Window)
+        expect(client.current.tabpage).to be_a(Tabpage)
+      end
+    end
+  end
+end

data/spec/neovim/current_spec.rb

@@ -0,0 +1,78 @@
+require "helper"
+
+module Neovim
+  RSpec.describe Current do
+    let(:client) { Neovim.attach_child(["-n", "-u", "NONE"]) }
+    let(:current) { client.current }
+
+    describe "#line" do
+      it "returns an empty string if the current line is empty" do
+        expect(current.line).to eq("")
+      end
+
+      it "returns the contents of the line" do
+        current.line = "New content"
+        expect(current.line).to eq("New content")
+      end
+    end
+
+    describe "#line=" do
+      it "sets the content of the current line" do
+        current.line = "New content"
+        expect(current.line).to eq("New content")
+      end
+    end
+
+    describe "#buffer" do
+      it "returns the current buffer" do
+        expect(current.buffer).to be_a(Buffer)
+      end
+    end
+
+    describe "#buffer=" do
+      it "sets the current buffer" do
+        initial_index = current.buffer.index
+        client.command("vnew")
+
+        expect {
+          current.buffer = initial_index
+        }.to change { current.buffer.index }
+      end
+    end
+
+    describe "#window" do
+      it "returns the current window" do
+        expect(current.window).to be_a(Window)
+      end
+    end
+
+    describe "#window=" do
+      it "sets the current window" do
+        client.command("vsp")
+        expect(current.window.index).not_to eq(1)
+
+        expect {
+          current.window = 1
+        }.to change { current.window.index }.to(1)
+      end
+    end
+
+    describe "#tabpage" do
+      it "returns the current tabpage" do
+        expect(current.tabpage).to be_a(Tabpage)
+      end
+    end
+
+    describe "#tabpage=" do
+      it "sets the current tabpage" do
+        initial_index = current.tabpage.index
+        client.command("tabnew")
+        expect(current.tabpage.index).not_to eq(initial_index)
+
+        expect {
+          current.tabpage = initial_index
+        }.to change { current.tabpage.index }.to(initial_index)
+      end
+    end
+  end
+end