neovim 0.4.0 → 0.5.0

data/lib/neovim/current.rb

@@ -9,14 +9,13 @@ module Neovim
   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)
+      @session.request(:nvim_get_current_line)
     end
 
     # Set the line under the cursor.
@@ -24,16 +23,14 @@ module Neovim
     # @param line [String] The target line contents.
     # @return [String]
     def line=(line)
-      @session.request(:vim_set_current_line, line)
+      @session.request(:nvim_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
+      @session.request(:nvim_get_current_buf)
     end
 
     # Set the active buffer.
@@ -41,14 +38,14 @@ module Neovim
     # @param buffer [Buffer, Integer] The target buffer or index.
     # @return [Buffer, Integer]
     def buffer=(buffer)
-      @session.request(:vim_set_current_buffer, buffer)
+      @session.request(:nvim_set_current_buf, buffer)
     end
 
     # Get the active window.
     #
     # @return [Window]
     def window
-      @session.request(:vim_get_current_window)
+      @session.request(:nvim_get_current_win)
     end
 
     # Set the active window.
@@ -56,14 +53,14 @@ module Neovim
     # @param window [Window, Integer] The target window or index.
     # @return [Window, Integer]
     def window=(window)
-      @session.request(:vim_set_current_window, window)
+      @session.request(:nvim_set_current_win, window)
     end
 
     # Get the active tabpage.
     #
     # @return [Tabpage]
     def tabpage
-      @session.request(:vim_get_current_tabpage)
+      @session.request(:nvim_get_current_tabpage)
     end
 
     # Set the active tabpage.
@@ -71,14 +68,7 @@ module Neovim
     # @param tabpage [Tabpage, Integer] The target tabpage or index.
     # @return [Tabpage, Integer]
     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
+      @session.request(:nvim_set_current_tabpage, tabpage)
     end
   end
 end

data/lib/neovim/executable.rb

@@ -23,11 +23,11 @@ module Neovim
     #
     # @return [String]
     def version
-      @version ||= IO.popen([path, "--version"]) do |io|
+      @version ||= IO.popen([@path, "--version"]) do |io|
         io.gets[VERSION_PATTERN, 1]
       end
     rescue => e
-      raise Error, "Couldn't load #{path}: #{e}"
+      raise Error, "Couldn't load #{@path}: #{e}"
     end
   end
 end

data/lib/neovim/line_range.rb

@@ -3,28 +3,35 @@ module Neovim
   class LineRange
     include Enumerable
 
-    def initialize(buffer, _begin, _end)
+    def initialize(buffer)
       @buffer = buffer
-      @begin = _begin
-      @end = _end
+    end
+
+    # Satisfy the +Enumerable+ interface by yielding each line.
+    #
+    # @yieldparam line [String]
+    def each(&block)
+      (0...@buffer.count).each_slice(5000) do |linenos|
+        _start, _stop = linenos[0], linenos[-1] + 1
+        @buffer.get_lines(_start, _stop, true).each(&block)
+      end
     end
 
     # Resolve to an array of lines as strings.
     #
     # @return [Array<String>]
     def to_a
-      @buffer.get_line_slice(@begin, @end, true, true)
+      map { |line| line }
     end
 
-    # Yield each line in the range.
+    # Override +#==+ to compare contents of lines.
     #
-    # @yield [String] The current line
-    # @return [Array<String>]
-    def each(&block)
-      to_a.each(&block)
+    # @return Boolean
+    def ==(other)
+      to_a == other.to_a
     end
 
-    # Access the line at the given index within the range.
+    # Access a line or line range.
     #
     # @overload [](index)
     #   @param index [Integer]
@@ -43,28 +50,17 @@ module Neovim
     # @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)
-        )
+      if Range === pos
+        @buffer.get_lines(*range_indices(pos), true)
       else
-        if len
-          LineRange.new(
-            @buffer,
-            abs_line(pos),
-            abs_line(pos + len - 1)
-          )
-        else
-          @buffer.get_line(abs_line(pos))
-        end
+        _begin, _end = length_indices(pos, len || 1)
+        lines = @buffer.get_lines(_begin, _end, true)
+        len ? lines : lines.first
       end
     end
     alias_method :slice, :[]
 
