neovim 0.5.1 → 0.6.0

data/lib/neovim/session/api.rb

@@ -1,95 +0,0 @@
-module 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 +nvim_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|
-          function = Function.new(func)
-          acc.merge(function.name => function)
-        end
-      end
-
-      # Return information about +nvim+ types. Used for registering MessagePack
-      # +ext+ types.
-      def types
-        @types ||= @api_info.fetch("types")
-      end
-
-      def function_for_object_method(obj, method_name)
-        functions[function_name(obj, method_name)]
-      end
-
-      def functions_for_object(obj)
-        pattern = function_pattern(obj)
-        functions.values.select { |func| func.name =~ pattern }
-      end
-
-      # Truncate the output of inspect so console sessions are more pleasant.
-      def inspect
-        "#<#{self.class}:0x%x @channel_id=#{@channel_id.inspect} @types={...} @functions={...}>" % (object_id << 1)
-      end
-
-      private
-
-      def function_name(obj, method_name)
-        case obj
-        when Client
-          "nvim_#{method_name}"
-        when Buffer
-          "nvim_buf_#{method_name}"
-        when Window
-          "nvim_win_#{method_name}"
-        when Tabpage
-          "nvim_tabpage_#{method_name}"
-        else
-          raise "Unknown object #{obj.inspect}"
-        end
-      end
-
-      def function_pattern(obj)
-        case obj
-        when Client
-          /^nvim_(?!(buf|win|tabpage)_)/
-        when Buffer
-          /^nvim_buf_/
-        when Window
-          /^nvim_win_/
-        when Tabpage
-          /^nvim_tabpage_/
-        else
-          raise "Unknown object #{obj.inspect}"
-        end
-      end
-
-      class Function
-        attr_reader :name
-
-        def initialize(attributes)
-          @name = attributes.fetch("name")
-        end
-
-        def method_name
-          @name.sub(/^nvim_(win_|buf_|tabpage_)?/, "").to_sym
-        end
-
-        # Apply this function to a running RPC session.
-        def call(session, *args)
-          session.request(name, *args)
-        end
-      end
-    end
-  end
-end

data/lib/neovim/session/event_loop.rb

@@ -1,100 +0,0 @@
-require "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 = Socket.tcp(host, port)
-        new(socket)
-      end
-
-      # Connect to a UNIX domain socket.
-      def self.unix(path)
-        socket = Socket.unix(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

data/lib/neovim/session/notification.rb

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

data/lib/neovim/session/request.rb

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

data/lib/neovim/session/rpc.rb

@@ -1,95 +0,0 @@
-require "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

data/lib/neovim/session/serializer.rb

@@ -1,62 +0,0 @@
-require "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

data/spec/integration/ruby_buffer_spec.rb

@@ -1,151 +0,0 @@
-begin
-  require "helper"
-rescue LoadError
-end
-
-RSpec.describe "Vim::Buffer", :embedded do
-  before do
-    $curbuf.set_lines(0, -1, true, ["one", "two", "three"])
-    $curwin.set_cursor([1, 0])
-  end
-
-  specify "$curbuf" do
-    expect($curbuf).to be_a(Vim::Buffer)
-  end
-
-  specify ".current" do
-    expect(Vim::Buffer.current).to eq($curbuf)
-  end
-
-  specify ".[]" do
-    expect(Vim::Buffer[0]).to eq($curbuf)
-  end
-
-  specify ".count" do
-    expect(Vim::Buffer.count).to be > 0
-  end
-
-  specify "#name" do
-    $curbuf.set_name("test_buf")
-    expect($curbuf.name).to include("test_buf")
-  end
-
-  specify "#number" do
-    expect($curbuf.number).to eq(1)
-  end
-
-  specify "#count" do
-    expect($curbuf.count).to eq(3)
-  end
-
-  specify "#length" do
-    expect($curbuf.length).to eq(3)
-  end
-
-  specify "#[]" do
-    expect($curbuf[1]).to eq("one")
-
-    expect do
-      $curbuf[-1]
-    end.to raise_error(/out of bounds/)
-
-    expect do
-      $curbuf[4]
-    end.to raise_error(/out of bounds/)
-  end
-
-  specify "#[]=" do
-    expect($curbuf[1] = "first").to eq("first")
-    expect($curbuf[1]).to eq("first")
-
-    expect do
-      $curbuf[4] = "line"
-    end.to raise_error(/out of bounds/)
-
-    expect do
-      $curbuf[-1] = "line"
-    end.to raise_error(/out of bounds/)
-  end
-
-  specify "#delete" do
-    expect($curbuf.delete(3)).to eq(nil)
-    expect($curbuf.count).to eq(2)
-
-    expect do
-      $curbuf.delete(-1)
-    end.to raise_error(/out of bounds/)
-
-    expect do
-      $curbuf.delete(4)
-    end.to raise_error(/out of bounds/)
-  end
-
-  specify "#append" do
-    expect($curbuf.append(2, "last")).to eq("last")
-    expect($curbuf[3]).to eq("last")
-
-    $curbuf.set_lines(0, -1, true, [])
-    $curbuf.append(0, "one")
-
-    expect($curbuf.lines.to_a).to eq(["one", ""])
-
-    expect do
-      $curbuf.append(0, "two")
-    end.not_to change { $curwin.cursor }
-
-    expect do
-      $curbuf.append(-1, "line")
-    end.to raise_error(/out of bounds/)
-
-    expect do
-      $curbuf.append(4, "line")
-    end.to raise_error(/out of bounds/)
-  end
-
-  specify "#line_number" do
-    expect do
-      Vim.command("normal j")
-    end.to change { $curbuf.line_number }.from(1).to(2)
-
-    original = $curbuf
-
-    begin
-      Vim.command("new")
-      expect(original.line_number).to eq(nil)
-    ensure
-      Vim.set_current_buf(original)
-    end
-  end
-
-  specify "#line" do
-    expect do
-      Vim.command("normal j")
-    end.to change { $curbuf.line }.from("one").to("two")
-
-    original = $curbuf
-
-    begin
-      Vim.command("new")
-      expect(original.line).to eq(nil)
-    ensure
-      Vim.set_current_buf(original)
-    end
-  end
-
-  specify "#line=" do
-    $curbuf.line = "first"
-    expect($curbuf[1]).to eq("first")
-
-    original = $curbuf
-
-    begin
-      Vim.command("new")
-
-      expect do
-        original.line = "line"
-      end.not_to change { original.lines.to_a }
-    ensure
-      Vim.set_current_buf(original)
-    end
-  end
-end