neovim 0.4.0 → 0.5.0

data/spec/neovim/current_spec.rb

@@ -135,13 +135,5 @@ module Neovim
         expect(current.tabpage = tp0).to eq(tp0)
       end
     end
-
-    describe "#range=" do
-      it "sets the line range of the current buffer" do
-        current.buffer.lines = ["one", "two", "three", "four"]
-        current.range = (1..2)
-        expect(current.buffer.range.to_a).to eq(["two", "three"])
-      end
-    end
   end
 end

data/spec/neovim/line_range_spec.rb

@@ -4,21 +4,31 @@ module Neovim
   RSpec.describe LineRange do
     let(:client) { Neovim.attach_child(Support.child_argv) }
     let(:buffer) { client.current.buffer }
-    let(:line_range) { LineRange.new(buffer, 0, -1) }
-    let(:sub_range) { LineRange.new(buffer, 1, 2) }
+    let(:line_range) { LineRange.new(buffer) }
 
     before do
-      client.command("normal i1")
-      client.command("normal o2")
-      client.command("normal o3")
-      client.command("normal o4")
+      buffer.set_lines(0, -1, true, ["1", "2", "3", "4"])
     end
 
     after { client.shutdown }
 
-    it "is enumerable" do
-      expect(line_range).to be_an(Enumerable)
-      expect(line_range.each.to_a).to eq(["1", "2", "3", "4"])
+    describe "#each" do
+      it "yields each line" do
+        yielded = []
+        line_range.each { |line| yielded << line }
+
+        expect(yielded).to eq(["1", "2", "3", "4"])
+      end
+
+      it "yields a large number of lines" do
+        lines = Array.new(6000, "x")
+        buffer.set_lines(0, -1, true, lines)
+
+        yielded = []
+        line_range.each { |line| yielded << line }
+
+        expect(yielded).to eq(lines)
+      end
     end
 
     describe "#to_a" do
@@ -26,82 +36,99 @@ module Neovim
         expect(line_range.to_a).to eq(["1", "2", "3", "4"])
       end
 
-      it "returns a subset of lines as an array" do
-        expect(sub_range.to_a).to eq(["2", "3"])
+      it "returns a large number of lines as an array" do
+        lines = Array.new(6000, "x")
+        buffer.set_lines(0, -1, true, lines)
+        expect(line_range.to_a).to eq(lines)
       end
     end
 
-    describe "#[]" do
-      it "accepts a single index" do
-        expect(line_range[1]).to eq("2")
-      end
-
-      it "returns lines at an offset from the index" do
-        expect(sub_range[0]).to eq("2")
-      end
+    describe "#==" do
+      it "compares line contents" do
+        client.command("new")
+        buffer2 = client.current.buffer
 
-      it "allows indexes beyond the bounds of a sub range" do
-        expect(sub_range[2]).to eq("4")
+        expect(buffer2.lines == buffer.lines).to eq(false)
+        buffer2.set_lines(0, -1, true, ["1", "2", "3", "4"])
+        expect(buffer2.lines == buffer.lines).to eq(true)
       end
+    end
 
-      it "returns lines at an offset with a negative index" do
-        expect(sub_range[-1]).to eq("3")
+    describe "#[]" do
+      it "accepts a single index" do
+        expect(line_range[1]).to eq("2")
+        expect(line_range[-1]).to eq("4")
+        expect(line_range[-2]).to eq("3")
       end
 
       it "accepts an index and length" do
-        expect(line_range[0, 2].to_a).to eq(["1", "2"])
-      end
+        expect(line_range[0, 2]).to eq(["1", "2"])
+        expect(line_range[-2, 2]).to eq(["3", "4"])
+        expect(line_range[-2, 3]).to eq(["3", "4"])
 
-      it "returns lines at an offset from an index and length" do
-        expect(sub_range[0, 2].to_a).to eq(["2", "3"])
+        expect {
+          line_range[2, 3]
+        }.to raise_error(/out of bounds/)
       end
 
       it "accepts a range" do