-    # Set the line at the given index within the range.
+    # Set a line or line range.
     #
     # @overload []=(index, string)
     #   @param index [Integer]
@@ -89,27 +85,11 @@ module Neovim
       *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
-        )
+      if Range === pos
+        @buffer.set_lines(*range_indices(pos), true, Array(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
+        _begin, _end = length_indices(pos, len || 1)
+        @buffer.set_lines(_begin, _end, true, Array(val))
       end
     end
 
@@ -117,29 +97,38 @@ module Neovim
     #
     # @param other [Array] The replacement lines
     def replace(other)
-      self[0..-1] = other
+      self[0..-1] = other.to_ary
       self
     end
 
-    # Insert line(s) at the given index within the range.
-    #
-    # @param index [Integer]
-    # @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 [Integer]
     def delete(index)
-      @buffer.del_line(abs_line(index))
+      i = Integer(index)
+      self[i].tap { self[i, 1] = [] }
+    rescue TypeError
     end
 
     private
 
-    def abs_line(n)
-      n < 0 ? (@end + n + 1) : @begin + n
+    def range_indices(range)
+      _begin = adjust_index(range.begin)
+      _end = adjust_index(range.end)
+      _end += 1 unless range.exclude_end?
+
+      [_begin, _end]
+    end
+
+    def length_indices(index, len)
+      _begin = adjust_index(index)
+      _end = _begin < 0 ? [_begin + len, -1].min : _begin + len
+
+      [_begin, _end]
+    end
+
+    def adjust_index(i)
+      i < 0 ? i - 1 : i
     end
   end
 end

data/lib/neovim/plugin/dsl.rb

@@ -43,7 +43,7 @@ module Neovim
       # @param &block [Proc, nil] The body of the function.
       #
       # @option options [String, Boolean] :range The range argument.
-      #   See +:h command-range+.
+      #   See +:h func-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
@@ -89,7 +89,7 @@ module Neovim
         if type == :autocmd
           options = _options.dup
         else
-          options = standardize_range(_options.dup)
+          options = standardize(_options.dup)
         end
 
         sync = options.delete(:sync)
@@ -99,12 +99,20 @@ module Neovim
         )
       end
 
-      def standardize_range(options)
+      def standardize(options)
         if options.key?(:range)
           options[:range] = "" if options[:range] == true
           options[:range] = ::Kernel.String(options[:range])
         end
 
+        [:bang, :register].each do |opt|
+          if options[opt]
+            options[opt] = ""
+          elsif options.key?(opt)
+            options.delete(opt)
+          end
+        end
+
         options
       end
     end

data/lib/neovim/remote_object.rb

@@ -23,7 +23,7 @@ module Neovim
 
     # Intercept method calls and delegate to appropriate RPC methods.
     def method_missing(method_name, *args)
-      if func = @api.function(qualify(method_name))
+      if func = @api.function_for_object_method(self, method_name)
         func.call(@session, @index, *args)
       else
         super
@@ -36,7 +36,7 @@ module Neovim
     end
 
     # Extend +methods+ to include RPC methods
-    def methods
+    def methods(*args)
       super | rpc_methods
     end
 
@@ -48,17 +48,7 @@ module Neovim
     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}"
+      @api.functions_for_object(self).map(&:method_name)
     end
   end
 end

data/lib/neovim/ruby_provider.rb

@@ -32,7 +32,7 @@ module Neovim
         end
 
         $stderr.define_singleton_method(:write) do |string|
-          client.report_error(string)
+          client.err_writeln(string)
         end
 
         begin
@@ -81,7 +81,7 @@ module Neovim
       __plug.__send__(:rpc, :ruby_do_range) do |__nvim, *__args|
         __wrap_client(__nvim) do
           __start, __stop, __ruby = __args
-          __buffer = __nvim.get_current_buffer
+          __buffer = __nvim.get_current_buf
 
           __update_lines_in_chunks(__buffer, __start, __stop, 5000) do |__lines|
             __lines.map do |__line|
