neovim 0.0.5 → 0.0.6

data/lib/neovim/plugin/handler.rb

@@ -0,0 +1,43 @@
+module Neovim
+  class Plugin
+    # @api private
+    class Handler
+      attr_reader :block
+
+      def initialize(source, type, name, sync, options, block)
+        @source = source
+        @type = type.to_sym
+        @name = name.to_s
+        @sync = !!sync
+        @options = options
+        @block = block || Proc.new {}
+      end
+
+      def qualified_name
+        if @type == :autocmd
+          pattern = @options.fetch(:pattern, "*")
+          "#{@source}:#{@type}:#{@name}:#{pattern}"
+        else
+          "#{@source}:#{@type}:#{@name}"
+        end
+      end
+
+      def sync?
+        @sync
+      end
+
+      def to_spec
+        {
+          :type => @type,
+          :name => @name,
+          :sync => @sync,
+          :opts => @options,
+        }
+      end
+
+      def call(*args)
+        @block.call(*args)
+      end
+    end
+  end
+end

data/lib/neovim/remote_object.rb

@@ -0,0 +1,64 @@
+module 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

data/lib/neovim/request.rb

@@ -1,4 +1,6 @@
 module Neovim
+  # A synchronous message from +nvim+.
+  # @api private
   class Request
     attr_reader :method_name, :arguments
 
@@ -14,12 +16,12 @@ module Neovim
     end
 
     def respond(value)
-      @msgpack_stream.send([1, @request_id, nil, value])
+      @msgpack_stream.write([1, @request_id, nil, value])
       self
     end
 
     def error(message)
-      @msgpack_stream.send([1, @request_id, message, nil])
+      @msgpack_stream.write([1, @request_id, message, nil])
       self
     end
   end

data/lib/neovim/session.rb

@@ -1,35 +1,186 @@
-require "neovim/api_info"
+require "neovim/api"
+require "fiber"
 
 module Neovim
+  # Wraps an +AsyncSession+ in a synchronous API using +Fiber+s.
   class Session
-    attr_reader :api_info
+    # Connect to a TCP socket.
+    #
+    # @param host [String] The hostname or IP address
+    # @param port [Fixnum] The port
+    # @return [Session]
+    # @see EventLoop.tcp
+    def self.tcp(host, port)
+      from_event_loop(EventLoop.tcp(host, port))
+    end
+
+    # Connect to a UNIX domain socket.
+    #
+    # @param socket_path [String] The socket path
+    # @return [Session]
+    # @see EventLoop.unix
+    def self.unix(socket_path)
+      from_event_loop(EventLoop.unix(socket_path))
+    end
+
+    # Spawn and connect to a child +nvim+ process.
+    #
+    # @param argv [Array] The arguments to pass to the spawned process
+    # @return [Session]
+    # @see EventLoop.child
+    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.
+    #
+    # @return [Session]
+    # @see EventLoop.stdio
+    def self.stdio
+      from_event_loop(EventLoop.stdio)
+    end
+
+    def self.from_event_loop(event_loop)
+      msgpack_stream = MsgpackStream.new(event_loop)
+      async_session = AsyncSession.new(msgpack_stream)
+      new(async_session)
+    end
+    private_class_method :from_event_loop
 
     def initialize(async_session)
       @async_session = async_session
-      @api_info = APIInfo.new(request(:vim_get_api_info))
+      @pending_messages = []
+      @in_handler = false
+      @running = false
+    end
+
+    # Return the +nvim+ API as described in the +vim_get_api_info+ call.
+    # Defaults to empty API information.
+    #
+    # @return [API]
+    # @see API.null
+    def api
+      @api ||= API.null
+    end
 
-      @async_session.register_session(self)
+    # Discover the +nvim+ API as described in the +vim_get_api_info+ call.
+    #
+    # @return [self]
+    # @see API
+    def discover_api
+      @api = API.new(request(:vim_get_api_info))
+      self
     end
 
+    # Run the event loop, handling messages in a +Fiber+.
+    #
+    # @yield [Object]
+    # @return [void]
+    # @see AsyncSession#run
+    # @see MsgpackStream#run
+    # @see EventLoop#run
+    def run
+      @running = true
+
+      while message = @pending_messages.shift
+        in_handler_fiber { yield message if block_given? }
+      end
+
+      return unless @running
+
+      @async_session.run(self) do |message|
+        in_handler_fiber { yield message if block_given? }
+      end
+    ensure
+      stop
+    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.
+    #
+    # @param method [String, Symbol] The RPC method name
+    # @param *args [Array] The RPC method arguments
+    # @return [Object] The response from the RPC call
+    # @raise [ArgumentError] An error returned from +nvim+
     def request(method, *args)
-      fiber = Fiber.new do
-        @async_session.request(method, *args) do |err, res|
-          Fiber.yield(err, res)
-        end.run
+      if @in_handler
+        err, res = running_request(method, *args)
+      else
+        err, res = stopped_request(method, *args)
       end
 