-        expect(line_range[0..1].to_a).to eq(["1", "2"])
-        expect(line_range[0...1].to_a).to eq(["1"])
-      end
+        expect(line_range[0..1]).to eq(["1", "2"])
+        expect(line_range[0...1]).to eq(["1"])
 
-      it "accepts a range with a negative end" do
-        expect(line_range[0..-1].to_a).to eq(["1", "2", "3", "4"])
-      end
+        expect(line_range[0..-1]).to eq(["1", "2", "3", "4"])
+        expect(line_range[0..-2]).to eq(["1", "2", "3"])
+        expect(line_range[-3..-2]).to eq(["2", "3"])
+
+        expect(line_range[0..-5]).to eq([])
+        expect(line_range[0...-4]).to eq([])
+        expect(line_range[-2..-3]).to eq([])
 
-      it "returns lines at an offset from a range" do
-        expect(sub_range[0..1].to_a).to eq(["2", "3"])
+        expect {
+          line_range[2..4]
+        }.to raise_error(/out of bounds/)
       end
     end
 
     describe "#[]=" do
       it "accepts a single index" do
-        line_range[0] = "foo"
+        expect(line_range[0] = "foo").to eq("foo")
         expect(line_range.to_a).to eq(["foo", "2", "3", "4"])
-      end
 
-      it "accepts a single index at an offset" do
-        sub_range[0] = "foo"
-        expect(buffer.lines.to_a).to eq(["1", "foo", "3", "4"])
+        expect(line_range[-1] = "bar").to eq("bar")
+        expect(line_range.to_a).to eq(["foo", "2", "3", "bar"])
+
+        expect {
+          line_range[-5] = "foo"
+        }.to raise_error(/out of bounds/)
       end
 
       it "accepts an index and length" do
-        line_range[0, 2] = ["foo"]
+        expect(line_range[0, 2] = ["foo"]).to eq(["foo"])
         expect(line_range.to_a).to eq(["foo", "3", "4"])
-      end
 
-      it "accepts an index and length at an offset" do
-        sub_range[0, 2] = ["foo"]
-        expect(buffer.lines.to_a).to eq(["1", "foo", "4"])
+        expect(line_range[-2, 2] = ["bar"]).to eq(["bar"])
+        expect(line_range.to_a).to eq(["foo", "bar"])
+
+        expect(line_range[0, 2] = "baz").to eq("baz")
+        expect(line_range.to_a).to eq(["baz"])
+
+        expect {
+          line_range[0, 5] = "foo"
+        }.to raise_error(/out of bounds/)
       end
 
       it "accepts a range" do
-        line_range[0..1] = ["foo"]
+        expect(line_range[0..1] = ["foo"]).to eq(["foo"])
         expect(line_range.to_a).to eq(["foo", "3", "4"])
 
-        line_range[0...1] = ["bar"]
+        expect(line_range[0...1] = ["bar"]).to eq(["bar"])
         expect(line_range.to_a).to eq(["bar", "3", "4"])
-      end
 
-      it "accepts a range at an offset" do
-        sub_range[0..1] = ["foo"]
-        expect(buffer.lines.to_a).to eq(["1", "foo", "4"])
+        expect(line_range[0..-2] = ["baz"]).to eq(["baz"])
+        expect(line_range.to_a).to eq(["baz", "4"])
+
+        expect(line_range[0...2] = "qux").to eq("qux")
+        expect(line_range.to_a).to eq(["qux"])
       end
     end
 
@@ -110,64 +137,32 @@ module Neovim
         line_range.replace(["4", "5"])
         expect(line_range.to_a).to eq(["4", "5"])
       end
-
-      it "replaces a subset of lines" do
-        sub_range.replace(["5", "6"])
-        expect(buffer.lines.to_a).to eq(["1", "5", "6", "4"])
-      end
     end
 
