Grep

// Grep: print the lines of some files that match a regular expression, the way the Unix tool of
// the same name does.
//
//     grep [options] <pattern> [paths...]
//
// `-i` ignores case, `-n` puts the line number in front of each line, `-c` prints only how many
// lines matched, `-v` turns the search around to select the lines that do not match, and `--help`
// prints the help. The exit status follows the real tool: 0 when a line was selected, 1 when none
// was, and 2 when something went wrong — a bad pattern, a file that cannot be read.
//
// Three packages do the work. `CommandLine` reads the options, `Regex` decides which lines match,
// and `FileSystem` opens each file, which a `BufferedReader` then reads line by line.
//
// Given no arguments at all, as `rux run` gives it, the program searches its own source with a
// few fixed command lines instead, so that a first run shows everything it can do.
import Allocator::{ Allocator, SystemAllocator };
import CommandLine::{
    Command, Flag, OptionSpec, Parse, Parsed, ParseProcess, PositionalSpec, Remaining, Required,
    WriteUsage
};
import FileSystem::{ File, OpenOptions };
import Io::{ BufferedReader, ConsoleWriter, IoError, Print, PrintLine, ReadTextLine };
import Path::{ OsString, OsStringView, Path };
import Process::ArgumentCount;
import Regex::{ Regex, RegexError };
import Text::{ Concat, FormatError, String, StringBuilder, StringView, TextError, TextWriter };

// How the selected lines of a file are shown.
struct Show {
    numbers: bool;
    countOnly: bool;
    invert: bool;
    // Whether to put the file's name in front, which only helps when there are several files.
    names: bool;
}

// Searches one file and returns how many of its lines were selected.
func SearchFile(allocator: Allocator, regex: &Regex, path: OsStringView, show: Show)
    -> uint ! (IoError | RegexError) {
    var file = File::Open(allocator, Path::FromView(path), OpenOptions::Reading())?;
    var reader = BufferedReader::New(allocator, file.Stream(), 0)?;
    var line = StringBuilder(allocator);
    var number: uint = 0;
    var selected: uint = 0;
    loop {
        // The end of the file is the one failure that is expected: it ends the loop.
        ReadTextLine(reader, line, 65536) catch {
            error if error.IsEnd() => break,
            error => fail error
        };
        number += 1;
        if regex.IsMatch(line.View().Bytes())? != show.invert {
            selected += 1;
            if !show.countOnly {
                if show.names { Print("{}:", path); }
                if show.numbers { Print("{}:", number); }
                PrintLine("{}", line.View());
            }
        }
        line.Clear();
    }
    if show.countOnly {
        if show.names { Print("{}:", path); }
        PrintLine("{}", selected);
    }
    return selected;
}

// The pattern as typed, with `(?i)` in front when case is to be ignored.
func Pattern(allocator: Allocator, parsed: &Parsed) -> String ! TextError {
    let typed = (parsed.Positional("pattern") ?? OsStringView()).ToText(allocator)?;
    if !parsed.Has("ignore-case") { return <-typed; }
    return Concat(allocator, StringView::FromValidated("(?i)"), typed.View());
}

// Does what a parsed command line asks, and returns the exit status.
func Run(allocator: Allocator, parsed: &Parsed, screen: &var TextWriter) -> int ! FormatError {
    if parsed.HelpRequested() {
        parsed.WriteHelp(screen)?;
        return 0;
    }
    let pattern = Pattern(allocator, parsed) catch {
        else => {
            PrintLine("grep: the pattern is not valid text");
            return 2;
        }
    };
    // A compiled `Regex` owns memory, so it is moved out of the match, not copied. Without the
    // arrow, `.Success(compiled) => compiled` is refused:
    //
    //     error: move-only value 'compiled' requires an explicit '<-' in conditional-arm
    let regex = match Regex::New(allocator, pattern.Bytes()) {
        .Success(compiled) => <-compiled,
        .Failure(error) => {
            PrintLine("grep: bad pattern '{}' at byte {}", pattern, error.offset);
            return 2;
        }
    };
    var files: uint = 0;
    for _ in parsed.Positionals("paths") {
        files += 1;
    }
    if files == 0 {
        PrintLine("grep: name at least one file to search");
        return 2;
    }
    let show = Show {
        numbers: parsed.Has("line-number"), countOnly: parsed.Has("count"),
        invert: parsed.Has("invert-match"), names: files > 1
    };
    // A file that cannot be read is reported and skipped; the others are still searched.
    var status = 1;
    for path in parsed.Positionals("paths") {
        match SearchFile(allocator, regex, path, show) {
            .Success(selected) => {
                if selected > 0 && status == 1 { status = 0; }
            },
            .Failure(_) => {
                PrintLine("grep: {}: cannot be read", path);
                status = 2;
            }
        }
    }
    return status;
}

// Splits native text at its spaces into `words`, as the CommandLine lesson did.
func Split(text: OsStringView, words: var OsStringView[..]) -> uint {
    let units = text.Units();
    var count: uint = 0;
    var start: uint = 0;
    for at in 0..=units.length {
        if at == units.length || units[at] as uint32 == 0x20 {
            if at > start && count < words.length {
                words[count] = OsStringView::FromUnits(units[start..at]);
                count += 1;
            }
            start = at + 1;
        }
    }
    return count;
}

func Main() -> int {
    var system = SystemAllocator();
    let allocator: Allocator = system;
    var failure: IoError? = none;
    var console = ConsoleWriter(@failure);
    let screen: &var TextWriter = console;

    let options: OptionSpec[4] = [
        Flag("ignore-case", 'i', "Ignore the difference between upper and lower case"),
        Flag("line-number", 'n', "Put each line's number in front of it"),
        Flag("count", 'c', "Print only how many lines were selected"),
        Flag("invert-match", 'v', "Select the lines that do not match")
    ];
    let positionals: PositionalSpec[2] = [
        Required("pattern", "The regular expression to look for"),
        Remaining("paths", "The files to search")
    ];
    let grep = Command("grep", "Print the lines of files that match a pattern")
        .WithOptions(options[..]).WithPositionals(positionals[..]);

    // Real arguments: one search, and its status is the program's.
    if ArgumentCount() > 1 {
        let parsed = ParseProcess(@grep) catch {
            error => {
                PrintLine("grep: {}", error);
                WriteUsage(grep, screen) catch { else => {} };
                return 2;
            }
        };
        return Run(allocator, parsed, screen) catch { else => 2 };
    }

    // No arguments: a tour of fixed command lines over this package's own files.
    let tour: char8[..][7] = [
        "-n ^func Src/Main.rux",
        "-c -i regex Src/Main.rux Rux.toml",
        "-v -c ^\\s*// Src/Main.rux",
        "-n (unclosed Src/Main.rux",
        "-x fn Src/Main.rux",
        "nothing Src/Missing.rux",
        "--help"
    ];
    for line in tour {
        PrintLine("$ grep {}", line);
        var holder = OsString::FromText(allocator, line) catch { else => return 2 };
        var words: OsStringView[8] = [OsStringView(); 8];
        let count = Split(holder.View(), words[..]);
        match Parse(@grep, words[..count]) {
            .Success(parsed) => {
                let status = Run(allocator, parsed, screen) catch { else => 2 };
                PrintLine("(exit status {})", status);
            },
            .Failure(error) => PrintLine("grep: {}", error)
        }
    }
    return 0;
}