2024-04-12 18:19:32 +08:00
|
|
|
#RUN: %fish %s
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# The "path" builtin for dealing with paths
|
|
|
|
|
|
|
|
|
|
# Extension - for figuring out the file extension of a given path.
|
|
|
|
|
path extension /
|
|
|
|
|
or echo None
|
2022-04-07 21:16:05 +08:00
|
|
|
# CHECK:
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: None
|
|
|
|
|
|
|
|
|
|
# No extension
|
|
|
|
|
path extension /.
|
|
|
|
|
or echo Filename is just a dot, no extension
|
2022-04-07 21:16:05 +08:00
|
|
|
# CHECK:
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: Filename is just a dot, no extension
|
|
|
|
|
|
|
|
|
|
# No extension - ".foo" is the filename
|
|
|
|
|
path extension /.foo
|
|
|
|
|
or echo None again
|
2022-04-07 21:16:05 +08:00
|
|
|
# CHECK:
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: None again
|
|
|
|
|
|
|
|
|
|
path extension /foo
|
|
|
|
|
or echo None once more
|
2022-04-07 21:16:05 +08:00
|
|
|
# CHECK:
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: None once more
|
|
|
|
|
path extension /foo.txt
|
|
|
|
|
and echo Success
|
2021-12-09 23:36:17 +08:00
|
|
|
# CHECK: .txt
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: Success
|
|
|
|
|
path extension /foo.txt/bar
|
|
|
|
|
or echo Not even here
|
2022-04-07 21:16:05 +08:00
|
|
|
# CHECK:
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: Not even here
|
|
|
|
|
path extension . ..
|
|
|
|
|
or echo No extension
|
2022-04-07 21:16:05 +08:00
|
|
|
# CHECK:
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: No extension
|
|
|
|
|
path extension ./foo.mp4
|
2021-12-09 23:36:17 +08:00
|
|
|
# CHECK: .mp4
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
path extension ../banana
|
2022-04-07 21:16:05 +08:00
|
|
|
# CHECK:
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# nothing, status 1
|
|
|
|
|
echo $status
|
|
|
|
|
# CHECK: 1
|
|
|
|
|
path extension ~/.config
|
2022-04-07 21:16:05 +08:00
|
|
|
# CHECK:
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# nothing, status 1
|
|
|
|
|
echo $status
|
|
|
|
|
# CHECK: 1
|
|
|
|
|
path extension ~/.config.d
|
2021-12-09 23:36:17 +08:00
|
|
|
# CHECK: .d
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
path extension ~/.config.
|
|
|
|
|
echo $status
|
2021-12-09 23:36:17 +08:00
|
|
|
# status 0
|
|
|
|
|
# CHECK: .
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: 0
|
|
|
|
|
|
2021-10-23 23:57:30 +08:00
|
|
|
path change-extension '' ./foo.mp4
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: ./foo
|
2021-12-09 23:36:17 +08:00
|
|
|
path change-extension wmv ./foo.mp4
|
|
|
|
|
# CHECK: ./foo.wmv
|
|
|
|
|
path change-extension .wmv ./foo.mp4
|
|
|
|
|
# CHECK: ./foo.wmv
|
2021-10-23 23:57:30 +08:00
|
|
|
path change-extension '' ../banana
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: ../banana
|
2021-10-24 17:15:25 +08:00
|
|
|
# still status 0, because there was an argument
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
echo $status
|
2021-10-24 17:15:25 +08:00
|
|
|
# CHECK: 0
|
2021-10-23 23:57:30 +08:00
|
|
|
path change-extension '' ~/.config
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: {{.*}}/.config
|
|
|
|
|
echo $status
|
2021-10-24 17:15:25 +08:00
|
|
|
# CHECK: 0
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
|
2021-10-23 23:49:48 +08:00
|
|
|
path basename ./foo.mp4
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: foo.mp4
|
2021-10-23 23:49:48 +08:00
|
|
|
path basename ../banana
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: banana
|
2021-10-23 23:49:48 +08:00
|
|
|
path basename /usr/bin/
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: bin
|
2021-10-23 23:49:48 +08:00
|
|
|
path dirname ./foo.mp4
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: .
|
2021-10-23 23:49:48 +08:00
|
|
|
path basename ../banana
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: banana
|
2021-10-23 23:49:48 +08:00
|
|
|
path basename /usr/bin/
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# CHECK: bin
|
|
|
|
|
|
|
|
|
|
cd $TMPDIR
|
|
|
|
|
mkdir -p bin
|
|
|
|
|
touch bin/{bash,bssh,chsh,dash,fish,slsh,ssh,zsh}
|
|
|
|
|
ln -s $TMPDIR/bin/bash bin/sh
|
|
|
|
|
|
|
|
|
|
chmod +x bin/*
|
|
|
|
|
# We need files from here on
|
|
|
|
|
path filter bin argagagji
|
|
|
|
|
# The (hopefully) nonexistent argagagji is filtered implicitly:
|
|
|
|
|
# CHECK: bin
|
2022-05-11 23:10:25 +08:00
|
|
|
|
|
|
|
|
# With --invert, the existing bin is filtered
|
|
|
|
|
path filter --invert bin argagagji
|
|
|
|
|
# CHECK: argagagji
|
|
|
|
|
|
|
|
|
|
# With --invert and a type, bin fails the type,
|
|
|
|
|
# and argagagji doesn't exist, so both are printed.
|
|
|
|
|
path filter -vf bin argagagji
|
|
|
|
|
# CHECK: bin
|
|
|
|
|
# CHECK: argagagji
|
|
|
|
|
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
path filter --type file bin bin/fish
|
|
|
|
|
# Only fish is a file
|
|
|
|
|
# CHECK: bin/fish
|
|
|
|
|
chmod 500 bin/fish
|
|
|
|
|
path filter --type file,dir --perm exec,write bin/fish .
|
|
|
|
|
# fish is a file, which passes, and executable, which passes,
|
|
|
|
|
# but not writable, which fails.
|
|
|
|
|
#
|
|
|
|
|
# . is a directory and both writable and executable, typically.
|
|
|
|
|
# So it passes.
|
|
|
|
|
# CHECK: .
|
|
|
|
|
|
2023-08-07 08:42:06 +08:00
|
|
|
mkdir -p sbin
|
|
|
|
|
touch sbin/setuid-exe sbin/setgid-exe
|
|
|
|
|
chmod u+s,a+x sbin/setuid-exe
|
|
|
|
|
path filter --perm suid sbin/*
|
|
|
|
|
# CHECK: sbin/setuid-exe
|
2023-08-07 23:21:07 +08:00
|
|
|
|
|
|
|
|
# On at least FreeBSD on our CI this fails with "permission denied".
|
|
|
|
|
# So we can't test it, and we fake the output instead.
|
|
|
|
|
if chmod g+s,a+x sbin/setgid-exe 2>/dev/null
|
|
|
|
|
path filter --perm sgid sbin/*
|
|
|
|
|
else
|
|
|
|
|
echo sbin/setgid-exe
|
|
|
|
|
end
|
2023-08-07 08:42:06 +08:00
|
|
|
# CHECK: sbin/setgid-exe
|
|
|
|
|
|
|
|
|
|
mkdir stuff
|
|
|
|
|
touch stuff/{read,write,exec,readwrite,readexec,writeexec,all,none}
|
|
|
|
|
chmod 400 stuff/read
|
|
|
|
|
chmod 200 stuff/write
|
|
|
|
|
chmod 100 stuff/exec
|
|
|
|
|
chmod 600 stuff/readwrite
|
|
|
|
|
chmod 500 stuff/readexec
|
|
|
|
|
chmod 300 stuff/writeexec
|
|
|
|
|
chmod 700 stuff/all
|
|
|
|
|
chmod 000 stuff/none
|
|
|
|
|
|
2023-08-08 10:56:27 +08:00
|
|
|
# Validate that globs are sorted.
|
|
|
|
|
test (path filter stuff/* | path sort | string join ",") = (path filter stuff/* | string join ",")
|
|
|
|
|
|
|
|
|
|
path filter --perm read stuff/*
|
2023-08-07 08:42:06 +08:00
|
|
|
# CHECK: stuff/all
|
|
|
|
|
# CHECK: stuff/read
|
|
|
|
|
# CHECK: stuff/readexec
|
|
|
|
|
# CHECK: stuff/readwrite
|
|
|
|
|
|
2023-08-08 10:56:27 +08:00
|
|
|
path filter -r stuff/*
|
2023-08-07 09:49:04 +08:00
|
|
|
# CHECK: stuff/all
|
|
|
|
|
# CHECK: stuff/read
|
|
|
|
|
# CHECK: stuff/readexec
|
|
|
|
|
# CHECK: stuff/readwrite
|
|
|
|
|
|
2023-08-08 10:56:27 +08:00
|
|
|
path filter --perm write stuff/*
|
2023-08-07 08:42:06 +08:00
|
|
|
# CHECK: stuff/all
|
|
|
|
|
# CHECK: stuff/readwrite
|
|
|
|
|
# CHECK: stuff/write
|
|
|
|
|
# CHECK: stuff/writeexec
|
|
|
|
|
|
2023-08-08 10:56:27 +08:00
|
|
|
path filter -w stuff/*
|
2023-08-07 09:49:04 +08:00
|
|
|
# CHECK: stuff/all
|
|
|
|
|
# CHECK: stuff/readwrite
|
|
|
|
|
# CHECK: stuff/write
|
|
|
|
|
# CHECK: stuff/writeexec
|
|
|
|
|
|
2023-08-08 10:56:27 +08:00
|
|
|
path filter --perm exec stuff/*
|
2023-08-07 08:42:06 +08:00
|
|
|
# CHECK: stuff/all
|
|
|
|
|
# CHECK: stuff/exec
|
|
|
|
|
# CHECK: stuff/readexec
|
|
|
|
|
# CHECK: stuff/writeexec
|
|
|
|
|
|
2023-08-08 10:56:27 +08:00
|
|
|
path filter -x stuff/*
|
2023-08-07 09:49:04 +08:00
|
|
|
# CHECK: stuff/all
|
|
|
|
|
# CHECK: stuff/exec
|
|
|
|
|
# CHECK: stuff/readexec
|
|
|
|
|
# CHECK: stuff/writeexec
|
|
|
|
|
|
2023-08-08 10:56:27 +08:00
|
|
|
path filter --perm read,write stuff/*
|
2023-08-07 08:42:06 +08:00
|
|
|
# CHECK: stuff/all
|
|
|
|
|
# CHECK: stuff/readwrite
|
|
|
|
|
|
2023-08-08 10:56:27 +08:00
|
|
|
path filter --perm read,exec stuff/*
|
2023-08-07 08:42:06 +08:00
|
|
|
# CHECK: stuff/all
|
|
|
|
|
# CHECK: stuff/readexec
|
|
|
|
|
|
2023-08-08 10:56:27 +08:00
|
|
|
path filter --perm write,exec stuff/*
|
2023-08-07 08:42:06 +08:00
|
|
|
# CHECK: stuff/all
|
|
|
|
|
# CHECK: stuff/writeexec
|
|
|
|
|
|
2023-08-08 10:56:27 +08:00
|
|
|
path filter --perm read,write,exec stuff/*
|
2023-08-07 08:42:06 +08:00
|
|
|
# CHECK: stuff/all
|
|
|
|
|
|
2023-08-08 10:56:27 +08:00
|
|
|
path filter stuff/*
|
2023-08-07 08:42:06 +08:00
|
|
|
# CHECK: stuff/all
|
|
|
|
|
# CHECK: stuff/exec
|
|
|
|
|
# CHECK: stuff/none
|
|
|
|
|
# CHECK: stuff/read
|
|
|
|
|
# CHECK: stuff/readexec
|
|
|
|
|
# CHECK: stuff/readwrite
|
|
|
|
|
# CHECK: stuff/write
|
|
|
|
|
# CHECK: stuff/writeexec
|
|
|
|
|
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
path normalize /usr/bin//../../etc/fish
|
|
|
|
|
# The "//" is squashed and the ".." components neutralize the components before
|
|
|
|
|
# CHECK: /etc/fish
|
|
|
|
|
path normalize /bin//bash
|
|
|
|
|
# The "//" is squashed, but /bin isn't resolved even if your system links it to /usr/bin.
|
|
|
|
|
# CHECK: /bin/bash
|
|
|
|
|
|
2022-03-26 17:45:22 +08:00
|
|
|
# Paths with "-" get a "./":
|
|
|
|
|
path normalize -- -/foo -foo/foo
|
|
|
|
|
# CHECK: ./-/foo
|
|
|
|
|
# CHECK: ./-foo/foo
|
|
|
|
|
path normalize -- ../-foo
|
|
|
|
|
# CHECK: ../-foo
|
|
|
|
|
|
2022-05-11 23:00:59 +08:00
|
|
|
# This goes for filter as well
|
|
|
|
|
touch -- -foo
|
|
|
|
|
path filter -f -- -foo
|
|
|
|
|
# CHECK: ./-foo
|
|
|
|
|
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# We need to remove the rest of the path because we have no idea what its value looks like.
|
2022-01-29 00:22:16 +08:00
|
|
|
path resolve bin//sh | string match -r -- 'bin/bash$'
|
Add "path" builtin
This adds a "path" builtin that can handle paths.
Implemented so far:
- "path filter PATHS", filters paths according to existence and optionally type and permissions
- "path base" and "path dir", run basename and dirname, respectively
- "path extension PATHS", prints the extension, if any
- "path strip-extension", prints the path without the extension
- "path normalize PATHS", normalizes paths - removing "/./" components
- and such.
- "path real", does realpath - i.e. normalizing *and* link resolution.
Some of these - base, dir, {strip-,}extension and normalize operate on the paths only as strings, so they handle nonexistent paths. filter and real ignore any nonexistent paths.
All output is split explicitly, so paths with newlines in them are
handled correctly. Alternatively, all subcommands have a "--null-input"/"-z" and "--null-output"/"-Z" option to handle null-terminated input and create null-terminated output. So
find . -print0 | path base -z
prints the basename of all files in the current directory,
recursively.
With "-Z" it also prints it null-separated.
(if stdout is going to a command substitution, we probably want to
skip this)
All subcommands also have a "-q"/"--quiet" flag that tells them to skip output. They return true "when something happened". For match/filter that's when a file passed, for "base"/"dir"/"extension"/"strip-extension" that's when something about the path *changed*.
Filtering
---------
`filter` supports all the file*types* `test` has - "dir", "file", "link", "block"..., as well as the permissions - "read", "write", "exec" and things like "suid".
It is missing the tty check and the check for the file being non-empty. The former is best done via `isatty`, the latter I don't think I've ever seen used.
There currently is no way to only get "real" files, i.e. ignore links pointing to files.
Examples
--------
> path real /bin///sh
/usr/bin/bash
> path extension foo.mp4
mp4
> path extension ~/.config
(nothing, because ".config" isn't an extension.)
2021-08-28 20:45:24 +08:00
|
|
|
# The "//" is squashed, and the symlink is resolved.
|
|
|
|
|
# sh here is bash
|
|
|
|
|
# CHECK: bin/bash
|
2022-01-26 04:08:07 +08:00
|
|
|
|
2022-04-07 21:13:10 +08:00
|
|
|
# "../" cancels out even files.
|
|
|
|
|
path resolve bin//sh/../ | string match -r -- 'bin$'
|
|
|
|
|
# CHECK: bin
|
|
|
|
|
|
2022-01-29 00:22:16 +08:00
|
|
|
# `path resolve` with nonexistent paths
|
|
|
|
|
set -l path (path resolve foo/bar)
|
2022-02-03 03:46:32 +08:00
|
|
|
string match -rq "^"(pwd -P | string escape --style=regex)'/' -- $path
|
2022-01-26 04:08:07 +08:00
|
|
|
and echo It matches pwd!
|
2022-02-03 03:30:43 +08:00
|
|
|
or echo pwd is \'$PWD\' resolved path is \'$path\'
|
2022-01-26 04:08:07 +08:00
|
|
|
# CHECK: It matches pwd!
|
2022-02-03 03:46:32 +08:00
|
|
|
string replace -r "^"(pwd -P | string escape --style=regex)'/' "" -- $path
|
2022-01-26 04:08:07 +08:00
|
|
|
# CHECK: foo/bar
|
|
|
|
|
|
2022-01-29 00:22:16 +08:00
|
|
|
path resolve /banana//terracota/terracota/booooo/../pie
|
2022-01-26 04:08:07 +08:00
|
|
|
# CHECK: /banana/terracota/terracota/pie
|
2022-04-07 22:09:28 +08:00
|
|
|
|
2022-05-29 23:47:25 +08:00
|
|
|
path sort --key=basename {def,abc}/{456,123,789,abc,def,0} | path sort --key=dirname -r
|
2022-04-07 22:09:28 +08:00
|
|
|
# CHECK: def/0
|
|
|
|
|
# CHECK: def/123
|
|
|
|
|
# CHECK: def/456
|
|
|
|
|
# CHECK: def/789
|
|
|
|
|
# CHECK: def/abc
|
|
|
|
|
# CHECK: def/def
|
|
|
|
|
# CHECK: abc/0
|
|
|
|
|
# CHECK: abc/123
|
|
|
|
|
# CHECK: abc/456
|
|
|
|
|
# CHECK: abc/789
|
|
|
|
|
# CHECK: abc/abc
|
|
|
|
|
# CHECK: abc/def
|
2022-04-27 03:10:54 +08:00
|
|
|
|
2022-05-20 03:11:52 +08:00
|
|
|
path sort --unique --key=basename {def,abc}/{456,123,789} def/{abc,def,0} abc/{foo,bar,baz}
|
2022-04-27 03:10:54 +08:00
|
|
|
# CHECK: def/0
|
|
|
|
|
# CHECK: def/123
|
|
|
|
|
# CHECK: def/456
|
|
|
|
|
# CHECK: def/789
|
|
|
|
|
# CHECK: def/abc
|
|
|
|
|
# CHECK: abc/bar
|
|
|
|
|
# CHECK: abc/baz
|
|
|
|
|
# CHECK: def/def
|
|
|
|
|
# CHECK: abc/foo
|
|
|
|
|
|
|
|
|
|
|
2022-05-20 03:08:11 +08:00
|
|
|
|
|
|
|
|
# Symlink loop.
|
|
|
|
|
# It goes brrr.
|
|
|
|
|
ln -s target link
|
|
|
|
|
ln -s link target
|
|
|
|
|
|
|
|
|
|
test (path resolve target) = (pwd -P)/target
|
|
|
|
|
and echo target resolves to target
|
|
|
|
|
# CHECK: target resolves to target
|
|
|
|
|
|
|
|
|
|
test (path resolve link) = (pwd -P)/link
|
|
|
|
|
and echo link resolves to link
|
|
|
|
|
# CHECK: link resolves to link
|
|
|
|
|
|
2022-07-19 02:39:01 +08:00
|
|
|
|
|
|
|
|
# path mtime
|
|
|
|
|
# These tests deal with *time*, so we have to account
|
|
|
|
|
# for slow systems (like CI).
|
|
|
|
|
# So we should only test with a lot of slack.
|
|
|
|
|
|
|
|
|
|
echo bananana >> foo
|
|
|
|
|
test (math abs (date +%s) - (path mtime foo)) -lt 20
|
|
|
|
|
or echo MTIME IS BOGUS
|
|
|
|
|
|
|
|
|
|
sleep 2
|
|
|
|
|
|
|
|
|
|
set -l mtime (path mtime --relative foo)
|
|
|
|
|
test $mtime -ge 1
|
|
|
|
|
or echo mtime is too small
|
|
|
|
|
|
|
|
|
|
test $mtime -lt 20
|
|
|
|
|
or echo mtime is too large
|
2022-09-20 22:05:46 +08:00
|
|
|
|
2022-09-20 22:15:42 +08:00
|
|
|
touch -m -t 197001020000 epoch
|
|
|
|
|
set -l epochtime (path mtime epoch)
|
|
|
|
|
# Allow for timezone shenanigans
|
|
|
|
|
test $epochtime -gt 0 -a $epochtime -lt 180000
|
|
|
|
|
or echo Oops not mtime
|
2022-10-05 23:15:56 +08:00
|
|
|
|
|
|
|
|
path basename -Z foo bar baz | path sort
|
|
|
|
|
# CHECK: bar
|
|
|
|
|
# CHECK: baz
|
|
|
|
|
# CHECK: foo
|
|
|
|
|
|
2024-05-25 07:03:42 +08:00
|
|
|
path basename -E foo.txt /usr/local/foo.bar /foo.tar.gz
|
|
|
|
|
# CHECK: foo
|
|
|
|
|
# CHECK: foo
|
|
|
|
|
# CHECK: foo.tar
|
|
|
|
|
|
2022-10-05 23:15:56 +08:00
|
|
|
path basename --null-out bar baz | string escape
|
|
|
|
|
# CHECK: bar\x00baz\x00
|