shfs 0.3.0 → 0.3.1

package/dist/{execute-khztC2iY.mjs → execute-1PmTy1KA.mjs}

@@ -791,8 +791,12 @@ function compileFind(command) {
 function parseFindArgs(argv) {
 	const state = {
 		action: { ...DEFAULT_ACTION },
+		currentBranch: [],
+		currentSideAllowsEmptyBranch: false,
 		diagnostics: [],
-		predicates: [],
+		lastOrTokenIndex: null,
+		predicateBranches: [],
+		sawOr: false,
 		traversal: { ...DEFAULT_TRAVERSAL }
 	};
 	const predicateStartIndex = findPredicateStartIndex(argv);
@@ -807,7 +811,7 @@ function parseFindArgs(argv) {
 	return {
 		action: state.action,
 		diagnostics: state.diagnostics,
-		predicates: state.predicates,
+		predicateBranches: finalizePredicateBranches(state),
 		startPaths,
 		traversal: state.traversal,
 		usageError: state.diagnostics.length > 0
@@ -822,6 +826,9 @@ function createDiagnostic$1(code, token, tokenIndex, message) {
 function createMissingValueDiagnostic(token, tokenIndex) {
 	return createDiagnostic$1("missing-value", token, tokenIndex, `find: missing argument to ${token}`);
 }
+function createMissingExpressionDiagnostic(side, tokenIndex) {
+	return createDiagnostic$1("invalid-expression", "-o", tokenIndex, `find: -o is missing a ${side} predicate expression`);
+}
 function findPredicateStartIndex(argv) {
 	for (const [index, word] of argv.entries()) if (expandedWordToString(word).startsWith("-")) return index;
 	return argv.length;
@@ -829,13 +836,16 @@ function findPredicateStartIndex(argv) {
 function parseFindToken(argv, index, token, state) {
 	if (token === "-name" || token === "-path") return parseStringPredicate(argv, index, token, state);
 	if (token === "-type") return parseTypePredicate(argv, index, state);
+	if (token === "-o" || token === "-or") return parseOrPredicateSeparator(index, state);
 	if (token === "-maxdepth" || token === "-mindepth") return parseTraversalOption(argv, index, token, state);
 	if (token === "-depth") {
 		state.traversal.depth = true;
+		state.currentSideAllowsEmptyBranch = true;
 		return index + 1;
 	}
 	if (token === "-print") {
 		state.action.explicit = true;
+		state.currentSideAllowsEmptyBranch = true;
 		return index + 1;
 	}
 	if (token.startsWith("-")) {
@@ -845,13 +855,25 @@ function parseFindToken(argv, index, token, state) {
 	state.diagnostics.push(createDiagnostic$1("unexpected-operand", token, index, `find: unexpected argument: ${token}`));
 	return index + 1;
 }
+function parseOrPredicateSeparator(index, state) {
+	state.sawOr = true;
+	state.lastOrTokenIndex = index;
+	if (state.currentBranch.length === 0 && !state.currentSideAllowsEmptyBranch) {
+		state.diagnostics.push(createMissingExpressionDiagnostic("left", index));
+		return index + 1;
+	}
+	state.predicateBranches.push(state.currentBranch);
+	state.currentBranch = [];
+	state.currentSideAllowsEmptyBranch = false;
+	return index + 1;
+}
 function parseStringPredicate(argv, index, token, state) {
 	const valueWord = argv[index + 1];
 	if (!valueWord) {
 		state.diagnostics.push(createMissingValueDiagnostic(token, index));
 		return index + 1;
 	}
-	state.predicates.push({
+	state.currentBranch.push({
 		kind: token === "-name" ? "name" : "path",
 		pattern: valueWord
 	});
@@ -865,12 +887,23 @@ function parseTypePredicate(argv, index, state) {
 	}
 	const parsedType = parseFindTypeValue(valueWord, index + 1);
 	if ("diagnostic" in parsedType) state.diagnostics.push(parsedType.diagnostic);
-	else state.predicates.push({
+	else state.currentBranch.push({
 		kind: "type",
 		types: parsedType.types
 	});
 	return index + 2;
 }
+function finalizePredicateBranches(state) {
+	if (state.currentBranch.length > 0) state.predicateBranches.push(state.currentBranch);
+	else if (state.sawOr && state.lastOrTokenIndex !== null) {
+		if (state.currentSideAllowsEmptyBranch) {
+			state.predicateBranches.push(state.currentBranch);
+			return state.predicateBranches;
+		}
+		state.diagnostics.push(createMissingExpressionDiagnostic("right", state.lastOrTokenIndex));
+	}
+	return state.predicateBranches;
+}
 function parseTraversalOption(argv, index, token, state) {
 	const valueWord = argv[index + 1];
 	if (!valueWord) {
@@ -884,6 +917,7 @@ function parseTraversalOption(argv, index, token, state) {
 	}
 	if (token === "-maxdepth") state.traversal.maxdepth = parsedNumericValue.value;
 	else state.traversal.mindepth = parsedNumericValue.value;
+	state.currentSideAllowsEmptyBranch = true;
 	return index + 2;
 }
 function parseFindTypeValue(word, tokenIndex) {
@@ -948,7 +982,9 @@ const parseGrepWords = createWordParser({
 		long: "before-context",
 		short: "B"
 	}),
+	binaryFiles: grepValueFlag({ long: "binary-files" }),
 	binaryFile: grepValueFlag({ long: "binary-file" }),
+	binaryWithoutMatch: grepBooleanFlag({ short: "I" }),
 	byteOffset: grepBooleanFlag({
 		long: "byte-offset",
 		short: "b"
@@ -1085,7 +1121,7 @@ function parseGrepArgs(argv) {
 	applyModeOption(parsed, options);
 	applyFilenameMode(parsed, options);
 	applyFileListingMode(parsed, options);
-	applyBinaryFileOption(parsed, argv, options);
+	applyBinaryFileOption(parsed, argv, options, diagnostics);
 	applyDirectoriesOption(parsed, argv, options);
 	applyMaxCountOption(parsed, argv, options, diagnostics);
 	applyContextOptions(parsed, argv, options, diagnostics);
@@ -1194,8 +1230,58 @@ function applyFileListingMode(parsed, options) {
 		options.listFilesWithMatches = false;
 	}
 }
-function applyBinaryFileOption(parsed, argv, options) {
-	for (const occurrence of getValueOccurrences(parsed, argv, "binaryFile")) options.binaryWithoutMatch = occurrence.value === "without-match";
+function applyBinaryFileOption(parsed, argv, options, diagnostics) {
+	const modeOccurrences = [];
+	for (const occurrence of getValueOccurrences(parsed, argv, "binaryFile")) {
+		const mode = parseBinaryMode(occurrence.value);
+		if (mode === null) {
+			diagnostics.push(makeDiagnostic("invalid-value", occurrence.token, occurrence.tokenIndex, `Invalid value for option ${splitLongOption(occurrence.token)}.`));
+			continue;
+		}
+		modeOccurrences.push({
+			mode,
+			order: occurrence.order
+		});
+	}
+	for (const occurrence of getValueOccurrences(parsed, argv, "binaryFiles")) {
+		const mode = parseBinaryMode(occurrence.value);
+		if (mode === null) {
+			diagnostics.push(makeDiagnostic("invalid-value", occurrence.token, occurrence.tokenIndex, `Invalid value for option ${splitLongOption(occurrence.token)}.`));
+			continue;
+		}
+		modeOccurrences.push({
+			mode,
+			order: occurrence.order
+		});
+	}
+	for (const order of parsed.flagOccurrenceOrder.binaryWithoutMatch ?? []) modeOccurrences.push({
+		mode: "without-match",
+		order
+	});
+	for (const order of parsed.flagOccurrenceOrder.textMode ?? []) modeOccurrences.push({
+		mode: "text",
+		order
+	});
+	modeOccurrences.sort((a, b) => a.order - b.order);
+	for (const occurrence of modeOccurrences) switch (occurrence.mode) {
+		case "binary":
+			options.binaryWithoutMatch = false;
+			options.textMode = false;
+			break;
+		case "text":
+			options.binaryWithoutMatch = false;
+			options.textMode = true;
+			break;
+		case "without-match":
+			options.binaryWithoutMatch = true;
+			options.textMode = false;
+			break;
+		default: break;
+	}
+}
+function parseBinaryMode(value) {
+	if (value === "binary" || value === "text" || value === "without-match") return value;
+	return null;
 }
 function applyDirectoriesOption(parsed, argv, options) {
 	for (const occurrence of getValueOccurrences(parsed, argv, "directories")) options.directories = occurrence.value === "skip" ? "skip" : "read";
@@ -4179,9 +4265,9 @@ async function* find(fs, context, args) {
 		writeDiagnosticsToStderr(context, args.diagnostics);
 		return;
 	}
-	let resolvedPredicates;
+	let resolvedPredicateBranches;
 	try {
-		resolvedPredicates = await resolvePredicates(args.predicates, fs, context);
+		resolvedPredicateBranches = await resolvePredicates(args.predicateBranches, fs, context);
 	} catch (error) {
 		context.status = diagnosticExitCode(error);
 		writeErrorToStderr(context, error);
@@ -4209,12 +4295,12 @@ async function* find(fs, context, args) {
 			...startPath,
 			depth: 0,
 			isDirectory: startStat.isDirectory
-		}, args, resolvedPredicates, state);
+		}, args, resolvedPredicateBranches, state);
 	}
 	context.status = state.hadError ? 1 : 0;
 }
-async function* walkEntry(fs, context, entry, args, predicates, state) {
-	const matches = entry.depth >= args.traversal.mindepth && matchesPredicates(entry, predicates);
+async function* walkEntry(fs, context, entry, args, predicateBranches, state) {
+	const matches = entry.depth >= args.traversal.mindepth && matchesPredicates(entry, predicateBranches);
 	if (!args.traversal.depth && matches) yield toFileRecord(entry);
 	if (entry.isDirectory && (args.traversal.maxdepth === null || entry.depth < args.traversal.maxdepth)) {
 		let childPaths;
@@ -4239,46 +4325,50 @@ async function* walkEntry(fs, context, entry, args, predicates, state) {
 				displayPath: appendDisplayPath(entry.displayPath, basename$2(childAbsolutePath)),
 				depth: entry.depth + 1,
 				isDirectory: childStat.isDirectory
-			}, args, predicates, state);
+			}, args, predicateBranches, state);
 		}
 	}
 	if (args.traversal.depth && matches) yield toFileRecord(entry);
 }
-async function resolvePredicates(predicates, fs, context) {
+async function resolvePredicates(predicateBranches, fs, context) {
 	const resolved = [];
-	for (const predicate of predicates) switch (predicate.kind) {
-		case "name": {
-			const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
-			resolved.push({
-				kind: "name",
-				matcher: picomatch(pattern, {
-					bash: true,
-					dot: true
-				})
-			});
-			break;
-		}
-		case "path": {
-			const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
-			resolved.push({
-				kind: "path",
-				matcher: picomatch(pattern, {
-					bash: true,
-					dot: true
-				})
-			});
-			break;
-		}
-		case "type":
-			resolved.push({
-				kind: "type",
-				types: new Set(predicate.types)
-			});
-			break;
-		default: {
-			const _exhaustive = predicate;
-			throw new Error(`Unsupported find predicate: ${JSON.stringify(_exhaustive)}`);
+	for (const branch of predicateBranches) {
+		const resolvedBranch = [];
+		for (const predicate of branch) switch (predicate.kind) {
+			case "name": {
+				const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
+				resolvedBranch.push({
+					kind: "name",
+					matcher: picomatch(pattern, {
+						bash: true,
+						dot: true
+					})
+				});
+				break;
+			}
+			case "path": {
+				const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
+				resolvedBranch.push({
+					kind: "path",
+					matcher: picomatch(pattern, {
+						bash: true,
+						dot: true
+					})
+				});
+				break;
+			}
+			case "type":
+				resolvedBranch.push({
+					kind: "type",
+					types: new Set(predicate.types)
+				});
+				break;
+			default: {
+				const _exhaustive = predicate;
+				throw new Error(`Unsupported find predicate: ${JSON.stringify(_exhaustive)}`);
+			}
 		}
+		resolved.push(resolvedBranch);
 	}
 	return resolved;
 }
@@ -4296,21 +4386,21 @@ async function resolveStartPaths(fs, context, startPathWords) {
 	}
 	return startPaths;
 }
-function matchesPredicates(entry, predicates) {
-	for (const predicate of predicates) {
-		if (predicate.kind === "name") {
-			if (!predicate.matcher(basename$2(entry.displayPath))) return false;
-			continue;
-		}
-		if (predicate.kind === "path") {
-			if (!predicate.matcher(entry.displayPath)) return false;
-			continue;
-		}
-		const entryType = entry.isDirectory ? "d" : "f";
-		if (!predicate.types.has(entryType)) return false;
-	}
+function matchesPredicates(entry, predicateBranches) {
+	if (predicateBranches.length === 0) return true;
+	const entryType = entry.isDirectory ? "d" : "f";
+	for (const branch of predicateBranches) if (matchesBranch(entry, entryType, branch)) return true;
+	return false;
+}
+function matchesBranch(entry, entryType, branch) {
+	for (const predicate of branch) if (!matchesPredicate(entry, entryType, predicate)) return false;
 	return true;
 }
+function matchesPredicate(entry, entryType, predicate) {
+	if (predicate.kind === "name") return predicate.matcher(basename$2(entry.displayPath));
+	if (predicate.kind === "path") return predicate.matcher(entry.displayPath);
+	return predicate.types.has(entryType);
+}
 async function readChildren(fs, path) {
 	const children = [];
 	for await (const childPath of fs.readdir(path)) children.push(childPath);
@@ -4486,23 +4576,21 @@ async function runGrepCommandInner(options) {
 			lines: [],
 			selectedLineCount: 0
 		};
-		if (target.stdin) result = searchBuffer(stdinBytes ?? new Uint8Array(), target.displayPath, matcherBuild.patterns, parsed.options, displayFilename);
+		let binaryInput = false;
+		let targetBytes = null;
+		if (target.stdin) targetBytes = stdinBytes ?? new Uint8Array();
 		else {
 			if (target.absolutePath === null) continue;
-			let bytes;
 			try {
-				bytes = await options.fs.readFile(target.absolutePath);
+				targetBytes = await options.fs.readFile(target.absolutePath);
 			} catch {
 				hadError = true;
 				continue;
 			}
-			if (parsed.options.binaryWithoutMatch && !parsed.options.textMode && isBinaryBuffer(bytes)) result = {
-				hasSelectedLine: false,
-				lines: [],
-				selectedLineCount: 0
-			};
-			else result = searchBuffer(bytes, target.displayPath, matcherBuild.patterns, parsed.options, displayFilename);
 		}
+		if (targetBytes === null) continue;
+		binaryInput = shouldTreatAsBinaryInput(targetBytes, parsed.options);
+		if (!(binaryInput && parsed.options.binaryWithoutMatch)) result = searchBuffer(targetBytes, target.displayPath, matcherBuild.patterns, parsed.options, displayFilename);
 		if (parsed.options.listFilesWithMatches) {
 			if (result.hasSelectedLine) {
 				lines.push(target.displayPath);
@@ -4528,7 +4616,8 @@ async function runGrepCommandInner(options) {
 			continue;
 		}
 		if (result.hasSelectedLine) anySelected = true;
-		if (!parsed.options.quiet) lines.push(...result.lines);
+		if (!parsed.options.quiet) if (shouldPrintBinaryMatchMessage(binaryInput, result.hasSelectedLine, parsed.options)) lines.push(`Binary file ${target.displayPath} matches`);
+		else lines.push(...result.lines);
 		if (parsed.options.quiet && anySelected) break;
 	}
 	const corpusOverride = await maybeOverrideWithCorpusStatus(parsed.options.mode, normalized.patterns, searchTargets.targets, options.fs);
@@ -5287,6 +5376,15 @@ function isValidUtf8(bytes) {
 function isBinaryBuffer(bytes) {
 	return bytes.includes(0);
 }
+function shouldTreatAsBinaryInput(bytes, options) {
+	if (options.textMode || options.nullData) return false;
+	return isBinaryBuffer(bytes);
+}
+function shouldPrintBinaryMatchMessage(binaryInput, hasSelectedLine, options) {
+	if (!(binaryInput && hasSelectedLine)) return false;
+	if (options.binaryWithoutMatch || options.countOnly || options.listFilesWithMatches || options.listFilesWithoutMatch) return false;
+	return true;
+}
 function byteLengthOfPrefix(text, charIndex) {
 	return UTF8_ENCODER.encode(text.slice(0, charIndex)).byteLength;
 }
@@ -5857,4 +5955,4 @@ function normalizeContext(context) {
 //#endregion
 export { formatStderr as a, compile as c, writeDiagnosticsToStderr as i, parse as l, execute_exports as n, formatStdoutRecord as o, isShellDiagnosticError as r, ParseSyntaxError as s, execute as t };
 
-//# sourceMappingURL=execute-khztC2iY.mjs.map
+//# sourceMappingURL=execute-1PmTy1KA.mjs.map