neovim-0.3.1/0000755000004100000410000000000013000040041013016 5ustar www-datawww-dataneovim-0.3.1/Rakefile0000644000004100000410000000035113000040041014462 0ustar www-datawww-datarequire "bundler/gem_tasks" require "rspec/core/rake_task" RSpec::Core::RakeTask.new(:spec) task :default => :spec desc "Generate Neovim remote API docs" task :docs do sh File.expand_path("../script/generate_docs", __FILE__) end neovim-0.3.1/bin/0000755000004100000410000000000013000040041013566 5ustar www-datawww-dataneovim-0.3.1/bin/neovim-ruby-host0000755000004100000410000000042313000040041016742 0ustar www-datawww-data#!/usr/bin/env ruby require "neovim/host" ARGV.each do |arg| break if arg == "--" if ["--version", "-V"].include?(arg) puts Neovim::VERSION exit(0) end end if STDIN.tty? abort("Can't run neovim-ruby-host interactively.") else Neovim::Host.run(ARGV) end neovim-0.3.1/Gemfile0000644000004100000410000000042313000040041014310 0ustar www-datawww-datasource "https://rubygems.org" gemspec group :development do if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new("2.0.0") gem "coveralls" gem "pry-byebug" else gem "term-ansicolor", "1.3.2" gem "coveralls", "0.8.13" gem "pry-debugger" end end neovim-0.3.1/.coveralls.yml0000644000004100000410000000003013000040041015602 0ustar www-datawww-dataservice_name: travis-ci neovim-0.3.1/neovim.gemspec0000644000004100000410000000156113000040041015663 0ustar www-datawww-data# 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 = "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 = ["neovim-ruby-host"] spec.test_files = spec.files.grep(%r{^spec/}) spec.require_paths = ["lib"] spec.add_dependency "msgpack", "~> 1.0" spec.add_development_dependency "bundler" spec.add_development_dependency "rake" spec.add_development_dependency "pry" spec.add_development_dependency "rspec", "~> 3.0" end neovim-0.3.1/script/0000755000004100000410000000000013000040041014322 5ustar www-datawww-dataneovim-0.3.1/script/j2mp0000755000004100000410000000024313000040041015117 0ustar www-datawww-data#!/usr/bin/env ruby # # Convert STDIN from JSON to MessagePack. require "json" require "msgpack" ARGF.binmode print MessagePack.pack(JSON.parse(ARGF.read.strip)) neovim-0.3.1/script/mp2j0000755000004100000410000000026413000040041015122 0ustar www-datawww-data#!/usr/bin/env ruby # # Convert STDIN from MessagePack to JSON require "json" require "msgpack" ARGF.binmode MessagePack::Unpacker.new(ARGF).each { |data| print JSON.dump(data) } neovim-0.3.1/script/generate_docs0000755000004100000410000000404013000040041017050 0ustar www-datawww-data#!/usr/bin/env ruby $:.unshift File.expand_path("../../lib", __FILE__) require "neovim" require "pathname" vim_docs = [] buffer_docs = [] window_docs = [] tabpage_docs = [] session = Neovim::Session.child(%w(nvim -u NONE -n)) vim_defs = Neovim::Client.instance_methods(false) buffer_defs = Neovim::Buffer.instance_methods(false) tabpage_defs = Neovim::Tabpage.instance_methods(false) window_defs = Neovim::Window.instance_methods(false) session.request(:vim_get_api_info)[1]["functions"].each do |func| prefix, method_name = func["name"].split("_", 2) case prefix when "vim" next if vim_defs.include?(method_name.to_sym) when "buffer" next if buffer_defs.include?(method_name.to_sym) when "tabpage" next if tabpage_defs.include?(method_name.to_sym) when "window" next if window_defs.include?(method_name.to_sym) end return_type = func["return_type"] params = func["parameters"] params.shift unless prefix == "vim" param_names = params.map(&:last) param_str = params.empty? ? "" : "(#{param_names.join(", ")})" method_decl = "@method #{method_name}#{param_str}" method_desc = " Send the +#{prefix}_#{method_name}+ RPC to +nvim+" param_docs = params.map do |type, name| " @param [#{type}] #{name}" end return_doc = " @return [#{return_type}]\n" method_doc = [method_decl, method_desc, *param_docs, return_doc].join("\n") method_doc.gsub!(/ArrayOf\((\w+)[^)]*\)/, 'Array<\1>') method_doc.gsub!(/Integer/, "Fixnum") case prefix when "vim" vim_docs << method_doc when "buffer" buffer_docs << method_doc when "tabpage" tabpage_docs << method_doc when "window" window_docs << method_doc end end lib_dir = Pathname.new(File.expand_path("../../lib/neovim", __FILE__)) { "client.rb" => vim_docs, "buffer.rb" => buffer_docs, "tabpage.rb" => tabpage_docs, "window.rb" => window_docs, }.each do |filename, docs| path = lib_dir.join(filename) contents = File.read(path) doc_str = ["=begin", *docs, "=end"].join("\n") File.write(path, contents.sub(/=begin.+=end/m, doc_str)) end neovim-0.3.1/LICENSE.txt0000644000004100000410000000205313000040041014641 0ustar www-datawww-dataCopyright (c) 2014 Alex Genco MIT License Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. neovim-0.3.1/spec/0000755000004100000410000000000013000040041013750 5ustar www-datawww-dataneovim-0.3.1/spec/helper.rb0000644000004100000410000000310113000040041015547 0ustar www-datawww-datarequire "bundler/setup" if ENV["REPORT_COVERAGE"] require "coveralls" Coveralls.wear! end require "fileutils" require "neovim" require "pry" require "stringio" require "timeout" module Support def self.workspace File.expand_path("../workspace", __FILE__) end def self.socket_path file_path("nvim.sock") end def self.tcp_port server = TCPServer.new("0.0.0.0", 0) begin server.addr[1] ensure server.close end end def self.file_path(name) File.join(workspace, name) end def self.setup_workspace FileUtils.mkdir_p(workspace) end def self.teardown_workspace FileUtils.rm_rf(workspace) end def self.child_argv ["nvim", "--headless", "-i", "NONE", "-u", "NONE", "-n"] end end unless system("#{Support.child_argv.join(" ")} +q") warn("Can't find `nvim` executable. See installation instructions:") warn("https://github.com/neovim/neovim/wiki/Installing-Neovim") exit(1) end RSpec.configure do |config| config.expect_with :rspec do |exp| exp.syntax = :expect end config.disable_monkey_patching! config.order = :random config.color = true config.around(:example) do |spec| Support.setup_workspace begin Timeout.timeout(5) { spec.run } ensure Support.teardown_workspace end end config.around(:example, :silence_logging) do |spec| old_logger = Neovim.logger begin Neovim.logger = Logger.new(StringIO.new) spec.run ensure Neovim.logger = old_logger end end Kernel.srand config.seed end Thread.abort_on_exception = true neovim-0.3.1/spec/neovim/0000755000004100000410000000000013000040041015245 5ustar www-datawww-dataneovim-0.3.1/spec/neovim/host_spec.rb0000644000004100000410000001105713000040041017565 0ustar www-datawww-datarequire "helper" require "neovim/host" module Neovim RSpec.describe Host do let(:session) { instance_double(Session) } let(:client) { instance_double(Client) } let(:host) { Host.new(session, client) } describe ".run" do it "loads plugins and runs the host event loop" do paths = ["/foo", "/bar"] expect(Host).to receive(:new).and_return(host) expect(host).to receive(:run) loader = instance_double(Host::Loader) expect(loader).to receive(:load).with(paths) expect(Host::Loader).to receive(:new). with(host). and_return(loader) Host.run(paths, :session => session, :client => client) end end describe "#run" do it "runs the session event loop and handles messages" do message = double(:message) expect(session).to receive(:run).and_yield(message) expect(host).to receive(:handle).with(message) host.run end it "rescues session exceptions", :silence_logging do expect(session).to receive(:run).and_raise("BOOM") expect { host.run }.not_to raise_error end end describe "#handlers" do it "has a default poll handler" do expect(host.handlers["poll"]).to respond_to(:call) end end describe "#specs" do it "has default specs" do expect(host.specs).to eq({}) end end describe "#register" do it "adds specs" do plugin = Plugin.from_config_block("source") do |plug| plug.command(:Foo) end expect { host.register(plugin) }.to change { host.specs }.from({}).to("source" => plugin.specs) end it "adds plugin handlers" do plugin = Plugin.from_config_block("source") do |plug| plug.command(:Foo) end expect { host.register(plugin) }.to change { host.handlers["source:command:Foo"] }.from(nil).to(kind_of(Proc)) end it "doesn't add top-level RPCs to specs" do plugin = Plugin.from_config_block("source") do |plug| plug.__send__(:rpc, :Foo) end expect { host.register(plugin) }.to change { host.specs }.from({}).to("source" => []) end end describe "#handle" do it "calls the poll handler" do message = double(:message, :method_name => "poll", :sync? => true) expect(message).to receive(:respond).with("ok") host.handle(message) end it "calls the specs handler" do plugin = Plugin.from_config_block("source") do |plug| plug.command(:Foo) end host.register(plugin) message = double(:message, :method_name => "specs", :sync? => true, :arguments => ["source"]) expect(message).to receive(:respond).with(plugin.specs) host.handle(message) end it "calls a plugin sync handler" do plugin = Plugin.from_config_block("source") do |plug| plug.command(:Foo, :sync => true) { |client, arg| [client, arg] } end host.register(plugin) message = double(:message, :method_name => "source:command:Foo", :sync? => true, :arguments => [:arg]) expect(message).to receive(:respond).with([client, :arg]) host.handle(message) end it "rescues plugin sync handler exceptions", :silence_logging do plugin = Plugin.from_config_block("source") do |plug| plug.command(:Foo, :sync => true) { raise "BOOM" } end host.register(plugin) message = double(:message, :method_name => "source:command:Foo", :sync? => true, :arguments => []) expect(message).to receive(:error).with("BOOM") host.handle(message) end it "calls a plugin async handler" do async_proc = Proc.new {} plugin = Plugin.from_config_block("source") do |plug| plug.command(:Foo, &async_proc) end host.register(plugin) message = double(:message, :method_name => "source:command:Foo", :sync? => false, :arguments => [:arg]) expect(async_proc).to receive(:call).with(client, :arg) host.handle(message) end it "calls a default sync handler" do message = double(:message, :method_name => "foobar", :sync? => true) expect(message).to receive(:error).with("Unknown request foobar") host.handle(message) end it "calls a default async handler" do message = double(:message, :method_name => "foobar", :sync? => false) host.handle(message) end end end end neovim-0.3.1/spec/neovim/buffer_spec.rb0000644000004100000410000001147013000040041020060 0ustar www-datawww-datarequire "helper" module Neovim RSpec.describe Buffer do let(:client) { Neovim.attach_child(Support.child_argv) } let(:buffer) { client.current.buffer } after { client.shutdown } describe "#lines" do it "returns a LineRange" do expect(buffer.lines).to be_a(LineRange) end end describe "#lines=" do it "updates the buffer's lines" do buffer.lines = ["one", "two"] expect(buffer.lines.to_a).to eq(["one", "two"]) end end describe "#range" do it "returns a LineRange" do expect(buffer.range).to be_a(LineRange) end end describe "#range=" do it "updates the buffer's range" do buffer.lines = ["one", "two", "three"] buffer.range = (0..1) expect(buffer.range.to_a).to eq(["one", "two"]) end end describe "if_ruby compatibility" do describe "#name" do it "returns the buffer path as a string" do buffer.set_name("test_buf") expect(File.basename(buffer.name)). to end_with("test_buf") end end describe "#number" do it "returns the buffer index" do expect(buffer.number).to be(1) end end describe "#count" do it "returns the number of lines" do buffer.lines = ["one", "two", "three"] expect(buffer.count).to be(3) end end describe "#length" do it "returns the number of lines" do buffer.lines = ["one", "two", "three"] expect(buffer.length).to be(3) end end describe "#[]" do it "returns the given line" do buffer.lines = ["one", "two", "three"] expect(buffer[2]).to eq("two") end end describe "#[]=" do it "sets the given line" do buffer.lines = ["first", "second"] expect { buffer[2] = "last" }.to change { buffer.lines.to_a }.to(["first", "last"]) end it "returns the line" do expect(buffer[0] = "first").to eq("first") end it "raises an out of bounds exception" do expect { buffer[10] = "line" }.to raise_error(/out of bounds/) end end describe "#delete" do it "deletes the line at the given index" do buffer.lines = ["one", "two"] expect { buffer.delete(1) }.to change { buffer.lines }.to(["two"]) end end describe "#append" do it "adds a line after the given index" do buffer.lines = ["one"] expect { buffer.append(1, "two") }.to change { buffer.lines.to_a }.to(["one", "two"]) end it "unshifts buffer lines using index 0" do buffer.lines = [] expect { buffer.append(0, "two") buffer.append(0, "one") }.to change { buffer.lines.to_a }.to(["one", "two", ""]) end it "leaves the cursor unchanged" do expect { buffer.append(0, "one") }.not_to change { client.current.window.cursor } end it "raises for out of bounds indexes" do expect { buffer.append(-1, "err") }.to raise_error(/out of bounds/i) expect { buffer.append(10, "err") }.to raise_error(/out of bounds/i) end it "returns the appended line" do expect(buffer.append(0, "two")).to eq("two") end end describe "#line" do it "returns the current line on an active buffer" do buffer.lines = ["one", "two"] expect(buffer.line).to eq("one") client.command("normal j") expect(buffer.line).to eq("two") end it "returns nil on an inactive buffer" do original = buffer client.command("vnew") expect(original.line).to be(nil) end end describe "#line=" do it "sets the current line on an active buffer" do expect { buffer.line = "line" }.to change { buffer.lines }.to(["line"]) end it "has no effect when called on an inactive buffer" do original = buffer client.command("vnew") original.line = "line" expect(original.lines.to_a).to eq([""]) expect(client.current.buffer.lines.to_a).to eq([""]) end end describe "#line_number" do it "returns the current line number on an active buffer" do client.command("normal oone") expect(buffer.line_number).to be(2) end it "returns nil on an inactive buffer" do original = buffer client.command("vnew") expect(original.line_number).to be(nil) end end end end end neovim-0.3.1/spec/neovim/logging_spec.rb0000644000004100000410000000347213000040041020240 0ustar www-datawww-datarequire "helper" module Neovim RSpec.describe Logging do around do |spec| old_logger = Logging.logger begin Logging.send(:remove_instance_variable, :@logger) spec.run ensure Logging.logger = old_logger end end describe ".logger" do it "fetches the output from $NVIM_RUBY_LOG_FILE" do logger = instance_double(Logger, :level= => nil) expect(Logger).to receive(:new).with("/tmp/nvim.log").and_return(logger) Logging.logger("NVIM_RUBY_LOG_FILE" => "/tmp/nvim.log") expect(Logging.logger).to be(logger) end it "defaults the output to STDERR" do logger = instance_double(Logger, :level= => nil) expect(Logger).to receive(:new).with(STDERR).and_return(logger) Logging.logger({}) expect(Logging.logger).to be(logger) end it "fetches the level from $NVIM_RUBY_LOG_LEVEL as a string" do logger = instance_double(Logger) expect(Logger).to receive(:new).and_return(logger) expect(logger).to receive(:level=).with(Logger::DEBUG) Logging.logger("NVIM_RUBY_LOG_LEVEL" => "DEBUG") expect(Logging.logger).to be(logger) end it "fetches the level from $NVIM_RUBY_LOG_LEVEL as an integer" do logger = instance_double(Logger) expect(Logger).to receive(:new).and_return(logger) expect(logger).to receive(:level=).with(0) Logging.logger("NVIM_RUBY_LOG_LEVEL" => "0") expect(Logging.logger).to be(logger) end it "defaults the level to WARN" do logger = instance_double(Logger) expect(Logger).to receive(:new).and_return(logger) expect(logger).to receive(:level=).with(Logger::WARN) Logging.logger({}) expect(Logging.logger).to be(logger) end end end end neovim-0.3.1/spec/neovim/current_spec.rb0000644000004100000410000000735413000040041020277 0ustar www-datawww-datarequire "helper" module Neovim RSpec.describe Current do let(:client) { Neovim.attach_child(Support.child_argv) } let(:current) { client.current } after { client.shutdown } 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 from an integer" do initial_index = current.buffer.index client.command("vnew") expect { current.buffer = initial_index }.to change { current.buffer.index }.to(initial_index) end it "sets the current buffer from a Buffer" do b0 = current.buffer client.command("vnew") b1 = current.buffer expect { current.buffer = b0 }.to change { current.buffer }.from(b1).to(b0) end it "returns an integer" do index = current.buffer.index expect(current.buffer = index).to eq(index) end it "returns a Buffer" do buffer = current.buffer expect(current.buffer = buffer).to eq(buffer) 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 from an integer" do client.command("vsp") expect(current.window.index).not_to eq(1) expect { current.window = 1 }.to change { current.window.index }.to(1) end it "sets the current window from a Window" do w0 = current.window client.command("vsp") w1 = current.window expect { current.window = w0 }.to change { current.window }.from(w1).to(w0) end it "returns an integer" do index = current.window.index expect(current.window = index).to eq(index) end it "returns a Window" do w0 = current.window expect(current.window = w0).to eq(w0) 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 from an integer" 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 it "sets the current tabpage from a Tabpage" do tp0 = current.tabpage client.command("tabnew") tp1 = current.tabpage expect { current.tabpage = tp0 }.to change { current.tabpage }.from(tp1).to(tp0) end it "returns an integer" do index = current.tabpage.index expect(current.tabpage = index).to eq(index) end it "returns a Tabpage" do tp0 = current.tabpage expect(current.tabpage = tp0).to eq(tp0) end end describe "#range=" do it "sets the line range of the current buffer" do current.buffer.lines = ["one", "two", "three", "four"] current.range = (1..2) expect(current.buffer.range.to_a).to eq(["two", "three"]) end end end end neovim-0.3.1/spec/neovim/remote_object_spec.rb0000644000004100000410000000544513000040041021435 0ustar www-datawww-datarequire "helper" module Neovim RSpec.describe RemoteObject do let(:client) { Neovim.attach_child(Support.child_argv) } after { client.shutdown } context Window do let(:window) { client.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 it "falls back to super" do expect { window.foobar }.to raise_error(NoMethodError) 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) { client.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) { client.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 neovim-0.3.1/spec/neovim/session_spec.rb0000644000004100000410000001054213000040041020271 0ustar www-datawww-datarequire "helper" require "securerandom" module Neovim RSpec.describe Session do shared_context "session behavior" do describe "#channel_id" do it "returns nil when the API hasn't been discovered" do expect(session.channel_id).to be(nil) end it "returns the channel_id when the API has been discovered" do session.discover_api expect(session.channel_id).to respond_to(:to_int) end end describe "#request" do it "synchronously returns a result" do expect(session.request(:vim_strwidth, "foobar")).to be(6) end it "raises an exception when there are errors" do expect { session.request(:vim_strwidth, "too", "many") }.to raise_error(/wrong number of arguments/i) end it "handles large data" do large_str = Array.new(1024 * 17) { SecureRandom.hex(1) }.join session.request(:vim_set_current_line, large_str) expect(session.request(:vim_get_current_line)).to eq(large_str) end it "fails outside of the main thread" do expect { Thread.new { session.request(:vim_strwidth, "foo") }.join }.to raise_error(/outside of the main thread/) end end describe "#notify" do it "returns nil" do expect(session.notify(:vim_input, "jk")).to be(nil) end it "doesn't raise exceptions" do expect { session.notify(:vim_strwidth, "too", "many") }.not_to raise_error end it "handles large data" do large_str = Array.new(1024 * 17) { SecureRandom.hex(1) }.join session.notify(:vim_set_current_line, large_str) expect(session.request(:vim_get_current_line)).to eq(large_str) end it "fails outside of the main thread" do expect { Thread.new { session.notify(:vim_set_current_line, "foo") }.join }.to raise_error(/outside of the main thread/) end end describe "#run" do it "enqueues messages received during blocking requests" do session.request(:vim_subscribe, "my_event") session.request(:vim_command, "call rpcnotify(0, 'my_event', 'foo')") message = nil session.run do |msg| message = msg session.shutdown end expect(message).to be_a(Session::Notification) expect(message.method_name).to eq("my_event") expect(message.arguments).to eq(["foo"]) end it "supports requests within callbacks" do session.request(:vim_subscribe, "my_event") session.request(:vim_command, "call rpcnotify(0, 'my_event', 'foo')") result = nil session.run do |msg| result = session.request(:vim_strwidth, msg.arguments.first) session.shutdown end expect(result).to be(3) end end end context "tcp" do let!(:nvim_port) { Support.tcp_port } let!(:nvim_pid) do pid = Process.spawn( {"NVIM_LISTEN_ADDRESS" => "0.0.0.0:#{nvim_port}"}, Support.child_argv.join(" "), [:out, :err] => "/dev/null" ) begin TCPSocket.open("0.0.0.0", nvim_port).close rescue Errno::ECONNREFUSED retry end pid end after do Process.kill(:TERM, nvim_pid) Process.waitpid(nvim_pid) end let!(:session) { Session.tcp("0.0.0.0", nvim_port) } include_context "session behavior" end context "unix" do let!(:socket_path) { Support.socket_path } let!(:nvim_pid) do pid = Process.spawn( {"NVIM_LISTEN_ADDRESS" => socket_path}, Support.child_argv.join(" "), [:out, :err] => "/dev/null" ) begin UNIXSocket.new(socket_path).close rescue Errno::ENOENT, Errno::ECONNREFUSED retry end pid end after do Process.kill(:TERM, nvim_pid) Process.waitpid(nvim_pid) end let!(:session) { Session.unix(socket_path) } include_context "session behavior" end context "child" do let!(:session) { Session.child(Support.child_argv) } include_context "session behavior" after { session.shutdown } end end end neovim-0.3.1/spec/neovim/window_spec.rb0000644000004100000410000000445013000040041020116 0ustar www-datawww-datarequire "helper" module Neovim RSpec.describe Window do let(:client) { Neovim.attach_child(Support.child_argv) } let(:window) { client.current.window } after { client.shutdown } describe "if_ruby compatibility" do describe "#buffer" do it "returns the buffer displayed in the window" do expect(window.buffer).to be_a(Buffer) end end describe "#height" do it "returns the height of the window" do client.set_option("lines", 5) expect(window.height).to be(3) end end describe "#height=" do it "sets the height of the window" do expect { window.height = 5 }.to change { window.height }.to(5) end end describe "#width" do it "returns the width of the window" do client.set_option("columns", 20) expect(window.width).to be(20) end end describe "#width=" do it "sets the width of a vertically split window" do client.command("vsplit") expect { window.width += 1 }.to change { window.width }.by(1) end end describe "#cursor" do it "returns the cursor coordinates" do expect(window.cursor).to eq([1, 0]) end end describe "#cursor=" do it "uses 1-index for line numbers" do window.buffer.lines = ["one", "two"] client.command("normal G") expect { window.cursor = [1, 2] }.to change { client.current.line }.from("two").to("one") end it "uses 0-index for column numbers" do window.buffer.lines = ["one", "two"] window.cursor = [1, 1] expect { client.command("normal ix") }.to change { client.current.line }.to("oxne") end it "supports out of range indexes" do window.buffer.lines = ["x", "xx"] expect { window.cursor = [10, 10] }.to change { window.cursor }.to([2, 1]) expect { window.cursor = [0, -1] }.to change { window.cursor }.to([1, 0]) end it "returns the cursor array" do expect(window.cursor = [10, 10]).to eq([10, 10]) end end end end end neovim-0.3.1/spec/neovim/ruby_provider/0000755000004100000410000000000013000040041020140 5ustar www-datawww-dataneovim-0.3.1/spec/neovim/ruby_provider/buffer_ext_spec.rb0000644000004100000410000000162513000040041023634 0ustar www-datawww-datarequire "helper" require "neovim/ruby_provider/buffer_ext" module Neovim RSpec.describe Buffer do let!(:nvim) do Neovim.attach_child(Support.child_argv).tap do |nvim| stub_const("::Vim", nvim) end end after { nvim.shutdown } describe ".current" do it "returns the current buffer from the global Vim client" do expect(Buffer.current).to eq(nvim.get_current_buffer) end end describe ".count" do it "returns the current buffer count from the global Vim client" do expect { nvim.command("new") }.to change { Buffer.count }.by(1) end end describe ".[]" do it "returns the buffer from the global Vim client at the given index" do expect(Buffer[0]).to eq(nvim.get_current_buffer) nvim.command("new") expect(Buffer[1]).to eq(nvim.get_current_buffer) end end end end neovim-0.3.1/spec/neovim/ruby_provider/vim_spec.rb0000644000004100000410000000122313000040041022270 0ustar www-datawww-datarequire "helper" require "neovim/ruby_provider/vim" RSpec.describe Vim do describe Vim::Buffer do it "refers to Neovim::Buffer" do expect(Vim::Buffer).to be(Neovim::Buffer) end end describe Vim::Window do it "refers to Neovim::Window" do expect(Vim::Window).to be(Neovim::Window) end end describe VIM do it "is an alias for the Vim module" do expect(VIM).to be(Vim) end end describe "#method_missing" do it "delegates method calls to @__client" do client = double(:client) expect(client).to receive(:foo).with(1, 2) Vim.__client = client Vim.foo(1, 2) end end end neovim-0.3.1/spec/neovim/ruby_provider/window_ext_spec.rb0000644000004100000410000000231513000040041023667 0ustar www-datawww-datarequire "helper" require "neovim/ruby_provider/window_ext" module Neovim RSpec.describe Window do let!(:nvim) do Neovim.attach_child(Support.child_argv).tap do |nvim| stub_const("::Vim", nvim) end end after { nvim.shutdown } describe ".current" do it "returns the current window from the global Vim client" do expect(Window.current).to eq(nvim.get_current_window) end end describe ".count" do it "returns the current window count from the global Vim client" do expect { nvim.command("new") }.to change { Window.count }.by(1) end it "only includes windows within a tabpage" do expect { nvim.command("tabnew") }.not_to change { Window.count }.from(1) end end describe ".[]" do it "returns the window at the given index" do expect { nvim.command("new") }.to change { Window[1] }.from(nil).to(kind_of(Window)) end it "only includes windows within a tabpage" do nvim.command("new") expect { nvim.command("tabnew") }.to change { Window[1] }.from(kind_of(Window)).to(nil) end end end end neovim-0.3.1/spec/neovim/client_spec.rb0000644000004100000410000000543013000040041020064 0ustar www-datawww-datarequire "helper" module Neovim RSpec.describe Client do let(:client) { Neovim.attach_child(Support.child_argv) } after { client.shutdown } specify do client.strwidth("foo") client.strwidth("bar") client.command("echom 'hi'") end 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 describe "if_ruby compatibility" do describe "#evaluate" do it "evaluates the vim expression" do client.command("let g:foo = [1, 2]") expect(client.evaluate("g:foo")).to eq([1, 2]) end end describe "#message" do it "writes a message (testing presence of method, not side-effects)" do client.send(:message, "test") end end describe "#set_option" do it "sets an option" do expect { client.set_option("makeprg", "rake") }.to change { client.get_option("makeprg") }.to("rake") end it "sets an option as a single string" do expect { client.set_option("makeprg=rake") }.to change { client.get_option("makeprg") }.to("rake") end it "sets an integer option as a single string" do expect { client.set_option("timeoutlen=0") }.to change { client.get_option("timeoutlen") }.to(0) end end describe "#command" do it "runs the provided command" do expect { client.command("normal ix") }.to change { client.current.buffer.lines }.to(["x"]) end end end end end neovim-0.3.1/spec/neovim/session/0000755000004100000410000000000013000040041016730 5ustar www-datawww-dataneovim-0.3.1/spec/neovim/session/rpc_spec.rb0000644000004100000410000000572613000040041021065 0ustar www-datawww-datarequire "helper" module Neovim class Session RSpec.describe RPC do shared_context "rpc behavior" do it "receives requests" do serializer = Serializer.new(event_loop) rpc = RPC.new(serializer) server_thread = Thread.new do client = server.accept client.write( MessagePack.pack( [0, 123, "func", [1, 2, 3]] ) ) end request = nil rpc.run do |msg| request = msg rpc.shutdown end server_thread.join expect(request).to be_a(Request) expect(request.method_name).to eq("func") expect(request.arguments).to eq([1, 2, 3]) end it "receives notifications" do serializer = Serializer.new(event_loop) rpc = RPC.new(serializer) server_thread = Thread.new do client = server.accept client.write( MessagePack.pack( [2, "func", [1, 2, 3]] ) ) end notification = nil rpc.run do |message| notification = message rpc.shutdown end server_thread.join expect(notification).to be_a(Notification) expect(notification.method_name).to eq("func") expect(notification.arguments).to eq([1, 2, 3]) end it "receives responses to requests" do serializer = Serializer.new(event_loop) rpc = RPC.new(serializer) request = nil server_thread = Thread.new do client = server.accept request = client.readpartial(1024) client.write( MessagePack.pack( [1, 0, [0, "error"], "result"] ) ) end error, result = nil rpc.request("func", 1, 2, 3) do |err, res| error, result = err, res rpc.shutdown end.run expect(error).to eq("error") expect(result).to eq("result") server_thread.join rpc.shutdown expect(request).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 "rpc behavior" end context "unix" do let!(:server) { UNIXServer.new(Support.socket_path) } let!(:event_loop) { EventLoop.unix(Support.socket_path) } include_context "rpc behavior" end describe "#run" do it "logs exceptions" do serializer = instance_double(Serializer) rpc = RPC.new(serializer) expect(serializer).to receive(:run).and_raise("BOOM") expect(rpc).to receive(:fatal).with(/BOOM/) rpc.run end end end end end neovim-0.3.1/spec/neovim/session/api_spec.rb0000644000004100000410000000337613000040041021051 0ustar www-datawww-datarequire "helper" module Neovim class Session RSpec.describe API do describe ".null" do it "returns an empty API object" do api = API.null expect(api.types).to be_empty expect(api.functions).to be_empty end end describe "#function" do it "returns a sync function object" do api = API.new( [nil, {"functions" => [ {"name" => "vim_sync", "async" => false} ]}] ) function = api.function("vim_sync") expect(function.name).to eq("vim_sync") expect(function.async).to be(false) session = instance_double(Session) expect(session).to receive(:request).with("vim_sync", "msg") function.call(session, "msg") end it "returns an async function object" do api = API.new( [nil, {"functions" => [ {"name" => "vim_async", "async" => true} ]}] ) function = api.function("vim_async") expect(function.name).to eq("vim_async") expect(function.async).to be(true) session = instance_double(Session) expect(session).to receive(:notify).with("vim_async", "msg") function.call(session, "msg") end end describe "#functions_with_prefix" do it "returns relevant functions" do api = API.new( [nil, {"functions" => [ {"name" => "vim_strwidth"}, {"name" => "buffer_get_lines"} ]}] ) functions = api.functions_with_prefix("vim_") expect(functions.size).to be(1) expect(functions.first.name).to eq("vim_strwidth") end end end end end neovim-0.3.1/spec/neovim/session/notification_spec.rb0000644000004100000410000000066613000040041022765 0ustar www-datawww-datarequire "helper" module Neovim class Session RSpec.describe Notification do let(:notification) { Notification.new(:method, ["arg"]) } it "has readers" do expect(notification.method_name).to eq("method") expect(notification.arguments).to eq(["arg"]) end describe "#sync?" do it "is false" do expect(notification.sync?).to be(false) end end end end end neovim-0.3.1/spec/neovim/session/serializer_spec.rb0000644000004100000410000000327413000040041022446 0ustar www-datawww-datarequire "socket" require "helper" module Neovim class Session RSpec.describe Serializer do shared_context "serializer behavior" do it "sends and receives data" do serializer = Serializer.new(event_loop) request = nil server_thread = Thread.new do client = server.accept request = client.readpartial(1024) client.write(MessagePack.pack(["res"])) client.close server.close end response = nil serializer.write(["req"]).run do |message| response = message serializer.shutdown end server_thread.join expect(request).to eq(MessagePack.pack(["req"])) expect(response).to eq(["res"]) 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 "serializer behavior" end context "unix" do let!(:server) { UNIXServer.new(Support.socket_path) } let!(:event_loop) { EventLoop.unix(Support.socket_path) } include_context "serializer behavior" end describe "#run" do it "logs exceptions" do unpacker = instance_double(MessagePack::Unpacker) event_loop = instance_double(EventLoop) serializer = Serializer.new(event_loop, unpacker) expect(event_loop).to receive(:run).and_yield("data") expect(unpacker).to receive(:feed_each).with("data").and_raise("BOOM") expect(serializer).to receive(:fatal).with(/BOOM/) serializer.run end end end end end neovim-0.3.1/spec/neovim/session/event_loop_spec.rb0000644000004100000410000000754513000040041022454 0ustar www-datawww-datarequire "helper" require "socket" module Neovim class Session RSpec.describe EventLoop do shared_context "socket behavior" do it "sends and receives data" do request = nil server_thread = Thread.new do client = server.accept request = client.readpartial(1024) client.write("res") client.close server.close end response = nil event_loop.write("req").run do |msg| response = msg event_loop.stop end server_thread.join event_loop.shutdown expect(request).to eq("req") expect(response).to eq("res") 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 "socket behavior" end context "unix" do let!(:server) { UNIXServer.new(Support.socket_path) } let!(:event_loop) { EventLoop.unix(Support.socket_path) } 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 request = nil server_thread = Thread.new do request = srv_stdout.readpartial(1024) srv_stdin.write("res") end response = nil event_loop.write("req").run do |msg| response = msg event_loop.stop end server_thread.join expect(request).to eq("req") expect(response).to eq("res") 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(Support.child_argv) input = MessagePack.pack([0, 0, :vim_strwidth, ["hi"]]) response = nil event_loop.write(input).run do |msg| response = msg event_loop.shutdown end expect(response).to eq(MessagePack.pack([1, 0, nil, 2])) end end describe "#run" do it "handles EOF" do rd, wr = IO.pipe wr.close event_loop = EventLoop.new(rd, wr) expect(event_loop).to receive(:info).with(/EOFError/) event_loop.run end it "handles other errors" do rd, wr = IO.pipe rd.close event_loop = EventLoop.new(rd, wr) expect(event_loop).to receive(:fatal).with(/IOError/) event_loop.run end end describe "#write" do it "retries when writes would block" do rd, wr = IO.pipe event_loop = EventLoop.new(rd, wr) err_class = Class.new(RuntimeError) { include IO::WaitWritable } expect(wr).to receive(:write_nonblock).and_raise(err_class) expect(wr).to receive(:write_nonblock).and_call_original event_loop.write("a") expect(rd.readpartial(1)).to eq("a") end end describe "#shutdown" do it "closes IO handles" do rd, wr = IO.pipe EventLoop.new(rd, wr).shutdown expect(rd).to be_closed expect(wr).to be_closed end it "kills spawned processes" do io = IO.popen("cat", "rb+") pid = io.pid expect(pid).to respond_to(:to_int) EventLoop.new(io).shutdown expect { Process.kill(0, pid) }.to raise_error(Errno::ESRCH) end end end end end neovim-0.3.1/spec/neovim/session/request_spec.rb0000644000004100000410000000164013000040041021760 0ustar www-datawww-datarequire "helper" module Neovim class Session RSpec.describe Request do let(:serializer) { double(:serializer) } let(:reqid) { 1 } let(:request) { Request.new(:method, ["arg"], serializer, reqid) } it "has readers" do expect(request.method_name).to eq("method") expect(request.arguments).to eq(["arg"]) end describe "#sync?" do it "is true" do expect(request.sync?).to be(true) end end describe "#respond" do it "writes an RPC response to serializer" do expect(serializer).to receive(:write).with([1, reqid, nil, "val"]) request.respond("val") end end describe "#error" do it "writes an RPC error response to serializer" do expect(serializer).to receive(:write).with([1, reqid, "err", nil]) request.error("err") end end end end end neovim-0.3.1/spec/neovim/line_range_spec.rb0000644000004100000410000001125713000040041020715 0ustar www-datawww-datarequire "helper" module Neovim RSpec.describe LineRange do let(:client) { Neovim.attach_child(Support.child_argv) } let(:buffer) { client.current.buffer } let(:line_range) { LineRange.new(buffer, 0, -1) } let(:sub_range) { LineRange.new(buffer, 1, 2) } before do client.command("normal i1") client.command("normal o2") client.command("normal o3") client.command("normal o4") end after { client.shutdown } it "is enumerable" do expect(line_range).to be_an(Enumerable) expect(line_range.each.to_a).to eq(["1", "2", "3", "4"]) end describe "#to_a" do it "returns lines as an array" do expect(line_range.to_a).to eq(["1", "2", "3", "4"]) end it "returns a subset of lines as an array" do expect(sub_range.to_a).to eq(["2", "3"]) end end describe "#[]" do it "accepts a single index" do expect(line_range[1]).to eq("2") end it "returns lines at an offset from the index" do expect(sub_range[0]).to eq("2") end it "allows indexes beyond the bounds of a sub range" do expect(sub_range[2]).to eq("4") end it "returns lines at an offset with a negative index" do expect(sub_range[-1]).to eq("3") end it "accepts an index and length" do expect(line_range[0, 2].to_a).to eq(["1", "2"]) end it "returns lines at an offset from an index and length" do expect(sub_range[0, 2].to_a).to eq(["2", "3"]) end it "accepts a range" do expect(line_range[0..1].to_a).to eq(["1", "2"]) expect(line_range[0...1].to_a).to eq(["1"]) end it "accepts a range with a negative end" do expect(line_range[0..-1].to_a).to eq(["1", "2", "3", "4"]) end it "returns lines at an offset from a range" do expect(sub_range[0..1].to_a).to eq(["2", "3"]) end end describe "#[]=" do it "accepts a single index" do line_range[0] = "foo" expect(line_range.to_a).to eq(["foo", "2", "3", "4"]) end it "accepts a single index at an offset" do sub_range[0] = "foo" expect(buffer.lines.to_a).to eq(["1", "foo", "3", "4"]) end it "accepts an index and length" do line_range[0, 2] = ["foo"] expect(line_range.to_a).to eq(["foo", "3", "4"]) end it "accepts an index and length at an offset" do sub_range[0, 2] = ["foo"] expect(buffer.lines.to_a).to eq(["1", "foo", "4"]) end it "accepts a range" do line_range[0..1] = ["foo"] expect(line_range.to_a).to eq(["foo", "3", "4"]) line_range[0...1] = ["bar"] expect(line_range.to_a).to eq(["bar", "3", "4"]) end it "accepts a range at an offset" do sub_range[0..1] = ["foo"] expect(buffer.lines.to_a).to eq(["1", "foo", "4"]) end end describe "#replace" do it "replaces all lines" do line_range.replace(["4", "5"]) expect(line_range.to_a).to eq(["4", "5"]) end it "replaces a subset of lines" do sub_range.replace(["5", "6"]) expect(buffer.lines.to_a).to eq(["1", "5", "6", "4"]) end end describe "#insert" do before { line_range.replace(["1", "2"]) } it "inserts lines at the beginning" do expect { line_range.insert(0, "z") }.to change { line_range.to_a }.to(["z", "1", "2"]) expect { line_range.insert(0, ["x", "y"]) }.to change { line_range.to_a }.to(["x", "y", "z", "1", "2"]) end it "inserts lines in the middle" do expect { line_range.insert(1, "z") }.to change { line_range.to_a }.to(["1", "z", "2"]) expect { line_range.insert(1, ["x", "y"]) }.to change { line_range.to_a }.to(["1", "x", "y", "z", "2"]) end it "inserts lines at the end" do expect { line_range.insert(-1, "x") }.to change { line_range.to_a }.to(["1", "2", "x"]) expect { line_range.insert(-1, ["y", "z"]) }.to change { line_range.to_a }.to(["1", "2", "x", "y", "z"]) end it "raises on out of bounds indexes" do expect { line_range.insert(10, "x") }.to raise_error(/out of bounds/i) end end describe "#delete" do it "deletes the line at the given index" do expect { line_range.delete(0) }.to change { line_range.to_a }.to(["2", "3", "4"]) end it "deletes the line at an offset" do expect { sub_range.delete(0) }.to change { buffer.lines.to_a }.to(["1", "3", "4"]) end end end end neovim-0.3.1/spec/neovim/plugin_spec.rb0000644000004100000410000000645613000040041020115 0ustar www-datawww-datarequire "helper" require "neovim/plugin" 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("source") do |plug| plug.command("Foo", :range => true, :nargs => 1, &cmd_block) end expect(plugin.handlers.size).to be(1) handler = plugin.handlers.first expect(handler.sync?).to be(false) expect(handler.qualified?).to be(true) expect(handler.block).to eq(cmd_block) expect(handler.qualified_name).to eq("source:command:Foo") expect(handler.to_spec).to eq( :type => :command, :name => "Foo", :sync => false, :opts => {:range => "", :nargs => 1}, ) end it "registers an autocmd" do au_block = Proc.new {} plugin = Plugin.from_config_block("source") do |plug| plug.autocmd("BufEnter", :pattern => "*.rb", &au_block) end expect(plugin.handlers.size).to be(1) handler = plugin.handlers.first expect(handler.sync?).to be(false) expect(handler.qualified?).to be(true) expect(handler.block).to eq(au_block) expect(handler.qualified_name).to eq("source:autocmd:BufEnter:*.rb") expect(handler.to_spec).to eq( :type => :autocmd, :name => "BufEnter", :sync => false, :opts => {:pattern => "*.rb"}, ) end it "registers a function" do fun_block = Proc.new {} plugin = Plugin.from_config_block("source") do |plug| plug.function("Foo", :range => true, :nargs => 1, &fun_block) end expect(plugin.handlers.size).to be(1) handler = plugin.handlers.first expect(handler.sync?).to be(false) expect(handler.qualified?).to be(true) expect(handler.block).to eq(fun_block) expect(handler.qualified_name).to eq("source:function:Foo") expect(handler.to_spec).to eq( :type => :function, :name => "Foo", :sync => false, :opts => {:range => "", :nargs => 1}, ) end it "registers a top level RPC" do cmd_block = Proc.new {} plugin = Plugin.from_config_block("source") do |plug| plug.__send__(:rpc, "Foo", &cmd_block) end expect(plugin.handlers.size).to be(1) handler = plugin.handlers.first expect(handler.sync?).to be(true) expect(handler.qualified?).to be(false) expect(handler.block).to eq(cmd_block) expect(handler.qualified_name).to eq("Foo") end end describe "#specs" do it "returns specs for plugin handlers" do plugin = Plugin.from_config_block("source") do |plug| plug.command("Foo", :sync => true, :nargs => 2) end expect(plugin.specs).to eq( [ { :type => :command, :name => "Foo", :sync => true, :opts=> {:nargs => 2} } ] ) end it "doesn't include specs for top-level RPCs" do plugin = Plugin.from_config_block("source") do |plug| plug.__send__(:rpc, "Foo") end expect(plugin.specs).to eq([]) end end end end neovim-0.3.1/spec/neovim/host/0000755000004100000410000000000013000040041016222 5ustar www-datawww-dataneovim-0.3.1/spec/neovim/host/loader_spec.rb0000644000004100000410000000277213000040041021037 0ustar www-datawww-datarequire "helper" require "neovim/host" require "neovim/host/loader" module Neovim class Host RSpec.describe Loader do describe "#load" do let(:plugin_path) { Support.file_path("plug.rb") } let(:host) { instance_double(Host, :register => nil) } let(:loader) { Loader.new(host) } before do File.write(plugin_path, "Neovim.plugin") end it "registers plugins defined in the provided files" do expect(host).to receive(:register).with(kind_of(Plugin)) loader.load([plugin_path]) end it "registers multiple plugins defined in the provided files" do File.write(plugin_path, "Neovim.plugin; Neovim.plugin") expect(host).to receive(:register).with(kind_of(Plugin)).twice loader.load([plugin_path]) end it "doesn't register plugins when none are defined" do File.write(plugin_path, "class FooClass; end") expect(host).not_to receive(:register) loader.load([plugin_path]) end it "doesn't leak constants defined in plugins" do File.write(plugin_path, "class FooClass; end") loader.load([plugin_path]) expect(Kernel.const_defined?(:FooClass)).to be(false) end it "doesn't leak the overidden Neovim.plugin method" do loader.load([plugin_path]) expect { Neovim.plugin }.to raise_error(/outside of a plugin host/) end end end end end neovim-0.3.1/spec/neovim_spec.rb0000644000004100000410000000251113000040041016603 0ustar www-datawww-datarequire "helper" RSpec.describe Neovim do describe ".attach_tcp" do it "attaches to a TCP socket" do port = Support.tcp_port env = {"NVIM_LISTEN_ADDRESS" => "0.0.0.0:#{port}"} pid = Process.spawn(env, *Support.child_argv, [:out, :err] => "/dev/null") begin client = Neovim.attach_tcp("0.0.0.0", port) rescue Errno::ECONNREFUSED retry end begin expect(client.strwidth("hi")).to eq(2) ensure Process.kill(:TERM, pid) Process.waitpid(pid) end end end describe ".attach_unix" do it "attaches to a UNIX socket" do socket_path = Support.socket_path env = {"NVIM_LISTEN_ADDRESS" => socket_path} pid = Process.spawn(env, *Support.child_argv, [:out, :err] => "/dev/null") begin client = Neovim.attach_unix(socket_path) rescue Errno::ENOENT, Errno::ECONNREFUSED retry end begin expect(client.strwidth("hi")).to eq(2) ensure Process.kill(:TERM, pid) Process.waitpid(pid) end end end describe ".attach_child" do it "spawns and attaches to a child process" do begin client = Neovim.attach_child(Support.child_argv) expect(client.strwidth("hi")).to eq(2) ensure client.shutdown end end end end neovim-0.3.1/spec/acceptance/0000755000004100000410000000000013000040041016036 5ustar www-datawww-dataneovim-0.3.1/spec/acceptance/neovim-ruby-host_spec.rb0000644000004100000410000000375213000040041022633 0ustar www-datawww-datarequire "helper" require "pty" RSpec.describe "neovim-ruby-host" do let(:host_exe) do File.expand_path("../../../bin/neovim-ruby-host", __FILE__) end it "prints the gem version" do ["--version", "-V"].each do |opt| expect { system(host_exe, opt) }.to output("#{Neovim::VERSION}\n").to_stdout_from_any_process end end it "fails when attached to a TTY" do PTY.spawn(host_exe) do |rd, wr, pid| expect(rd.gets).to match(/can't run.+interactively/i) _, status = Process.waitpid2(pid) expect(status.exitstatus).to be(1) end end it "loads and runs plugins from Ruby source files" do plugin_path = Support.file_path("plugin1.rb") File.write(plugin_path, <<-RUBY) Neovim.plugin do |plug| plug.command(:AsyncSetLine, :args => 1) do |nvim, str| nvim.current.line = str end plug.function(:SyncAdd, :args => 2, :sync => true) do |nvim, x, y| x + y end plug.autocmd(:BufEnter, :pattern => "*.rb") do |nvim| nvim.current.line = "Ruby file, eh?" end end RUBY nvim = Neovim.attach_child(Support.child_argv) nvim.command("let host = rpcstart('#{host_exe}', ['#{plugin_path}'])") expect(nvim.eval("rpcrequest(host, 'poll')")).to eq("ok") expect(nvim.eval("rpcrequest(host, '#{plugin_path}:function:SyncAdd', [1, 2])")).to eq(3) expect { nvim.command("call rpcnotify(host, '#{plugin_path}:autocmd:BufEnter:*.rb')") sleep 0.01 }.to change { nvim.current.buffer.lines.to_a }.from([""]).to(["Ruby file, eh?"]) expect { nvim.command("call rpcnotify(host, '#{plugin_path}:command:AsyncSetLine', ['foo'])") sleep 0.01 }.to change { nvim.current.buffer.lines.to_a }.from(["Ruby file, eh?"]).to(["foo"]) expect { nvim.command("call rpcnotify(host, 'Unknown')") }.not_to raise_error expect { nvim.command("call rpcrequest(host, 'Unknown')") }.to raise_error(ArgumentError) end end neovim-0.3.1/spec/acceptance/ruby_provider_spec.rb0000644000004100000410000001133413000040041022272 0ustar www-datawww-datarequire "helper" RSpec.describe "ruby_provider" do let!(:nvim) do Neovim.attach_child(Support.child_argv) end around do |spec| provider_path = Support.file_path("provider.rb") File.write(provider_path, "require 'neovim/ruby_provider'") host_exe = File.expand_path("../../../bin/neovim-ruby-host", __FILE__) nvim.current.buffer.lines = ["line1", "line2"] nvim.command("let host = rpcstart('#{host_exe}', ['#{provider_path}'])") begin spec.run ensure nvim.shutdown end end describe "ruby_execute" do it "exposes the VIM constant" do ruby = "VIM.equal?(Vim) || raise".inspect nvim.eval("rpcrequest(host, 'ruby_execute', #{ruby})") end it "exposes the $curwin variable" do nvim.command("vsplit") expect { ruby = "$curwin.width -= 1".inspect nvim.eval("rpcrequest(host, 'ruby_execute', #{ruby})") }.to change { nvim.current.window.width }.by(-1) end it "exposes the $curbuf variable" do expect { ruby = "$curbuf.lines = ['line']".inspect nvim.eval("rpcrequest(host, 'ruby_execute', #{ruby})") }.to change { nvim.current.buffer.lines.to_a }.to(["line"]) end it "persists state between requests" do nvim.eval("rpcrequest(host, 'ruby_execute', 'def foo; Vim.command(\"let g:called = 1\"); end')") expect { nvim.get_var("called") }.to raise_error(/key not found/i) nvim.eval("rpcrequest(host, 'ruby_execute', 'foo')") expect(nvim.get_var("called")).to be(1) end it "persists instance state in $curbuf" do nvim.eval("rpcrequest(host, 'ruby_execute', '$curbuf.instance_variable_set(:@foo, 123)')") nvim.eval("rpcrequest(host, 'ruby_execute', 'Vim.command(\"let g:foo = \#{$curbuf.instance_variable_get(:@foo)}\")')") expect(nvim.get_var("foo")).to be(123) end end describe "ruby_execute_file" do let(:script_path) { Support.file_path("script.rb") } it "exposes the VIM constant" do File.write(script_path, "VIM.equal?(Vim) || raise") nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')") end it "runs ruby from a file" do File.write(script_path, "Vim.command('let myvar = [1, 2]')") nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')") expect(nvim.eval("g:myvar")).to eq([1, 2]) end it "exposes the $curwin variable" do File.write(script_path, "$curwin.width -= 1") nvim.command("vsplit") expect { nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')") }.to change { nvim.current.window.width }.by(-1) end it "exposes the $curbuf variable" do File.write(script_path, "$curbuf.lines = ['line']") expect { nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')") }.to change { nvim.current.buffer.lines.to_a }.to(["line"]) end it "persists state between requests" do File.write(script_path, "def foo; Vim.command(\"let g:called = 1\"); end") nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')") expect { nvim.get_var("called") }.to raise_error(/key not found/i) nvim.eval("rpcrequest(host, 'ruby_execute', 'foo')") expect(nvim.get_var("called")).to be(1) end it "can run the same file multiple times" do nvim.set_var("called", 0) File.write(script_path, "Vim.command(\"let g:called += 1\")") nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')") expect(nvim.get_var("called")).to be(1) nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')") expect(nvim.get_var("called")).to be(2) end it "persists instance state in $curbuf" do File.write(script_path, <<-RUBY) def $curbuf.foo @foo ||= 0 @foo += 1 end Vim.command("let g:foo = \#{$curbuf.foo}") RUBY nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')") expect(nvim.get_var("foo")).to be(1) nvim.eval("rpcrequest(host, 'ruby_execute_file', '#{script_path}')") expect(nvim.get_var("foo")).to be(2) end end describe "ruby_do_range" do it "mutates lines via the $_ variable" do nvim.current.buffer.lines = ["a", "b", "c", "d"] expect { nvim.eval("rpcrequest(host, 'ruby_do_range', 2, 3, '$_.upcase!; 42')") }.to change { nvim.current.buffer.lines.to_a }.to(["a", "B", "C", "d"]) end it "handles large amounts of lines" do xs = Array.new(6000, "x") ys = Array.new(6000, "y") nvim.current.buffer.lines = xs expect { nvim.eval("rpcrequest(host, 'ruby_do_range', 1, 6000, '$_.succ!')") }.to change { nvim.current.buffer.lines.to_a }.to(ys) end end end neovim-0.3.1/.travis.yml0000644000004100000410000000051113000040041015124 0ustar www-datawww-datalanguage: ruby sudo: false branches: only: master rvm: - 1.9.3 - 2.0.0 - 2.1.0 - 2.2.0 - 2.3.0 - ruby-head before_install: - eval "$(curl -Ss https://raw.githubusercontent.com/neovim/bot-ci/master/scripts/travis-setup.sh) nightly-x64" env: REPORT_COVERAGE=1 script: travis_retry bundle exec rake --trace spec neovim-0.3.1/lib/0000755000004100000410000000000013000040041013564 5ustar www-datawww-dataneovim-0.3.1/lib/neovim.rb0000644000004100000410000000646213000040041015416 0ustar www-datawww-datarequire "neovim/client" require "neovim/logging" require "neovim/session" require "neovim/version" # The main entrypoint to the +Neovim+ gem. It allows you to connect to a # running +nvim+ instance programmatically or define a remote plugin to be # autoloaded by +nvim+. # # You can connect to a running +nvim+ instance by setting or inspecting the # +NVIM_LISTEN_ADDRESS+ environment variable and connecting via the appropriate # +attach_+ method. This is currently supported for both UNIX domain sockets # and TCP. You can also spawn and connect to an +nvim+ subprocess via # +Neovim.attach_child(argv)+. # # You can define a remote plugin using the +Neovim.plugin+ DSL, which allows # you to register commands, functions, and autocmds. Plugins are autoloaded by # +nvim+ from the +rplugin/ruby+ directory in your +nvim+ runtime path. # # @example Connect over a TCP socket # Neovim.attach_tcp("0.0.0.0", 3333) # => Neovim::Client # # @example Connect over a UNIX domain socket # Neovim.attach_unix("/tmp/nvim.sock") # => Neovim::Client # # @example Spawn and connect to a child +nvim+ process # Neovim.attach_child(["nvim", "--embed"]) # => Neovim::Client # # @example Define a Ruby plugin # # ~/.config/nvim/rplugin/ruby/plugin.rb # # Neovim.plugin do |plug| # # Define a command called "SetLine" which sets the contents of the # # current line. This command is executed asynchronously, so the return # # value is ignored. # plug.command(:SetLine, :nargs => 1) do |nvim, str| # nvim.current.line = str # end # # # Define a function called "Sum" which adds two numbers. This function is # # executed synchronously, so the result of the block will be returned to # # nvim. # plug.function(:Sum, :nargs => 2, :sync => true) do |nvim, x, y| # x + y # end # # # Define an autocmd for the BufEnter event on Ruby files. # plug.autocmd(:BufEnter, :pattern => "*.rb") do |nvim| # nvim.command("echom 'Ruby file, eh?'") # end # end # # @see Client # @see Plugin::DSL module Neovim # Connect to a running +nvim+ instance over TCP. # # @param host [String] The hostname or IP address # @param port [Fixnum] The port # @return [Client] # @see Session.tcp def self.attach_tcp(host, port) Client.new Session.tcp(host, port) end # Connect to a running +nvim+ instance over a UNIX domain socket. # # @param socket_path [String] The socket path # @return [Client] # @see Session.unix def self.attach_unix(socket_path) Client.new Session.unix(socket_path) end # Spawn and connect to a child +nvim+ process. # # @param argv [Array] The arguments to pass to the spawned process # @return [Client] # @see Session.child def self.attach_child(argv=["nvim"]) Client.new Session.child(argv) end # Placeholder method for exposing the remote plugin DSL. This gets # temporarily overwritten in +Host::Loader#load+. # # @see Host::Loader#load # @see Plugin::DSL def self.plugin raise "Can't call Neovim.plugin outside of a plugin host." end # Set the Neovim global logger. # # @param logger [Logger] The target logger # @return [Logger] # @see Logging def self.logger=(logger) Logging.logger = logger end # The Neovim global logger. # # @return [Logger] # @see Logging def self.logger Logging.logger end end neovim-0.3.1/lib/neovim/0000755000004100000410000000000013000040041015061 5ustar www-datawww-dataneovim-0.3.1/lib/neovim/buffer.rb0000644000004100000410000001444613000040041016670 0ustar www-datawww-datarequire "neovim/remote_object" require "neovim/line_range" module Neovim # Class representing an +nvim+ buffer. class Buffer < RemoteObject # A +LineRange+ object representing the buffer's lines. # # @return [LineRange] # @see LineRange def lines @lines ||= LineRange.new(self, 0, -1) end # Replace all the lines of the buffer. # # @param strs [Array] The replacement lines # @return [Array] def lines=(strs) lines[0..-1] = strs end # A +LineRange+ object representing the buffer's selection range. # # @return [LineRange] # @see LineRange def range @range ||= LineRange.new(self, 0, -1) end # Set the buffer's current selection range. # # @param _range [Range] The replacement range # @return [LineRange] # @see LineRange def range=(_range) _end = _range.exclude_end? ? _range.end - 1 : _range.end @range = LineRange.new(self, _range.begin, _end) end # Get the buffer name. # # @return [String] def name get_name end # Get the buffer index. # # @return [Fixnum] def number get_number end # Get the number of lines. # # @return [Fixnum] def count line_count end # Get the number of lines. # # @return [Fixnum] def length count end # Get the given line (1-indexed). # # @param index [Fixnum] # @return [String] def [](index) lines[index-1] end # Set the given line (1-indexed). # # @param index [Fixnum] # @param str [String] # @return [String] def []=(index, str) lines[index-1] = str end # Delete the given line (1-indexed). # # @param index [Fixnum] # @return [void] def delete(index) lines.delete(index-1) end # Append a line after the given line (1-indexed). # # To maintain backwards compatibility with +vim+, the cursor is forced back # to its previous position after inserting the line. # # @param index [Fixnum] # @param str [String] # @return [String] def append(index, str) window = @session.request(:vim_get_current_window) cursor = window.cursor if index < 0 raise ArgumentError, "Index out of bounds" else set_lines(index, index, true, [str]) window.set_cursor(cursor) end str end # Get the current line of an active buffer. # # @return [String, nil] def line if active? @session.request(:vim_get_current_line) end end # Set the current line of an active buffer. # # @param str [String] # @return [String, nil] def line=(str) if active? @session.request(:vim_set_current_line, str) end end # Get the current line number of an active buffer. # # @return [Fixnum, nil] def line_number if active? window = @session.request(:vim_get_current_window) @session.request(:window_get_cursor, window)[0] end end # Determine if the buffer is active. # # @return [Boolean] def active? @session.request(:vim_get_current_buffer) == self end # The following methods are dynamically generated. =begin @method line_count Send the +buffer_line_count+ RPC to +nvim+ @return [Fixnum] @method get_line(index) Send the +buffer_get_line+ RPC to +nvim+ @param [Fixnum] index @return [String] @method set_line(index, line) Send the +buffer_set_line+ RPC to +nvim+ @param [Fixnum] index @param [String] line @return [void] @method del_line(index) Send the +buffer_del_line+ RPC to +nvim+ @param [Fixnum] index @return [void] @method get_line_slice(start, end, include_start, include_end) Send the +buffer_get_line_slice+ RPC to +nvim+ @param [Fixnum] start @param [Fixnum] end @param [Boolean] include_start @param [Boolean] include_end @return [Array] @method get_lines(start, end, strict_indexing) Send the +buffer_get_lines+ RPC to +nvim+ @param [Fixnum] start @param [Fixnum] end @param [Boolean] strict_indexing @return [Array] @method set_line_slice(start, end, include_start, include_end, replacement) Send the +buffer_set_line_slice+ RPC to +nvim+ @param [Fixnum] start @param [Fixnum] end @param [Boolean] include_start @param [Boolean] include_end @param [Array] replacement @return [void] @method set_lines(start, end, strict_indexing, replacement) Send the +buffer_set_lines+ RPC to +nvim+ @param [Fixnum] start @param [Fixnum] end @param [Boolean] strict_indexing @param [Array] replacement @return [void] @method get_var(name) Send the +buffer_get_var+ RPC to +nvim+ @param [String] name @return [Object] @method set_var(name, value) Send the +buffer_set_var+ RPC to +nvim+ @param [String] name @param [Object] value @return [Object] @method del_var(name) Send the +buffer_del_var+ RPC to +nvim+ @param [String] name @return [Object] @method get_option(name) Send the +buffer_get_option+ RPC to +nvim+ @param [String] name @return [Object] @method set_option(name, value) Send the +buffer_set_option+ RPC to +nvim+ @param [String] name @param [Object] value @return [void] @method get_number Send the +buffer_get_number+ RPC to +nvim+ @return [Fixnum] @method get_name Send the +buffer_get_name+ RPC to +nvim+ @return [String] @method set_name(name) Send the +buffer_set_name+ RPC to +nvim+ @param [String] name @return [void] @method is_valid Send the +buffer_is_valid+ RPC to +nvim+ @return [Boolean] @method insert(lnum, lines) Send the +buffer_insert+ RPC to +nvim+ @param [Fixnum] lnum @param [Array] lines @return [void] @method get_mark(name) Send the +buffer_get_mark+ RPC to +nvim+ @param [String] name @return [Array] @method add_highlight(src_id, hl_group, line, col_start, col_end) Send the +buffer_add_highlight+ RPC to +nvim+ @param [Fixnum] src_id @param [String] hl_group @param [Fixnum] line @param [Fixnum] col_start @param [Fixnum] col_end @return [Fixnum] @method clear_highlight(src_id, line_start, line_end) Send the +buffer_clear_highlight+ RPC to +nvim+ @param [Fixnum] src_id @param [Fixnum] line_start @param [Fixnum] line_end @return [void] =end end end neovim-0.3.1/lib/neovim/plugin/0000755000004100000410000000000013000040041016357 5ustar www-datawww-dataneovim-0.3.1/lib/neovim/plugin/handler.rb0000644000004100000410000000221713000040041020323 0ustar www-datawww-datamodule Neovim class Plugin # @api private class Handler attr_reader :block def self.unqualified(name, 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 @options = options @block = block || Proc.new {} @qualified = options.key?(:qualified) ? options.delete(:qualified) : true end def sync? @sync end def qualified? @qualified end def qualified_name return @name unless qualified? if @type == :autocmd pattern = @options.fetch(:pattern, "*") "#{@source}:#{@type}:#{@name}:#{pattern}" else "#{@source}:#{@type}:#{@name}" end end def to_spec { :type => @type, :name => @name, :sync => @sync, :opts => @options, } end def call(*args) @block.call(*args) end end end end neovim-0.3.1/lib/neovim/plugin/dsl.rb0000644000004100000410000000717313000040041017476 0ustar www-datawww-datarequire "neovim/plugin/handler" module Neovim class Plugin # The DSL exposed in +Neovim.plugin+ blocks. # # @api public class DSL < BasicObject def initialize(plugin) @plugin = plugin end # Register an +nvim+ command. See +:h command+. # # @param name [String] The name of the command. # @param options [Hash] Command options. # @param &block [Proc, nil] The body of the command. # # @option options [Fixnum] :nargs The number of arguments to accept. See # +:h command-nargs+. # @option options [String, Boolean] :range The range argument. # See +:h command-range+. # @option options [Fixnum] :count The default count argument. # See +:h command-count+. # @option options [Boolean] :bang Whether the command can take a +!+ # modifier. See +:h command-bang+. # @option options [Boolean] :register Whether the command can accept a # register name. See +:h command-register+. # @option options [Boolean] :complete Set the completion attributes of # the command. See +:h command-completion+. # @option options [String] :eval An +nvim+ expression. Gets evaluated and # passed as an argument to the block. # @option options [Boolean] :sync (false) Whether +nvim+ should receive # the return value of the block. def command(name, options={}, &block) register_handler(:command, name, options, block) end # Register an +nvim+ function. See +:h function+. # # @param name [String] The name of the function. # @param options [Hash] Function options. # @param &block [Proc, nil] The body of the function. # # @option options [String, Boolean] :range The range argument. # See +:h command-range+. # @option options [String] :eval An +nvim+ expression. Gets evaluated and # passed as an argument to the block. # @option options [Boolean] :sync (false) Whether +nvim+ should receive # the return value of the block. def function(name, options={}, &block) register_handler(:function, name, options, block) end # Register an +nvim+ autocmd. See +:h autocmd+. # # @param event [String] The event type. See +:h autocmd-events+ # @param options [Hash] Autocmd options. # @param &block [Proc, nil] The body of the autocmd. # # @option options [String] :pattern The buffer name pattern. # See +:h autocmd-patterns+. # @option options [String] :eval An +nvim+ expression. Gets evaluated and # passed as an argument to the block. def autocmd(event, options={}, &block) register_handler(:autocmd, event, options, block) end private # Directly define a synchronous RPC call without a namespace. This is # used for exposing legacy ruby provider calls, and not meant to be used # publicly in plugin definitions. def rpc(name, &block) @plugin.handlers.push(Handler.unqualified(name, block)) end def register_handler(type, name, _options, block) if type == :autocmd options = _options.dup else options = standardize_range(_options.dup) end sync = options.delete(:sync) @plugin.handlers.push( Handler.new(@plugin.source, type, name, sync, options, block) ) end def standardize_range(options) if options.key?(:range) options[:range] = "" if options[:range] == true options[:range] = ::Kernel.String(options[:range]) end options end end end end neovim-0.3.1/lib/neovim/ruby_provider.rb0000644000004100000410000000747613000040041020317 0ustar www-datawww-datarequire "neovim/ruby_provider/vim" require "neovim/ruby_provider/buffer_ext" require "neovim/ruby_provider/window_ext" module Neovim # This class is used to define a +Neovim::Plugin+ to act as a backend for the # legacy +:ruby+, +:rubyfile+, and +:rubydo+ Vim commands. It is autoloaded # from +nvim+ and not intended to be required directly. # # @api private module RubyProvider @__buffer_cache = {} def self.__define_plugin! Thread.abort_on_exception = true Neovim.plugin do |plug| __define_ruby_execute(plug) __define_ruby_execute_file(plug) __define_ruby_do_range(plug) end end # Evaluate the provided Ruby code, exposing the +Vim+ constant for # interactions with the editor. # # This is used by the +:ruby+ command. def self.__define_ruby_execute(plug) plug.__send__(:rpc, :ruby_execute) do |nvim, ruby| __wrap_client(nvim) do eval(ruby, TOPLEVEL_BINDING, __FILE__, __LINE__) end end end private_class_method :__define_ruby_execute # Evaluate the provided Ruby file, exposing the +Vim+ constant for # interactions with the editor. # # This is used by the +:rubyfile+ command. def self.__define_ruby_execute_file(plug) plug.__send__(:rpc, :ruby_execute_file) do |nvim, path| __wrap_client(nvim) { load(path) } end end private_class_method :__define_ruby_execute_file # Evaluate the provided Ruby code over each line of a range. The contents # of the current line can be accessed and modified via the +$_+ variable. # # Since this method evaluates each line in the local binding, all local # variables and methods are available to the user. Thus the +__+ prefix # obfuscation. # # This is used by the +:rubydo+ command. def self.__define_ruby_do_range(__plug) __plug.__send__(:rpc, :ruby_do_range) do |__nvim, *__args| __wrap_client(__nvim) do __start, __stop, __ruby = __args __buffer = __nvim.get_current_buffer __update_lines_in_chunks(__buffer, __start, __stop, 5000) do |__lines| __lines.map do |__line| $_ = __line eval(__ruby, binding, __FILE__, __LINE__) $_ end end end end end private_class_method :__define_ruby_do_range def self.__wrap_client(client) __with_globals(client) do __with_vim_constant(client) do __with_redirect_streams(client) do yield end end end nil end private_class_method :__wrap_client def self.__with_globals(client) bufnr = client.evaluate("bufnr('%')") $curbuf = @__buffer_cache.fetch(bufnr) do @__buffer_cache[bufnr] = client.get_current_buffer end $curwin = client.get_current_window yield end private_class_method :__with_globals def self.__with_vim_constant(client) ::Vim.__client = client yield end private_class_method :__with_vim_constant def self.__with_redirect_streams(client) @__with_redirect_streams ||= begin $stdout.define_singleton_method(:write) do |string| client.out_write(string) end $stderr.define_singleton_method(:write) do |string| client.err_write(string) end true end yield end private_class_method :__with_redirect_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) buffer.set_lines(_start, _stop, true, yield(lines)) end end private_class_method :__update_lines_in_chunks end end Neovim::RubyProvider.__define_plugin! neovim-0.3.1/lib/neovim/plugin.rb0000644000004100000410000000112413000040041016702 0ustar www-datawww-datarequire "neovim/plugin/dsl" module Neovim # @api private class Plugin attr_accessor :handlers 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? end end def initialize(source) @handlers = [] @source = source 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 end end neovim-0.3.1/lib/neovim/ruby_provider/0000755000004100000410000000000013000040041017754 5ustar www-datawww-dataneovim-0.3.1/lib/neovim/ruby_provider/vim.rb0000644000004100000410000000075013000040041021076 0ustar www-datawww-datarequire "neovim/buffer" require "neovim/window" # The VIM module provides backwards compatibility for the legacy +:ruby+, # +:rubyfile+, and +:rubydo+ +vim+ functions. module Vim Buffer = ::Neovim::Buffer Window = ::Neovim::Window def self.__client=(client) @__client = client end # Delegate all method calls to the underlying +Neovim::Client+ object. def self.method_missing(method, *args, &block) @__client.public_send(method, *args, &block) end end VIM = Vim neovim-0.3.1/lib/neovim/ruby_provider/window_ext.rb0000644000004100000410000000044713000040041022475 0ustar www-datawww-datarequire "neovim/ruby_provider/vim" module Neovim class Window def self.current ::Vim.get_current_window end def self.count ::Vim.get_current_tabpage.get_windows.size end def self.[](index) ::Vim.get_current_tabpage.get_windows[index] end end end neovim-0.3.1/lib/neovim/ruby_provider/buffer_ext.rb0000644000004100000410000000037713000040041022441 0ustar www-datawww-datarequire "neovim/ruby_provider/vim" module Neovim class Buffer def self.current ::Vim.get_current_buffer end def self.count ::Vim.get_buffers.size end def self.[](index) ::Vim.get_buffers[index] end end end neovim-0.3.1/lib/neovim/tabpage.rb0000644000004100000410000000137713000040041017021 0ustar www-datawww-datarequire "neovim/remote_object" module Neovim class Tabpage < RemoteObject # The following methods are dynamically generated. =begin @method get_windows Send the +tabpage_get_windows+ RPC to +nvim+ @return [Array] @method get_var(name) Send the +tabpage_get_var+ RPC to +nvim+ @param [String] name @return [Object] @method set_var(name, value) Send the +tabpage_set_var+ RPC to +nvim+ @param [String] name @param [Object] value @return [Object] @method del_var(name) Send the +tabpage_del_var+ RPC to +nvim+ @param [String] name @return [Object] @method get_window Send the +tabpage_get_window+ RPC to +nvim+ @return [Window] @method is_valid Send the +tabpage_is_valid+ RPC to +nvim+ @return [Boolean] =end end end neovim-0.3.1/lib/neovim/remote_object.rb0000644000004100000410000000264213000040041020233 0ustar www-datawww-datamodule Neovim # @abstract Superclass for all +nvim+ remote objects. # # @see Buffer # @see Window # @see Tabpage class RemoteObject attr_reader :index def initialize(index, session) @index = index @session = session @api = session.api end # Serialize object to MessagePack. # # @param packer [MessagePack::Packer] # @return [String] def to_msgpack(packer) packer.pack(@index) end # Intercept method calls and delegate to appropriate RPC methods. def method_missing(method_name, *args) if func = @api.function(qualify(method_name)) func.call(@session, @index, *args) else super end end # Extend +respond_to?+ to support RPC methods. def respond_to?(method_name) super || rpc_methods.include?(method_name.to_sym) end # Extend +methods+ to include RPC methods def methods super | rpc_methods end # Extend +==+ to only look at class and index. def ==(other) other.class.equal?(self.class) && @index == other.index end private def rpc_methods @api.functions_with_prefix(function_prefix).map do |func| func.name.sub(/\A#{function_prefix}/, "").to_sym end end def function_prefix "#{self.class.to_s.split("::").last.downcase}_" end def qualify(method_name) :"#{function_prefix}#{method_name}" end end end neovim-0.3.1/lib/neovim/client.rb0000644000004100000410000001463313000040041016673 0ustar www-datawww-datarequire "neovim/current" module Neovim # Client to a running +nvim+ instance. The interface is generated at # runtime via the +vim_get_api_info+ RPC call. Some methods return # +RemoteObject+ subclasses (i.e. +Buffer+, +Window+, or +Tabpage+), # which similarly have dynamically generated interfaces. # # @see Buffer # @see Window # @see Tabpage class Client attr_reader :session def initialize(session) session.discover_api @session = session @api = session.api end # Intercept method calls and delegate to appropriate RPC methods. def method_missing(method_name, *args) if func = @api.function("vim_#{method_name}") func.call(@session, *args) else super end end # Extend +respond_to?+ to support RPC methods. def respond_to?(method_name) super || rpc_methods.include?(method_name.to_sym) end # Extend +methods+ to include RPC methods. def methods super | rpc_methods end # Access to objects belonging to the current +nvim+ context. # # @return [Current] # @example Get the current buffer # client.current.buffer # @example Set the current line # client.current.line = "New line" # @see Current def current @current ||= Current.new(@session) end # Evaluate the VimL expression (alias for +vim_eval+). # # @param expr [String] A VimL expression. # @return [Object] # @example Return a list from VimL # client.evaluate('[1, 2]') # => [1, 2] def evaluate(expr) @api.function(:vim_eval).call(@session, expr) end # Display a message. # # @param string [String] The message. # @return [void] def message(string) out_write(string) end # Set an option. # # @overload set_option(key, value) # @param [String] key # @param [String] value # # @overload set_option(optstr) # @param [String] optstr # # @example Set the +timeoutlen+ option # client.set_option("timeoutlen", 0) # client.set_option("timeoutlen=0") def set_option(*args) if args.size > 1 @api.function("vim_set_option").call(@session, *args) else @api.function("vim_command").call(@session, "set #{args.first}") end end def shutdown @session.shutdown end private def rpc_methods @api.functions_with_prefix("vim_").map do |func| func.name.sub(/\Avim_/, "").to_sym end end public # The following methods are dynamically generated. =begin @method command(str) Send the +vim_command+ RPC to +nvim+ @param [String] str @return [void] @method feedkeys(keys, mode, escape_csi) Send the +vim_feedkeys+ RPC to +nvim+ @param [String] keys @param [String] mode @param [Boolean] escape_csi @return [void] @method input(keys) Send the +vim_input+ RPC to +nvim+ @param [String] keys @return [Fixnum] @method replace_termcodes(str, from_part, do_lt, special) Send the +vim_replace_termcodes+ RPC to +nvim+ @param [String] str @param [Boolean] from_part @param [Boolean] do_lt @param [Boolean] special @return [String] @method command_output(str) Send the +vim_command_output+ RPC to +nvim+ @param [String] str @return [String] @method eval(str) Send the +vim_eval+ RPC to +nvim+ @param [String] str @return [Object] @method call_function(fname, args) Send the +vim_call_function+ RPC to +nvim+ @param [String] fname @param [Array] args @return [Object] @method strwidth(str) Send the +vim_strwidth+ RPC to +nvim+ @param [String] str @return [Fixnum] @method list_runtime_paths Send the +vim_list_runtime_paths+ RPC to +nvim+ @return [Array] @method change_directory(dir) Send the +vim_change_directory+ RPC to +nvim+ @param [String] dir @return [void] @method get_current_line Send the +vim_get_current_line+ RPC to +nvim+ @return [String] @method set_current_line(line) Send the +vim_set_current_line+ RPC to +nvim+ @param [String] line @return [void] @method del_current_line Send the +vim_del_current_line+ RPC to +nvim+ @return [void] @method get_var(name) Send the +vim_get_var+ RPC to +nvim+ @param [String] name @return [Object] @method set_var(name, value) Send the +vim_set_var+ RPC to +nvim+ @param [String] name @param [Object] value @return [Object] @method del_var(name) Send the +vim_del_var+ RPC to +nvim+ @param [String] name @return [Object] @method get_vvar(name) Send the +vim_get_vvar+ RPC to +nvim+ @param [String] name @return [Object] @method get_option(name) Send the +vim_get_option+ RPC to +nvim+ @param [String] name @return [Object] @method out_write(str) Send the +vim_out_write+ RPC to +nvim+ @param [String] str @return [void] @method err_write(str) Send the +vim_err_write+ RPC to +nvim+ @param [String] str @return [void] @method report_error(str) Send the +vim_report_error+ RPC to +nvim+ @param [String] str @return [void] @method get_buffers Send the +vim_get_buffers+ RPC to +nvim+ @return [Array] @method get_current_buffer Send the +vim_get_current_buffer+ RPC to +nvim+ @return [Buffer] @method set_current_buffer(buffer) Send the +vim_set_current_buffer+ RPC to +nvim+ @param [Buffer] buffer @return [void] @method get_windows Send the +vim_get_windows+ RPC to +nvim+ @return [Array] @method get_current_window Send the +vim_get_current_window+ RPC to +nvim+ @return [Window] @method set_current_window(window) Send the +vim_set_current_window+ RPC to +nvim+ @param [Window] window @return [void] @method get_tabpages Send the +vim_get_tabpages+ RPC to +nvim+ @return [Array] @method get_current_tabpage Send the +vim_get_current_tabpage+ RPC to +nvim+ @return [Tabpage] @method set_current_tabpage(tabpage) Send the +vim_set_current_tabpage+ RPC to +nvim+ @param [Tabpage] tabpage @return [void] @method subscribe(event) Send the +vim_subscribe+ RPC to +nvim+ @param [String] event @return [void] @method unsubscribe(event) Send the +vim_unsubscribe+ RPC to +nvim+ @param [String] event @return [void] @method name_to_color(name) Send the +vim_name_to_color+ RPC to +nvim+ @param [String] name @return [Fixnum] @method get_color_map Send the +vim_get_color_map+ RPC to +nvim+ @return [Dictionary] @method get_api_info Send the +vim_get_api_info+ RPC to +nvim+ @return [Array] =end end end neovim-0.3.1/lib/neovim/logging.rb0000644000004100000410000000255113000040041017037 0ustar www-datawww-datarequire "logger" module Neovim # Mixed into classes for unified logging helper methods. # # @api private module Logging class << self attr_writer :logger end # Return the value of @logger, or construct it from the environment. # $NVIM_RUBY_LOG_FILE specifies a file to log to (default +STDERR+), while # NVIM_RUBY_LOG_LEVEL specifies the level (default +WARN+) 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 if env_level = env["NVIM_RUBY_LOG_LEVEL"] begin @logger.level = Integer(env_level) rescue ArgumentError @logger.level = Logger.const_get(env_level.upcase) end else @logger.level = Logger::WARN end @logger end def self.included(base) base.send(:include, Helpers) end module Helpers private def fatal(msg) logger.fatal(self.class) { msg } end def warn(msg) logger.warn(self.class) { msg } end def info(msg) logger.info(self.class) { msg } end def debug(msg) logger.debug(self.class) { msg } end def logger Logging.logger end end end end neovim-0.3.1/lib/neovim/version.rb0000644000004100000410000000007013000040041017070 0ustar www-datawww-datamodule Neovim VERSION = Gem::Version.new("0.3.1") end neovim-0.3.1/lib/neovim/window.rb0000644000004100000410000000526613000040041016726 0ustar www-datawww-datarequire "neovim/remote_object" module Neovim class Window < RemoteObject # Get the buffer displayed in the window # # @return [Buffer] def buffer get_buffer end # Get the height of the window # # @return [Fixnum] def height get_height end # Set the height of the window # # @param height [Fixnum] # @return [Fixnum] def height=(height) set_height(height) height end # Get the width of the window # # @return [Fixnum] def width get_width end # Set the width of the window # # @param width [Fixnum] # @return [Fixnum] def width=(width) set_width(width) width end # Get the cursor coordinates # # @return [Array(Fixnum, Fixnum)] def cursor get_cursor end # Set the cursor coodinates # # @param coords [Array(Fixnum, Fixnum)] # @return [Array(Fixnum, Fixnum)] def cursor=(coords) _x, _y = coords x = [_x, 1].max y = [_y, 0].max + 1 @session.request(:vim_eval, "cursor(#{x}, #{y})") end # The following methods are dynamically generated. =begin @method get_buffer Send the +window_get_buffer+ RPC to +nvim+ @return [Buffer] @method get_cursor Send the +window_get_cursor+ RPC to +nvim+ @return [Array] @method set_cursor(pos) Send the +window_set_cursor+ RPC to +nvim+ @param [Array] pos @return [void] @method get_height Send the +window_get_height+ RPC to +nvim+ @return [Fixnum] @method set_height(height) Send the +window_set_height+ RPC to +nvim+ @param [Fixnum] height @return [void] @method get_width Send the +window_get_width+ RPC to +nvim+ @return [Fixnum] @method set_width(width) Send the +window_set_width+ RPC to +nvim+ @param [Fixnum] width @return [void] @method get_var(name) Send the +window_get_var+ RPC to +nvim+ @param [String] name @return [Object] @method set_var(name, value) Send the +window_set_var+ RPC to +nvim+ @param [String] name @param [Object] value @return [Object] @method del_var(name) Send the +window_del_var+ RPC to +nvim+ @param [String] name @return [Object] @method get_option(name) Send the +window_get_option+ RPC to +nvim+ @param [String] name @return [Object] @method set_option(name, value) Send the +window_set_option+ RPC to +nvim+ @param [String] name @param [Object] value @return [void] @method get_position Send the +window_get_position+ RPC to +nvim+ @return [Array] @method get_tabpage Send the +window_get_tabpage+ RPC to +nvim+ @return [Tabpage] @method is_valid Send the +window_is_valid+ RPC to +nvim+ @return [Boolean] =end end end neovim-0.3.1/lib/neovim/host.rb0000644000004100000410000000553613000040041016374 0ustar www-datawww-datarequire "neovim" require "neovim/host/loader" module Neovim # @api private class Host include Logging attr_reader :handlers, :specs # Start a plugin host. This is called by the +nvim-ruby-host+ executable, # which is spawned by +nvim+ to discover and run Ruby plugins, and acts as # the bridge between +nvim+ and the plugin. def self.run(rplugin_paths, options={}) session = options.fetch(:session) { Session.stdio } client = options.fetch(:client) { Client.new(session) } new(session, client).tap do |host| Loader.new(host).load(rplugin_paths) end.run end def initialize(session, client) @session = session @client = client @handlers = {"poll" => poll_handler, "specs" => specs_handler} @specs = {} end # Register a +Plugin+ to receive +Host+ messages. def register(plugin) plugin.handlers.each do |handler| @handlers[handler.qualified_name] = wrap_plugin_handler(handler) end @specs[plugin.source] = plugin.specs end # Run the event loop, passing received messages to the appropriate handler. def run @session.run { |msg| handle(msg) } rescue => e fatal("got unexpected error #{e.inspect}") debug(e.backtrace.join("\n")) end # Handle messages received from the host. Sends a +Neovim::Client+ along # with the message to be used in plugin callbacks. def handle(message) debug("received #{message.inspect}") @handlers. fetch(message.method_name, default_handler). call(@client, message) rescue => e fatal("got unexpected error #{e.inspect}") debug(e.backtrace.join("\n")) end private def poll_handler @poll_handler ||= Proc.new do |_, req| debug("received 'poll' request #{req.inspect}") req.respond("ok") end end def specs_handler @specs_handler ||= Proc.new do |_, req| debug("received 'specs' request #{req.inspect}") 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_handler @default_handler ||= Proc.new do |_, message| if message.sync? message.error("Unknown request #{message.method_name}") end end end def wrap_plugin_handler(handler) Proc.new do |client, message| begin debug("received #{message.inspect}") args = message.arguments.flatten(1) result = handler.call(client, *args) message.respond(result) if message.sync? rescue => e warn("got unexpected error #{e.inspect}") debug(e.backtrace.join("\n")) message.error(e.message) if message.sync? end end end end end neovim-0.3.1/lib/neovim/session/0000755000004100000410000000000013000040041016544 5ustar www-datawww-dataneovim-0.3.1/lib/neovim/session/rpc.rb0000644000004100000410000000503713000040041017662 0ustar www-datawww-datarequire "neovim/logging" require "neovim/session/request" require "neovim/session/notification" module Neovim class Session # Handles formatting RPC requests and writing them to the +Serializer+. # This exposes an asynchronous API, in which responses are handled in # callbacks. # # @api private class RPC include Logging attr_reader :serializer def initialize(serializer) @serializer = serializer @request_id = 0 @pending_requests = {} end # Send an RPC request and enqueue it's callback to be called when a # response is received. def request(method, *args, &response_cb) reqid = @request_id @request_id += 1 @serializer.write([0, reqid, method, args]) @pending_requests[reqid] = response_cb || Proc.new {} self end # Send an RPC notification. Notifications don't receive a response # from +nvim+. def notify(method, *args) @serializer.write([2, method, args]) self end # Run the event loop, yielding received RPC messages to the block. RPC # requests and notifications from +nvim+ will be wrapped in +Request+ # and +Notification+ objects, respectively, and responses will be # passed to their callbacks with optional errors. def run(&callback) @serializer.run do |msg| debug("received #{msg.inspect}") kind, *payload = msg case kind when 0 handle_request(payload, callback) when 1 handle_response(payload) when 2 handle_notification(payload, callback) end end rescue => e fatal("got unexpected error #{e.inspect}") debug(e.backtrace.join("\n")) end # Stop the event loop. def stop @serializer.stop end # Shut down the event loop. def shutdown @serializer.shutdown end private def handle_request(payload, callback) callback ||= Proc.new {} reqid, method, args = payload callback.call(Request.new(method, args, @serializer, reqid)) end def handle_response(payload) reqid, (_, error), result = payload callback = @pending_requests.delete(reqid) || Proc.new {} callback.call(error, result) end def handle_notification(payload, callback) callback ||= Proc.new {} method, args = payload callback.call(Notification.new(method, args)) end end end end neovim-0.3.1/lib/neovim/session/request.rb0000644000004100000410000000117213000040041020562 0ustar www-datawww-datamodule Neovim class Session # A synchronous message from +nvim+. # # @api private class Request attr_reader :method_name, :arguments def initialize(method_name, args, serializer, request_id) @method_name = method_name.to_s @arguments = args @serializer = serializer @request_id = request_id end def sync? true end def respond(value) @serializer.write([1, @request_id, nil, value]) self end def error(message) @serializer.write([1, @request_id, message, nil]) self end end end end neovim-0.3.1/lib/neovim/session/api.rb0000644000004100000410000000354113000040041017645 0ustar www-datawww-datamodule Neovim class Session # @api private class API attr_reader :channel_id # Represents an unknown API. Used as a stand-in when the API hasn't been # discovered yet via the +vim_get_api_info+ RPC call. def self.null new([nil, {"functions" => [], "types" => []}]) end def initialize(payload) @channel_id, @api_info = payload end # Return all functions defined by the API. def functions @functions ||= @api_info.fetch("functions").inject({}) do |acc, func| name, async = func.values_at("name", "async") acc.merge(name => Function.new(name, async)) end end # Return information about +nvim+ types. Used for registering MessagePack # +ext+ types. def types @types ||= @api_info.fetch("types") end # Return a list of functions with the given name prefix. def functions_with_prefix(prefix) functions.inject([]) do |acc, (name, function)| name =~ /\A#{prefix}/ ? acc.push(function) : acc end end # Find a function with the given name. def function(name) functions[name.to_s] end # Truncate the output of inspect so console sessions are more pleasant. def inspect "#<#{self.class}:0x%x @types={...} @functions={...}>" % (object_id << 1) end class Function attr_reader :name, :async def initialize(name, async) @name, @async = name, async end # Apply this function to a running RPC session. Sends either a request if # +async+ is +false+ or a notification if +async+ is +true+. def call(session, *args) if async session.notify(name, *args) else session.request(name, *args) end end end end end end neovim-0.3.1/lib/neovim/session/serializer.rb0000644000004100000410000000305713000040041021247 0ustar www-datawww-datarequire "neovim/logging" require "msgpack" module Neovim class Session # Handles serializing RPC messages to MessagePack and passing them to # the event loop. # # @api private class Serializer include Logging def initialize(event_loop, unpacker=nil) @event_loop = event_loop @unpacker = unpacker || MessagePack::Unpacker.new end # Serialize an RPC message to and write it to the event loop. def write(msg) debug("writing #{msg.inspect}") @event_loop.write(MessagePack.pack(msg)) self end # Run the event loop, yielding deserialized messages to the block. def run @event_loop.run do |data| @unpacker.feed_each(data) do |msg| debug("received #{msg.inspect}") yield msg if block_given? end end rescue => e fatal("got unexpected error #{e.inspect}") debug(e.backtrace.join("\n")) end # Stop the event loop. def stop @event_loop.stop end # Shut down the event loop. def shutdown @event_loop.shutdown end # Register msgpack ext types using the provided API and session def register_types(api, session) info("registering msgpack ext types") api.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 end end end neovim-0.3.1/lib/neovim/session/event_loop.rb0000644000004100000410000000443513000040041021251 0ustar www-datawww-datarequire "neovim/logging" require "socket" module Neovim class Session # The lowest level interface to reading from and writing to +nvim+. # # @api private class EventLoop include Logging # Connect to a TCP socket. def self.tcp(host, port) socket = TCPSocket.new(host, port) new(socket) end # Connect to a UNIX domain socket. def self.unix(path) socket = UNIXSocket.new(path) new(socket) end # Spawn and connect to a child +nvim+ process. def self.child(_argv) argv = _argv.include?("--embed") ? _argv : _argv + ["--embed"] io = IO.popen(argv, "rb+").tap do |_io| Process.detach(_io.pid) end new(io) end # Connect to the current process's standard streams. This is used to # promote the current process to a Ruby plugin host. def self.stdio new(STDIN, STDOUT) end def initialize(rd, wr=rd) @rd, @wr = rd, wr @running = false end # Write data to the underlying +IO+. This will block until all the # data has been written. def write(data) start = 0 size = data.size debug("writing #{data.inspect}") begin while start < size start += @wr.write_nonblock(data[start..-1]) end self rescue IO::WaitWritable IO.select(nil, [@wr], nil, 1) retry end end # Run the event loop, reading from the underlying +IO+ and yielding # received messages to the block. def run @running = true loop do break unless @running message = @rd.readpartial(1024 * 16) debug("received #{message.inspect}") yield message if block_given? end rescue EOFError info("got EOFError") rescue => e fatal("got unexpected error #{e.inspect}") debug(e.backtrace.join("\n")) end # Stop the event loop. def stop @running = false end # Stop the event loop and close underlying +IO+s. def shutdown stop [@rd, @wr].each do |io| begin io.close rescue IOError end end end end end end neovim-0.3.1/lib/neovim/session/notification.rb0000644000004100000410000000052413000040041021560 0ustar www-datawww-datamodule Neovim class Session # An asynchronous message from +nvim+. # # @api private class Notification attr_reader :method_name, :arguments def initialize(method_name, args) @method_name = method_name.to_s @arguments = args end def sync? false end end end end neovim-0.3.1/lib/neovim/session.rb0000644000004100000410000001006613000040041017074 0ustar www-datawww-datarequire "neovim/logging" require "neovim/session/api" require "neovim/session/event_loop" require "neovim/session/rpc" require "neovim/session/serializer" require "fiber" module Neovim # Wraps a +Session::RPC+ in a synchronous API using +Fiber+s. # # @api private class Session include Logging # Connect to a TCP socket. def self.tcp(host, port) from_event_loop(EventLoop.tcp(host, port)) end # Connect to a UNIX domain socket. def self.unix(socket_path) from_event_loop(EventLoop.unix(socket_path)) end # Spawn and connect to a child +nvim+ process. def self.child(argv) from_event_loop(EventLoop.child(argv)) end # Connect to the current process's standard streams. This is used to # promote the current process to a Ruby plugin host. def self.stdio from_event_loop(EventLoop.stdio) end def self.from_event_loop(event_loop) serializer = Serializer.new(event_loop) rpc = RPC.new(serializer) new(rpc) end private_class_method :from_event_loop def initialize(rpc) @rpc = rpc @pending_messages = [] @main_thread = Thread.current @main_fiber = Fiber.current @running = false end # Return the +nvim+ API as described in the +vim_get_api_info+ call. # Defaults to empty API information. def api @api ||= API.null end # Discover the +nvim+ API as described in the +vim_get_api_info+ call, # propagating it down to lower layers of the stack. def discover_api @api = API.new(request(:vim_get_api_info)).tap do |api| @rpc.serializer.register_types(api, self) end end # Run the event loop, handling messages in a +Fiber+. def run @running = true while pending = @pending_messages.shift Fiber.new { yield pending if block_given? }.resume end return unless @running @rpc.run do |message| Fiber.new { yield message if block_given? }.resume end ensure shutdown end # Make an RPC request and return its response. # # If this method is called inside a callback, we are already inside a # +Fiber+ handler. In that case, we write to the stream and yield the # +Fiber+. Once the response is received, resume the +Fiber+ and # return the result. # # If this method is called outside a callback, write to the stream and # run the event loop until a response is received. Messages received # in the meantime are enqueued to be handled later. def request(method, *args) main_thread_only do if Fiber.current == @main_fiber debug("handling blocking request") err, res = stopped_request(method, *args) else debug("yielding request to fiber") err, res = running_request(method, *args) end err ? raise(ArgumentError, err) : res end end # Make an RPC notification. +nvim+ will not block waiting for a response. def notify(method, *args) main_thread_only do @rpc.notify(method, *args) nil end end # Return the channel ID if registered via +vim_get_api_info+. def channel_id api.channel_id end def stop @running = false @rpc.stop end def shutdown @running = false @rpc.shutdown end private def running_request(method, *args) fiber = Fiber.current @rpc.request(method, *args) do |err, res| fiber.resume(err, res) end Fiber.yield end def stopped_request(method, *args) error, result = nil @rpc.request(method, *args) do |err, res| error, result = err, res stop end.run do |message| @pending_messages << message end [error, result] end def main_thread_only if Thread.current == @main_thread yield if block_given? else raise( "A Ruby plugin attempted to call neovim outside of the main thread, " + "which is not yet supported by the neovim gem." ) end end end end neovim-0.3.1/lib/neovim/line_range.rb0000644000004100000410000000666113000040041017522 0ustar www-datawww-datamodule Neovim # Provide an enumerable interface for dealing with ranges of lines. class LineRange include Enumerable def initialize(buffer, _begin, _end) @buffer = buffer @begin = _begin @end = _end end # Resolve to an array of lines as strings. # # @return [Array] def to_a @buffer.get_line_slice(@begin, @end, true, true) end # Yield each line in the range. # # @yield [String] The current line # @return [Array] def each(&block) to_a.each(&block) end # Access the line at the given index within the range. # # @overload [](index) # @param index [Fixnum] # # @overload [](range) # @param range [Range] # # @overload [](index, length) # @param index [Fixnum] # @param length [Fixnum] # # @example Get the first line using an index # line_range[0] # => "first" # @example Get the first two lines using a +Range+ # line_range[0..1] # => ["first", "second"] # @example Get the first two lines using an index and length # line_range[0, 2] # => ["first", "second"] def [](pos, len=nil) case pos when Range LineRange.new( @buffer, abs_line(pos.begin), abs_line(pos.exclude_end? ? pos.end - 1 : pos.end) ) else if len LineRange.new( @buffer, abs_line(pos), abs_line(pos + len - 1) ) else @buffer.get_line(abs_line(pos)) end end end alias_method :slice, :[] # Set the line at the given index within the range. # # @overload []=(index, string) # @param index [Fixnum] # @param string [String] # # @overload []=(index, length, strings) # @param index [Fixnum] # @param length [Fixnum] # @param strings [Array] # # @overload []=(range, strings) # @param range [Range] # @param strings [Array] # # @example Replace the first line using an index # line_range[0] = "first" # @example Replace the first two lines using a +Range+ # line_range[0..1] = ["first", "second"] # @example Replace the first two lines using an index and length # line_range[0, 2] = ["first", "second"] def []=(*args) *target, val = args pos, len = target case pos when Range @buffer.set_line_slice( abs_line(pos.begin), abs_line(pos.end), true, !pos.exclude_end?, val ) else if len @buffer.set_line_slice( abs_line(pos), abs_line(pos + len), true, false, val ) else @buffer.set_line(abs_line(pos), val) end end end # Replace the range of lines. # # @param other [Array] The replacement lines def replace(other) self[0..-1] = other self end # Insert line(s) at the given index within the range. # # @param index [Fixnum] # @param lines [String] def insert(index, lines) @buffer.insert(index, Array(lines)) end # Delete the line at the given index within the range. # # @param index [Fixnum] def delete(index) @buffer.del_line(abs_line(index)) end private def abs_line(n) n < 0 ? (@end + n + 1) : @begin + n end end end neovim-0.3.1/lib/neovim/current.rb0000644000004100000410000000352213000040041017072 0ustar www-datawww-datarequire "neovim/buffer" require "neovim/tabpage" require "neovim/window" module Neovim # Support for +Client#current+ chaining. # # @see Client#current class Current def initialize(session) @session = session @range = (0..-1) end # Get the line under the cursor. # # @return [String] def line @session.request(:vim_get_current_line) end # Set the line under the cursor. # # @param line [String] The target line contents. # @return [String] def line=(line) @session.request(:vim_set_current_line, line) end # Get the active buffer. # # @return [Buffer] def buffer @session.request(:vim_get_current_buffer).tap do |buf| buf.range = @range end end # Set the active buffer. # # @param buffer [Buffer, Fixnum] The target buffer or index. # @return [Buffer, Fixnum] def buffer=(buffer) @session.request(:vim_set_current_buffer, buffer) end # Get the active window. # # @return [Window] def window @session.request(:vim_get_current_window) end # Set the active window. # # @param window [Window, Fixnum] The target window or index. # @return [Window, Fixnum] def window=(window) @session.request(:vim_set_current_window, window) end # Get the active tabpage. # # @return [Tabpage] def tabpage @session.request(:vim_get_current_tabpage) end # Set the active tabpage. # # @param tabpage [Tabpage, Fixnum] The target tabpage or index. # @return [Tabpage, Fixnum] def tabpage=(tabpage) @session.request(:vim_set_current_tabpage, tabpage) end # Set the current line range of the current buffer. # # @param range [Range] The target range def range=(range) @range = range end end end neovim-0.3.1/lib/neovim/host/0000755000004100000410000000000013000040041016036 5ustar www-datawww-dataneovim-0.3.1/lib/neovim/host/loader.rb0000644000004100000410000000157513000040041017641 0ustar www-datawww-datarequire "neovim/plugin" module Neovim class Host # @api private class Loader def initialize(host) @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 Kernel.load(path, true) end end end private def override_plugin_method(path) old_plugin_def = Neovim.method(:plugin) at_host = @host Neovim.define_singleton_method(:plugin) do |&block| plugin = Plugin.from_config_block(path, &block) at_host.register(plugin) end yield ensure Neovim.define_singleton_method(:plugin, &old_plugin_def) end end end end neovim-0.3.1/.gitignore0000644000004100000410000000027413000040041015011 0ustar www-datawww-data*.gem *.rbc .swp .bundle .config .yardoc Gemfile.lock InstalledFiles _yardoc coverage doc/ lib/bundler/man pkg rdoc spec/reports test/tmp test/version_tmp tmp spec/workspace vendor/bundle neovim-0.3.1/CHANGELOG.md0000644000004100000410000000531613000040041014634 0ustar www-datawww-data# 0.3.1 - Remove window caching to fix incompatibilities with command-t - Add `Vim` module alias - Fix `Window.count` and `Window.[]` to work with tabpages - Fix `EventLoop.child` bug with repeated arguments - Fix `Window#cursor=` incompatibilities - Make `Neovim.attach_child` have default argv of `["nvim"]` # 0.3.0 - Mark `Plugin::DSL#rpc` private - Rename Session constants: - `Neovim::EventLoop` -> `Neovim::Session::EventLoop` - `Neovim::MsgpackStream` -> `Neovim::Session::Serializer` - `Neovim::AsyncSession` -> `Neovim::Session::RPC` - `Neovim::API` -> `Neovim::Session::API` - `Neovim::Request` -> `Neovim::Session::Request` - `Neovim::Notification` -> `Neovim::Session::Notification` # 0.2.5 - Optimize remote function lookup - Fix bug where $curbuf and $curwin weren't persisting instance state between requests # 0.2.4 - Maintain cursor position on Buffer#append for compatibility with vim - Fix excessive fetching of API metadata # 0.2.3 - Detach child processes in `Neovim::EventLoop.child` - Improve performance/compatibility of `Buffer#append` - Various improvements around `Host` loading # 0.2.2 - Make `VIM` constant a module instead of a class - Make `Client#set_option` accept a single string argument # 0.2.1 - Fix race condition in Fiber handling - General improvements to ruby\_provider.rb # 0.2.0 - Backwards incompatible, but we're pre-1.0.0 so going with minor bump instead - Make legacy ruby functions 1-indexed - Add Client#evaluate and Client#message - Make ruby functions affect global scope - Add VIM::{Buffer,Window}.{count,index} - Add minor debug logging to Session and AsyncSession - Remove race condition in Session fiber handling # 0.1.0 - Add --version, -V to neovim-ruby-host executable - Update object interfaces to be compatible with Vim :ruby API - `NVIM_RUBY_LOG_LEVEL` now takes strings, e.g. `DEBUG` - Add `rpc` plugin DSL method for exposing top-level functions - Add `ruby_provider.rb` for Vim :ruby API compatibility - Remove Cursor class - Remove vendored `neovim` # 0.0.6 - Update Session with improved Fiber coordination - Documentation - Rename APIInfo -> API - Rename Object -> RemoteObject # 0.0.5 - Various fixes for Ruby remote plugins - Move Current#range and #range= methods to Buffer - Add better logging # 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 - Add Window#cursor interface - Fix race condition when loading plugins from host # 0.0.2 - Add Neovim.plugin DSL for defining plugins - Add neovim-ruby-host executable for spawning plugins neovim-0.3.1/README.md0000644000004100000410000000751413000040041014304 0ustar www-datawww-data# Neovim Ruby [![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.svg)](https://coveralls.io/r/alexgenco/neovim-ruby) [![Code Climate](https://codeclimate.com/github/alexgenco/neovim-ruby/badges/gpa.svg)](https://codeclimate.com/github/alexgenco/neovim-ruby) [![Gem Version](https://badge.fury.io/rb/neovim.svg)](https://badge.fury.io/rb/neovim) [![Dependency Status](https://gemnasium.com/badges/github.com/alexgenco/neovim-ruby.svg)](https://gemnasium.com/github.com/alexgenco/neovim-ruby) [![Inline docs](http://inch-ci.org/github/alexgenco/neovim-ruby.svg?branch=master)](http://inch-ci.org/github/alexgenco/neovim-ruby) Ruby bindings for [Neovim](https://github.com/neovim/neovim). *Warning*: This project follows [Semantic Versioning](http://semver.org/), thus its API should be considered unstable until it reaches v1.0.0 ([spec](http://semver.org/#spec-item-4)). ## Installation Add this line to your application's Gemfile: gem "neovim" And then execute: $ bundle Or install it yourself as: $ gem install neovim ## Usage You can control a running `nvim` process by connecting to `$NVIM_LISTEN_ADDRESS`. For example, to connect to `nvim` over a UNIX domain socket, start it up like this: ```shell $ NVIM_LISTEN_ADDRESS=/tmp/nvim.sock nvim ``` You can then connect to that socket path to get a `Neovim::Client`: ```ruby require "neovim" client = Neovim.attach_unix("/tmp/nvim.sock") ``` Refer to the [`Neovim` docs](http://www.rubydoc.info/github/alexgenco/neovim-ruby/master/Neovim) for other ways to connect to `nvim`, and the [`Neovim::Client` docs](http://www.rubydoc.info/github/alexgenco/neovim-ruby/master/Neovim/Client) for a summary of the client interface. ### Plugins The `neovim-ruby-host` executable can be used to spawn Ruby plugins via the `rpcstart` command. A plugin can be defined like this: ```ruby # $VIMRUNTIME/rplugin/ruby/my_plugin.rb Neovim.plugin do |plug| # Define a command called "SetLine" which sets the contents of the current # line. This command is executed asynchronously, so the return value is # ignored. plug.command(:SetLine, :nargs => 1) do |nvim, str| nvim.current.line = str end # Define a function called "Sum" which adds two numbers. This function is # executed synchronously, so the result of the block will be returned to nvim. plug.function(:Sum, :nargs => 2, :sync => true) do |nvim, x, y| x + y end # Define an autocmd for the BufEnter event on Ruby files. plug.autocmd(:BufEnter, :pattern => "*.rb") do |nvim| nvim.command("echom 'Ruby file, eh?'") end end ``` Ruby plugins go in the `$VIMRUNTIME/rplugin/ruby` directory, and are auto-loaded after calling `:UpdateRemotePlugins`. Refer to the [`Neovim::Plugin::DSL` docs](http://www.rubydoc.info/github/alexgenco/neovim-ruby/master/Neovim/Plugin/DSL) for a more complete overview. ### Legacy Plugin Support The Neovim gem also acts as a compatibility layer for Ruby plugins written for legacy `vim`. The `:ruby`, `:rubyfile`, and `:rubydo` commands are intended to behave the same as they did in `vim`, and their documentation can be found [here](https://neovim.io/doc/user/if_ruby.html). ## Links * Source: * Bugs: * CI: * Documentation: * Latest Gem: * Master: ## Contributing 1. Fork it (http://github.com/alexgenco/neovim-ruby/fork) 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your changes (`git commit -am 'Add some feature'`) 4. Push to the branch (`git push origin my-new-feature`) 5. Create new Pull Request