neovim 0.2.5 → 0.3.0

data/lib/neovim/api.rb

@@ -1,80 +0,0 @@
-module Neovim
-  # @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.
-    #
-    # @return [API]
-    def self.null
-      new([nil, {"functions" => [], "types" => []}])
-    end
-
-    def initialize(api_info)
-      @channel_id, @api_info = api_info
-    end
-
-    # Return all functions defined by the API.
-    #
-    # @return [Hash{String => Function}] A +Hash+ mapping function names to
-    #   +Function+ objects.
-    # @see Function
-    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.
-    #
-    # @return [Hash]
-    def types
-      @types ||= @api_info.fetch("types")
-    end
-
-    # Return a list of functions with the given name prefix.
-    #
-    # @param prefix [String] The function prefix
-    # @return [Array<Function>]
-    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.
-    #
-    # @param name [String] The name of the function
-    # @return [Function, nil]
-    def function(name)
-      functions[name.to_s]
-    end
-
-    # Truncate the output of inspect so console sessions are more pleasant.
-    #
-    # @return [String]
-    def inspect
-      "#<#{self.class}:0x%x @types={...} @functions={...}>" % (object_id << 1)
-    end
-
-    # Encapsulate an RPC function.
-    class Function < Struct.new(:name, :async)
-      # Apply this function to a running RPC session. Sends either a request if
-      # +async+ is +false+ or a notification if +async+ is +true+.
-      #
-      # @param session [Session] The session to apply the function to.
-      # @param *args [Array] Arguments to the function.
-      # @return [Object, nil]
-      def call(session, *args)
-        if async
-          session.notify(name, *args)
-        else
-          session.request(name, *args)
-        end
-      end
-    end
-  end
-end

data/lib/neovim/async_session.rb

