neovim 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c69f05bcd8852ed00d741fa9c86b4453a34acea8
+  data.tar.gz: fdf05283ab34d8f5692dc8cb95d3335d2b105bda
+SHA512:
+  metadata.gz: 3f6d303d8fd49a35c9ba809e0be985533a80e26a20940e565797821a3eefe968e3c579a3ae760f0f739eadf478ae7325e720553e60dcfd059bf470b82b2d0803
+  data.tar.gz: 14a9f4aa0be233fedac15c11e1064d8c54903fed3d868472c600063be30f7f8a692db1993da8ac0b77bc5622ccc848c99f39ac9a7d808cbd47b8c382d71f0929

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,18 @@
+*.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

data/.gitmodules

@@ -0,0 +1,4 @@
+[submodule "vendor/neovim"]
+	path = vendor/neovim
+	url = https://github.com/neovim/neovim.git
+	branch = master

data/.travis.yml

@@ -0,0 +1,30 @@
+language: ruby
+sudo: false
+
+branches:
+  only: master
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0
+
+os:
+  - linux
+  - osx
+
+addons:
+  apt:
+    packages:
+      - libtool
+      - autoconf
+      - automake
+      - cmake
+      - libncurses5-dev
+      - g++
+      - pkg-config
+
+env: REPORT_COVERAGE=1
+before_script: bundle exec rake neovim:install
+script: travis_retry bundle exec rake

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (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.

data/README.md

@@ -0,0 +1,47 @@
+# 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.png)](https://coveralls.io/r/alexgenco/neovim-ruby)
+
+Ruby bindings for [Neovim](https://github.com/neovim/neovim).
+
+*Warning*: This project is currently incomplete and unstable.
+
+## 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`. Start it up like this:
+
+```shell
+$ NVIM_LISTEN_ADDRESS=/tmp/nvim.sock nvim
+```
+
+You can then connect to that socket to get a `Neovim::Client`:
+
+```ruby
+require "neovim"
+client = Neovim.attach_unix("/tmp/nvim.sock")
+```
+
+The interface of the client is generated at runtime from the `vim_get_api_info` RPC call. For now, you can refer to the Node client's auto-generated [API description](https://github.com/neovim/node-client/blob/master/index.d.ts). Note that methods will be in `snake_case` rather than `camelCase`.
+
+## 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

data/Rakefile

@@ -0,0 +1,26 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+namespace :neovim do
+  vendor = File.expand_path("../vendor/neovim", __FILE__)
+
+  desc "Install Neovim"
+  task :install do
+    sh "git submodule update --init && " +
+       "cd #{vendor} && " +
+       "make distclean && " +
+       "make"
+  end
+
+  desc "Update Neovim installation"
+  task :update do
+    sh "git submodule update --init && " +
+       "cd #{vendor} && " +
+       "make distclean && " +
+       "git pull origin master && " +
+       "make"
+  end
+end

data/lib/neovim.rb

@@ -0,0 +1,31 @@
+require "neovim/async_session"
+require "neovim/client"
+require "neovim/event_loop"
+require "neovim/msgpack_stream"
+require "neovim/session"
+
+module Neovim
+  def self.attach_tcp(host, port)
+    attach_event_loop(EventLoop.tcp(host, port))
+  end
+
+  def self.attach_unix(socket_path)
+    attach_event_loop(EventLoop.unix(socket_path))
+  end
+
+  def self.attach_child(argv=[])
+    attach_event_loop(EventLoop.child(argv))
+  end
+
+  class << self
+    private
+
+    def attach_event_loop(event_loop)
+      msgpack_stream = MsgpackStream.new(event_loop)
+      async_session = AsyncSession.new(msgpack_stream)
+      session = Session.new(async_session)
+
+      Client.new(session)
+    end
+  end
+end

data/lib/neovim/api_info.rb

@@ -0,0 +1,27 @@
+require "delegate"
+
+module Neovim
+  class APIInfo < SimpleDelegator
+    def functions
+      @functions ||= fetch(1).fetch("functions")
+    end
+
+    def types
+      @types ||= fetch(1).fetch("types")
+    end
+
+    def channel_id
+      @channel_id ||= fetch(0)
+    end
+
+    def defined?(function)
+      functions.any? do |func|
+        func["name"] == function.to_s
+      end
+    end
+
+    def inspect
+      "#<#{self.class}:0x%x @channel_id=#{@channel_id.inspect} @types={...} @functions={...}>" % (object_id << 1)
+    end
+  end
+end

data/lib/neovim/async_session.rb

@@ -0,0 +1,75 @@
+module Neovim
+  class AsyncSession
+    def initialize(msgpack_stream)
+      @msgpack_stream = msgpack_stream
+      @request_id = 0
+      @pending_requests = {}
+    end
+
+    def register_session(session)
+      @msgpack_stream.register_session(session)
+    end
+
+    def request(method, *args, &response_cb)
+      reqid = @request_id
+      @request_id += 1
+
+      @msgpack_stream.send([0, reqid, method, args])
+      @pending_requests[reqid] = response_cb || Proc.new {}
+      self
+    end
+
+    def notify(method, *args)
+      @msgpack_stream.send([2, method, args])
+      self
+    end
+
+    def run(request_cb=nil, notification_cb=nil)
+      request_cb ||= Proc.new {}
+      notification_cb ||= Proc.new {}
+
+      @msgpack_stream.run do |msg|
+        kind, *rest = msg
+
+        case kind
+        when 0
+          reqid, method, args = rest
+          request_cb.call(method, args, Responder.new(@msgpack_stream, reqid))
+        when 1
+          reqid, (_, error), result = rest
+          @pending_requests.fetch(reqid).call(error, result)
+        when 2
+          event, args = rest
+          notification_cb.call(event, args)
+        end
+      end
+    end
+
+    def stop
+      @msgpack_stream.stop
+      self
+    end
+
+    def shutdown
+      @msgpack_stream.shutdown
+      self
+    end
+
+    class Responder
+      def initialize(msgpack_stream, request_id)
+        @msgpack_stream = msgpack_stream
+        @request_id = request_id
+      end
+
+      def send(value)
+        @msgpack_stream.send([1, @request_id, nil, value])
+        self
+      end
+
+      def error(value)
+        @msgpack_stream.send([1, @request_id, value, nil])
+        self
+      end
+    end
+  end
+end

data/lib/neovim/client.rb

@@ -0,0 +1,29 @@
+require "neovim/current"
+
+module Neovim
+  class Client
+    def initialize(session)
+      @session = session
+    end
+
+    def method_missing(method_name, *args)
+      if methods.include?(method_name)
+        @session.request("vim_#{method_name}", *args)
+      else
+        super
+      end
+    end
+
+    def respond_to?(method_name)
+      super || methods.include?(method_name.to_sym)
+    end
+
+    def methods
+      super | @session.api_methods_for_prefix("vim_")
+    end
+
+    def current
+      Current.new(@session)
+    end
+  end
+end

data/lib/neovim/current.rb

@@ -0,0 +1,44 @@
+require "neovim/object"
+
+module Neovim
+  class Current
+    def initialize(session)
+      @session = session
+    end
+
+    def line
+      @session.request(:vim_get_current_line)
+    end
+
+    def line=(ln)
+      @session.request(:vim_set_current_line, ln)
+    end
+
+    def buffer
+      @session.request(:vim_get_current_buffer)
+    end
+
+    def buffer=(buffer_index)
+      buffer = Buffer.new(buffer_index, @session)
+      @session.request(:vim_set_current_buffer, buffer)
+    end
+
+    def window
+      @session.request(:vim_get_current_window)
+    end
+
+    def window=(window_index)
+      window = Window.new(window_index, @session)
+      @session.request(:vim_set_current_window, window)
+    end
+
+    def tabpage
+      @session.request(:vim_get_current_tabpage)
+    end
+
+    def tabpage=(tabpage_index)
+      tabpage = Tabpage.new(tabpage_index, @session)
+      @session.request(:vim_set_current_tabpage, tabpage)
+    end
+  end
+end

data/lib/neovim/event_loop.rb

@@ -0,0 +1,75 @@
+require "eventmachine"
+require "socket"
+
+module Neovim
+  class EventLoop
+    def self.tcp(host, port)
+      socket = TCPSocket.new(host, port)
+      new(socket, socket)
+    end
+
+    def self.unix(path)
+      socket = UNIXSocket.new(path)
+      new(socket, socket)
+    end
+
+    def self.child(argv)
+      argv = [ENV.fetch("NVIM_EXECUTABLE", "nvim"), "--embed"] | argv.to_ary
+      io = IO.popen(argv, "rb+")
+      new(io, io)
+    end
+
+    def self.stdio
+      new(STDIN, STDOUT)
+    end
+
+    def initialize(rd, wr)
+      @read_stream, @write_stream = rd, wr
+    end
+
+    def send(data)
+      EM.schedule do
+        @write_conn.send_data(data)
+      end
+      self
+    end
+
+    def run(&message_callback)
+      message_callback ||= Proc.new {}
+
+      EM.run do
+        @read_conn = EM.watch(@read_stream, Connection)
+        @write_conn = EM.watch(@write_stream, Connection) unless @write_stream == @read_stream
+        @write_conn ||= @read_conn
+
+        @read_conn.notify_readable = true
+        @read_conn.message_callback = message_callback
+      end
+    end
+
+    def stop
+      EM.stop_event_loop
+      self
+    end
+
+    def shutdown
+      stop
+      self
+    ensure
+      @read_conn.close if @read_conn.respond_to?(:close)
+      @write_conn.close if @write_conn.respond_to?(:close)
+    end
+
+    class Connection < EM::Connection
+      attr_writer :message_callback
+
+      def send_data(data)
+        @io.write_nonblock(data)
+      end
+
+      def notify_readable
+        @message_callback.call(@io.readpartial(1024 * 16))
+      end
+    end
+  end
+end