-    describe "#insert" do
-      before { line_range.replace(["1", "2"]) }
-
-      it "inserts lines at the beginning" do
-        expect {
-          line_range.insert(0, "z")
-        }.to change { line_range.to_a }.to(["z", "1", "2"])
-
-        expect {
-          line_range.insert(0, ["x", "y"])
-        }.to change { line_range.to_a }.to(["x", "y", "z", "1", "2"])
-      end
-
-      it "inserts lines in the middle" do
-        expect {
-          line_range.insert(1, "z")
-        }.to change { line_range.to_a }.to(["1", "z", "2"])
-
-        expect {
-          line_range.insert(1, ["x", "y"])
-        }.to change { line_range.to_a }.to(["1", "x", "y", "z", "2"])
-      end
-
-      it "inserts lines at the end" do
+    describe "#delete" do
+      it "deletes the line at the given index" do
         expect {
-          line_range.insert(-1, "x")
-        }.to change { line_range.to_a }.to(["1", "2", "x"])
+          line_range.delete(0)
+        }.to change { line_range.to_a }.to(["2", "3", "4"])
 
         expect {
-          line_range.insert(-1, ["y", "z"])
-        }.to change { line_range.to_a }.to(["1", "2", "x", "y", "z"])
-      end
+          line_range.delete(-1)
+        }.to change { line_range.to_a }.to(["2", "3"])
 
-      it "raises on out of bounds indexes" do
         expect {
-          line_range.insert(10, "x")
-        }.to raise_error(/out of bounds/i)
+          line_range.delete(-2)
+        }.to change { line_range.to_a }.to(["3"])
       end
-    end
 
-    describe "#delete" do
-      it "deletes the line at the given index" do
-        expect {
-          line_range.delete(0)
-        }.to change { line_range.to_a }.to(["2", "3", "4"])
+      it "returns the line deleted" do
+        expect(line_range.delete(0)).to eq("1")
+        expect(line_range.delete(-1)).to eq("4")
       end
 
-      it "deletes the line at an offset" do
+      it "returns nil if provided a non-integer" do
         expect {
-          sub_range.delete(0)
-        }.to change { buffer.lines.to_a }.to(["1", "3", "4"])
+          expect(line_range.delete(:foo)).to eq(nil)
+        }.not_to change { line_range.to_a }
       end
     end
   end

data/spec/neovim/plugin_spec.rb

@@ -8,7 +8,14 @@ module Neovim
         cmd_block = Proc.new {}
 
         plugin = Plugin.from_config_block("source") do |plug|
-          plug.command("Foo", :range => true, :nargs => 1, &cmd_block)
+          plug.command(
+            "Foo",
+            :nargs => 1,
+            :range => true,
+            :bang => true,
+            :register => true,
+            &cmd_block
+          )
         end
 
         expect(plugin.handlers.size).to be(1)
@@ -22,7 +29,12 @@ module Neovim
           :type => :command,
           :name => "Foo",
           :sync => false,
-          :opts => {:range => "", :nargs => 1},
+          :opts => {
+            :nargs => 1,
+            :range => "",
+            :bang => "",
+            :register => "",
+          },
         )
       end
 

data/spec/neovim/remote_object_spec.rb

@@ -23,7 +23,7 @@ module Neovim
       end
 
       describe "#method_missing" do
-        it "enables window_* function calls" do
+        it "enables nvim_win_* function calls" do
           expect(window.get_cursor).to eq([1, 0])
         end
 
@@ -61,7 +61,7 @@ module Neovim
       end
 
       describe "#method_missing" do
-        it "enables tabpage_* function calls" do
+        it "enables nvim_tabpage_* function calls" do
           expect(tabpage.is_valid).to be(true)
         end
       end
@@ -72,7 +72,7 @@ module Neovim
         end
 
         it "returns api methods" do
-          expect(tabpage.methods).to include(:get_windows)
+          expect(tabpage.methods).to include(:list_wins)
         end
       end
     end
@@ -95,7 +95,7 @@ module Neovim
       end
 
       describe "#method_missing" do
-        it "enables buffer_* function calls" do
+        it "enables nvim_buf_* function calls" do
           expect(buffer.line_count).to be(1)
         end
       end

data/spec/neovim/ruby_provider/buffer_ext_spec.rb

@@ -13,7 +13,7 @@ module Neovim
 
     describe ".current" do
       it "returns the current buffer from the global Vim client" do
