jmarya/knowledge
jmarya/knowledge
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

remove non ascii whitespaces

Browse source
This commit is contained in:
JMARyA 2024-01-17 09:44:04 +01:00
parent 598a10bc28
commit 5a6d6c4d13
Signed by: jmarya
GPG key ID: 901B2ADDF27C2263
117 changed files with 1928 additions and 1928 deletions
Download patch file Download diff file Expand all files Collapse all files

14
technology/applications/cli/Shell.md
View file

@ -133,7 +133,7 @@ command2 < mypipe # Reading from the pipe
### **tee Command**
The `tee` command reads from standard input and writes to standard output and files simultaneously.
```shell
echo "Hello, World!" | tee output.txt | wc -l
echo "Hello, World!" | tee output.txt | wc -l
```
### **/dev/null**
@ -210,7 +210,7 @@ esac
#### Operators
##### Arithmetic Operators
Assume variable **a** holds 10 and variable **b** holds 20 then −
Assume variable **a** holds 10 and variable **b** holds 20 then −
| Operator | Description | Example |
| ------------------ | --------------------------------------------------------------------- | --------------------------------------- |
@ -226,7 +226,7 @@ Assume variable **a** holds 10 and variable **b** holds 20 then −
##### Relational Operators
For example, following operators will work to check a relation between 10 and 20 as well as in between "10" and "20" but not in between "ten" and "twenty".
Assume variable **a** holds 10 and variable **b** holds 20 then −
Assume variable **a** holds 10 and variable **b** holds 20 then −
| Operator | Description | Example |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------- |
@ -238,18 +238,18 @@ Assume variable **a** holds 10 and variable **b** holds 20 then −
| **-le** | Checks if the value of left operand is less than or equal to the value of right operand; if yes, then the condition becomes true. | `[ $a -le $b ]` is true. |
##### Boolean Operators
Assume variable **a** holds 10 and variable **b** holds 20 then −
Assume variable **a** holds 10 and variable **b** holds 20 then −
| Operator | Description | Example |
| -------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------- |
| **!** | This is logical negation. This inverts a true condition into false and vice versa. | `[ ! false ]` is true. |
| **-o** | This is logical **OR**. If one of the operands is true, then the condition becomes true. | `[ $a -lt 20 -o $b -gt 100 ]` is true. |
| **-a** | This is logical **AND**. If both the operands are true, then the condition becomes true otherwise false. | `[ $a -lt 20 -a $b -gt 100 ]` is false. |
| **-o** | This is logical **OR**. If one of the operands is true, then the condition becomes true. | `[ $a -lt 20 -o $b -gt 100 ]` is true. |
| **-a** | This is logical **AND**. If both the operands are true, then the condition becomes true otherwise false. | `[ $a -lt 20 -a $b -gt 100 ]` is false. |
##### File Test Operators
We have a few operators that can be used to test various properties associated with a Unix file.
Assume a variable **file** holds an existing file name "test" the size of which is 100 bytes and has **read**, **write** and **execute** permission.
Assume a variable **file** holds an existing file name "test" the size of which is 100 bytes and has **read**, **write** and **execute** permission.
| Operator | Description | Example |
| ----------- | ---------------------------------------------------------------------------------------------------------------------- | --------------------------- |

2
technology/applications/cli/choose.md
View file

@ -7,7 +7,7 @@ os:
repo: https://github.com/theryangeary/choose
---
# choose
`choose`, a human-friendly and fast alternative to `cut` and (sometimes) `awk`
`choose`, a human-friendly and fast alternative to `cut` and (sometimes) `awk`
## Usage
```shell

2
technology/applications/cli/compression/tar.md
View file

@ -5,7 +5,7 @@ website: https://savannah.gnu.org/projects/tar
repo: https://git.savannah.gnu.org/cgit/tar.git
---
# Tar
Tar is the most widely used command in Unix and Linux like operating system for creating archive of multiple files and folders into a single archive file and that archive file can be further compressed using other compression techniques
Tar is the most widely used command in Unix and Linux like operating system for creating archive of multiple files and folders into a single archive file and that archive file can be further compressed using other compression techniques
Creating Archives:
```shell

2
technology/applications/cli/crunch.md
View file

@ -19,5 +19,5 @@ Usage: `crunch <min-len> <max-len> [<charset string>] [options]`
| `-i` | Inverts the output so instead of aaa,aab,aac,aad, etc you get aaa,baa,caa,daa,aba,bba |
| `-o wordlist.txt` | Specifies the file to write the output to, eg: wordlist.txt |
| `-s startblock` | Specifies a starting string, eg: 03god22fs |
| `-t @,%^` | Specifies a pattern, eg: @@god@@@@ where the only the @'s, ,'s, %'s, and ^'s  will change. <br>`@` will insert lower case characters<br>`,` will insert upper case characters<br>`%` will insert numbers<br>`^` will insert symbols |
| `-t @,%^` | Specifies a pattern, eg: @@god@@@@ where the only the @'s, ,'s, %'s, and ^'s will change. <br>`@` will insert lower case characters<br>`,` will insert upper case characters<br>`%` will insert numbers<br>`^` will insert symbols |
| `-z gzip, bzip2, lzma, and 7z` | Compresses the output from the -o option. Valid parameters are gzip, bzip2, lzma, and [7z](compression/p7zip.md). |

16
technology/applications/cli/eza.md
View file