-      error, response = fiber.resume
-      error ? raise(ArgumentError, error) : response
+      err ? raise(ArgumentError, err) : res
+    end
+
+    # Make an RPC notification
+    #
+    # @param method [String, Symbol] The RPC method name
+    # @param *args [Array] The RPC method arguments
+    # @return [nil]
+    def notify(method, *args)
+      @async_session.notify(method, *args)
+      nil
+    end
+
+    # Stop the event loop
+    #
+    # @return [void]
+    # @see EventLoop#stop
+    def stop
+      @running = false
+      @async_session.stop
+    end
+
+    # Shut down the event loop
+    #
+    # @return [void]
+    # @see EventLoop#shutdown
+    def shutdown
+      @running = false
+      @async_session.shutdown
     end
 
-    def api_methods_for_prefix(prefix)
-      @api_info.functions.inject([]) do |acc, function|
-        if function["name"] =~ /\A#{prefix}/
-          acc + [function["name"].sub(/\A#{prefix}/, "").to_sym]
-        else
-          acc
+    private
+
+    def in_handler_fiber(&block)
+      Fiber.new do
+        @in_handler = true
+        begin
+          block.call
+        ensure
+          @in_handler = false
         end
+      end.resume
+    end
+
+    def running_request(method, *args)
+      fiber = Fiber.current
+      @async_session.request(method, *args) do |err, res|
+        fiber.resume(err, res)
+      end
+      Fiber.yield
+    end
+
+    def stopped_request(method, *args)
+      error, result = nil
+
+      @async_session.request(method, *args) do |err, res|
+        error, result = err, res
+        stop
+      end.run(self) do |message|
+        @pending_messages << message
       end
+
+      [error, result]
     end
   end
 end

data/lib/neovim/tabpage.rb

@@ -1,6 +1,28 @@
-require "neovim/object"
+require "neovim/remote_object"
 
 module Neovim
-  class Tabpage < Neovim::Object
+  class Tabpage < RemoteObject
+
+# The following methods are dynamically generated.
+=begin
+@method get_windows
+  @return [Array<Window>]
+
+@method get_var(name)
+  @param [String] name
+  @return [Object]
+
+@method set_var(name, value)
+  @param [String] name
+  @param [Object] value
+  @return [Object]
+
+@method get_window
+  @return [Window]
+
+@method is_valid
+  @return [Boolean]
+
+=end
   end
 end

data/lib/neovim/version.rb

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

data/lib/neovim/window.rb

@@ -1,7 +1,11 @@
-require "neovim/object"
+require "neovim/remote_object"
 
 module Neovim
-  class Window < Neovim::Object
+  class Window < RemoteObject
+    # Interface for interacting with the cursor position.
+    #
+    # @return [Cursor]
+    # @see Cursor
     def cursor
       @cursor ||= Cursor.new(self)
     end
@@ -11,29 +15,115 @@ module Neovim
         @window = window
       end
 
+      # Get the current coordinates of the cursor.
+      #
+      # @return [Array<Fixnum>]
+      # @note coordinates are 1-indexed
       def coordinates
         @window.get_cursor
       end
 
+      # Set the coordinates of the cursor.
+      #
+      # @param coords [Array<Fixnum>] The coordinates as a pair of integers
+      # @return [Array<Fixnum>]
+      # @note coordinates are 1-indexed
+      # @example Move the cursor to line 1, column 2
+      #   window.cursor.coordinates = [1, 2]
       def coordinates=(coords)
         @window.set_cursor(coords)
       end
 
+      # Get the cursor's line number.
+      #
+      # @return [Fixnum]
+      # @note Line numbers are 1-indexed
       def line
         coordinates[0]
       end
 
+      # Set the cursor's line number.
+      #
+      # @param n [Fixnum]
+      # @return [Fixnum]
+      # @note Line numbers are 1-indexed
       def line=(n)
         self.coordinates = [n, column]
+        n
       end
 
+      # Get the cursor's column number.
+      #
+      # @return [Fixnum]
+      # @note Column numbers are 1-indexed
       def column
         coordinates[1]
       end
 
+      # Set the cursor's column number.
+      #
+      # @param n [Fixnum]
+      # @return [Fixnum]
+      # @note Column numbers are 1-indexed
       def column=(n)
         self.coordinates = [line, n]
+        n
       end
     end
+
+# The following methods are dynamically generated.
+=begin
+@method get_buffer
+  @return [Buffer]
+
+@method get_cursor
+  @return [Array<Fixnum>]
+
+@method set_cursor(pos)
+  @param [Array<Fixnum>] pos
+  @return [void]
+
+@method get_height
+  @return [Fixnum]
+
+@method set_height(height)
+  @param [Fixnum] height
+  @return [void]
+
+@method get_width
+  @return [Fixnum]
+
+@method set_width(width)
+  @param [Fixnum] width
+  @return [void]
+
+@method get_var(name)
+  @param [String] name
+  @return [Object]
+
+@method set_var(name, value)
+  @param [String] name
+  @param [Object] value
+  @return [Object]
+
+@method get_option(name)
+  @param [String] name
+  @return [Object]
+
+@method set_option(name, value)
+  @param [String] name
+  @param [Object] value
+  @return [void]
+
+@method get_position
+  @return [Array<Fixnum>]
+
+@method get_tabpage
+  @return [Tabpage]
+
+@method is_valid
+  @return [Boolean]
+
+=end
   end
 end