ep_vim 0.7.1 → 0.9.2

package/static/js/vim-core.js

@@ -13,6 +13,7 @@ const getLineText = (rep, line) => rep.lines.atIndex(line).text;
 
 const firstNonBlank = (lineText) => {
   let i = 0;
+  if (!lineText) return 0;
   while (i < lineText.length && isWhitespace(lineText[i])) i++;
   return i;
 };
@@ -301,6 +302,79 @@ const textBracketRange = (lineText, char, bracket, type) => {
   return null;
 };
 
+const getFullText = (rep) => {
+  const lines = [];
+  for (let i = 0; i < rep.lines.length(); i++) {
+    lines.push(getLineText(rep, i));
+  }
+  return lines.join("\n");
+};
+
+const posToAbsolute = (rep, line, char) => {
+  let pos = 0;
+  for (let i = 0; i < line; i++) {
+    pos += getLineText(rep, i).length + 1;
+  }
+  return pos + char;
+};
+
+const absoluteToPos = (rep, absPos) => {
+  let pos = 0;
+  const totalLines = rep.lines.length();
+  for (let i = 0; i < totalLines; i++) {
+    const lineLen = getLineText(rep, i).length;
+    if (pos + lineLen + 1 > absPos) {
+      return [i, absPos - pos];
+    }
+    pos += lineLen + 1;
+  }
+  return [totalLines - 1, getLineText(rep, totalLines - 1).length];
+};
+
+const searchForward = (rep, fromLine, fromChar, pattern, count = 1) => {
+  if (!pattern || pattern.length === 0) return null;
+  const text = getFullText(rep);
+  let currentPos = posToAbsolute(rep, fromLine, fromChar);
+  let matchPos = -1;
+  for (let i = 0; i < count; i++) {
+    matchPos = text.indexOf(pattern, currentPos);
+    if (matchPos !== -1) {
+      currentPos = matchPos + pattern.length;
+    } else {
+      matchPos = text.indexOf(pattern);
+      if (matchPos !== -1) {
+        currentPos = matchPos + pattern.length;
+      } else {
+        return null;
+      }
+    }
+  }
+  return absoluteToPos(rep, matchPos);
+};
+
+const searchBackward = (rep, fromLine, fromChar, pattern, count = 1) => {
+  if (!pattern || pattern.length === 0) return null;
+  const text = getFullText(rep);
+  let currentPos = posToAbsolute(rep, fromLine, fromChar);
+  let matchPos = -1;
+  for (let i = 0; i < count; i++) {
+    if (currentPos > 0) {
+      matchPos = text.lastIndexOf(pattern, currentPos - 1);
+      if (matchPos !== -1) {
+        currentPos = matchPos;
+        continue;
+      }
+    }
+    matchPos = text.lastIndexOf(pattern);
+    if (matchPos !== -1) {
+      currentPos = matchPos;
+    } else {
+      return null;
+    }
+  }
+  return absoluteToPos(rep, matchPos);
+};
+
 const offsetToPos = (rep, offset) => {
   const totalLines = rep.lines.length();
   for (let i = 0; i < totalLines; i++) {
@@ -465,4 +539,9 @@ module.exports = {
   matchingBracketPos,
   paragraphTextRange,
   sentenceTextRange,
+  getFullText,
+  posToAbsolute,
+  absoluteToPos,
+  searchForward,
+  searchBackward,
 };

package/static/js/vim-core.test.js

@@ -24,6 +24,11 @@ const {
   paragraphForward,
   paragraphBackward,
   getTextInRange,
+  getFullText,
+  posToAbsolute,
+  absoluteToPos,
+  searchForward,
+  searchBackward,
 } = require("./vim-core");
 
 const makeRep = (lines) => ({
@@ -674,3 +679,116 @@ describe("paragraphBackward", () => {
     assert.equal(paragraphBackward(rep, 5, 1), 2);
   });
 });
+
+describe("getFullText", () => {
+  it("joins lines with newlines", () => {
+    const rep = makeRep(["hello", "world", "test"]);
+    assert.equal(getFullText(rep), "hello\nworld\ntest");
+  });
+
+  it("handles single line", () => {
+    const rep = makeRep(["hello"]);
+    assert.equal(getFullText(rep), "hello");
+  });
+
+  it("handles empty lines", () => {
+    const rep = makeRep(["hello", "", "world"]);
+    assert.equal(getFullText(rep), "hello\n\nworld");
+  });
+});
+
+describe("posToAbsolute and absoluteToPos", () => {
+  const rep = makeRep(["hello", "world", "test"]);
+
+  it("converts position to absolute and back", () => {
+    assert.deepEqual(absoluteToPos(rep, posToAbsolute(rep, 0, 0)), [0, 0]);
+    assert.deepEqual(absoluteToPos(rep, posToAbsolute(rep, 0, 3)), [0, 3]);
+    assert.deepEqual(absoluteToPos(rep, posToAbsolute(rep, 1, 0)), [1, 0]);
+    assert.deepEqual(absoluteToPos(rep, posToAbsolute(rep, 1, 2)), [1, 2]);
+    assert.deepEqual(absoluteToPos(rep, posToAbsolute(rep, 2, 4)), [2, 4]);
+  });
+
+  it("converts line start positions correctly", () => {
+    assert.equal(posToAbsolute(rep, 0, 0), 0);
+    assert.equal(posToAbsolute(rep, 1, 0), 6);
+    assert.equal(posToAbsolute(rep, 2, 0), 12);
+  });
+});
+
+describe("searchForward", () => {
+  const rep = makeRep(["hello world", "foo hello bar", "hello"]);
+
+  it("finds pattern forward from position", () => {
+    const pos = searchForward(rep, 0, 0, "hello");
+    assert.deepEqual(pos, [0, 0]);
+  });
+
+  it("finds next occurrence after cursor", () => {
+    const pos = searchForward(rep, 0, 6, "hello");
+    assert.deepEqual(pos, [1, 4]);
+  });
+
+  it("wraps to beginning when pattern not found after cursor", () => {
+    const pos = searchForward(rep, 2, 5, "hello");
+    assert.deepEqual(pos, [0, 0]);
+  });
+
+  it("finds pattern across lines", () => {
+    const pos = searchForward(rep, 0, 0, "world");
+    assert.deepEqual(pos, [0, 6]);
+  });
+
+  it("returns null for empty pattern", () => {
+    assert.equal(searchForward(rep, 0, 0, ""), null);
+  });
+
+  it("returns null when pattern not found", () => {
+    assert.equal(searchForward(rep, 0, 0, "xyz"), null);
+  });
+});
+
+describe("searchBackward", () => {
+  const rep = makeRep(["hello world", "foo hello bar", "hello"]);
+
+  it("finds pattern backward from position", () => {
+    const pos = searchBackward(rep, 2, 5, "hello");
+    assert.deepEqual(pos, [2, 0]);
+  });
+
+  it("finds previous occurrence before cursor", () => {
+    const pos = searchBackward(rep, 2, 0, "hello");
+    assert.deepEqual(pos, [1, 4]);
+  });
+
+  it("wraps to end when pattern not found before cursor", () => {
+    const pos = searchBackward(rep, 0, 0, "hello");
+    assert.deepEqual(pos, [2, 0]);
+  });
+
+  it("returns null for empty pattern", () => {
+    assert.equal(searchBackward(rep, 2, 5, ""), null);
+  });
+
+  it("returns null when pattern not found", () => {
+    assert.equal(searchBackward(rep, 2, 5, "xyz"), null);
+  });
+
+  it("searches multiple times with count", () => {
+    const pos = searchBackward(rep, 2, 5, "hello", 2);
+    assert.deepEqual(pos, [1, 4]);
+  });
+});
+
+describe("searchForward and searchBackward with count", () => {
+  const rep = makeRep(["aa", "aa", "aa", "aa"]);
+
+  it("searchForward finds nth occurrence", () => {
+    const pos = searchForward(rep, 0, 0, "aa", 3);
+    assert.deepEqual(pos, [2, 0]);
+  });
+
+  it("searchBackward finds nth occurrence backward", () => {
+    const pos = searchBackward(rep, 3, 2, "aa", 2);
+    assert.deepEqual(pos, [2, 0]);
+  });
+});