@ -4,17 +4,17 @@ os: linux
repo: https://github.com/eza-community/eza
---
# exa
[**eza**](https://eza.rocks/) is a modern replacement for the venerable file-listing command-line program `ls` that ships with Unix and Linux operating systems, giving it more features and better defaults. It uses colours to distinguish file types and metadata. It knows about symlinks, extended attributes, and Git. And it’s **small**, **fast**, and just **one single binary**.
[**eza**](https://eza.rocks/) is a modern replacement for the venerable file-listing command-line program `ls` that ships with Unix and Linux operating systems, giving it more features and better defaults. It uses colours to distinguish file types and metadata. It knows about symlinks, extended attributes, and Git. And it’s **small**, **fast**, and just **one single binary**.
## Usage
Flags:
```shell
-l, --long         display extended file metadata as a table
-R, --recurse      recurse into directories
-l, --long display extended file metadata as a table
-R, --recurse recurse into directories
-L, --level DEPTH limit the depth of recursion
-T, --tree         recurse into directories as a tree
-a, --all          show hidden and 'dot' files
-r, --reverse      reverse the sort order
-D, --only-dirs    list only directories
--git-ignore       ignore files mentioned in '.gitignore'
-T, --tree recurse into directories as a tree
-a, --all show hidden and 'dot' files
-r, --reverse reverse the sort order
-D, --only-dirs list only directories
--git-ignore ignore files mentioned in '.gitignore'
```

2
technology/applications/cli/fd.md
View file

@ -4,7 +4,7 @@ os: linux
repo: https://github.com/sharkdp/fd
---
# fd
`fd` is a program to find entries in your filesystem. It is a simple, fast and user-friendly alternative to [`find`](https://www.gnu.org/software/findutils/). While it does not aim to support all of `find`'s powerful functionality, it provides sensible (opinionated) defaults for a majority of use cases.
`fd` is a program to find entries in your filesystem. It is a simple, fast and user-friendly alternative to [`find`](https://www.gnu.org/software/findutils/). While it does not aim to support all of `find`'s powerful functionality, it provides sensible (opinionated) defaults for a majority of use cases.
## Usage
Usage: `fd [OPTIONS] [pattern] [path]...`

2
technology/applications/cli/handlr.md
View file

@ -4,7 +4,7 @@ os: linux
repo: https://github.com/chmln/handlr
---
# Handlr
Manage your default applications with ease using `handlr`!
Manage your default applications with ease using `handlr`!
Open files in default application:
```shell

4
technology/applications/cli/hck.md
View file

@ -4,11 +4,11 @@ os: linux
repo: https://github.com/sstadick/hck
---
# hck
_`hck` is a shortening of `hack`, a rougher form of `cut`._
_`hck` is a shortening of `hack`, a rougher form of `cut`._
A close to drop in replacement for cut that can use a regex delimiter instead of a fixed string. Additionally this tool allows for specification of the order of the output columns using the same column selection syntax as cut (see below for examples).
No single feature of `hck` on its own makes it stand out over `awk`, `cut`, `xsv` or other such tools. Where `hck` excels is making common things easy, such as reordering output fields, or splitting records on a weird delimiter. It is meant to be simple and easy to use while exploring datasets. Think of this as filling a gap between `cut` and `awk`.
No single feature of `hck` on its own makes it stand out over `awk`, `cut`, `xsv` or other such tools. Where `hck` excels is making common things easy, such as reordering output fields, or splitting records on a weird delimiter. It is meant to be simple and easy to use while exploring datasets. Think of this as filling a gap between `cut` and `awk`.
## Usage
Usage: `hck [options]`

2
technology/applications/cli/hexyl.md
View file

@ -5,7 +5,7 @@ os:
repo: https://github.com/sharkdp/hexyl
---
# Hexyl
`hexyl` is a simple hex viewer for the terminal. It uses a colored output to distinguish different categories of bytes (NULL bytes, printable [ASCII](../../files/ASCII.md) characters, [ASCII](../../files/ASCII.md) whitespace characters, other [ASCII](../../files/ASCII.md) characters and non-[ASCII](../../files/ASCII.md)).
`hexyl` is a simple hex viewer for the terminal. It uses a colored output to distinguish different categories of bytes (NULL bytes, printable [ASCII](../../files/ASCII.md) characters, [ASCII](../../files/ASCII.md) whitespace characters, other [ASCII](../../files/ASCII.md) characters and non-[ASCII](../../files/ASCII.md)).
## Usage
Usage: `hexyl [OPTIONS] [FILE]`

8
technology/applications/cli/huniq.md
View file

@ -10,11 +10,11 @@ Command line utility to remove duplicates from the given input. Note that huniq
## Usage
Flags:
```shell
-c, --count      Output the amount of times a line was encountered
-c, --count Output the amount of times a line was encountered
-d, --delim <delim>        Which delimiter between elements to use. [default: "\n"]
-d, --delim <delim> Which delimiter between elements to use. [default: "\n"]
-s, --sort                     Sort output by the number of occurences, in ascending order
-s, --sort Sort output by the number of occurences, in ascending order
-S, --sort-descending          Order output by the number of occurences, in descending order
-S, --sort-descending Order output by the number of occurences, in descending order
```

2
technology/applications/cli/intermodal.md
View file

@ -5,7 +5,7 @@ repo: https://github.com/casey/intermodal
---
# Intermodal
[Repo](https://github.com/casey/intermodal)
Intermodal is a user-friendly and featureful command-line [BitTorrent](../../internet/BitTorrent.md) metainfo utility. The binary is called `imdl` and runs on [Linux](../../linux/Linux.md), [Windows](../../windows/Windows.md), and [macOS](../../macos/macOS.md).
Intermodal is a user-friendly and featureful command-line [BitTorrent](../../internet/BitTorrent.md) metainfo utility. The binary is called `imdl` and runs on [Linux](../../linux/Linux.md), [Windows](../../windows/Windows.md), and [macOS](../../macos/macOS.md).
## Usage
### Create torrent file:

2
technology/applications/cli/jless.md
View file

@ -3,4 +3,4 @@ obj: application
os: linux
---
# Jless
[`jless`](https://jless.io/) is a command-line [JSON](../../files/JSON.md) viewer. Use it as a replacement for whatever combination of `less`, `jq`, `cat` and your editor you currently use for viewing [JSON](../../files/JSON.md) files. It is written in [Rust](../../dev/programming/languages/Rust.md) and can be installed as a single standalone binary.
[`jless`](https://jless.io/) is a command-line [JSON](../../files/JSON.md) viewer. Use it as a replacement for whatever combination of `less`, `jq`, `cat` and your editor you currently use for viewing [JSON](../../files/JSON.md) files. It is written in [Rust](../../dev/programming/languages/Rust.md) and can be installed as a single standalone binary.

78
technology/applications/cli/jq.md
View file

@ -8,7 +8,7 @@ jq is a lightweight and flexible command-line [JSON](../../files/JSON.md) proces
## Usage
```shell
cat data.json | jq [FILTER]
cat data.json | jq [FILTER]
# Raw Data
cat data.json | jq -r [FILTER]
@ -16,67 +16,67 @@ cat data.json | jq -r [FILTER]
## Filters
### Identity
The absolute simplest filter is `.` . This filter takes its input and produces the same value as output. That is, this is the identity operator.
The absolute simplest filter is `.` . This filter takes its input and produces the same value as output. That is, this is the identity operator.
### Object Identifier
The simplest _useful_ filter has the form `.foo`. When given a [JSON](../../files/JSON.md) object (aka dictionary or hash) as input, `.foo` produces the value at the key "foo" if the key is present, or null otherwise.
The simplest _useful_ filter has the form `.foo`. When given a [JSON](../../files/JSON.md) object (aka dictionary or hash) as input, `.foo` produces the value at the key "foo" if the key is present, or null otherwise.
The `.foo` syntax only works for simple, identifier-like keys, that is, keys that are all made of alphanumeric characters and underscore, and which do not start with a digit.
The `.foo` syntax only works for simple, identifier-like keys, that is, keys that are all made of alphanumeric characters and underscore, and which do not start with a digit.
If the key contains special characters or starts with a digit, you need to surround it with double quotes like this: `."foo$"`, or else `.["foo$"]`.
If the key contains special characters or starts with a digit, you need to surround it with double quotes like this: `."foo$"`, or else `.["foo$"]`.
### Array Index
When the index value is an integer, `.[<number>]` can index arrays. Arrays are zero-based, so `.[2]` returns the third element.
When the index value is an integer, `.[<number>]` can index arrays. Arrays are zero-based, so `.[2]` returns the third element.
Negative indices are allowed, with -1 referring to the last element, -2 referring to the next to last element, and so on.
### Array/String Slice
The `.[<number>:<number>]` syntax can be used to return a subarray of an array or substring of a string. The array returned by `.[10:15]` will be of length 5, containing the elements from index 10 (inclusive) to index 15 (exclusive). Either index may be negative (in which case it counts backwards from the end of the array), or omitted (in which case it refers to the start or end of the array). Indices are zero-based.
The `.[<number>:<number>]` syntax can be used to return a subarray of an array or substring of a string. The array returned by `.[10:15]` will be of length 5, containing the elements from index 10 (inclusive) to index 15 (exclusive). Either index may be negative (in which case it counts backwards from the end of the array), or omitted (in which case it refers to the start or end of the array). Indices are zero-based.
### Array/Object Value Iterator
If you use the `.[index]` syntax, but omit the index entirely, it will return _all_ of the elements of an array. Running `.[]` with the input `[1,2,3]` will produce the numbers as three separate results, rather than as a single array. A filter of the form `.foo[]` is equivalent to `.foo | .[]`.
If you use the `.[index]` syntax, but omit the index entirely, it will return _all_ of the elements of an array. Running `.[]` with the input `[1,2,3]` will produce the numbers as three separate results, rather than as a single array. A filter of the form `.foo[]` is equivalent to `.foo | .[]`.
You can also use this on an object, and it will return all the values of the object.
Note that the iterator operator is a generator of values.
### Comma
If two filters are separated by a comma, then the same input will be fed into both and the two filters' output value streams will be concatenated in order: first, all of the outputs produced by the left expression, and then all of the outputs produced by the right. For instance, filter `.foo, .bar`, produces both the "foo" fields and "bar" fields as separate outputs.
If two filters are separated by a comma, then the same input will be fed into both and the two filters' output value streams will be concatenated in order: first, all of the outputs produced by the left expression, and then all of the outputs produced by the right. For instance, filter `.foo, .bar`, produces both the "foo" fields and "bar" fields as separate outputs.
The `,` operator is one way to contruct generators.
The `,` operator is one way to contruct generators.
### Pipe
The `|` operator combines two filters by feeding the output(s) of the one on the left into the input of the one on the right. It's similar to the Unix [shell](Shell.md)'s pipe, if you're used to that.
If the one on the left produces multiple results, the one on the right will be run for each of those results. So, the expression `.[] | .foo` retrieves the "foo" field of each element of the input array. This is a cartesian product, which can be surprising.
If the one on the left produces multiple results, the one on the right will be run for each of those results. So, the expression `.[] | .foo` retrieves the "foo" field of each element of the input array. This is a cartesian product, which can be surprising.
Note that `.a.b.c` is the same as `.a | .b | .c`.
Note that `.a.b.c` is the same as `.a | .b | .c`.
Note too that `.` is the input value at the particular stage in a "pipeline", specifically: where the `.` expression appears. Thus `.a | . | .b` is the same as `.a.b`, as the `.` in the middle refers to whatever value `.a` produced.
Note too that `.` is the input value at the particular stage in a "pipeline", specifically: where the `.` expression appears. Thus `.a | . | .b` is the same as `.a.b`, as the `.` in the middle refers to whatever value `.a` produced.
### Array Construction: `[]`
As in [JSON](../../files/JSON.md), `[]` is used to construct arrays, as in `[1,2,3]`. The elements of the arrays can be any jq expression, including a pipeline. All of the results produced by all of the expressions are collected into one big array. You can use it to construct an array out of a known quantity of values (as in `[.foo, .bar, .baz]`) or to "collect" all the results of a filter into an array (as in `[.items[].name]`)
As in [JSON](../../files/JSON.md), `[]` is used to construct arrays, as in `[1,2,3]`. The elements of the arrays can be any jq expression, including a pipeline. All of the results produced by all of the expressions are collected into one big array. You can use it to construct an array out of a known quantity of values (as in `[.foo, .bar, .baz]`) or to "collect" all the results of a filter into an array (as in `[.items[].name]`)
Once you understand the "," operator, you can look at jq's array syntax in a different light: the expression `[1,2,3]` is not using a built-in syntax for comma-separated arrays, but is instead applying the `[]` operator (collect results) to the expression 1,2,3 (which produces three different results).
Once you understand the "," operator, you can look at jq's array syntax in a different light: the expression `[1,2,3]` is not using a built-in syntax for comma-separated arrays, but is instead applying the `[]` operator (collect results) to the expression 1,2,3 (which produces three different results).
If you have a filter `X` that produces four results, then the expression `[X]` will produce a single result, an array of four elements.
If you have a filter `X` that produces four results, then the expression `[X]` will produce a single result, an array of four elements.
### Object Construction: `{}`
Like [JSON](../../files/JSON.md), `{}` is for constructing objects (aka dictionaries or hashes), as in: `{"a": 42, "b": 17}`.
Like [JSON](../../files/JSON.md), `{}` is for constructing objects (aka dictionaries or hashes), as in: `{"a": 42, "b": 17}`.
If the keys are "identifier-like", then the quotes can be left off, as in `{a:42, b:17}`. Variable references as key expressions use the value of the variable as the key. Key expressions other than constant literals, identifiers, or variable references, need to be parenthesized, e.g., `{("a"+"b"):59}`.
If the keys are "identifier-like", then the quotes can be left off, as in `{a:42, b:17}`. Variable references as key expressions use the value of the variable as the key. Key expressions other than constant literals, identifiers, or variable references, need to be parenthesized, e.g., `{("a"+"b"):59}`.
The value can be any expression (although you may need to wrap it in parentheses if, for example, it contains colons), which gets applied to the {} expression's input (remember, all filters have an input and an output).
```
{foo: .bar}
```
will produce the [JSON](../../files/JSON.md) object `{"foo": 42}` if given the [JSON](../../files/JSON.md) object `{"bar":42, "baz":43}` as its input. You can use this to select particular fields of an object: if the input is an object with "user", "title", "id", and "content" fields and you just want "user" and "title", you can write
will produce the [JSON](../../files/JSON.md) object `{"foo": 42}` if given the [JSON](../../files/JSON.md) object `{"bar":42, "baz":43}` as its input. You can use this to select particular fields of an object: if the input is an object with "user", "title", "id", and "content" fields and you just want "user" and "title", you can write
```
{user: .user, title: .title}
```
Because that is so common, there's a shortcut syntax for it: `{user, title}`.
Because that is so common, there's a shortcut syntax for it: `{user, title}`.
If one of the expressions produces multiple results, multiple dictionaries will be produced. If the input's
```
@ -106,55 +106,55 @@ produces
## Functions
### `has(key)`
The builtin function `has` returns whether the input object has the given key, or the input array has an element at the given index.
The builtin function `has` returns whether the input object has the given key, or the input array has an element at the given index.
### `map(f)`, `map_values(f)`
For any filter `f`, `map(f)` and `map_values(f)` apply `f` to each of the values in the input array or object, that is, to the values of `.[]`.
For any filter `f`, `map(f)` and `map_values(f)` apply `f` to each of the values in the input array or object, that is, to the values of `.[]`.
In the absence of errors, `map(f)` always outputs an array whereas `map_values(f)` outputs an array if given an array, or an object if given an object.
In the absence of errors, `map(f)` always outputs an array whereas `map_values(f)` outputs an array if given an array, or an object if given an object.
When the input to `map_values(f)` is an object, the output object has the same keys as the input object except for those keys whose values when piped to `f` produce no values at all.
When the input to `map_values(f)` is an object, the output object has the same keys as the input object except for those keys whose values when piped to `f` produce no values at all.
`map(f)` is equivalent to `[.[] | f]` and `map_values(f)` is equivalent to `.[] |= f`.
`map(f)` is equivalent to `[.[] | f]` and `map_values(f)` is equivalent to `.[] |= f`.
### `del(path)`
The builtin function `del` removes a key and its corresponding value from an object.
The builtin function `del` removes a key and its corresponding value from an object.
### `reverse`
This function reverses an array.
### `contains(element)`
The filter `contains(b)` will produce true if b is completely contained within the input. A string B is contained in a string A if B is a substring of A. An array B is contained in an array A if all elements in B are contained in any element in A. An object B is contained in object A if all of the values in B are contained in the value in A with the same key. All other types are assumed to be contained in each other if they are equal.
The filter `contains(b)` will produce true if b is completely contained within the input. A string B is contained in a string A if B is a substring of A. An array B is contained in an array A if all elements in B are contained in any element in A. An object B is contained in object A if all of the values in B are contained in the value in A with the same key. All other types are assumed to be contained in each other if they are equal.
### `startswith(str)`
Outputs `true` if . starts with the given string argument.
Outputs `true` if . starts with the given string argument.
### `endswith(str)` 
Outputs `true` if . ends with the given string argument.
### `endswith(str)`
Outputs `true` if . ends with the given string argument.
### `split(str)`
Splits an input string on the separator argument.
### `join(str)`
Joins the array of elements given as input, using the argument as separator. It is the inverse of `split`: that is, running `split("foo") | join("foo")` over any input string returns said input string.
Joins the array of elements given as input, using the argument as separator. It is the inverse of `split`: that is, running `split("foo") | join("foo")` over any input string returns said input string.
## Conditionals
### if-then-else-end
`if A then B else C end` will act the same as `B` if `A` produces a value other than false or null, but act the same as `C` otherwise.
`if A then B else C end` will act the same as `B` if `A` produces a value other than false or null, but act the same as `C` otherwise.
`if A then B end` is the same as `if A then B else . end`. That is, the `else` branch is optional, and if absent is the same as `.`. This also applies to `elif` with absent ending `else` branch.
`if A then B end` is the same as `if A then B else . end`. That is, the `else` branch is optional, and if absent is the same as `.`. This also applies to `elif` with absent ending `else` branch.
Checking for false or null is a simpler notion of "truthiness" than is found in JavaScript or [Python](../../dev/programming/languages/Python.md), but it means that you'll sometimes have to be more explicit about the condition you want. You can't test whether, e.g. a string is empty using `if .name then A else B end`; you'll need something like `if .name == "" then A else B end` instead.
Checking for false or null is a simpler notion of "truthiness" than is found in JavaScript or [Python](../../dev/programming/languages/Python.md), but it means that you'll sometimes have to be more explicit about the condition you want. You can't test whether, e.g. a string is empty using `if .name then A else B end`; you'll need something like `if .name == "" then A else B end` instead.
If the condition `A` produces multiple results, then `B` is evaluated once for each result that is not false or null, and `C` is evaluated once for each false or null.
If the condition `A` produces multiple results, then `B` is evaluated once for each result that is not false or null, and `C` is evaluated once for each false or null.
More cases can be added to an if using `elif A then B` syntax.
More cases can be added to an if using `elif A then B` syntax.
Example: `jq 'if . == 0 then "zero" elif . == 1 then "one" else "many" end'`
### Alternative Operator `//`
The `//` operator produces all the values of its left-hand side that are neither `false` nor `null`, or, if the left-hand side produces no values other than `false` or `null`, then `//` produces all the values of its right-hand side.
The `//` operator produces all the values of its left-hand side that are neither `false` nor `null`, or, if the left-hand side produces no values other than `false` or `null`, then `//` produces all the values of its right-hand side.
A filter of the form `a // b` produces all the results of `a` that are not `false` or `null`. If `a` produces no results, or no results other than `false` or `null`, then `a // b` produces the results of `b`.
A filter of the form `a // b` produces all the results of `a` that are not `false` or `null`. If `a` produces no results, or no results other than `false` or `null`, then `a // b` produces the results of `b`.
This is useful for providing defaults: `.foo // 1` will evaluate to `1` if there's no `.foo` element in the input.
This is useful for providing defaults: `.foo // 1` will evaluate to `1` if there's no `.foo` element in the input.

270
technology/applications/cli/just.md
View file

@ -4,12 +4,12 @@ website: https://just.systems/
repo: https://github.com/casey/just
---
# just
`just` is a handy way to save and run project-specific commands.
Commands, called recipes, are stored in a file called `justfile` with syntax inspired by `make`:
`just` is a handy way to save and run project-specific commands.
Commands, called recipes, are stored in a file called `justfile` with syntax inspired by `make`:
![Screenshot][Screenshot]
You can then run them with `just RECIPE`:
You can then run them with `just RECIPE`:
```shell
$ just test-all
cc *.c -o main
@ -50,7 +50,7 @@ just --variables
| `-d, --working-directory <WORKING-DIRECTORY>` | Use \<WORKING-DIRECTORY> as working directory. `--justfile` must also be set |
## Quick Start
Create a file named `justfile` in the root of your project with the following contents:
Create a file named `justfile` in the root of your project with the following contents:
```
recipe-name:
echo 'This is a recipe!'
@ -60,11 +60,11 @@ another-recipe:
@echo 'This is another recipe.'
```
When you invoke `just` it looks for file `justfile` in the current directory and upwards, so you can invoke it from any subdirectory of your project.
When you invoke `just` it looks for file `justfile` in the current directory and upwards, so you can invoke it from any subdirectory of your project.
The search for a `justfile` is case insensitive, so any case, like `Justfile`, `JUSTFILE`, or `JuStFiLe`, will work. `just` will also look for files with the name `.justfile`, in case you’d like to hide a `justfile`.
The search for a `justfile` is case insensitive, so any case, like `Justfile`, `JUSTFILE`, or `JuStFiLe`, will work. `just` will also look for files with the name `.justfile`, in case you’d like to hide a `justfile`.
Running `just` with no arguments runs the first recipe in the `justfile`:
Running `just` with no arguments runs the first recipe in the `justfile`:
```shell
$ just
echo 'This is a recipe!'
@ -77,16 +77,16 @@ $ just another-recipe
This is another recipe.
```
`just` prints each command to standard error before running it, which is why `echo 'This is a recipe!'` was printed. This is suppressed for lines starting with `@`, which is why `echo 'This is another recipe.'` was not printed.
`just` prints each command to standard error before running it, which is why `echo 'This is a recipe!'` was printed. This is suppressed for lines starting with `@`, which is why `echo 'This is another recipe.'` was not printed.
Recipes stop running if a command fails. Here `cargo publish` will only run if `cargo test` succeeds:
Recipes stop running if a command fails. Here `cargo publish` will only run if `cargo test` succeeds:
```
publish:
cargo test # tests passed, time to publish!
cargo publish
```
Recipes can depend on other recipes. Here the `test` recipe depends on the `build` recipe, so `build` will run before `test`:
Recipes can depend on other recipes. Here the `test` recipe depends on the `build` recipe, so `build` will run before `test`:
```
build:
@ -115,7 +115,7 @@ cc main.c foo.c bar.c -o main
## Features
### Default Recipe
When `just` is invoked without a recipe, it runs the first recipe in the `justfile`. This recipe might be the most frequently run command in the project, like running the tests:
When `just` is invoked without a recipe, it runs the first recipe in the `justfile`. This recipe might be the most frequently run command in the project, like running the tests:
```
test:
cargo test
@ -135,14 +135,14 @@ lint:
echo Linting
```
If no recipe makes sense as the default recipe, you can add a recipe to the beginning of your `justfile` that lists the available recipes:
If no recipe makes sense as the default recipe, you can add a recipe to the beginning of your `justfile` that lists the available recipes:
```
default:
@just --list
```
### Listing Available Recipes
Recipes can be listed in alphabetical order with `just --list`:
Recipes can be listed in alphabetical order with `just --list`:
```shell
$ just --list
Available recipes:
@ -152,21 +152,21 @@ Available recipes:
lint
```
`just --summary` is more concise:
`just --summary` is more concise:
```shell
$ just --summary
build test deploy lint
```
If you'd like `just` to default to listing the recipes in the `justfile`, you can use this as your default recipe:
If you'd like `just` to default to listing the recipes in the `justfile`, you can use this as your default recipe:
```just
default:
@just --list
```
> Note that you may need to add `--justfile {{justfile()}}` to the line above above. Without it, if you executed `just -f /some/distant/justfile -d .` or `just -f ./non-standard-justfile`, the plain `just --list` inside the recipe would not necessarily use the file you provided. It would try to find a justfile in your current path, maybe even resulting in a `No justfile found` error.
> Note that you may need to add `--justfile {{justfile()}}` to the line above above. Without it, if you executed `just -f /some/distant/justfile -d .` or `just -f ./non-standard-justfile`, the plain `just --list` inside the recipe would not necessarily use the file you provided. It would try to find a justfile in your current path, maybe even resulting in a `No justfile found` error.
The heading text can be customized with `--list-heading`:
The heading text can be customized with `--list-heading`:
```shell
$ just --list --list-heading $'Cool stuff…\n'
Cool stuff…
@ -191,7 +191,7 @@ Building!
```
### Settings
Settings control interpretation and execution. Each setting may be specified at most once, anywhere in the `justfile`.
Settings control interpretation and execution. Each setting may be specified at most once, anywhere in the `justfile`.
For example:
```just
@ -205,36 +205,36 @@ foo:
#### Table of Settings
| Name | Value | Default | Description |
| ------------------------- | ------------------ | ------- | --------------------------------------------------------------------------------------------- |
| `allow-duplicate-recipes` | boolean | `false` | Allow recipes appearing later in a `justfile` to override earlier recipes with the same name. |
| `dotenv-filename` | string | - | Load a `.env` file with a custom name, if present. |
| `dotenv-load` | boolean | `false` | Load a `.env` file, if present. |
| `dotenv-path` | string | - | Load a `.env` file from a custom path, if present. Overrides `dotenv-filename`. |
| `allow-duplicate-recipes` | boolean | `false` | Allow recipes appearing later in a `justfile` to override earlier recipes with the same name. |
| `dotenv-filename` | string | - | Load a `.env` file with a custom name, if present. |
| `dotenv-load` | boolean | `false` | Load a `.env` file, if present. |
| `dotenv-path` | string | - | Load a `.env` file from a custom path, if present. Overrides `dotenv-filename`. |
| `export` | boolean | `false` | Export all variables as [environment variables](../../linux/Environment%20Variables.md). |
| `fallback` | boolean | `false` | Search `justfile` in parent directory if the first recipe on the command line is not found. |
| `ignore-comments` | boolean | `false` | Ignore recipe lines beginning with `#`. |
| `fallback` | boolean | `false` | Search `justfile` in parent directory if the first recipe on the command line is not found. |
| `ignore-comments` | boolean | `false` | Ignore recipe lines beginning with `#`. |
| `positional-arguments` | boolean | `false` | Pass positional arguments. |
| `shell` | `[COMMAND, ARGS…]` | - | Set the command used to invoke recipes and evaluate backticks. |
| `tempdir` | string | - | Create temporary directories in `tempdir` instead of the system default temporary directory. |
| `windows-powershell` | boolean | `false` | Use PowerShell on [Windows](../../windows/Windows.md) as default [shell](Shell.md). (Deprecated. Use `windows-shell` instead. |
| `tempdir` | string | - | Create temporary directories in `tempdir` instead of the system default temporary directory. |
| `windows-powershell` | boolean | `false` | Use PowerShell on [Windows](../../windows/Windows.md) as default [shell](Shell.md). (Deprecated. Use `windows-shell` instead. |
| `windows-shell` | `[COMMAND, ARGS…]` | - | Set the command used to invoke recipes and evaluate backticks. |
#### Dotenv Settings
If `dotenv-load`, `dotenv-filename` or `dotenv-path` is set, `just` will load [environment variables](../../linux/Environment%20Variables.md) from a file.
If `dotenv-load`, `dotenv-filename` or `dotenv-path` is set, `just` will load [environment variables](../../linux/Environment%20Variables.md) from a file.
If `dotenv-path` is set, `just` will look for a file at the given path.
If `dotenv-path` is set, `just` will look for a file at the given path.
Otherwise, `just` looks for a file named `.env` by default, unless `dotenv-filename` set, in which case the value of `dotenv-filename` is used. This file can be located in the same directory as your `justfile` or in a parent directory.
Otherwise, `just` looks for a file named `.env` by default, unless `dotenv-filename` set, in which case the value of `dotenv-filename` is used. This file can be located in the same directory as your `justfile` or in a parent directory.
The loaded variables are [environment variables](../../linux/Environment%20Variables.md), not `just` variables, and so must be accessed using `$VARIABLE_NAME` in recipes and backticks.
The loaded variables are [environment variables](../../linux/Environment%20Variables.md), not `just` variables, and so must be accessed using `$VARIABLE_NAME` in recipes and backticks.
For example, if your `.env` file contains:
For example, if your `.env` file contains:
```shell
# a comment, will be ignored
DATABASE_ADDRESS=localhost:6379
SERVER_PORT=1337
```
And your `justfile` contains:
And your `justfile` contains:
```just
set dotenv-load
@ -243,7 +243,7 @@ serve:
./server --database $DATABASE_ADDRESS --port $SERVER_PORT
```
`just serve` will output:
`just serve` will output:
```shell
$ just serve
Starting server with database localhost:6379 on port 1337…
@ -251,7 +251,7 @@ Starting server with database localhost:6379 on port 1337…
```
#### Positional Arguments
If `positional-arguments` is `true`, recipe arguments will be passed as positional arguments to commands. For linewise recipes, argument `$0` will be the name of the recipe.
If `positional-arguments` is `true`, recipe arguments will be passed as positional arguments to commands. For linewise recipes, argument `$0` will be the name of the recipe.
For example, running this recipe:
```just
@ -269,7 +269,7 @@ foo
hello
```
When using an `sh`-compatible [shell](Shell.md), such as [`bash`](bash.md) or [`zsh`](zsh.md), `$@` expands to the positional arguments given to the recipe, starting from one. When used within double quotes as `"$@"`, arguments including whitespace will be passed on as if they were double-quoted. That is, `"$@"` is equivalent to `"$1" "$2"`… When there are no positional parameters, `"$@"` and `$@` expand to nothing (i.e., they are removed).
When using an `sh`-compatible [shell](Shell.md), such as [`bash`](bash.md) or [`zsh`](zsh.md), `$@` expands to the positional arguments given to the recipe, starting from one. When used within double quotes as `"$@"`, arguments including whitespace will be passed on as if they were double-quoted. That is, `"$@"` is equivalent to `"$1" "$2"`… When there are no positional parameters, `"$@"` and `$@` expand to nothing (i.e., they are removed).
This example recipe will print arguments one by one on separate lines:
```just
@ -279,7 +279,7 @@ set positional-arguments
bash -c 'while (( "$#" )); do echo - $1; shift; done' -- "$@"
```
Running it with _two_ arguments:
Running it with _two_ arguments:
```shell
$ just test foo "bar baz"
- foo
@ -287,7 +287,7 @@ $ just test foo "bar baz"
```
#### Shell
The `shell` setting controls the command used to invoke recipe lines and backticks. Shebang recipes are unaffected.
The `shell` setting controls the command used to invoke recipe lines and backticks. Shebang recipes are unaffected.
```just
# use python3 to execute recipe lines and backticks
set shell := ["python3", "-c"]
@ -300,10 +300,10 @@ foo:
print("{{foos}}")
```
`just` passes the command to be executed as an argument. Many shells will need an additional flag, often `-c`, to make them evaluate the first argument.
`just` passes the command to be executed as an argument. Many shells will need an additional flag, often `-c`, to make them evaluate the first argument.
### Documentation Comments
Comments immediately preceding a recipe will appear in `just --list`:
Comments immediately preceding a recipe will appear in `just --list`:
```just
# build stuff
build:
@ -322,7 +322,7 @@ Available recipes:
```
### Variables and Substitution
Variables, strings, concatenation, path joining, and substitution using `{{…}}` are supported:
Variables, strings, concatenation, path joining, and substitution using `{{…}}` are supported:
```just
tmpdir := `mktemp -d`
version := "0.2.7"
@ -339,7 +339,7 @@ publish:
```
#### Joining Paths
The `/` operator can be used to join two strings with a slash:
The `/` operator can be used to join two strings with a slash:
```just
foo := "a" / "b"
```
@ -349,7 +349,7 @@ $ just --evaluate foo
a/b
```
Note that a `/` is added even if one is already present:
Note that a `/` is added even if one is already present:
```just
foo := "a/"
bar := foo / "b"
@ -370,14 +370,14 @@ $ just --evaluate foo
/b
```
#### Escaping `{{`
To write a recipe containing `{{`, use `{{{{`:
#### Escaping `{{`
To write a recipe containing `{{`, use `{{{{`:
```just
braces:
echo 'I {{{{LOVE}} curly braces!'
```
(An unmatched `}}` is ignored, so it doesn't need to be escaped.)
(An unmatched `}}` is ignored, so it doesn't need to be escaped.)
Another option is to put all the text you'd like to escape inside of an interpolation:
```just
@ -385,14 +385,14 @@ braces:
echo '{{'I {{LOVE}} curly braces!'}}'
```
Yet another option is to use `{{ "{{" }}`:
Yet another option is to use `{{ "{{" }}`:
```just
braces:
echo 'I {{ "{{" }}LOVE}} curly braces!'
```
### Ignoring Errors
Normally, if a command returns a non-zero exit status, execution will stop. To continue execution after a command, even if it fails, prefix the command with `-`:
Normally, if a command returns a non-zero exit status, execution will stop. To continue execution after a command, even if it fails, prefix the command with `-`:
```just
foo:
-cat foo
@ -408,13 +408,13 @@ Done!
```
### Functions
`just` provides a few built-in functions that might be useful when writing recipes.
`just` provides a few built-in functions that might be useful when writing recipes.
#### System Information
- `arch()` — Instruction set architecture. Possible values are: `"aarch64"`, `"arm"`, `"asmjs"`, `"hexagon"`, `"mips"`, `"msp430"`, `"powerpc"`, `"powerpc64"`, `"s390x"`, `"sparc"`, `"wasm32"`, `"x86"`, `"x86_64"`, and `"xcore"`.
- `num_cpus()` - Number of logical CPUs.
- `os()` — Operating system. Possible values are: `"android"`, `"bitrig"`, `"dragonfly"`, `"emscripten"`, `"freebsd"`, `"haiku"`, `"ios"`, `"linux"`, `"macos"`, `"netbsd"`, `"openbsd"`, `"solaris"`, and `"windows"`.
- `os_family()` — Operating system family; possible values are: `"unix"` and `"windows"`.
- `arch()` — Instruction set architecture. Possible values are: `"aarch64"`, `"arm"`, `"asmjs"`, `"hexagon"`, `"mips"`, `"msp430"`, `"powerpc"`, `"powerpc64"`, `"s390x"`, `"sparc"`, `"wasm32"`, `"x86"`, `"x86_64"`, and `"xcore"`.
- `num_cpus()` - Number of logical CPUs.
- `os()` — Operating system. Possible values are: `"android"`, `"bitrig"`, `"dragonfly"`, `"emscripten"`, `"freebsd"`, `"haiku"`, `"ios"`, `"linux"`, `"macos"`, `"netbsd"`, `"openbsd"`, `"solaris"`, and `"windows"`.
- `os_family()` — Operating system family; possible values are: `"unix"` and `"windows"`.
For example:
```just
@ -428,7 +428,7 @@ This is an x86_64 machine
```
#### [Environment Variables](../../linux/Environment%20Variables.md)
- `env_var(key)` — Retrieves the environment variable with name `key`, aborting if it is not present.
- `env_var(key)` — Retrieves the environment variable with name `key`, aborting if it is not present.
```just
home_dir := env_var('HOME')
@ -442,14 +442,14 @@ $ just
/home/user1
```
- `env_var_or_default(key, default)` — Retrieves the environment variable with name `key`, returning `default` if it is not present.
- `env(key)` — Alias for `env_var(key)`.
- `env(key, default)` — Alias for `env_var_or_default(key, default)`.
- `env_var_or_default(key, default)` — Retrieves the environment variable with name `key`, returning `default` if it is not present.
- `env(key)` — Alias for `env_var(key)`.
- `env(key, default)` — Alias for `env_var_or_default(key, default)`.
#### Invocation Directory
- `invocation_directory()` - Retrieves the absolute path to the current directory when `just` was invoked.
- `invocation_directory()` - Retrieves the absolute path to the current directory when `just` was invoked.
For example, to call `rustfmt` on files just under the "current directory" (from the user/invoker's perspective), use the following rule:
For example, to call `rustfmt` on files just under the "current directory" (from the user/invoker's perspective), use the following rule:
```just
rustfmt:
find {{invocation_directory()}} -name \*.rs -exec rustfmt {} \;
@ -462,17 +462,17 @@ build:
```
#### Justfile and Justfile Directory
- `justfile()` - Retrieves the path of the current `justfile`.
- `justfile_directory()` - Retrieves the path of the parent directory of the current `justfile`.
- `justfile()` - Retrieves the path of the current `justfile`.
- `justfile_directory()` - Retrieves the path of the parent directory of the current `justfile`.
For example, to run a command relative to the location of the current `justfile`:
For example, to run a command relative to the location of the current `justfile`:
```just
script:
./{{justfile_directory()}}/scripts/some_script
```
#### Just Executable
- `just_executable()` - Absolute path to the `just` executable.
- `just_executable()` - Absolute path to the `just` executable.
For example:
```just
@ -486,54 +486,54 @@ The executable is at: /bin/just
```
#### String Manipulation
- `quote(s)` - Replace all single quotes with `'\''` and prepend and append single quotes to `s`. This is sufficient to escape special characters for many shells, including most Bourne [shell](Shell.md) descendants.
- `replace(s, from, to)` - Replace all occurrences of `from` in `s` to `to`.
- `replace_regex(s, regex, replacement)` - Replace all occurrences of `regex` in `s` to `replacement`. Regular expressions are provided by the [Rust `regex` crate](https://docs.rs/regex/latest/regex/). See the [syntax documentation](https://docs.rs/regex/latest/regex/#syntax) for usage examples. Capture groups are supported. The `replacement` string uses [Replacement string syntax](https://docs.rs/regex/latest/regex/struct.Regex.html#replacement-string-syntax).
- `trim(s)` - Remove leading and trailing whitespace from `s`.
- `trim_end(s)` - Remove trailing whitespace from `s`.
- `trim_end_match(s, pat)` - Remove suffix of `s` matching `pat`.
- `trim_end_matches(s, pat)` - Repeatedly remove suffixes of `s` matching `pat`.
- `trim_start(s)` - Remove leading whitespace from `s`.
- `trim_start_match(s, pat)` - Remove prefix of `s` matching `pat`.
- `trim_start_matches(s, pat)` - Repeatedly remove prefixes of `s` matching `pat`.
- `quote(s)` - Replace all single quotes with `'\''` and prepend and append single quotes to `s`. This is sufficient to escape special characters for many shells, including most Bourne [shell](Shell.md) descendants.
- `replace(s, from, to)` - Replace all occurrences of `from` in `s` to `to`.
- `replace_regex(s, regex, replacement)` - Replace all occurrences of `regex` in `s` to `replacement`. Regular expressions are provided by the [Rust `regex` crate](https://docs.rs/regex/latest/regex/). See the [syntax documentation](https://docs.rs/regex/latest/regex/#syntax) for usage examples. Capture groups are supported. The `replacement` string uses [Replacement string syntax](https://docs.rs/regex/latest/regex/struct.Regex.html#replacement-string-syntax).
- `trim(s)` - Remove leading and trailing whitespace from `s`.
- `trim_end(s)` - Remove trailing whitespace from `s`.
- `trim_end_match(s, pat)` - Remove suffix of `s` matching `pat`.
- `trim_end_matches(s, pat)` - Repeatedly remove suffixes of `s` matching `pat`.
- `trim_start(s)` - Remove leading whitespace from `s`.
- `trim_start_match(s, pat)` - Remove prefix of `s` matching `pat`.
- `trim_start_matches(s, pat)` - Repeatedly remove prefixes of `s` matching `pat`.
#### Case Conversion
- `capitalize(s)` - Convert first character of `s` to uppercase and the rest to lowercase.
- `kebabcase(s)` - Convert `s` to `kebab-case`.
- `lowercamelcase(s)` - Convert `s` to `lowerCamelCase`.
- `lowercase(s)` - Convert `s` to lowercase.
- `shoutykebabcase(s)` - Convert `s` to `SHOUTY-KEBAB-CASE`.
- `shoutysnakecase(s)` - Convert `s` to `SHOUTY_SNAKE_CASE`.
- `snakecase(s)` - Convert `s` to `snake_case`.
- `titlecase(s)` - Convert `s` to `Title Case`.
- `uppercamelcase(s)` - Convert `s` to `UpperCamelCase`.
- `uppercase(s)` - Convert `s` to uppercase.
- `capitalize(s)` - Convert first character of `s` to uppercase and the rest to lowercase.
- `kebabcase(s)` - Convert `s` to `kebab-case`.
- `lowercamelcase(s)` - Convert `s` to `lowerCamelCase`.
- `lowercase(s)` - Convert `s` to lowercase.
- `shoutykebabcase(s)` - Convert `s` to `SHOUTY-KEBAB-CASE`.
- `shoutysnakecase(s)` - Convert `s` to `SHOUTY_SNAKE_CASE`.
- `snakecase(s)` - Convert `s` to `snake_case`.
- `titlecase(s)` - Convert `s` to `Title Case`.
- `uppercamelcase(s)` - Convert `s` to `UpperCamelCase`.
- `uppercase(s)` - Convert `s` to uppercase.
#### Path Manipulation
##### Fallible
- `absolute_path(path)` - Absolute path to relative `path` in the working directory. `absolute_path("./bar.txt")` in directory `/foo` is `/foo/bar.txt`.
- `extension(path)` - Extension of `path`. `extension("/foo/bar.txt")` is `txt`.
- `file_name(path)` - File name of `path` with any leading directory components removed. `file_name("/foo/bar.txt")` is `bar.txt`.
- `file_stem(path)` - File name of `path` without extension. `file_stem("/foo/bar.txt")` is `bar`.
- `parent_directory(path)` - Parent directory of `path`. `parent_directory("/foo/bar.txt")` is `/foo`.
- `without_extension(path)` - `path` without extension. `without_extension("/foo/bar.txt")` is `/foo/bar`.
- `absolute_path(path)` - Absolute path to relative `path` in the working directory. `absolute_path("./bar.txt")` in directory `/foo` is `/foo/bar.txt`.
- `extension(path)` - Extension of `path`. `extension("/foo/bar.txt")` is `txt`.
- `file_name(path)` - File name of `path` with any leading directory components removed. `file_name("/foo/bar.txt")` is `bar.txt`.
- `file_stem(path)` - File name of `path` without extension. `file_stem("/foo/bar.txt")` is `bar`.
- `parent_directory(path)` - Parent directory of `path`. `parent_directory("/foo/bar.txt")` is `/foo`.
- `without_extension(path)` - `path` without extension. `without_extension("/foo/bar.txt")` is `/foo/bar`.
These functions can fail, for example if a path does not have an extension, which will halt execution.
##### Infallible
- `clean(path)` - Simplify `path` by removing extra path separators, intermediate `.` components, and `..` where possible. `clean("foo//bar")` is `foo/bar`, `clean("foo/..")` is `.`, `clean("foo/./bar")` is `foo/bar`.
- `join(a, b…)` - _This function uses `/` on Unix and `\` on [Windows](../../windows/Windows.md), which can be lead to unwanted behavior. The `/` operator, e.g., `a / b`, which always uses `/`, should be considered as a replacement unless `\`s are specifically desired on [Windows](../../windows/Windows.md)._ Join path `a` with path `b`. `join("foo/bar", "baz")` is `foo/bar/baz`. Accepts two or more arguments.
- `clean(path)` - Simplify `path` by removing extra path separators, intermediate `.` components, and `..` where possible. `clean("foo//bar")` is `foo/bar`, `clean("foo/..")` is `.`, `clean("foo/./bar")` is `foo/bar`.
- `join(a, b…)` - _This function uses `/` on Unix and `\` on [Windows](../../windows/Windows.md), which can be lead to unwanted behavior. The `/` operator, e.g., `a / b`, which always uses `/`, should be considered as a replacement unless `\`s are specifically desired on [Windows](../../windows/Windows.md)._ Join path `a` with path `b`. `join("foo/bar", "baz")` is `foo/bar/baz`. Accepts two or more arguments.
#### Filesystem Access
- `path_exists(path)` - Returns `true` if the path points at an existing entity and `false` otherwise. Traverses symbolic links, and returns `false` if the path is inaccessible or points to a broken symlink.
- `path_exists(path)` - Returns `true` if the path points at an existing entity and `false` otherwise. Traverses symbolic links, and returns `false` if the path is inaccessible or points to a broken symlink.
#### Error Reporting
- `error(message)` - Abort execution and report error `message` to user.
- `error(message)` - Abort execution and report error `message` to user.
#### UUID and Hash Generation
- `sha256(string)` - Return the [SHA](../../cryptography/SHA.md)-256 hash of `string` as a hexadecimal string.
- `sha256_file(path)` - Return the [SHA](../../cryptography/SHA.md)-256 hash of the file at `path` as a hexadecimal string.
- `uuid()` - Return a randomly generated UUID.
- `sha256(string)` - Return the [SHA](../../cryptography/SHA.md)-256 hash of `string` as a hexadecimal string.
- `sha256_file(path)` - Return the [SHA](../../cryptography/SHA.md)-256 hash of the file at `path` as a hexadecimal string.
- `uuid()` - Return a randomly generated UUID.
### Recipe Attributes
Recipes may be annotated with attributes that change their behavior.
@ -546,7 +546,7 @@ Recipes may be annotated with attributes that change their behavior.
| `[macos]` | Enable recipe on [MacOS](../../macos/macOS.md). |
| `[unix]` | Enable recipe on Unixes. (Includes [MacOS](../../macos/macOS.md)). |
| `[windows]` | Enable recipe on [Windows](../../windows/Windows.md). |
| `[private]`1 | See Private Recipes. |
| `[private]`1 | See Private Recipes. |
A recipe can have multiple attributes, either on multiple lines:
```just
@ -564,9 +564,9 @@ foo:
```
#### Enabling and Disabling Recipes
The `[linux]`, `[macos]`, `[unix]`, and `[windows]` attributes are configuration attributes. By default, recipes are always enabled. A recipe with one or more configuration attributes will only be enabled when one or more of those configurations is active.
The `[linux]`, `[macos]`, `[unix]`, and `[windows]` attributes are configuration attributes. By default, recipes are always enabled. A recipe with one or more configuration attributes will only be enabled when one or more of those configurations is active.
This can be used to write `justfile`s that behave differently depending on which operating system they run on. The `run` recipe in this `justfile` will compile and run `main.c`, using a different C compiler and using the correct output binary name for that compiler depending on the operating system:
This can be used to write `justfile`s that behave differently depending on which operating system they run on. The `run` recipe in this `justfile` will compile and run `main.c`, using a different C compiler and using the correct output binary name for that compiler depending on the operating system:
```just
[unix]
@ -581,9 +581,9 @@ run:
```
#### Disabling Changing Directory
`just` normally executes recipes with the current directory set to the directory that contains the `justfile`. This can be disabled using the `[no-cd]` attribute. This can be used to create recipes which use paths relative to the invocation directory, or which operate on the current directory.
`just` normally executes recipes with the current directory set to the directory that contains the `justfile`. This can be disabled using the `[no-cd]` attribute. This can be used to create recipes which use paths relative to the invocation directory, or which operate on the current directory.
For example, this `commit` recipe:
For example, this `commit` recipe:
```just
[no-cd]
commit file:
@ -591,7 +591,7 @@ commit file:
git commit
```
Can be used with paths that are relative to the current directory, because `[no-cd]` prevents `just` from changing the current directory when executing `commit`.
Can be used with paths that are relative to the current directory, because `[no-cd]` prevents `just` from changing the current directory when executing `commit`.
### Command Evaluation Using Backticks
Backticks can be used to store the result of commands:
@ -612,7 +612,7 @@ stuff := ```
</code></pre>
### Conditional Expressions
`if`/`else` expressions evaluate different branches depending on if two expressions evaluate to the same value:
`if`/`else` expressions evaluate different branches depending on if two expressions evaluate to the same value:
```just
foo := if "2" == "2" { "Good!" } else { "1984" }
@ -651,7 +651,7 @@ $ just bar
match
```
Regular expressions are provided by the [regex crate](https://github.com/rust-lang/regex), whose syntax is documented on [docs.rs](https://docs.rs/regex/1.5.4/regex/#syntax). Since regular expressions commonly use backslash escape sequences, consider using single-quoted string literals, which will pass slashes to the regex parser unmolested.
Regular expressions are provided by the [regex crate](https://github.com/rust-lang/regex), whose syntax is documented on [docs.rs](https://docs.rs/regex/1.5.4/regex/#syntax). Since regular expressions commonly use backslash escape sequences, consider using single-quoted string literals, which will pass slashes to the regex parser unmolested.
Conditional expressions short-circuit, which means they only evaluate one of their branches. This can be used to make sure that backtick expressions don't run when they shouldn't.
```just
@ -664,7 +664,7 @@ bar foo:
echo {{ if foo == "bar" { "hello" } else { "goodbye" } }}
```
> Note the space after the final `}`! Without the space, the interpolation will be prematurely closed.
> Note the space after the final `}`! Without the space, the interpolation will be prematurely closed.
Multiple conditionals can be chained:
```just
@ -686,7 +686,7 @@ abc
```
### Stopping execution with error
Execution can be halted with the `error` function. For example:
Execution can be halted with the `error` function. For example:
```just
foo := if "hello" == "goodbye" {
"xyz"
@ -722,14 +722,14 @@ $ just
./test --test linux
```
Any number of arguments of the form `NAME=VALUE` can be passed before recipes:
Any number of arguments of the form `NAME=VALUE` can be passed before recipes:
```shell
$ just os=plan9
./build plan9
./test --test plan9
```
Or you can use the `--set` flag:
Or you can use the `--set` flag:
```shell
$ just --set os bsd
./build bsd
@ -737,8 +737,8 @@ $ just --set os bsd
```
### Getting and Setting [Environment Variables](../../linux/Environment%20Variables.md)
#### Exporting `just` Variables
Assignments prefixed with the `export` keyword will be exported to recipes as [environment variables](../../linux/Environment%20Variables.md):
#### Exporting `just` Variables
Assignments prefixed with the `export` keyword will be exported to recipes as [environment variables](../../linux/Environment%20Variables.md):
```just
export RUST_BACKTRACE := "1"
@ -747,7 +747,7 @@ test:
cargo test
```
Parameters prefixed with a `$` will be exported as [environment variables](../../linux/Environment%20Variables.md):
Parameters prefixed with a `$` will be exported as [environment variables](../../linux/Environment%20Variables.md):
```just
test $RUST_BACKTRACE="1":
# will print a stack trace if it crashes
@ -767,7 +767,7 @@ a $A $B=`echo $A`:
echo $A $B
```
When `export` is set, all `just` variables are exported as [environment variables](../../linux/Environment%20Variables.md).
When `export` is set, all `just` variables are exported as [environment variables](../../linux/Environment%20Variables.md).
#### Getting [Environment Variables](../../linux/Environment%20Variables.md) from the environment
[Environment variables](../../linux/Environment%20Variables.md) from the environment are passed automatically to the recipes.
@ -782,11 +782,11 @@ $ just
HOME is '/home/myuser'
```
#### Setting `just` Variables from [Environment Variables](../../linux/Environment%20Variables.md)
[Environment variables](../../linux/Environment%20Variables.md) can be propagated to `just` variables using the functions `env_var()` and `env_var_or_default()`.
#### Setting `just` Variables from [Environment Variables](../../linux/Environment%20Variables.md)
[Environment variables](../../linux/Environment%20Variables.md) can be propagated to `just` variables using the functions `env_var()` and `env_var_or_default()`.
### Recipe Parameters
Recipes may have parameters. Here recipe `build` has a parameter called `target`:
Recipes may have parameters. Here recipe `build` has a parameter called `target`:
```just
build target:
@echo 'Building {{target}}…'
@ -860,13 +860,13 @@ test triple=(arch + "-unknown-unknown") input=(arch / "input.dat"):
./test {{triple}}
```
The last parameter of a recipe may be variadic, indicated with either a `+` or a `*` before the argument name:
The last parameter of a recipe may be variadic, indicated with either a `+` or a `*` before the argument name:
```just
backup +FILES:
scp {{FILES}} me@server.com:
```
Variadic parameters prefixed with `+` accept _one or more_ arguments and expand to a string containing those arguments separated by spaces:
Variadic parameters prefixed with `+` accept _one or more_ arguments and expand to a string containing those arguments separated by spaces:
```shell
$ just backup FAQ.md GRAMMAR.md
scp FAQ.md GRAMMAR.md me@server.com:
@ -874,7 +874,7 @@ FAQ.md 100% 1831 1.8KB/s 00:00
GRAMMAR.md 100% 1666 1.6KB/s 00:00
```
Variadic parameters prefixed with `*` accept _zero or more_ arguments and expand to a string containing those arguments separated by spaces, or an empty string if no arguments are present:
Variadic parameters prefixed with `*` accept _zero or more_ arguments and expand to a string containing those arguments separated by spaces, or an empty string if no arguments are present:
```just
commit MESSAGE *FLAGS:
git commit {{FLAGS}} -m "{{MESSAGE}}"
@ -886,7 +886,7 @@ test +FLAGS='-q':
cargo test {{FLAGS}}
```
`{{…}}` substitutions may need to be quoted if they contain spaces. For example, if you have the following recipe:
`{{…}}` substitutions may need to be quoted if they contain spaces. For example, if you have the following recipe:
```just
search QUERY:
lynx https://www.google.com/?q={{QUERY}}
@ -897,7 +897,7 @@ And you type:
$ just search "cat toupee"
```
`just` will run the command `lynx https://www.google.com/?q=cat toupee`, which will get parsed by `sh` as `lynx`, `https://www.google.com/?q=cat`, and `toupee`, and not the intended `lynx` and `https://www.google.com/?q=cat toupee`.
`just` will run the command `lynx https://www.google.com/?q=cat toupee`, which will get parsed by `sh` as `lynx`, `https://www.google.com/?q=cat`, and `toupee`, and not the intended `lynx` and `https://www.google.com/?q=cat toupee`.
You can fix this by adding quotes:
```just
@ -905,7 +905,7 @@ search QUERY:
lynx 'https://www.google.com/?q={{QUERY}}'
```
Parameters prefixed with a `$` will be exported as [environment variables](../../linux/Environment%20Variables.md):
Parameters prefixed with a `$` will be exported as [environment variables](../../linux/Environment%20Variables.md):
```just
foo $bar:
echo $bar
@ -914,7 +914,7 @@ foo $bar:
### Running Recipes at the End of a Recipe
Normal dependencies of a recipes always run before a recipe starts. That is to say, the dependee always runs before the depender. These dependencies are called "prior dependencies".
A recipe can also have subsequent dependencies, which run after the recipe and are introduced with an `&&`:
A recipe can also have subsequent dependencies, which run after the recipe and are introduced with an `&&`:
```just
a:
echo 'A!'
@ -929,7 +929,7 @@ d:
echo 'D!'
```
…running _b_ prints:
…running _b_ prints:
```shell
$ just b
echo 'A!'
@ -943,7 +943,7 @@ D!
```
### Running Recipes in the Middle of a Recipe
`just` doesn't support running recipes in the middle of another recipe, but you can call `just` recursively in the middle of a recipe. Given the following `justfile`:
`just` doesn't support running recipes in the middle of another recipe, but you can call `just` recursively in the middle of a recipe. Given the following `justfile`:
```just
a:
echo 'A!'
@ -957,7 +957,7 @@ c:
echo 'C!'
```
…running _b_ prints:
…running _b_ prints:
```shell
$ just b
echo 'A!'
@ -970,10 +970,10 @@ echo 'B end!'
B end!
```
This has limitations, since recipe `c` is run with an entirely new invocation of `just`: Assignments will be recalculated, dependencies might run twice, and command line arguments will not be propagated to the child `just` process.
This has limitations, since recipe `c` is run with an entirely new invocation of `just`: Assignments will be recalculated, dependencies might run twice, and command line arguments will not be propagated to the child `just` process.
### Writing Recipes in Other Languages
Recipes that start with `#!` are called shebang recipes, and are executed by saving the recipe body to a file and running it. This lets you write recipes in different languages:
Recipes that start with `#!` are called shebang recipes, and are executed by saving the recipe body to a file and running it. This lets you write recipes in different languages:
```just
polyglot: python js perl sh ruby nu
@ -1014,14 +1014,14 @@ Hola from a nushell script!
Hello from ruby!
```
On Unix-like operating systems, including [Linux](../../linux/Linux.md) and [MacOS](../../macos/macOS.md), shebang recipes are executed by saving the recipe body to a file in a temporary directory, marking the file as executable, and executing it. The OS then parses the shebang line into a command line and invokes it, including the path to the file. For example, if a recipe starts with `#!/usr/bin/env bash`, the final command that the OS runs will be something like `/usr/bin/env bash /tmp/PATH_TO_SAVED_RECIPE_BODY`. Keep in mind that different operating systems split shebang lines differently.
On Unix-like operating systems, including [Linux](../../linux/Linux.md) and [MacOS](../../macos/macOS.md), shebang recipes are executed by saving the recipe body to a file in a temporary directory, marking the file as executable, and executing it. The OS then parses the shebang line into a command line and invokes it, including the path to the file. For example, if a recipe starts with `#!/usr/bin/env bash`, the final command that the OS runs will be something like `/usr/bin/env bash /tmp/PATH_TO_SAVED_RECIPE_BODY`. Keep in mind that different operating systems split shebang lines differently.
[Windows](../../windows/Windows.md) does not support shebang lines. On [Windows](../../windows/Windows.md), `just` splits the shebang line into a command and arguments, saves the recipe body to a file, and invokes the split command and arguments, adding the path to the saved recipe body as the final argument.
[Windows](../../windows/Windows.md) does not support shebang lines. On [Windows](../../windows/Windows.md), `just` splits the shebang line into a command and arguments, saves the recipe body to a file, and invokes the split command and arguments, adding the path to the saved recipe body as the final argument.
### Multi-Line Constructs
Recipes without an initial shebang are evaluated and run line-by-line, which means that multi-line constructs probably won't do what you want.
For example, with the following `justfile`:
For example, with the following `justfile`:
```makefile
conditional:
if true; then
@ -1029,7 +1029,7 @@ conditional:
fi
```
The extra leading whitespace before the second line of the `conditional` recipe will produce a parse error:
The extra leading whitespace before the second line of the `conditional` recipe will produce a parse error:
```shell
$ just conditional
error: Recipe line has extra leading whitespace
@ -1040,7 +1040,7 @@ error: Recipe line has extra leading whitespace
To work around this, you can write conditionals on one line, escape newlines with slashes, or add a shebang to your recipe. Some examples of multi-line constructs are provided for reference.
#### `if` statements
#### `if` statements
```just
conditional:
if true; then echo 'True!'; fi
@ -1061,7 +1061,7 @@ conditional:
fi
```
#### `for` loops
#### `for` loops
```just
for:
for file in `ls .`; do echo $file; done
@ -1082,7 +1082,7 @@ for:
done
```
#### `while` loops
#### `while` loops
```just
while:
while `server-is-dead`; do ping -c 1 server; done
@ -1104,7 +1104,7 @@ while:
```
### Private Recipes
Recipes and aliases whose name starts with a `_` are omitted from `just --list`:
Recipes and aliases whose name starts with a `_` are omitted from `just --list`:
```just
test: _test-helper
./bin/test
@ -1119,7 +1119,7 @@ Available recipes:
test
```
The `[private]` attribute may also be used to hide recipes or aliases without needing to change the name:
The `[private]` attribute may also be used to hide recipes or aliases without needing to change the name:
```just
[private]
foo:

36
technology/applications/cli/micro.md
View file

@ -5,7 +5,7 @@ repo: https://github.com/zyedidia/micro
website: https://micro-editor.github.io/
---
# micro
**micro** is a terminal-based text editor that aims to be easy to use and intuitive, while also taking advantage of the capabilities of modern terminals. It comes as a single, batteries-included, static binary with no dependencies; you can download and use it right now!
**micro** is a terminal-based text editor that aims to be easy to use and intuitive, while also taking advantage of the capabilities of modern terminals. It comes as a single, batteries-included, static binary with no dependencies; you can download and use it right now!
As its name indicates, micro aims to be somewhat of a successor to the nano editor by being easy to install and use. It strives to be enjoyable as a full-time editor for people who prefer to work in a terminal, or those who regularly edit files over [SSH](../network/SSH.md).
@ -283,30 +283,30 @@ MouseWheelRight
```
# Commands
Micro provides the following commands that can be executed at the command-bar by pressing `Ctrl-e` and entering the command. Arguments are placed in single quotes here but these are not necessary when entering the command in micro.
Micro provides the following commands that can be executed at the command-bar by pressing `Ctrl-e` and entering the command. Arguments are placed in single quotes here but these are not necessary when entering the command in micro.
- `bind 'key' 'action'`: creates a keybinding from key to action. See the `keybindings` documentation for more information about binding keys. This command will modify `bindings.json` and overwrite any bindings to `key` that already exist.
- `help 'topic'?`: opens the corresponding help topic. If no topic is provided opens the default help screen. Help topics are stored as `.md` files in the `runtime/help` directory of the source tree, which is embedded in the final binary.
- `bind 'key' 'action'`: creates a keybinding from key to action. See the `keybindings` documentation for more information about binding keys. This command will modify `bindings.json` and overwrite any bindings to `key` that already exist.
- `help 'topic'?`: opens the corresponding help topic. If no topic is provided opens the default help screen. Help topics are stored as `.md` files in the `runtime/help` directory of the source tree, which is embedded in the final binary.
- `save 'filename'?`: saves the current buffer. If the file is provided it will 'save as' the filename.
- `quit`: quits micro.
- `goto 'line'`: jumps to the given line number. A negative number can be passed to jump inward from the end of the file; for example, -5 jumps to the 5th-last line in the file.
- `replace 'search' 'value' 'flags'?`: This will replace `search` with `value`. The `flags` are optional. Possible flags are:
- `replace 'search' 'value' 'flags'?`: This will replace `search` with `value`. The `flags` are optional. Possible flags are:
- `-a`: Replace all occurrences at once
- `-l`: Do a literal search instead of a [regex](../../tools/Regex.md) search
Note that `search` must be a valid [regex](../../tools/Regex.md) (unless `-l` is passed). If one of the arguments does not have any spaces in it, you may omit the quotes.
- `replaceall 'search' 'value'`: this will replace all occurrences of `search` with `value` without user confirmation.
See `replace` command for more information.
- `set 'option' 'value'`: sets the option to value. See the `options` help topic for a list of options you can set. This will modify your `settings.json` with the new value.
- `setlocal 'option' 'value'`: sets the option to value locally (only in the current buffer). This will _not_ modify `settings.json`.
Note that `search` must be a valid [regex](../../tools/Regex.md) (unless `-l` is passed). If one of the arguments does not have any spaces in it, you may omit the quotes.
- `replaceall 'search' 'value'`: this will replace all occurrences of `search` with `value` without user confirmation.
See `replace` command for more information.
- `set 'option' 'value'`: sets the option to value. See the `options` help topic for a list of options you can set. This will modify your `settings.json` with the new value.
- `setlocal 'option' 'value'`: sets the option to value locally (only in the current buffer). This will _not_ modify `settings.json`.
- `show 'option'`: shows the current value of the given option.
- `run 'sh-command'`: runs the given [shell](Shell.md) command in the background. The command's output will be displayed in one line when it finishes running.
- `vsplit 'filename'`: opens a vertical split with `filename`. If no filename is provided, a vertical split is opened with an empty buffer.
- `hsplit 'filename'`: same as `vsplit` but opens a horizontal split instead of a vertical split.
- `vsplit 'filename'`: opens a vertical split with `filename`. If no filename is provided, a vertical split is opened with an empty buffer.
- `hsplit 'filename'`: same as `vsplit` but opens a horizontal split instead of a vertical split.
- `tab 'filename'`: opens the given file in a new tab.
- `tabmove '[-+]?n'`: Moves the active tab to another slot. `n` is an integer. If `n` is prefixed with `-` or `+`, then it represents a relative position (e.g. `tabmove +2` moves the tab to the right by `2`). If `n` has no prefix, it represents an absolute position (e.g. `tabmove 2` moves the tab to slot `2`).
- `tabswitch 'tab'`: This command will switch to the specified tab. The `tab` can either be a tab number, or a name of a tab.
- `textfilter 'sh-command'`: filters the current selection through a [shell](Shell.md) command as standard input and replaces the selection with the stdout of the [shell](Shell.md) command. For example, to sort a list of numbers, first select them, and then execute `> textfilter sort -n`.
- `tabmove '[-+]?n'`: Moves the active tab to another slot. `n` is an integer. If `n` is prefixed with `-` or `+`, then it represents a relative position (e.g. `tabmove +2` moves the tab to the right by `2`). If `n` has no prefix, it represents an absolute position (e.g. `tabmove 2` moves the tab to slot `2`).
- `tabswitch 'tab'`: This command will switch to the specified tab. The `tab` can either be a tab number, or a name of a tab.
- `textfilter 'sh-command'`: filters the current selection through a [shell](Shell.md) command as standard input and replaces the selection with the stdout of the [shell](Shell.md) command. For example, to sort a list of numbers, first select them, and then execute `> textfilter sort -n`.
- `log`: opens a log of all messages and debug statements.
- `plugin list`: lists all installed plugins.
- `plugin install 'pl'`: install a plugin.
@ -315,13 +315,13 @@ Micro provides the following commands that can be executed at the command-bar by
- `plugin search 'pl'`: search available plugins for a keyword.
- `plugin available`: show available plugins that can be installed.
- `reload`: reloads all runtime files.
- `cd 'path'`: Change the working directory to the given `path`.
- `cd 'path'`: Change the working directory to the given `path`.
- `pwd`: Print the current working directory.
- `open 'filename'`: Open a file in the current buffer.
- `reset 'option'`: resets the given option to its default value
- `retab`: Replaces all leading tabs with spaces or leading spaces with tabs depending on the value of `tabstospaces`.
- `retab`: Replaces all leading tabs with spaces or leading spaces with tabs depending on the value of `tabstospaces`.
- `raw`: micro will open a new tab and show the escape sequence for every event it receives from the terminal. This shows you what micro actually sees from the terminal and helps you see which bindings aren't possible and why. This is most useful for debugging keybindings.
- `showkey`: Show the action(s) bound to a given key. For example running `> showkey Ctrl-c` will display `Copy`.
- `showkey`: Show the action(s) bound to a given key. For example running `> showkey Ctrl-c` will display `Copy`.
- `term exec?`: Open a terminal emulator running the given executable. If no executable is given, this will open the default [shell](Shell.md) in the terminal emulator.
## Settings

2
technology/applications/cli/network/aria2.md
View file

@ -24,7 +24,7 @@ aria2c [<OPTIONS>] [<URI>|<MAGNET>|<TORRENT_FILE>|<METALINK_FILE>]
| `-V, --check-integrity [true/false]` | Check file integrity by validating piece hashes or a hash of entire file. This option has effect only in [BitTorrent](../../../internet/BitTorrent.md), Metalink downloads with checksums or [HTTP](../../../internet/HTTP.md)(S)/[FTP](../../../internet/FTP.md) downloads with --checksum option. If piece hashes are provided, this option can detect damaged portions of a file and re-download them. If a hash of entire file is provided, hash check is only done when file has been already download. This is determined by file length. If hash check fails, file is re-downloaded from scratch. If both piece hashes and a hash of entire file are provided, only piece hashes are used. Default: false |
| `-c, --continue [true/false]` | Continue downloading a partially downloaded file. Use this option to resume a download started by a web browser or another program which downloads files sequentially from the beginning. Currently this option is only applicable to [HTTP](../../../internet/HTTP.md)(S)/[FTP](../../../internet/FTP.md) downloads. |
| `--checksum=<TYPE>=<DIGEST>` | Set checksum. TYPE is hash type. The supported hash type is listed in Hash Algorithms in aria2c -v. DIGEST is hex digest. For example, setting sha-1 digest looks like this: `sha-1=0192ba11326fe2298c8cb4de616f4d4140213838` This option applies only to [HTTP](../../../internet/HTTP.md)(S)/[FTP](../../../internet/FTP.md) downloads. |
| `-x, --max-connection-per-server=<NUM>` | The maximum number of connections to one server for each download.  Default: **1** |
| `-x, --max-connection-per-server=<NUM>` | The maximum number of connections to one server for each download. Default: **1** |
| `-k, --min-split-size=<SIZE>` | aria2 does not split less than 2\*SIZE byte range. For example, let's consider downloading 20MiB file. If SIZE is 10M, aria2 can split file into 2 range (0-10MiB) and (10MiB-20MiB) and download it using 2 sources(if --split >= 2, of course). If SIZE is 15M, since 2\*15M > 20MiB, aria2 does not split file and download it using 1 source. You can append K or M (1K = 1024, 1M = 1024K). Possible Values: 1M -1024M Default: 20M |
| `-o, --out=<FILE>` | The file name of the downloaded file. It is always relative to the directory given in `--dir` option. |
| `-s, --split=<N>` | Download a file using N connections. If more than N URIs are given, first N URIs are used and remaining URIs are used for backup. If less than N URIs are given, those URIs are used more than once so that N connections total are made simultaneously. The number of connections to the same host is restricted by the `--max-connection-per-server` option. See also the `--min-split-size` option. Default: 5 |

16
technology/applications/cli/network/netcat.md
View file

@ -4,7 +4,7 @@ wiki: https://en.wikipedia.org/wiki/Netcat
---
# netcat
The `nc` (or `netcat`) utility is used for just about anything under the sun involving [TCP](../../../internet/TCP.md), [UDP](../../../internet/UDP.md), or UNIX-domain sockets. It can open [TCP](../../../internet/TCP.md) connections, send [UDP](../../../internet/UDP.md) packets, listen on arbitrary [TCP](../../../internet/TCP.md) and [UDP](../../../internet/UDP.md) ports, do port scanning, and deal with both IPv4 and IPv6.
The `nc` (or `netcat`) utility is used for just about anything under the sun involving [TCP](../../../internet/TCP.md), [UDP](../../../internet/UDP.md), or UNIX-domain sockets. It can open [TCP](../../../internet/TCP.md) connections, send [UDP](../../../internet/UDP.md) packets, listen on arbitrary [TCP](../../../internet/TCP.md) and [UDP](../../../internet/UDP.md) ports, do port scanning, and deal with both IPv4 and IPv6.
Common uses include:
- simple [TCP](../../../internet/TCP.md) proxies
@ -19,32 +19,32 @@ Common uses include:
| `-6` | Use IPv6 addresses only |
| `-b` | Allow broadcast |
| `-l` | Listen for an incoming connection rather than initiating a connection to a remote host |
| `-N` | shutdown the network socket after EOF on the input. Some servers require this to finish their work |
| `-p <source_port>` | Specify the source port `nc` should use, subject to privilege restrictions and availability |
| `-N` | shutdown the network socket after EOF on the input. Some servers require this to finish their work |
| `-p <source_port>` | Specify the source port `nc` should use, subject to privilege restrictions and availability |
## Examples
### Client/Server Model
On one console, start `nc` listening on a specific port for a connection. For example:
On one console, start `nc` listening on a specific port for a connection. For example:
```shell
nc -l 1234
```
`nc` is now listening on port 1234 for a connection. On a second console (or a second machine), connect to the machine and port being listened on:
`nc` is now listening on port 1234 for a connection. On a second console (or a second machine), connect to the machine and port being listened on:
```shell
nc -N 127.0.0.1 1234
```
There should now be a connection between the ports. Anything typed at the second console will be concatenated to the first, and vice-versa. After the connection has been set up, `nc` does not really care which side is being used as a ‘server’ and which side is being used as a ‘client’. The connection may be terminated using an `EOF` (`^D`), as the `-N` flag was given.
There should now be a connection between the ports. Anything typed at the second console will be concatenated to the first, and vice-versa. After the connection has been set up, `nc` does not really care which side is being used as a ‘server’ and which side is being used as a ‘client’. The connection may be terminated using an `EOF` (`^D`), as the `-N` flag was given.
### Data Transfer
The example in the previous section can be expanded to build a basic data transfer model. Any information input into one end of the connection will be output to the other end, and input and output can be easily captured in order to emulate file transfer.
Start by using `nc` to listen on a specific port, with output captured into a file:
Start by using `nc` to listen on a specific port, with output captured into a file:
```shell
nc -l 1234 > filename.out
```
Using a second machine, connect to the listening `nc` process, feeding it the file which is to be transferred:
Using a second machine, connect to the listening `nc` process, feeding it the file which is to be transferred:
```shell
nc -N host.example.com 1234 < filename.in
```

42
technology/applications/cli/network/wget.md
View file

@ -17,7 +17,7 @@ Wget has been designed for robustness over slow or unstable network connections;
| Option | Description |
| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-b, --background` | Go to background immediately after startup. If no output file is specified via the -o, output is redirected to wget-log. |
| `-e, --execute command` | Execute  command  as  if  it were a part of .wgetrc.  A command thus invoked will be executed after the commands in .wgetrc, thus taking precedence over them.  If you need to specify more than one wgetrc command, use multiple instances of -e. |
| `-e, --execute command` | Execute command as if it were a part of .wgetrc. A command thus invoked will be executed after the commands in .wgetrc, thus taking precedence over them. If you need to specify more than one wgetrc command, use multiple instances of -e. |
### Logging Options
| Option | Description |
@ -25,48 +25,48 @@ Wget has been designed for robustness over slow or unstable network connections;
| `-o, --output-file=logfile` | Log all messages to logfile. The messages are normally reported to standard error. |
| `-a, --append-output=logfile` | Append to logfile. This is the same as -o, only it appends to logfile instead of overwriting the old log file. |
| `-q, --quiet` | Turn off Wget's output. |
| `-i, --input-file=file` | Read URLs from a local or external file.  If - is specified as file, URLs are read from the standard input.  (Use ./- to read from a file literally named -.). If this function is used, no URLs need be present on the command line.  If there are URLs both on the command line and in an input file, those on the command lines will be the first ones to be retrieved. If --force-html is not specified, then file should consist of a series of URLs, one per line. However, if you specify --force-html, the document will be regarded as [html](../../../internet/HTML.md).  In that case you may have problems with relative links, which you can solve either by adding "\<base href="url">" to the documents or by specifying --base=url on the command line. If the file is an external one, the document will be automatically treated as [html](../../../internet/HTML.md) if the Content-Type matches text/html. Furthermore, the file's location will be implicitly used as base href if none was specified. |
| `-B, --base=URL` | Resolves relative links using URL as the point of reference, when reading links from an [HTML](../../../internet/HTML.md) file specified via the -i/--input-file option (together with --force-html, or when the input file was fetched remotely from a server describing it as [HTML](../../../internet/HTML.md)). This is equivalent to the presence of a "BASE" tag in the [HTML](../../../internet/HTML.md) input file, with URL as the value for the "href" attribute. |
| `-i, --input-file=file` | Read URLs from a local or external file. If - is specified as file, URLs are read from the standard input. (Use ./- to read from a file literally named -.). If this function is used, no URLs need be present on the command line. If there are URLs both on the command line and in an input file, those on the command lines will be the first ones to be retrieved. If --force-html is not specified, then file should consist of a series of URLs, one per line. However, if you specify --force-html, the document will be regarded as [html](../../../internet/HTML.md). In that case you may have problems with relative links, which you can solve either by adding "\<base href="url">" to the documents or by specifying --base=url on the command line. If the file is an external one, the document will be automatically treated as [html](../../../internet/HTML.md) if the Content-Type matches text/html. Furthermore, the file's location will be implicitly used as base href if none was specified. |
| `-B, --base=URL` | Resolves relative links using URL as the point of reference, when reading links from an [HTML](../../../internet/HTML.md) file specified via the -i/--input-file option (together with --force-html, or when the input file was fetched remotely from a server describing it as [HTML](../../../internet/HTML.md)). This is equivalent to the presence of a "BASE" tag in the [HTML](../../../internet/HTML.md) input file, with URL as the value for the "href" attribute. |
### Download Options
| Option | Description |
| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-t, --tries=number` | Set number of tries to number. Specify 0 or inf for infinite retrying.  The default is to retry 20 times, with the exception of fatal errors like "connection refused" or "not found" (404), which are not retried. |
| `-O, --output-document=file` | The documents will not be written to the appropriate files, but all will be concatenated together and written to file.  If - is used as file, documents will be printed to standard output, disabling link conversion.  (Use ./- to print to a file literally named -.) |
| `--backups=backups` | Before (over)writing a file, back up an existing file by adding a .1 suffix (\_1 on VMS) to the file name.  Such backup files are rotated to .2, .3, and so on, up to `backups` (and lost beyond that) |
| `-c, --continue` | Continue  getting  a  partially-downloaded file.  This is useful when you want to finish up a download started by a previous instance of Wget, or by another program. |
| `-t, --tries=number` | Set number of tries to number. Specify 0 or inf for infinite retrying. The default is to retry 20 times, with the exception of fatal errors like "connection refused" or "not found" (404), which are not retried. |
| `-O, --output-document=file` | The documents will not be written to the appropriate files, but all will be concatenated together and written to file. If - is used as file, documents will be printed to standard output, disabling link conversion. (Use ./- to print to a file literally named -.) |
| `--backups=backups` | Before (over)writing a file, back up an existing file by adding a .1 suffix (\_1 on VMS) to the file name. Such backup files are rotated to .2, .3, and so on, up to `backups` (and lost beyond that) |
| `-c, --continue` | Continue getting a partially-downloaded file. This is useful when you want to finish up a download started by a previous instance of Wget, or by another program. |
| `--show-progress` | Force wget to display the progress bar in any verbosity. |
| `-T, --timeout=seconds` | Set the network timeout to `seconds` seconds. |
| `--limit-rate=amount` | Limit the download speed to amount bytes per second.  Amount may be expressed in bytes, kilobytes with the k suffix, or megabytes with the  m  suffix. For example, --limit-rate=20k will limit the retrieval rate to 20KB/s. This is useful when, for whatever reason, you don't want Wget to consume the entire available bandwidth. |
| `-w, --wait=seconds` | Wait the specified number of seconds between the retrievals. Use of this option is recommended, as it lightens the server load by making the requests less frequent. Instead of in seconds, the time can be specified in minutes using the "m" suffix, in hours using "h" suffix, or in days using "d" suffix. |
| `--waitretry=seconds` | If you don't want Wget to wait between every retrieval, but only between retries of failed downloads, you can use this option. Wget  will use linear backoff, waiting 1 second after the first failure on a given file, then waiting 2 seconds after the second failure on  that file, up to the maximum number of seconds you specify. |
| `--random-wait` | Some web sites may perform log analysis to identify retrieval programs such as Wget by looking for statistically significant  similarities in the time between requests. This option causes the time between requests to vary between 0.5 and 1.5 * wait seconds,  where wait was specified using the --wait option, in order to mask Wget's presence from such analysis. |
| `--limit-rate=amount` | Limit the download speed to amount bytes per second. Amount may be expressed in bytes, kilobytes with the k suffix, or megabytes with the m suffix. For example, --limit-rate=20k will limit the retrieval rate to 20KB/s. This is useful when, for whatever reason, you don't want Wget to consume the entire available bandwidth. |
| `-w, --wait=seconds` | Wait the specified number of seconds between the retrievals. Use of this option is recommended, as it lightens the server load by making the requests less frequent. Instead of in seconds, the time can be specified in minutes using the "m" suffix, in hours using "h" suffix, or in days using "d" suffix. |
| `--waitretry=seconds` | If you don't want Wget to wait between every retrieval, but only between retries of failed downloads, you can use this option. Wget will use linear backoff, waiting 1 second after the first failure on a given file, then waiting 2 seconds after the second failure on that file, up to the maximum number of seconds you specify. |
| `--random-wait` | Some web sites may perform log analysis to identify retrieval programs such as Wget by looking for statistically significant similarities in the time between requests. This option causes the time between requests to vary between 0.5 and 1.5 * wait seconds, where wait was specified using the --wait option, in order to mask Wget's presence from such analysis. |
| `--user=user, --password=password` | Specify the username and password for both [FTP](../../../internet/FTP.md) and [HTTP](../../../internet/HTTP.md) file retrieval. |
| `--ask-password` | Prompt for a password for each connection established. |
### Directory Options
| Option | Description |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-nH, --no-host-directories` | Disable generation of host-prefixed directories. By default, invoking Wget with -r http://fly.srk.fer.hr/ will create a structure of  directories beginning with fly.srk.fer.hr/. This option disables such behavior. |
| `-nH, --no-host-directories` | Disable generation of host-prefixed directories. By default, invoking Wget with -r http://fly.srk.fer.hr/ will create a structure of directories beginning with fly.srk.fer.hr/. This option disables such behavior. |
| `--cut-dirs=number` | Ignore number directory components. This is useful for getting a fine-grained control over the directory where recursive retrieval will be saved. |
| `-P, --directory-prefix=prefix` | Set directory prefix to prefix. The directory prefix is the directory where all other files and subdirectories will be saved to, i.e.  the top of the retrieval tree. The default is . (the current directory). |
| `-P, --directory-prefix=prefix` | Set directory prefix to prefix. The directory prefix is the directory where all other files and subdirectories will be saved to, i.e. the top of the retrieval tree. The default is . (the current directory). |
### HTTP Options
| Option | Description |
| ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--no-cookies` | Disable the use of cookies. |
| `--load-cookies file` | Load cookies from file before the first [HTTP](../../../internet/HTTP.md) retrieval.  file is a textual file in the format originally used by Netscape's  cookies.txt file. |
| `--load-cookies file` | Load cookies from file before the first [HTTP](../../../internet/HTTP.md) retrieval. file is a textual file in the format originally used by Netscape's cookies.txt file. |
| `--save-cookies file` | Save cookies to file before exiting. This will not save cookies that have expired or that have no expiry time (so-called "session cookies"), but also see --keep-session-cookies. |
| `--keep-session-cookies` | When specified, causes --save-cookies to also save session cookies. Session cookies are normally not saved because they are meant to be  kept in memory and forgotten when you exit the browser. Saving them is useful on sites that require you to log in or to visit the home  page before you can access some pages. With this option, multiple Wget runs are considered a single browser session as far as the site  is concerned. |
| `--header=header-line` | Send header-line along with the rest of the headers in each [HTTP](../../../internet/HTTP.md) request. The supplied header is sent as-is, which means it must  contain name and value separated by colon, and must not contain newlines. |
| `--proxy-user=user, --proxy-password=password` | Specify the username user and password password for authentication on a proxy server. Wget will encode them using the "basic"  authentication scheme. |
| `--referer=url` | Include 'Referer: url' header in [HTTP](../../../internet/HTTP.md) request. Useful for retrieving documents with server-side processing that assume they are always  being retrieved by interactive web browsers and only come out properly when Referer is set to one of the pages that point to them. |
| `--keep-session-cookies` | When specified, causes --save-cookies to also save session cookies. Session cookies are normally not saved because they are meant to be kept in memory and forgotten when you exit the browser. Saving them is useful on sites that require you to log in or to visit the home page before you can access some pages. With this option, multiple Wget runs are considered a single browser session as far as the site is concerned. |
| `--header=header-line` | Send header-line along with the rest of the headers in each [HTTP](../../../internet/HTTP.md) request. The supplied header is sent as-is, which means it must contain name and value separated by colon, and must not contain newlines. |
| `--proxy-user=user, --proxy-password=password` | Specify the username user and password password for authentication on a proxy server. Wget will encode them using the "basic" authentication scheme. |
| `--referer=url` | Include 'Referer: url' header in [HTTP](../../../internet/HTTP.md) request. Useful for retrieving documents with server-side processing that assume they are always being retrieved by interactive web browsers and only come out properly when Referer is set to one of the pages that point to them. |
| `-U, --user-agent=agent-string` | Identify as `agent-string` to the [HTTP](../../../internet/HTTP.md) server. |
### HTTPS Options
| Option | Description |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `--no-check-certificate` | Don't check the server certificate against the available certificate authorities. Also don't require the URL host name to match the  common name presented by the certificate. |
| `--no-check-certificate` | Don't check the server certificate against the available certificate authorities. Also don't require the URL host name to match the common name presented by the certificate. |
| `--ca-certificate=file` | Use file as the file with the bundle of certificate authorities ("CA") to verify the peers. The certificates must be in PEM format. |
| `--ca-directory=directory` | Specifies directory containing CA certificates in PEM format. |
@ -75,5 +75,5 @@ Wget has been designed for robustness over slow or unstable network connections;
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `-r, --recursive` | Turn on recursive retrieving. The default maximum depth is 5. |
| `-l, --level=depth` | Set the maximum number of subdirectories that Wget will recurse into to depth. |
| `-k, --convert-links` | After the download is complete, convert the links in the document to make them suitable for local viewing. This affects not only the  visible hyperlinks, but any part of the document that links to external content, such as embedded images, links to style sheets,  hyperlinks to non-[HTML](../../../internet/HTML.md) content, etc. |
| `-p, --page-requisites` | This option causes Wget to download all the files that are necessary to properly display a given [HTML](../../../internet/HTML.md) page. This includes such things  as inlined images, sounds, and referenced stylesheets. |
| `-k, --convert-links` | After the download is complete, convert the links in the document to make them suitable for local viewing. This affects not only the visible hyperlinks, but any part of the document that links to external content, such as embedded images, links to style sheets, hyperlinks to non-[HTML](../../../internet/HTML.md) content, etc. |
| `-p, --page-requisites` | This option causes Wget to download all the files that are necessary to properly display a given [HTML](../../../internet/HTML.md) page. This includes such things as inlined images, sounds, and referenced stylesheets. |

2
technology/applications/cli/patch.md
View file

@ -21,7 +21,7 @@ patch -i <dir> <patch-file>
## Options
| Option | Description |
| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-b, --backup` | Make backup files. That is, when patching a file, rename or copy the original instead of removing it.  When backing up a file that does not exist, an empty, unreadable backup file is created as a placeholder to represent the nonexistent file |
| `-b, --backup` | Make backup files. That is, when patching a file, rename or copy the original instead of removing it. When backing up a file that does not exist, an empty, unreadable backup file is created as a placeholder to represent the nonexistent file |
| `-d, --directory <dir>` | Change to the directory dir immediately, before doing anything else. |
| `--dry-run` | Print the results of applying the patches without actually changing any files |
| `-i, --input <patchfile>` | Read the patch from patchfile. If patchfile is -, read from standard input, the default |

22
technology/applications/cli/pueue.md
View file

@ -5,30 +5,30 @@ repo: https://github.com/nukesor/pueue
# pueue
Pueue is a command-line task management tool for sequential and parallel execution of long-running tasks.
Simply put, it's a tool that **p**rocesses a q**ueue** of [shell](Shell.md) commands. On top of that, there are a lot of convenient features and abstractions.
Simply put, it's a tool that **p**rocesses a q**ueue** of [shell](Shell.md) commands. On top of that, there are a lot of convenient features and abstractions.
Since Pueue is not bound to any terminal, you can control your tasks from any terminal on the same machine. The queue will be continuously processed, even if you no longer have any active [ssh](../network/SSH.md) sessions.
## Start the Daemon
Before you can use the `pueue` client, you have to start the daemon.
Before you can use the `pueue` client, you have to start the daemon.
**Local:** The daemon can be run in the current [shell](Shell.md). Just run `pueued` anywhere on your command line. It'll exit if you close the terminal, though.
**Local:** The daemon can be run in the current [shell](Shell.md). Just run `pueued` anywhere on your command line. It'll exit if you close the terminal, though.
**Background:** To fork and run `pueued` into the background, add the `-d` or `--daemonize` flag. E.g. `pueued -d`.
The daemon can always be shut down using the client command `pueue shutdown`.
**Background:** To fork and run `pueued` into the background, add the `-d` or `--daemonize` flag. E.g. `pueued -d`.
The daemon can always be shut down using the client command `pueue shutdown`.
### Systemd
[Systemd](../../linux/systemd/Systemd.md) user services allow every user to start/enable their own session on [Linux](../../linux/Linux.md) operating system distributions.
If you didn't install Pueue with a package manager, follow these instructions first:
1. download `pueued.service` from the GitHub Releases page;
2. place `pueued.service` in `/etc/systemd/user/` or `~/.config/systemd/user/`;
3. make sure the `pueued` binary is placed at `/usr/bin`, which is where `pueued.service` expects is to be.
1. download `pueued.service` from the GitHub Releases page;
2. place `pueued.service` in `/etc/systemd/user/` or `~/.config/systemd/user/`;
3. make sure the `pueued` binary is placed at `/usr/bin`, which is where `pueued.service` expects is to be.
Then, regardless of how you installed Pueue, run:
1. `systemctl --user start pueued`, to start the `pueued` service;
2. `systemctl --user enable pueued`, to run the `pueued` service at system startup;
3. `systemctl --user status pueued`, to ensure it is **active (running)**.
1. `systemctl --user start pueued`, to start the `pueued` service;
2. `systemctl --user enable pueued`, to run the `pueued` service at system startup;
3. `systemctl --user status pueued`, to ensure it is **active (running)**.
## Using pueue
Usage: `pueue <action> <options>`

2
technology/applications/cli/ripgrep.md
View file

@ -6,7 +6,7 @@ repo: https://github.com/BurntSushi/ripgrep
---
# ripgrep
ripgrep is a line-oriented search tool that recursively searches the current directory for a [regex](../../tools/Regex.md) pattern. By default, ripgrep will respect gitignore rules and automatically skip hidden files/directories and binary files. ripgrep has first class support on Windows, [macOS](../../macos/macOS.md) and [Linux](../../linux/Linux.md) with binary downloads available for [every release](https://github.com/BurntSushi/ripgrep/releases). ripgrep is similar to other popular search tools like The Silver Searcher, ack and grep.
ripgrep is a line-oriented search tool that recursively searches the current directory for a [regex](../../tools/Regex.md) pattern. By default, ripgrep will respect gitignore rules and automatically skip hidden files/directories and binary files. ripgrep has first class support on Windows, [macOS](../../macos/macOS.md) and [Linux](../../linux/Linux.md) with binary downloads available for [every release](https://github.com/BurntSushi/ripgrep/releases). ripgrep is similar to other popular search tools like The Silver Searcher, ack and grep.
## Usage
```shell

16
technology/applications/cli/rnr.md
View file

@ -5,16 +5,16 @@ repo: https://github.com/ismaelgv/rnr
---
# rnr
[Repo](https://github.com/ismaelgv/rnr)
**RnR** is a command-line tool to **securely rename** multiple files and directories that supports regular expressions.
**RnR** is a command-line tool to **securely rename** multiple files and directories that supports regular expressions.
## Usage
Flags
```shell
-n, --dry-run         Only show what would be done (default mode)
-f, --force           Make actual changes to files
-x, --hidden          Include hidden files and directories
-D, --include-dirs    Rename matching directories
-r, --recursive       Recursive mode
-s, --silent          Do not print any information
--no-dump         Do not dump operations into a file
-n, --dry-run Only show what would be done (default mode)
-f, --force Make actual changes to files
-x, --hidden Include hidden files and directories
-D, --include-dirs Rename matching directories
-r, --recursive Recursive mode
-s, --silent Do not print any information
--no-dump Do not dump operations into a file
```

2
technology/applications/cli/sd.md
View file

@ -5,7 +5,7 @@ repo: https://github.com/chmln/sd
---
# sd
[Repo](https://github.com/chmln/sd)
`sd` is an intuitive find & replace CLI.
`sd` is an intuitive find & replace CLI.
## Usage
```shell

2
technology/applications/cli/smbmap.md
View file

@ -8,7 +8,7 @@ source: https://www.kali.org/tools/smbmap
SMBMap allows users to enumerate [samba](../web/Samba.md) share drives across an entire domain. List share drives, drive permissions, share contents, upload/download functionality, file name auto-download pattern matching, and even execute remote commands. This tool was designed with pen testing in mind, and is intended to simplify searching for potentially sensitive data across large networks.
## Usage
Usage: `smbmap [options]...`
Usage: `smbmap [options]...`
### Options
#### Main arguments

2
technology/applications/cli/system/Core Utils.md
View file

@ -238,7 +238,7 @@ Usage: `install [OPTION]... SOURCE... DIRECTORY`
| ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `-b` | make a backup of each existing destination file |
| `-S, --suffix=SUFFIX` | override the usual backup suffix |
| `-C, --compare` | compare  content of source and destination files, and if no change to content, ownership, and permissions, do not modify the destination at all |
| `-C, --compare` | compare content of source and destination files, and if no change to content, ownership, and permissions, do not modify the destination at all |
| `-d, --directory` | treat all arguments as directory names; create all components of the specified directories |
| `-g, --group=GROUP` | set group ownership, instead of process' current group |
| `-m, --mode=MODE` | set permission mode (as in chmod), instead of rwxr-xr-x |

14
technology/applications/cli/system/doas.md
View file

@ -29,7 +29,7 @@ $ doas -s
The configuration for doas is stored at `/etc/doas.conf`.
The config file consist of rules with the following format:
`permit|deny [options] identity [as target] [cmd command [args ...]]`
`permit|deny [options] identity [as target] [cmd command [args ...]]`
Rules consist of the following parts:
- `permit|deny`: The action to be taken if this rule matches.
@ -39,19 +39,19 @@ Options:
| Option | Description |
| -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `nopass` | The user is not required to enter a password. |
| `nolog` | Do not log successful command execution to syslogd |
| `nolog` | Do not log successful command execution to syslogd |
| `persist` | After the user successfully authenticates, do not ask for a password again for some time. |
| `keepenv` | Environment variables other than those listed in doas are retained when creating the environment for the new process. |
| `setenv {var=value}` | Keep or set the space-separated specified variables. Variables may also be removed with a leading ‘-’ or set using the latter syntax. If the first character of value is a ‘`$`’ then the value to be set is taken from the existing environment variable of the indicated name. This option is processed after the default environment has been created. |
| `keepenv` | Environment variables other than those listed in doas are retained when creating the environment for the new process. |
| `setenv {var=value}` | Keep or set the space-separated specified variables. Variables may also be removed with a leading ‘-’ or set using the latter syntax. If the first character of value is a ‘`$`’ then the value to be set is taken from the existing environment variable of the indicated name. This option is processed after the default environment has been created. |
- `identity`: The username to match. Groups may be specified by prepending a colon (‘:’). Numeric IDs are also accepted.
- `as`: The target user the running user is allowed to run the command as. The default is all users.
- `as`: The target user the running user is allowed to run the command as. The default is all users.
- `cmd`: The command the user is allowed or denied to run. The default is all commands. Be advised that it is best to specify absolute paths. If a relative path is specified, only a restricted `PATH` will be searched.
- `cmd`: The command the user is allowed or denied to run. The default is all commands. Be advised that it is best to specify absolute paths. If a relative path is specified, only a restricted `PATH` will be searched.
- `args`: Arguments to command. The command arguments provided by the user need to match those specified. The keyword `args` alone means that command must be run without any arguments.
- `args`: Arguments to command. The command arguments provided by the user need to match those specified. The keyword `args` alone means that command must be run without any arguments.
The last matching rule determines the action taken. If no rule matches, the action is denied.

2
technology/applications/cli/zsh.md
View file

@ -10,4 +10,4 @@ repo: https://github.com/zsh-users/zsh
Zsh is a powerful [shell](Shell.md) that operates as both an interactive [shell](Shell.md) and as a scripting language interpreter.
## Configuration
`~/.zshrc`: Used for setting user's interactive [shell](Shell.md) configuration and executing commands, will be read when starting as an _**interactive shell**_.
`~/.zshrc`: Used for setting user's interactive [shell](Shell.md) configuration and executing commands, will be read when starting as an _**interactive shell**_.