filter

#!/usr/bin/env raku
# filter - Filter a list of filenames, outputting only those whose extension denotes a specified "type".

# Usage:
#
# filter [--print=FORMAT] [--invert] <type>
#
# TYPE can be abbreviated when unambiguous. Use --print=types to get a list of supported types.
#
# If --print is provided, just print the list of extensions that would be used rather than filtering.
# --print's output format can be one of: find, space, newline (the default), or types (newline-separated list of supported types).
# --print=find will print the extensions as arguments for the "find" command.

# Examples:

# List all the video files in ~/media:
# find ~/media | filter v

# List every image and video file in your home directory:
# find ~/ | filter visual

# List files whose file extensions are not recognized by filter:
# find ~/ | filter --invert supported

# Code:

our %types := { # initial definition should have fundamental types only, not compound types like "visual" or "media".
    text => qw/ txt text log md org /,
    config => qw/ csv xml json ini yaml yml conf cnf service /,
    script => qw/ sh bash fish py tcl perl raku rb /, # "scripting languages"
    source => qw/ lisp cl factor c cpp h rs zig /, # compiled languages
    document => qw/ pdf epub doc docx odt rtf /,
    image => qw/ bmp gif jpeg jpg png webp /,
    audio => qw/ aac aif aiff flac m4a mp3 ogg opus wav wma /,
    video => qw/ avi flv m2t m4v mkv mov mp4 ogv webm wmv /,
    archive => qw/ 7z bz2 gz rar tar tgz zip /,
    directory => ("/", ),
};
%types{"visual"} = (|%types{"image"}, |%types{"video"});
%types{"media"} = (|%types{"image"}, |%types{"audio"}, |%types{"video"});
%types{"code"} = (|%types{"script"}, |%types{"source"});
%types{"supported"} = %types.values.reduce({ $^a.Array.append($^b.Array); }).List;

sub types() {
    #= Get a list of supported types.
    return (|%types.keys, |("all", ));
}

sub normalize-type($_) {
    #= Get the "canonical" un-abbreviated name of the type.
    return "text" if /^ t(e?xt(ual)?)? $/;
    return "config" if /^ co?nf(ig)? $/;
    return "script" if /^ scr(ipt)? $/;
    return "source" if /^ s(ou)?rce? $/;
    return "document" if /^ do(c(u(ment)?)?)? $/;
    return "image" if /^ ( i(ma?ge?s?)? | p(ic(tures?)?)? ) $/;
    return "audio" if /^ ( a(udio)? | mu(sic)? | s(ound)? ) $/;
    return "video" if /^ v(ideos?)? $/;
    return "archive" if /^ ( c(omp(ress(ed)?)?)? | ar(ch(ive)?)? ) $/;
    return "visual" if /^ vis(ual)? $/;
    return "media" if /^ me(dia)? $/;
    return "code" if /^ code $/;
    return "supported" if /^ su(p(port(ed)?)?)? $/;
    return "directory" if /^ d(ir(ectory)?)? $/;
    return "all" if /^ ( a(ll|ny) | '*' ) $/;
    fail "Unknown type \"$_\". Try instead one of: " ~ types().sort.join(", ") ~ ".";
}

sub type-extensions($type is copy) {
    #= Get a list of file extensions for TYPE.
    if ($type ~~ /^\./) {
        return $type.split(",").map(*.subst(/^\./, "")).List;
    }
    return %types{normalize-type($type)};
}

sub extension-of($filename) {
    #= Get the lowercased file extension of FILENAME. If it's a directory, "/" is returned.
    return "/" if ($filename.IO.d);
    return $filename.IO.extension.lc;
}

sub is-type($filename, $type) {
    #= True when FILENAME is of the specified type.
    if ($type eq 'all') {
        return True;
    }
    return extension-of($filename) ~~ any(|type-extensions($type));
}

sub GENERATE-USAGE(&main, |capture) is export {
    &*GENERATE-USAGE(&main, |capture).subst('{types}', "all, " ~ types().sort.join(", "), :g);
}

sub MAIN(
    $type? is copy, #= The type to filter to. A file extension (including period) can be specified, or a media type (or an abbreviation of one). Supported media types are: {types}.
    Bool :$invert=False, #= "Invert" the output; only print non-matches.
                  :$print is copy, #= Print the extensions for TYPE rather than filtering. A value can be provided to change the format. Supported formats are: newline, space, find.
) {
    if ($print.defined) {
        $type //= "supported";
        my $extensions = type-extensions($type);

        if ($type eq 'all') {
            fail "Printing all is not implemented; maybe try \"supported\" instead?";
        }

        if ($invert) {
            $extensions = (type-extensions("supported") ⊖ $extensions).keys;
        }

        given $print {
            when $_ === True or any(qw/ n nl newline /) {
                type-extensions($type).map(&say);
            }
            when any(qw/ s sp space spaces /) {
                type-extensions($type).join(" ").say;
            }
            when any(qw/ find bfs /) {
                $extensions.map(
                    {
                        if ($_ eq '/') {
                            "-type\nd";
                        } else {
                            "-iname\n*." ~ $_;
                        }
                    }).join("\n-or\n").say;
            }
            when any(qw/ types type /) {
                %types.keys.map(&say);
            }
            default {
                fail "Unknown --print format: \"$_\". Try instead one of: newline, space, find, types.";
            }
        }
        exit;
    }

    fail "A type must be provided. Try one of: " ~ types().sort.join(", ") ~ "." unless $type.defined;

    for $*IN.lines {
        my $is = is-type($_, $type);
        if ($invert) {
            .say unless $is;
        } else {
            .say when $is;
        };
    };
}