Import tests and implement many features

Author: cramforce

src/commands/grep/grep.advanced.test.ts

@@ -150,7 +150,8 @@ describe("grep advanced", () => {
         },
       });
       const result = await env.exec("grep -A1 match /test.txt");
-      expect(result.stdout).toBe("match1\nb\nmatch2\nd\n");
+      // Separator between non-contiguous groups (GNU grep behavior)
+      expect(result.stdout).toBe("match1\nb\n--\nmatch2\nd\n");
       expect(result.exitCode).toBe(0);
     });
 

src/commands/rg/gitignore.ts

@@ -204,7 +204,7 @@ export class GitignoreParser {
 /**
  * Hierarchical gitignore manager
  *
- * Loads .gitignore files from the root down to the current directory,
+ * Loads .gitignore and .ignore files from the root down to the current directory,
  * applying patterns in order (child patterns override parent patterns).
  */
 export class GitignoreManager {
@@ -218,7 +218,7 @@ export class GitignoreManager {
   }
 
   /**
-   * Load all .gitignore files from root to the specified path
+   * Load all .gitignore and .ignore files from root to the specified path
    */
   async load(targetPath: string): Promise<void> {
     // Build list of directories from root to target
@@ -232,16 +232,19 @@ export class GitignoreManager {
       current = parent;
     }
 
-    // Load .gitignore from each directory
+    // Load .gitignore and .ignore from each directory
+    // ripgrep loads them in order: .gitignore, then .ignore (ignore can override)
     for (const dir of dirs) {
-      const gitignorePath = this.fs.resolvePath(dir, ".gitignore");
-      try {
-        const content = await this.fs.readFile(gitignorePath);
-        const parser = new GitignoreParser(dir);
-        parser.parse(content);
-        this.parsers.push(parser);
-      } catch {
-        // No .gitignore in this directory
+      for (const filename of [".gitignore", ".ignore"]) {
+        const ignorePath = this.fs.resolvePath(dir, filename);
+        try {
+          const content = await this.fs.readFile(ignorePath);
+          const parser = new GitignoreParser(dir);
+          parser.parse(content);
+          this.parsers.push(parser);
+        } catch {
+          // No ignore file in this directory
+        }
       }
     }
   }

src/commands/rg/imported-tests/README.md

@@ -0,0 +1,33 @@
+# Imported ripgrep Tests
+
+These tests are transliterated from [ripgrep](https://github.com/BurntSushi/ripgrep), the original Rust-based search tool.
+
+## Source
+
+Tests were imported from the ripgrep test suite:
+- https://github.com/BurntSushi/ripgrep/tree/master/tests
+
+## Files
+
+| File | Source | Description |
+|------|--------|-------------|
+| `binary.test.ts` | `tests/binary.rs` | Binary file detection and handling |
+| `feature.test.ts` | `tests/feature.rs` | Feature tests from GitHub issues |
+| `misc.test.ts` | `tests/misc.rs` | Miscellaneous behavior tests |
+| `regression.test.ts` | `tests/regression.rs` | Regression tests from bug reports |
+
+## Skipped Test Files
+
+- `json.rs` - JSON output format not implemented
+- `multiline.rs` - Multiline matching not implemented
+
+## Skipped Individual Tests
+
+Some tests are skipped due to implementation differences:
+- `.ignore` file support (we only support `.gitignore`)
+- Complex `-A/-B/-C` flag precedence rules
+- Word boundary behavior with non-word characters
+
+## License
+
+ripgrep is licensed under the MIT license. See the [ripgrep repository](https://github.com/BurntSushi/ripgrep) for details.

src/commands/rg/imported-tests/binary.test.ts

@@ -0,0 +1,287 @@
+/**
+ * Tests imported from ripgrep: tests/binary.rs
+ *
+ * These tests cover binary file detection and handling.
+ * ripgrep skips binary files by default (files containing NUL bytes).
+ *
+ * Note: Many ripgrep binary tests involve --mmap, --binary, and --text flags
+ * which we don't fully support. This file contains applicable tests.
+ */
+import { describe, expect, it } from "vitest";
+import { Bash } from "../../../Bash.js";
+
+// Simple binary content with NUL byte
+const BINARY_CONTENT = "hello\x00world\n";
+const TEXT_CONTENT = "hello world\n";
+
+describe("rg binary: basic detection", () => {
+  it("should skip binary files by default in directory search", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/text.txt": TEXT_CONTENT,
+        "/home/user/binary.bin": BINARY_CONTENT,
+      },
+    });
+    const result = await bash.exec("rg hello");
+    expect(result.exitCode).toBe(0);
+    // Should only find match in text file, not binary
+    expect(result.stdout).toBe("text.txt:1:hello world\n");
+    expect(result.stdout).not.toContain("binary.bin");
+  });
+
+  it("should skip binary files when searching single explicit file", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/binary.bin": BINARY_CONTENT,
+      },
+    });
+    const result = await bash.exec("rg hello binary.bin");
+    expect(result.exitCode).toBe(1);
+    expect(result.stdout).toBe("");
+  });
+
+  it("should detect binary in first 8KB of file", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        // NUL byte early in file
+        "/home/user/early.bin": `\x00${"a".repeat(100)}pattern\n`,
+      },
+    });
+    const result = await bash.exec("rg pattern");
+    expect(result.exitCode).toBe(1);
+  });
+
+  it("should not detect binary if NUL after 8KB sample", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        // NUL byte after 8KB - won't be detected in sample
+        "/home/user/late.txt": `pattern\n${"a".repeat(9000)}\x00end\n`,
+      },
+    });
+    const result = await bash.exec("rg pattern");
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("pattern");
+  });
+});
+
+describe("rg binary: with count flag", () => {
+  it("should not count matches in binary files", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/text.txt": "match\nmatch\n",
+        "/home/user/binary.bin": "match\x00match\n",
+      },
+    });
+    const result = await bash.exec("rg -c match");
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe("text.txt:2\n");
+  });
+});
+
+describe("rg binary: with files-with-matches flag", () => {
+  it("should not list binary files with -l", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/text.txt": "findme\n",
+        "/home/user/binary.bin": "findme\x00\n",
+      },
+    });
+    const result = await bash.exec("rg -l findme");
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe("text.txt\n");
+  });
+});
+
+describe("rg binary: mixed content", () => {
+  it("should only search text files in mixed directory", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/readme.md": "documentation\n",
+        "/home/user/image.png": "\x89PNG\r\n\x1a\n\x00\x00\x00",
+        "/home/user/script.sh": "echo documentation\n",
+      },
+    });
+    const result = await bash.exec("rg documentation");
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("readme.md");
+    expect(result.stdout).toContain("script.sh");
+    expect(result.stdout).not.toContain("image.png");
+  });
+
+  it("should handle multiple binary and text files", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/a.txt": "test\n",
+        "/home/user/b.bin": "test\x00\n",
+        "/home/user/c.txt": "test\n",
+        "/home/user/d.bin": "test\x00\n",
+      },
+    });
+    const result = await bash.exec("rg test");
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe("a.txt:1:test\nc.txt:1:test\n");
+  });
+});
+
+describe("rg binary: edge cases", () => {
+  it("should handle file with only NUL bytes", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/nulls.bin": "\x00\x00\x00\x00",
+      },
+    });
+    const result = await bash.exec("rg anything");
+    expect(result.exitCode).toBe(1);
+  });
+
+  it("should handle NUL at start of file", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/start.bin": "\x00hello world\n",
+      },
+    });
+    const result = await bash.exec("rg hello");
+    expect(result.exitCode).toBe(1);
+  });
+
+  it("should handle NUL at end of file", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/end.bin": "hello world\n\x00",
+      },
+    });
+    const result = await bash.exec("rg hello");
+    expect(result.exitCode).toBe(1);
+  });
+
+  it("should handle multiple NUL bytes", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/multi.bin": "a\x00b\x00c\x00d\n",
+      },
+    });
+    const result = await bash.exec("rg '[a-d]'");
+    expect(result.exitCode).toBe(1);
+  });
+});
+
+describe("rg binary: common binary file types", () => {
+  it("should skip files with common binary signatures", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        // PNG signature
+        "/home/user/image.png": "\x89PNG\r\n\x1a\n\x00data",
+        // PDF signature (simplified)
+        "/home/user/doc.pdf": "%PDF-1.4\n\x00binary",
+        // ZIP signature
+        "/home/user/archive.zip": "PK\x03\x04\x00\x00data",
+        // Text file for comparison
+        "/home/user/text.txt": "data\n",
+      },
+    });
+    const result = await bash.exec("rg data");
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe("text.txt:1:data\n");
+  });
+});
+
+describe("rg binary: with other flags", () => {
+  it("should work with -i flag", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/text.txt": "HELLO world\n",
+        "/home/user/binary.bin": "HELLO\x00world\n",
+      },
+    });
+    const result = await bash.exec("rg -i hello");
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe("text.txt:1:HELLO world\n");
+  });
+
+  it("should work with -v flag", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/text.txt": "keep\nremove\nkeep\n",
+        "/home/user/binary.bin": "keep\x00remove\n",
+      },
+    });
+    const result = await bash.exec("rg -v remove");
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe("text.txt:1:keep\ntext.txt:3:keep\n");
+  });
+
+  it("should work with -w flag", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/text.txt": "foo bar\nfoobar\n",
+        "/home/user/binary.bin": "foo bar\x00\n",
+      },
+    });
+    const result = await bash.exec("rg -w foo");
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe("text.txt:1:foo bar\n");
+  });
+
+  it("should work with context flags", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/text.txt": "before\nmatch\nafter\n",
+        "/home/user/binary.bin": "before\x00match\nafter\n",
+      },
+    });
+    const result = await bash.exec("rg -C1 match");
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("before");
+    expect(result.stdout).toContain("match");
+    expect(result.stdout).toContain("after");
+    expect(result.stdout).not.toContain("binary.bin");
+  });
+
+  it("should work with -m flag", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/text.txt": "match\nmatch\nmatch\n",
+        "/home/user/binary.bin": "match\x00match\n",
+      },
+    });
+    const result = await bash.exec("rg -m1 match");
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe("text.txt:1:match\n");
+  });
+});
+
+describe("rg binary: subdirectories", () => {
+  it("should skip binary files in subdirectories", async () => {
+    const bash = new Bash({
+      cwd: "/home/user",
+      files: {
+        "/home/user/src/code.ts": "export const x = 1;\n",
+        "/home/user/assets/image.bin": "export\x00data\n",
+        "/home/user/lib/util.ts": "export function foo() {}\n",
+      },
+    });
+    const result = await bash.exec("rg export");
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("src/code.ts");
+    expect(result.stdout).toContain("lib/util.ts");
+    expect(result.stdout).not.toContain("assets/image.bin");
+  });
+});