-        expect(Buffer.current).to eq(nvim.get_current_buffer)
+        expect(Buffer.current).to eq(nvim.get_current_buf)
       end
     end
 
@@ -27,9 +27,9 @@ module Neovim
 
     describe ".[]" do
       it "returns the buffer from the global Vim client at the given index" do
-        expect(Buffer[0]).to eq(nvim.get_current_buffer)
+        expect(Buffer[0]).to eq(nvim.get_current_buf)
         nvim.command("new")
-        expect(Buffer[1]).to eq(nvim.get_current_buffer)
+        expect(Buffer[1]).to eq(nvim.get_current_buf)
       end
     end
   end

data/spec/neovim/ruby_provider/window_ext_spec.rb

@@ -13,7 +13,7 @@ module Neovim
 
     describe ".current" do
       it "returns the current window from the global Vim client" do
-        expect(Window.current).to eq(nvim.get_current_window)
+        expect(Window.current).to eq(nvim.get_current_win)
       end
     end
 

data/spec/neovim/session/api_spec.rb

@@ -12,52 +12,57 @@ module Neovim
         end
       end
 
-      describe "#function" do
-        it "returns a sync function object" do
-          api = API.new(
-            [nil, {"functions" => [
-              {"name" => "vim_sync", "async" => false}
-            ]}]
-          )
+      let(:client) { Neovim.attach_child(Support.child_argv) }
 
-          function = api.function("vim_sync")
-          expect(function.name).to eq("vim_sync")
-          expect(function.async).to be(false)
+      let(:api) do
+        API.new(
+          [
+            nil,
+            {
+              "functions" => [
+                {"name" => "nvim_func"},
+                {"name" => "nvim_buf_func"},
+                {"name" => "nvim_win_func"},
+                {"name" => "nvim_tabpage_func"},
+              ]
+            }
+          ]
+        )
+      end
 
-          session = instance_double(Session)
-          expect(session).to receive(:request).with("vim_sync", "msg")
-          function.call(session, "msg")
-        end
+      describe "#functions_for_object_method" do
+        it "returns relevant functions" do
+          function = api.function_for_object_method(client, :func)
+          expect(function.name).to eq("nvim_func")
 
-        it "returns an async function object" do
-          api = API.new(
-            [nil, {"functions" => [
-              {"name" => "vim_async", "async" => true}
-            ]}]
-          )
+          function = api.function_for_object_method(client.get_current_buf, :func)
+          expect(function.name).to eq("nvim_buf_func")
 
-          function = api.function("vim_async")
-          expect(function.name).to eq("vim_async")
-          expect(function.async).to be(true)
+          function = api.function_for_object_method(client.get_current_win, :func)
+          expect(function.name).to eq("nvim_win_func")
 
-          session = instance_double(Session)
-          expect(session).to receive(:notify).with("vim_async", "msg")
-          function.call(session, "msg")
+          function = api.function_for_object_method(client.get_current_tabpage, :func)
+          expect(function.name).to eq("nvim_tabpage_func")
         end
       end
 
-      describe "#functions_with_prefix" do
+      describe "#functions_for_object" do
         it "returns relevant functions" do
-          api = API.new(
-            [nil, {"functions" => [
-              {"name" => "vim_strwidth"},
-              {"name" => "buffer_get_lines"}
-            ]}]
-          )
+          functions = api.functions_for_object(client)
+          expect(functions.size).to be(1)
+          expect(functions.first.name).to eq("nvim_func")
+
+          functions = api.functions_for_object(client.get_current_buf)
+          expect(functions.size).to be(1)
+          expect(functions.first.name).to eq("nvim_buf_func")
+
+          functions = api.functions_for_object(client.get_current_win)
+          expect(functions.size).to be(1)
+          expect(functions.first.name).to eq("nvim_win_func")
 
-          functions = api.functions_with_prefix("vim_")
+          functions = api.functions_for_object(client.get_current_tabpage)
           expect(functions.size).to be(1)
-          expect(functions.first.name).to eq("vim_strwidth")
+          expect(functions.first.name).to eq("nvim_tabpage_func")
         end
       end
     end