@@ -118,7 +118,7 @@ module Neovim
         yield
       rescue SyntaxError, LoadError, StandardError => e
         msg = [e.class, e.message].join(": ")
-        client.report_error(msg.lines.first.strip)
+        client.err_writeln(msg.lines.first.strip)
       end
     end
 

data/lib/neovim/ruby_provider/buffer_ext.rb

@@ -3,15 +3,15 @@ require "neovim/ruby_provider/vim"
 module Neovim
   class Buffer
     def self.current
-      ::Vim.get_current_buffer
+      ::Vim.get_current_buf
     end
 
     def self.count
-      ::Vim.get_buffers.size
+      ::Vim.list_bufs.size
     end
 
     def self.[](index)
-      ::Vim.get_buffers[index]
+      ::Vim.list_bufs[index]
     end
   end
 end

data/lib/neovim/ruby_provider/vim.rb

@@ -24,10 +24,10 @@ module Vim
     bufnr = client.evaluate("bufnr('%')")
 
     $curbuf = @__buffer_cache.fetch(bufnr) do
-      @__buffer_cache[bufnr] = client.get_current_buffer
+      @__buffer_cache[bufnr] = client.get_current_buf
     end
 
-    $curwin = client.get_current_window
+    $curwin = client.get_current_win
   end
 end
 

data/lib/neovim/ruby_provider/window_ext.rb

@@ -3,15 +3,15 @@ require "neovim/ruby_provider/vim"
 module Neovim
   class Window
     def self.current
-      ::Vim.get_current_window
+      ::Vim.get_current_win
     end
 
     def self.count
-      ::Vim.get_current_tabpage.get_windows.size
+      ::Vim.get_current_tabpage.list_wins.size
     end
 
     def self.[](index)
-      ::Vim.get_current_tabpage.get_windows[index]
+      ::Vim.get_current_tabpage.list_wins[index]
     end
   end
 end

data/lib/neovim/session.rb

@@ -48,16 +48,16 @@ module Neovim
       @running = false
     end
 
-    # Return the +nvim+ API as described in the +vim_get_api_info+ call.
+    # Return the +nvim+ API as described in the +nvim_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,
+    # Discover the +nvim+ API as described in the +nvim_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|
+      @api = API.new(request(:nvim_get_api_info)).tap do |api|
         @rpc.serializer.register_types(api, self)
       end
     end
@@ -111,7 +111,7 @@ module Neovim
       end
     end
 
-    # Return the channel ID if registered via +vim_get_api_info+.
+    # Return the channel ID if registered via +nvim_get_api_info+.
     def channel_id
       api.channel_id
     end

data/lib/neovim/session/api.rb

@@ -5,7 +5,7 @@ module Neovim
       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.
+      # discovered yet via the +nvim_get_api_info+ RPC call.
       def self.null
         new([nil, {"functions" => [], "types" => []}])
       end
@@ -17,8 +17,8 @@ module Neovim
       # 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))
+          function = Function.new(func)
+          acc.merge(function.name => function)
         end
       end
 
@@ -28,38 +28,66 @@ module Neovim
         @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
+      def function_for_object_method(obj, method_name)
+        functions[function_name(obj, method_name)]
       end
 
-      # Find a function with the given name.
-      def function(name)
-        functions[name.to_s]
+      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 @types={...} @functions={...}>" % (object_id << 1)
+        "#<#{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, :async
+        attr_reader :name
+
+        def initialize(attributes)
+          @name = attributes.fetch("name")
+        end
 
-        def initialize(name, async)
-          @name, @async = name, async
+        def method_name
+          @name.sub(/^nvim_(win_|buf_|tabpage_)?/, "").to_sym
         end
 
-        # Apply this function to a running RPC session. Sends either a request if
-        # +async+ is +false+ or a notification if +async+ is +true+.
+        # Apply this function to a running RPC session.
         def call(session, *args)
-          if async
-            session.notify(name, *args)
-          else
-            session.request(name, *args)
-          end
+          session.request(name, *args)
         end
       end
     end