@@ -1,119 +0,0 @@
-require "neovim/logging"
-require "neovim/request"
-require "neovim/notification"
-
-module Neovim
-  # Handles formatting RPC requests and writing them to the
-  # +MsgpackStream+. This exposes an asynchronous API, in which responses
-  # are handled in callbacks.
-  #
-  # @api private
-  class AsyncSession
-    include Logging
-
-    attr_reader :msgpack_stream
-
-    def initialize(msgpack_stream)
-      @msgpack_stream = msgpack_stream
-      @request_id = 0
-      @pending_requests = {}
-    end
-
-    # Send an RPC request and enqueue it's callback to be called when a
-    # response is received.
-    #
-    # @param method [Symbol, String] The RPC method name
-    # @param *args [Array] The arguments to the RPC method
-    # @return [self]
-    # @example
-    #   async_session.request(:vim_strwidth, "foobar") do |response|
-    #     $stderr.puts("Got a response #{response}")
-    #   end
-    def request(method, *args, &response_cb)
-      reqid = @request_id
-      @request_id += 1
-
-      @msgpack_stream.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+.
-    #
-    # @param method [Symbol, String] The RPC method name
-    # @param *args [Array] The arguments to the RPC method
-    # @return [self]
-    # @example
-    #   async_session.notify(:vim_input, "jk")
-    def notify(method, *args)
-      @msgpack_stream.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.
-    #
-    # @param session [Session] The current session
-    # @yield [Object]
-    # @return [void]
-    # @see MsgpackStream#run
-    # @see EventLoop#run
-    def run(&callback)
-      @msgpack_stream.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.
-    #
-    # @return [void]
-    # @see EventLoop#stop
-    def stop
-      @msgpack_stream.stop
-    end
-
-    # Shut down the event loop.
-    #
-    # @return [void]
-    # @see EventLoop#shutdown
-    def shutdown
-      @msgpack_stream.shutdown
-    end
-
-    private
-
-    def handle_request(payload, callback)
-      callback ||= Proc.new {}
-      reqid, method, args = payload
-      callback.call(Request.new(method, args, @msgpack_stream, 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

data/lib/neovim/event_loop.rb

@@ -1,128 +0,0 @@
-require "neovim/logging"
-require "socket"
-
-module Neovim
-  # The lowest level interface to reading from and writing to +nvim+.
-  #
-  # @api private
-  class EventLoop
-    include Logging
-
-    private_class_method :new
-
-    # Connect to a TCP socket.
-    #
-    # @param host [String] The hostname or IP address
-    # @param port [Fixnum] The port
-    # @return [EventLoop]
-    def self.tcp(host, port)
-      socket = TCPSocket.new(host, port)
-      new(socket)
-    end
-
-    # Connect to a UNIX domain socket.
-    #
-    # @param path [String] The socket path
-    # @return [EventLoop]
-    def self.unix(path)
-      socket = UNIXSocket.new(path)
-      new(socket)
-    end
-
-    # Spawn and connect to a child +nvim+ process.
-    #
-    # @param argv [Array] The arguments to pass to the spawned process
-    # @return [EventLoop]
-    def self.child(argv)
-      io = IO.popen(argv | ["--embed"], "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.
-    #
-    # @return [EventLoop]
-    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.
-    #
-    # @param data [String] The data to write (typically message-packed)
-    # @return [self]
-    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.
-    #
-    # @yield [String]
-    # @return [void]
-    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.
-    #
-    # @return [void]
-    def stop
-      @running = false
-    end
-
-    # Stop the event loop and close underlying +IO+s.
-    #
-    # @return [void]
-    def shutdown
-      stop
-
-      [@rd, @wr].each do |io|
-        begin
-          io.close
-        rescue IOError
-        end
-
-        begin
-          if pid = io.pid
-            Process.kill(:TERM, pid)
-            Process.waitpid(pid)
-          end
-        rescue IOError, Errno::ESRCH, Errno::ECHILD
-        end
-      end
-    end
-  end
-end

data/lib/neovim/msgpack_stream.rb

@@ -1,80 +0,0 @@
-require "neovim/logging"
-require "msgpack"
-
-module Neovim
-  # Handles serializing RPC messages to MessagePack and passing them to
-  # the event loop.
-  #
-  # @api private
-  class MsgpackStream
-    include Logging
-
-    def initialize(event_loop)
-      @event_loop = event_loop
-      @unpacker = MessagePack::Unpacker.new
-    end
-
-    # Serialize an RPC message to and write it to the event loop.
-    #
-    # @param msg [Array] The RPC message
-    # @return [self]
-    # @example Write an RPC request
-    #   msgpack_stream.write([0, 1, :vim_strwidth, ["foobar"]])
-    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.
-    #
-    # @param session [Session] Used for registering msgpack +ext+ types as
-    #   described by the +vim_get_api_info+ call
-    # @return [void]
-    # @see EventLoop#run
-    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.
-    #
-    # @return [void]
-    # @see EventLoop#stop
-    def stop
-      @event_loop.stop
-    end
-
-    # Shut down the event loop.
-    #
-    # @return [void]
-    # @see EventLoop#shutdown
-    def shutdown
-      @event_loop.shutdown
-    end
-
-    # Register msgpack ext types using the provided API and session
-    #
-    # @param api [API]
-    # @param session [Session]
-    # @see Session#discover_api
-    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

data/lib/neovim/notification.rb

@@ -1,17 +0,0 @@
-module Neovim
-  # 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

data/lib/neovim/request.rb

@@ -1,29 +0,0 @@
-module Neovim
-  # A synchronous message from +nvim+.
-  #
-  # @api private
-  class Request
-    attr_reader :method_name, :arguments
-
-    def initialize(method_name, args, msgpack_stream, request_id)
-      @method_name = method_name.to_s
-      @arguments = args
-      @msgpack_stream = msgpack_stream
-      @request_id = request_id
-    end
-
-    def sync?
-      true
-    end
-
-    def respond(value)
-      @msgpack_stream.write([1, @request_id, nil, value])
-      self
-    end
-
-    def error(message)
-      @msgpack_stream.write([1, @request_id, message, nil])
-      self
-    end
-  end
-end