Compare commits

..
7 Commits
Author SHA1 Message Date
chris 12b0d3d8b8 Remove blade-nav 2026-06-18 21:50:07 +01:00
Chris 9c6d49cd5d Always render markdown 2026-06-17 07:48:33 +01:00
chris fff9a0e70e Update files 2026-06-16 22:03:42 +01:00
Chris ecbc266165 Cheatsheets and debuggin 2026-06-16 16:26:28 +01:00
Chris 5dd9b59b90 Force saving 2026-05-14 16:30:06 +01:00
Chris 1768a69cf1 Blade 2026-05-06 09:30:50 +01:00
Chris 35e45b9fd5 Update files 2026-05-04 13:43:47 +01:00
17 changed files with 1479 additions and 282 deletions
+391
View File
@@ -0,0 +1,391 @@
# Bash Cheat Sheet
## Conditionals
```bash
if [[ -z "$string" ]]; then
echo "String is empty"
elif [[ -n "$string" ]]; then
echo "String is not empty"
fi
```
### String conditions
┌────────────────────────┬──────────────────┐
`[[ -z STRING ]]` │ Empty string │
├────────────────────────┼──────────────────┤
`[[ -n STRING ]]` │ Not empty string │
├────────────────────────┼──────────────────┤
`[[ STRING == STRING ]]` │ Equal │
├────────────────────────┼──────────────────┤
`[[ STRING != STRING ]]` │ Not Equal │
├────────────────────────┼──────────────────┤
`[[ STRING =~ STRING ]]` │ Regex │
└────────────────────────┴──────────────────┘
### Number conditions
┌────────────────────────┬───────────────────────┐
`[[ NUM1 -eq NUM2 ]]` │ Equal │
├────────────────────────┼───────────────────────┤
`[[ NUM1 -ne NUM2 ]]` │ Not Equal │
├────────────────────────┼───────────────────────┤
`[[ NUM1 -lt NUM2 ]]` │ Less than │
├────────────────────────┼───────────────────────┤
`[[ NUM1 -le NUM2 ]]` │ Less than or equal │
├────────────────────────┼───────────────────────┤
`[[ NUM1 -gt NUM2 ]]` │ Greater than │
├────────────────────────┼───────────────────────┤
`[[ NUM1 -ge NUM2 ]]` │ Greater than or equal │
├────────────────────────┼───────────────────────┤
`(( NUM < NUM ))` │ Numeric conditions │
└────────────────────────┴───────────────────────┘
### File conditions
┌───────────────────────┬─────────────────────────┐
`[[ -e FILE ]]` │ Exists │
├───────────────────────┼─────────────────────────┤
`[[ -r FILE ]]` │ Readable │
├───────────────────────┼─────────────────────────┤
`[[ -h FILE ]]` │ Symlink │
├───────────────────────┼─────────────────────────┤
`[[ -d FILE ]]` │ Directory │
├───────────────────────┼─────────────────────────┤
`[[ -w FILE ]]` │ Writable │
├───────────────────────┼─────────────────────────┤
`[[ -s FILE ]]` │ Size is > 0 bytes │
├───────────────────────┼─────────────────────────┤
`[[ -f FILE ]]` │ File │
├───────────────────────┼─────────────────────────┤
`[[ -x FILE ]]` │ Executable │
├───────────────────────┼─────────────────────────┤
`[[ FILE1 -nt FILE2 ]]` │ 1 is more recent than 2 │
├───────────────────────┼─────────────────────────┤
`[[ FILE1 -ot FILE2 ]]` │ 2 is more recent than 1 │
├───────────────────────┼─────────────────────────┤
`[[ FILE1 -ef FILE2 ]]` │ Same files │
└───────────────────────┴─────────────────────────┘
### Other conditions
┌────────────────────┬────────────────────┐
`[[ -o noclobber ]]` │ Option enabled │
├────────────────────┼────────────────────┤
`[[ ! EXPR ]]` │ Not │
├────────────────────┼────────────────────┤
`[[ X && Y ]]` │ And │
├────────────────────┼────────────────────┤
`[[ X || Y ]]` │ Or │
└────────────────────┴────────────────────┘
## Parameter manipulation
┌─────────────────────────────────┬────────────────────────────────────────────────────────────────┐
`${foo}` │ Variable │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo/from/to}` │ Replace first match │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo/#from/to}`/`${foo/%from/to}` │ Replace first match anchored to start (default) or end │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo//from/to}` │ Replace all │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo:start:length}` │ Slice from `start` to `length` (both optional and can be negative) │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo%suffix}`/`${foo%%suffix}` │ Remove `suffix` (ungreedy/greedy) │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo#prefix}`/`${foo##prefix}` │ Remove `prefix` (ungreedy/greedy) │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${#foo}` │ Length of `foo`
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo,}` │ Lowercase first letter │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo,,}` │ Lowercase all letters │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo^}` │ Uppercase first letter │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo^^}` │ Uppercase all letters │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo:-val}` │ Use `val` if `foo` is unset or null │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo:=val}` │ Set `foo` to `val` if unset or null │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo:+val}` │ Use `val` if `foo` **is** set and not null │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo:?message}` │ Print `message` and exit if `foo` is unset or null │
└─────────────────────────────────┴────────────────────────────────────────────────────────────────┘
> Omitting the `:` for default values will only check if the variable is set, not if it is null.
### Examples
```bash
name="John"
echo "${name}"
echo "${name/J/j}" #=> "john" (substitution)
echo "${name:0:2}" #=> "Jo" (slicing)
echo "${name::2}" #=> "Jo" (slicing)
echo "${name::-1}" #=> "Joh" (slicing)
echo "${name:(-1)}" #=> "n" (slicing from right)
echo "${name:(-2):1}" #=> "h" (slicing from right)
echo "${food:-Cake}" #=> $food or "Cake"
length=2
echo "${name:0:length}" #=> "Jo" (slicing with variable)
str="/path/to/foo.cpp"
echo "${str%.cpp}" # /path/to/foo
echo "${str%.cpp}.o" # /path/to/foo.o
echo "${str%/*}" # /path/to
echo "${str##*.}" # cpp (extension)
echo "${str##*/}" # foo.cpp (basepath)
echo "${str#*o}" # o/foo.cpp (first occurrence of 'o')
echo "${str##*o}" # oo.cpp (last occurrence of 'o')
echo "${str#*/}" # path/to/foo.cpp
echo "${str##*/}" # foo.cpp
echo "${str/foo/bar}" # /path/to/bar.cpp
str="HELLO WORLD!"
echo "${str,}" #=> "hELLO WORLD!" (lowercase 1st letter)
echo "${str,,}" #=> "hello world!" (all lowercase)
str="hello world!"
echo "${str^}" #=> "Hello world!" (uppercase 1st letter)
echo "${str^^}" #=> "HELLO WORLD!" (all uppercase)
```
## Comments
```bash
# This is a comment
: '
This is a multi-line comment workaround
'
```
## Loops
### Basic for loop
```bash
for i in /etc/rc.*; do
echo "$i"
done
```
### C-style for loop
```bash
for (( i = 0; i < 10; i++ )); do
echo "$i"
done
```
### Ranges
```bash
for i in {1..10}; do
echo "$i"
done
# With step size
for i in {1..10..2}; do
echo "$i"
done
```
### Reading lines
```bash
while IFS= read -r line; do
echo "$line"
done < file.txt
```
### Infinite loop
```bash
while true; do
echo "Press [CTRL+C] to stop.."
sleep 1
done
```
## History
┌───────────────┬────────────────────────────────────────────────────────────────┐
`!!` │ Expand latest command in history │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!$` │ Expand last parameter of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!*` │ Expand all parameters of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!-n` │ Expand nth latest command in history │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!n` │ Expand nth command in history │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!string` │ Expand latest command starting with string │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!!:s/from/to` │ Replace first occurrence of "from" with "to" in latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!!:gs/from/to` │ Replace all occurrences of "from" with "to" in latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!!:p` │ Print latest command without executing it │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!$:t` │ Expand basename of last parameter of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!$:h` │ Expand directory of last parameter of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!!:n` │ Expand only nth parameter of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!^` │ Expand first parameter of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!$` │ Expand last parameter of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!!:n-m` │ Expand parameters from nth to mth of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!!:n-$` │ Expand parameters from nth to last of latest command │
└───────────────┴────────────────────────────────────────────────────────────────┘
## Redirection
┌────────────────────────────┬─────────────────────────────────┐
`SCRIPT > FILE` │ stdout to FILE │
├────────────────────────────┼─────────────────────────────────┤
`SCRIPT >> FILE` │ Append stdout to FILE │
├────────────────────────────┼─────────────────────────────────┤
`SCRIPT 2> FILE` │ stderr to FILE │
├────────────────────────────┼─────────────────────────────────┤
`SCRIPT 2>&1`/`SCRIPT &> FILE` │ stderr to stdout │
├────────────────────────────┼─────────────────────────────────┤
`SCRIPT 2> /dev/null` │ stderr to /dev/null │
├────────────────────────────┼─────────────────────────────────┤
`SCRIPT > FILE 2>&1` │ stdout and stderr to FILE │
├────────────────────────────┼─────────────────────────────────┤
`SCRIPT &> /dev/null` │ stdout and stderr to /dev/null │
├────────────────────────────┼─────────────────────────────────┤
`echo "$0: warning" >&2` │ Print to stderr │
├────────────────────────────┼─────────────────────────────────┤
`SCRIPT < FILE` │ stdin from FILE │
└────────────────────────────┴─────────────────────────────────┘
## Switch statement
```bash
case "$1" in
start | up)
vagrant up
;;
*)
echo "Usage: $0 {start|stop|ssh}"
;;
esac
```
### Options switch statement
```bash
while [[ "$1" =~ ^- && ! "$1" == "--" ]]; do case $1 in
-V | --version )
echo "$version"
exit
;;
-s | --string )
shift; string=$1
;;
-f | --flag )
flag=1
;;
esac; shift; done
if [[ "$1" == '--' ]]; then shift; fi
```
## Functions
```bash
my_function() {
echo "Hello, World!"
}
```
### Arguments
┌────┬───────────────────────────────────┐
`$#` │ Number of arguments │
├────┼───────────────────────────────────┤
`$*` │ All arguments │
├────┼───────────────────────────────────┤
`$@` │ All arguments as separate strings │
├────┼───────────────────────────────────┤
`$1` │ First argument │
├────┼───────────────────────────────────┤
`$_` │ Last argument │
└────┴───────────────────────────────────┘
## Arrays
```bash
# Create an array in one line
Fruits=('Apple' 'Banana' 'Orange')
# Or assign each value
Fruits[0]="Apple"
Fruits[1]="Banana"
Fruits[2]="Orange"
# Associative array
declare -A sounds
sounds[dog]="bark"
sounds[cow]="moo"
sounds[bird]="tweet"
sounds[wolf]="howl"
```
### Array element expansion
┌──────────────────────┬────────────────────────────────────────────────────┐
`${array[key]}` │ Element at `key`
├──────────────────────┼────────────────────────────────────────────────────┤
`${array[-1]}` │ Last element (not for associative) │
├──────────────────────┼────────────────────────────────────────────────────┤
`${array[@]}` │ All elements │
├──────────────────────┼────────────────────────────────────────────────────┤
`${#array[@]}` │ Number of elements │
├──────────────────────┼────────────────────────────────────────────────────┤
`${#array}` │ String length of 1st element (not for associative) │
├──────────────────────┼────────────────────────────────────────────────────┤
`${#array[key]}` │ String length of element at `key`
├──────────────────────┼────────────────────────────────────────────────────┤
`${array[@]:n:length}``length` eements from position `n`
├──────────────────────┼────────────────────────────────────────────────────┤
`${!array[@]}` │ Keys of all elements │
└──────────────────────┴────────────────────────────────────────────────────┘
### Operations
```bash
Fruits=("${Fruits[@]}" "Watermelon") # Push
Fruits+=('Watermelon') # Also Push
Fruits=( "${Fruits[@]/Ap*/}" ) # Remove by regex match
unset Fruits[2] # Remove one item
Fruits=("${Fruits[@]}") # Duplicate
Fruits=("${Fruits[@]}" "${Veggies[@]}") # Concatenate
words=($(< datafile)) # From file (split by IFS)
```
### Looping
```bash
for i in "${Fruits[@]}"; do
echo "$i"
done
for key in "${!sounds[@]}"; do
echo "$key"
done
```
## Misc
### Directory of script
```bash
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
```
### Special variables
┌──────────────────┬────────────────────────────────────────┐
`$?` │ Exit status of last task │
├──────────────────┼────────────────────────────────────────┤
`$!` │ PID of last background task │
├──────────────────┼────────────────────────────────────────┤
`$$` │ PID of shell │
├──────────────────┼────────────────────────────────────────┤
`$0` │ Filename of the shell script │
├──────────────────┼────────────────────────────────────────┤
`$_` │ Last arugment of altest command │
├──────────────────┼────────────────────────────────────────┤
`${PIPESTATUS[n]}` │ Return value of piped commands (array) │
└──────────────────┴────────────────────────────────────────┘
+205
View File
@@ -0,0 +1,205 @@
# Regex Cheat Sheet
## Anchors
┌────┬─────────────────────────────────────────────────────────┐
│ ^ │ Start of string, or start of line in multi-line pattern │
├────┼─────────────────────────────────────────────────────────┤
│ \A │ Start of string │
├────┼─────────────────────────────────────────────────────────┤
│ $ │ End of string, or end of line in multi-line pattern │
├────┼─────────────────────────────────────────────────────────┤
│ \Z │ End of string │
├────┼─────────────────────────────────────────────────────────┤
│ \b │ Word boundary │
├────┼─────────────────────────────────────────────────────────┤
│ \B │ Not word boundary │
├────┼─────────────────────────────────────────────────────────┤
│ \< │ Start of word │
├────┼─────────────────────────────────────────────────────────┤
│ \> │ End of word │
└────┴─────────────────────────────────────────────────────────┘
## Character Classes
┌────┬────────────────────┐
│ \c │ Control character │
├────┼────────────────────┤
│ \s │ White space │
├────┼────────────────────┤
│ \S │ Not white space │
├────┼────────────────────┤
│ \d │ Digit │
├────┼────────────────────┤
│ \D │ Not digit │
├────┼────────────────────┤
│ \w │ Word │
├────┼────────────────────┤
│ \W │ Not word │
├────┼────────────────────┤
│ \x │ Hexadecimal digit │
├────┼────────────────────┤
│ \O │ Octal digit │
└────┴────────────────────┘
## POSIX
┌───────────┬───────────────────────────────┐
`[:upper:]` │ Upper case letters │
├───────────┼───────────────────────────────┤
`[:lower:]` │ Lower case letters │
├───────────┼───────────────────────────────┤
`[:alpha:]` │ All letters │
├───────────┼───────────────────────────────┤
`[:alnum:]` │ Digits and letters │
├───────────┼───────────────────────────────┤
`[:digit:]` │ Digits │
├───────────┼───────────────────────────────┤
`[:xdigit:]`│ Hexadecimal digits │
├───────────┼───────────────────────────────┤
`[:punct:]` │ Punctuation │
├───────────┼───────────────────────────────┤
`[:blank:]` │ Space and tab │
├───────────┼───────────────────────────────┤
`[:space:]` │ Blank characters │
├───────────┼───────────────────────────────┤
`[:cntrl:]` │ Control characters │
├───────────┼───────────────────────────────┤
`[:graph:]` │ Printed characters │
├───────────┼───────────────────────────────┤
`[:print:]` │ Printed characters and spaces │
├───────────┼───────────────────────────────┤
`[:word:]` │ Digits, letters and underscore│
└───────────┴───────────────────────────────┘
## Assertions
┌──────┬──────────────────────────────┐
│ ?= │ Lookahead assertion │
├──────┼──────────────────────────────┤
│ ?! │ Negative lookahead │
├──────┼──────────────────────────────┤
│ ?<= │ Lookbehind assertion │
├──────┼──────────────────────────────┤
│ ?!= │ Negative lookbehind │
│ ?<! │ │
├──────┼──────────────────────────────┤
│ ?> │ Once-only subexpression │
├──────┼──────────────────────────────┤
│ ?() │ Condition `[if then]`
├──────┼──────────────────────────────┤
│ ?()| │ Condition `[if then else]`
├──────┼──────────────────────────────┤
│ ?# │ Comment │
└──────┴──────────────────────────────┘
## Quantifiers
┌───────┬─────────────┐
│ * │ 0 or more │
├───────┼─────────────┤
│ + │ 1 or more │
├───────┼─────────────┤
│ ? │ 0 or 1 │
├───────┼─────────────┤
│ {3} │ Exactly 3 │
├───────┼─────────────┤
│ {3,} │ 3 or more │
├───────┼─────────────┤
│ {3,5} │ 3, 4 or 5 │
└───────┴─────────────┘
> Add a `?` to a quantifier to make it ungreedy.
## Escape Sequences
┌────┬─────────────────────────────┐
│ \ │ Escape following character │
├────┼─────────────────────────────┤
│ \Q │ Begin literal sequence │
├────┼─────────────────────────────┤
│ \E │ End literal sequence │
└────┴─────────────────────────────┘
> "Escaping" is a way of treating characters which have a special meaning in regular expressions literally, rather than as special characters.
## Common Metacharacters
┌───┬───┬───┬───┐
│ ^ │ [ │ . │ $ │
├───┼───┼───┼───┤
│ { │ * │ ( │ \ │
├───┼───┼───┼───┤
│ + │ ) │ | │ ? │
├───┼───┼───┼───┤
│ < │ > │ │ │
└───┴───┴───┴───┘
> The escape character is usually `\`.
## Special Characters
┌──────┬────────────────────┐
│ \n │ New line │
├──────┼────────────────────┤
│ \r │ Carriage return │
├──────┼────────────────────┤
│ \t │ Tab │
├──────┼────────────────────┤
│ \v │ Vertical tab │
├──────┼────────────────────┤
│ \f │ Form feed │
├──────┼────────────────────┤
│ \xxx │ Octal character xxx│
├──────┼────────────────────┤
│ \xhh │ Hex character hh │
└──────┴────────────────────┘
## Groups and Ranges
┌─────────┬────────────────────────────────────┐
│ . │ Any character except new line (\n) │
├─────────┼────────────────────────────────────┤
│ (a|b) │ a or b │
├─────────┼────────────────────────────────────┤
│ (...) │ Group │
├─────────┼────────────────────────────────────┤
│ (?:...) │ Passive (non-capturing) group │
├─────────┼────────────────────────────────────┤
`[abc]` │ Range (a or b or c) │
├─────────┼────────────────────────────────────┤
`[^abc]` │ Not (a or b or c) │
├─────────┼────────────────────────────────────┤
`[a-q]` │ Lower case letter from a to q │
├─────────┼────────────────────────────────────┤
`[A-Q]` │ Upper case letter from A to Q │
├─────────┼────────────────────────────────────┤
`[0-7]` │ Digit from 0 to 7 │
├─────────┼────────────────────────────────────┤
│ \x │ Group/subpattern number "x" │
└─────────┴────────────────────────────────────┘
> Ranges are inclusive.
## Pattern Modifiers
┌────┬────────────────────────────────────┐
│ g │ Global match │
├────┼────────────────────────────────────┤
│ i │ Case-insensitive │
├────┼────────────────────────────────────┤
│ m │ Multiple lines │
├────┼────────────────────────────────────┤
│ s │ Treat string as single line │
├────┼────────────────────────────────────┤
│ x │ Allow comments and whitespace │
├────┼────────────────────────────────────┤
│ e │ Evaluate replacement │
├────┼────────────────────────────────────┤
│ U │ Ungreedy pattern │
└────┴────────────────────────────────────┘
> * PCRE modifier
## String Replacement
┌────┬──────────────────────────────────┐
`$n` │ nth non-passive group │
├────┼──────────────────────────────────┤
`$2` │ "xyz" in `/^(abc(xyz))$/`
├────┼──────────────────────────────────┤
`$1` │ "xyz" in `/^(?:abc)(xyz)$/`
├────┼──────────────────────────────────┤
`$`` │ Before matched string │
├────┼──────────────────────────────────┤
│ `$'` │ After matched string │
├────┼──────────────────────────────────┤
│ `$+` │ Last matched string │
├────┼──────────────────────────────────┤
│ `$&` │ Entire matched string │
└────┴──────────────────────────────────┘
> Some regex implementations use `\` instead of `$`.
+437
View File
@@ -0,0 +1,437 @@
# ZSH Cheat Sheet
## Conditionals
```zsh
if [[ -z "$string" ]]; then
echo "String is empty"
elif [[ -n "$string" ]]; then
echo "String is not empty"
fi
```
### String conditions
┌────────────────────────┬──────────────────┐
`[[ -z STRING ]]` │ Empty string │
├────────────────────────┼──────────────────┤
`[[ -n STRING ]]` │ Not empty string │
├────────────────────────┼──────────────────┤
`[[ STRING == STRING ]]` │ Equal │
├────────────────────────┼──────────────────┤
`[[ STRING != STRING ]]` │ Not Equal │
├────────────────────────┼──────────────────┤
`[[ STRING =~ STRING ]]` │ Regex │
└────────────────────────┴──────────────────┘
### Number conditions
┌────────────────────────┬───────────────────────┐
`[[ NUM1 -eq NUM2 ]]` │ Equal │
├────────────────────────┼───────────────────────┤
`[[ NUM1 -ne NUM2 ]]` │ Not Equal │
├────────────────────────┼───────────────────────┤
`[[ NUM1 -lt NUM2 ]]` │ Less than │
├────────────────────────┼───────────────────────┤
`[[ NUM1 -le NUM2 ]]` │ Less than or equal │
├────────────────────────┼───────────────────────┤
`[[ NUM1 -gt NUM2 ]]` │ Greater than │
├────────────────────────┼───────────────────────┤
`[[ NUM1 -ge NUM2 ]]` │ Greater than or equal │
├────────────────────────┼───────────────────────┤
`(( NUM < NUM ))` │ Numeric conditions │
└────────────────────────┴───────────────────────┘
### File conditions
┌───────────────────────┬─────────────────────────┐
`[[ -e FILE ]]` │ Exists │
├───────────────────────┼─────────────────────────┤
`[[ -r FILE ]]` │ Readable │
├───────────────────────┼─────────────────────────┤
`[[ -h FILE ]]` │ Symlink │
├───────────────────────┼─────────────────────────┤
`[[ -d FILE ]]` │ Directory │
├───────────────────────┼─────────────────────────┤
`[[ -w FILE ]]` │ Writable │
├───────────────────────┼─────────────────────────┤
`[[ -s FILE ]]` │ Size is > 0 bytes │
├───────────────────────┼─────────────────────────┤
`[[ -f FILE ]]` │ File │
├───────────────────────┼─────────────────────────┤
`[[ -x FILE ]]` │ Executable │
├───────────────────────┼─────────────────────────┤
`[[ FILE1 -nt FILE2 ]]` │ 1 is more recent than 2 │
├───────────────────────┼─────────────────────────┤
`[[ FILE1 -ot FILE2 ]]` │ 2 is more recent than 1 │
├───────────────────────┼─────────────────────────┤
`[[ FILE1 -ef FILE2 ]]` │ Same files │
└───────────────────────┴─────────────────────────┘
### Other conditions
┌────────────────────┬────────────────────┐
`[[ -o noclobber ]]` │ Option enabled │
├────────────────────┼────────────────────┤
`[[ ! EXPR ]]` │ Not │
├────────────────────┼────────────────────┤
`[[ X && Y ]]` │ And │
├────────────────────┼────────────────────┤
`[[ X || Y ]]` │ Or │
└────────────────────┴────────────────────┘
## Parameter manipulation
┌─────────────────────────────────┬────────────────────────────────────────────────────────────────┐
`${foo}` │ Variable │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo/from/to}` │ Replace first match │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo/#from/to}`/`${foo/%from/to}` │ Replace first match anchored to start (default) or end │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo//from/to}` │ Replace all │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo[start,length]}` │ Slice from `start` to `length` (`length` can be negative) │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo%suffix}`/`${foo%%suffix}` │ Remove `suffix` (ungreedy/greedy) │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo#prefix}`/`${foo##prefix}` │ Remove `prefix` (ungreedy/greedy) │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${#foo}` │ Length of `foo`
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${(L)foo}` │ Lowercase all letters │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${(U)foo}` │ Uppercase all letters │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${(q)foo}` │ Quote safely │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${(qq)foo}` │ Quote more explicitely │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${(s.del.)foo}` │ Split on `del`
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${(j.del.)foo}` │ Join with `del`
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${file:h}` │ Directory of `file`
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${file:t}` │ Filename of `file`
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${file:e}` │ Extension of `file`
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${file:r}` │ Root of `file` (without extension) │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${file:a}` │ Absolute path of `file`
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${file:A}` │ Absolute path of `file` (resolves symlinks) │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo:-val}` │ Use `val` if `foo` is unset or null │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo:=val}` │ Set `foo` to `val` if unset or null │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo:+val}` │ Use `val` if `foo` **is** set and not null │
├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤
`${foo:?message}` │ Print `message` and exit if `foo` is unset or null │
└─────────────────────────────────┴────────────────────────────────────────────────────────────────┘
> Omitting the `:` for default values will only check if the variable is set, not if it is null.
### Examples
```zsh
name="John"
echo "${name}"
echo "${name/J/j}" #=> "john" (substitution)
echo "${name[0,2]}" #=> "Jo" (slicing)
echo "${food:-Cake}" #=> $food or "Cake"
length=2
echo "${name[1,length]}" #=> "Jo" (slicing with variable)
str="/path/to/foo.cpp"
echo "${str%.cpp}" # /path/to/foo
echo "${str%.cpp}.o" # /path/to/foo.o
echo "${str%/*}" # /path/to
echo "${str##*.}" # cpp (extension)
echo "${str##*/}" # foo.cpp (basepath)
echo "${str#*o}" # o/foo.cpp (first occurrence of 'o')
echo "${str##*o}" # oo.cpp (last occurrence of 'o')
echo "${str#*/}" # path/to/foo.cpp
echo "${str##*/}" # foo.cpp
echo "${str/foo/bar}" # /path/to/bar.cpp
str="HELLO WORLD!"
echo "${(L)str}" #=> "hello world!" (all lowercase)
str="hello world!"
echo "${(U)str}" #=> "HELLO WORLD!" (all uppercase)
```
## Globs
┌───────────────┬───────────────────────┐
`ls **/*.js` │ Recursive expansion │
├───────────────┼───────────────────────┤
`ls *(.)` │ Plain files │
├───────────────┼───────────────────────┤
`ls *(/)` │ Directories │
├───────────────┼───────────────────────┤
`ls *(@)` │ Symlinks │
├───────────────┼───────────────────────┤
`ls *(*)` │ Executables │
├───────────────┼───────────────────────┤
`ls *(L+1M)` │ Files larger than 1MB │
├───────────────┼───────────────────────┤
`ls *(om[1,5])` │ 5 newest files │
├───────────────┼───────────────────────┤
`ls *(.)~*.bak` │ Files except *.bak │
└───────────────┴───────────────────────┘
## Comments
```zsh
# This is a comment
: '
This is a multi-line comment workaround
'
```
## Loops
### Basic for loop
```zsh
for i in /etc/rc.*; do
echo "$i"
done
```
### C-style for loop
```zsh
for (( i = 0; i < 10; i++ )); do
echo "$i"
done
```
### Ranges
```zsh
for i in {1..10}; do
echo "$i"
done
# With step size
for i in {1..10..2}; do
echo "$i"
done
```
### Reading lines
```zsh
while IFS= read -r line; do
print -r -- "$line"
done < file.txt
```
### Infinite loop
```zsh
while true; do
echo "Press [CTRL+C] to stop.."
sleep 1
done
```
## History
┌───────────────┬────────────────────────────────────────────────────────────────┐
`!!` │ Expand latest command in history │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!$` │ Expand last parameter of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!*` │ Expand all parameters of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!-n` │ Expand nth latest command in history │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!n` │ Expand nth command in history │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!string` │ Expand latest command starting with string │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!!:s/from/to` │ Replace first occurrence of "from" with "to" in latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!!:gs/from/to` │ Replace all occurrences of "from" with "to" in latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!!:p` │ Print latest command without executing it │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!$:t` │ Expand basename of last parameter of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!$:h` │ Expand directory of last parameter of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!!:n` │ Expand only nth parameter of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!^` │ Expand first parameter of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!$` │ Expand last parameter of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!!:n-m` │ Expand parameters from nth to mth of latest command │
├───────────────┼────────────────────────────────────────────────────────────────┤
`!!:n-$` │ Expand parameters from nth to last of latest command │
└───────────────┴────────────────────────────────────────────────────────────────┘
## Redirection
┌────────────────────────┬─────────────────────────────────┐
`SCRIPT > FILE` │ stdout to FILE │
├────────────────────────┼─────────────────────────────────┤
`SCRIPT >> FILE` │ Append stdout to FILE │
├────────────────────────┼─────────────────────────────────┤
`SCRIPT 2> FILE` │ stderr to FILE │
├────────────────────────┼─────────────────────────────────┤
`SCRIPT 2>&1` │ stderr to stdout │
├────────────────────────┼─────────────────────────────────┤
`SCRIPT &> FILE` │ stderr and stdout to FILE │
├────────────────────────┼─────────────────────────────────┤
`SCRIPT 2> /dev/null` │ stderr to /dev/null │
├────────────────────────┼─────────────────────────────────┤
`SCRIPT > FILE 2>&1` │ stdout and stderr to FILE │
├────────────────────────┼─────────────────────────────────┤
`SCRIPT &> /dev/null` │ stdout and stderr to /dev/null │
├────────────────────────┼─────────────────────────────────┤
`echo "$0: warning" >&2` │ Print to stderr │
├────────────────────────┼─────────────────────────────────┤
`SCRIPT < FILE` │ stdin from FILE │
└────────────────────────┴─────────────────────────────────┘
## Switch statement
```zsh
case "$1" in
start | up)
vagrant up
;;
*)
echo "Usage: $0 {start|stop|ssh}"
;;
esac
```
### Options switch statement
```zsh
while [[ "$1" =~ ^- && ! "$1" == "--" ]]; do case $1 in
-V | --version )
echo "$version"
exit
;;
-s | --string )
shift; string=$1
;;
-f | --flag )
flag=1
;;
esac; shift; done
if [[ "$1" == '--' ]]; then shift; fi
```
## Functions
```zsh
my_function() {
echo "Hello, World!"
}
```
### Arguments
┌────┬───────────────────────────────────┐
`$#` │ Number of arguments │
├────┼───────────────────────────────────┤
`$*` │ All arguments │
├────┼───────────────────────────────────┤
`$@` │ All arguments as separate strings │
├────┼───────────────────────────────────┤
`$1` │ First argument │
├────┼───────────────────────────────────┤
`$_` │ Last argument │
└────┴───────────────────────────────────┘
## Arrays
```zsh
# Create an array in one line
Fruits=('Apple' 'Banana' 'Orange')
# Or assign each value
Fruits[1]="Apple"
Fruits[2]="Banana"
Fruits[3]="Orange"
# Associative array
typeset -A sounds
sounds[dog]="bark"
sounds[cow]="moo"
sounds[bird]="tweet"
sounds[wolf]="howl"
```
### Array element expansion
┌──────────────────────────────────────┬────────────────────────────────────┐
`${array[key]}` │ Element at `key`
├──────────────────────────────────────┼────────────────────────────────────┤
`${array[-1]}` │ Last element (not for associative) │
├──────────────────────────────────────┼────────────────────────────────────┤
`${array[@]}` │ All elements │
├──────────────────────────────────────┼────────────────────────────────────┤
`${#array}` │ Number of elements │
├──────────────────────────────────────┼────────────────────────────────────┤
`${#array[key]}` │ String length of element at `key`
├──────────────────────────────────────┼────────────────────────────────────┤
`${array:n:length}`/`${array[n,length]}``length` eements from position `n`
├──────────────────────────────────────┼────────────────────────────────────┤
`${(k)array}` │ Keys of all elements │
└──────────────────────────────────────┴────────────────────────────────────┘
### Operations
```zsh
Fruits=("${Fruits[@]}" "Watermelon") # Push
Fruits+=('Watermelon') # Also Push
Fruits=( "${Fruits[@]/Ap*/}" ) # Remove by regex match
unset Fruits[3] # Remove one item
Fruits=("${Fruits[@]}") # Duplicate
Fruits=("${Fruits[@]}" "${Veggies[@]}") # Concatenate
words=($(< datafile)) # From file (split by IFS)
```
### Looping
```zsh
for i in "${Fruits[@]}"; do
echo "$i"
done
for val in "${(v)sounds}"; do
echo "$val"
done
for key in "${(k)sounds}"; do
echo "$key"
done
```
## Misc
### Directory of script
```zsh
DIR="$( cd "$( dirname "${ZSH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
```
### Special variables
┌──────────────────┬───────────────────────────────────────────────┐
`$?` │ Exit status of last task │
├──────────────────┼───────────────────────────────────────────────┤
`$!` │ PID of last background task │
├──────────────────┼───────────────────────────────────────────────┤
`$$` │ PID of shell │
├──────────────────┼───────────────────────────────────────────────┤
`$#` │ Number of arguments passed to script │
├──────────────────┼───────────────────────────────────────────────┤
`$0` │ Filename of the shell script │
├──────────────────┼───────────────────────────────────────────────┤
`$_` │ Last arugment of altest command │
├──────────────────┼───────────────────────────────────────────────┤
`$argv` │ Array of all arguments passed to script │
├──────────────────┼───────────────────────────────────────────────┤
`$ARGC` │ Number of arguments passed to script │
├──────────────────┼───────────────────────────────────────────────┤
`${pipestatus[n]}` │ Return value of piped commands (array) │
├──────────────────┼───────────────────────────────────────────────┤
`$RANDOM` │ Random number between 0 and 32767 │
├──────────────────┼───────────────────────────────────────────────┤
`$SECONDS` │ Number of seconds since the shell was started │
├──────────────────┼───────────────────────────────────────────────┤
`$PWD` │ Current working directory │
├──────────────────┼───────────────────────────────────────────────┤
`$OLDPWD` │ Previous working directory │
└──────────────────┴───────────────────────────────────────────────┘
+74 -71
View File
@@ -18,12 +18,14 @@ vim.api.nvim_create_autocmd('FocusLost', {
group = autosave_group, group = autosave_group,
pattern = '*', pattern = '*',
command = 'silent! wa', -- Save all files when moving away from the window command = 'silent! wa', -- Save all files when moving away from the window
nested = true, -- Allow other autocommands to run after this one
}) })
vim.api.nvim_create_autocmd('InsertLeave', { vim.api.nvim_create_autocmd('BufLeave', {
group = autosave_group, group = autosave_group,
pattern = '*', pattern = '*',
command = 'silent! wa', -- Save all files when leaving insert mode command = 'silent! wa', -- Save all files when switching buffers
nested = true, -- Allow other autocommands to run after this one
}) })
vim.api.nvim_create_autocmd('SwapExists', { vim.api.nvim_create_autocmd('SwapExists', {
@@ -35,23 +37,23 @@ vim.api.nvim_create_autocmd('SwapExists', {
}) })
-- vim.api.nvim_create_autocmd('TextChanged', { -- vim.api.nvim_create_autocmd('TextChanged', {
-- group = autosave_group, -- group = autosave_group,
-- pattern = '*', -- pattern = '*',
-- command = 'silent! wa', -- Save all files when text is changed -- command = 'silent! wa', -- Save all files when text is changed
-- }) -- })
vim.api.nvim_create_autocmd('User', { vim.api.nvim_create_autocmd('User', {
pattern = 'OilActionsPost', pattern = 'OilActionsPost',
callback = function(event) callback = function(event)
if event.data.actions.type == 'move' then if event.data.actions.type == 'move' then
Snacks.rename.on_rename_file(event.data.actions.src_url, event.data.actions.dest_url) Snacks.rename.on_rename_file(event.data.actions.src_url, event.data.actions.dest_url)
end end
end, end,
}) })
local fidget_group = vim.api.nvim_create_augroup('CodeCompanionFidgetHooks', { clear = true }) local fidget_group = vim.api.nvim_create_augroup('CodeCompanionFidgetHooks', { clear = true })
vim.api.nvim_create_autocmd({ 'User' }, { vim.api.nvim_create_autocmd({ 'User' }, {
pattern = 'CodeCompanionRequestStarted', pattern = 'CodeCompanionRequestStarted',
group = fidget_group, group = fidget_group,
callback = function(event) callback = function(event)
@@ -60,9 +62,9 @@ vim.api.nvim_create_autocmd('SwapExists', {
local handle = FidgetHelper:create_progress_handle(event) local handle = FidgetHelper:create_progress_handle(event)
FidgetHelper:store_progress_handle(event.data.id, handle) FidgetHelper:store_progress_handle(event.data.id, handle)
end, end,
}) })
vim.api.nvim_create_autocmd({ 'User' }, { vim.api.nvim_create_autocmd({ 'User' }, {
pattern = 'CodeCompanionRequestFinished', pattern = 'CodeCompanionRequestFinished',
group = fidget_group, group = fidget_group,
callback = function(event) callback = function(event)
@@ -73,96 +75,98 @@ vim.api.nvim_create_autocmd('SwapExists', {
handle:finish() handle:finish()
end end
end, end,
}) })
-- vim.api.nvim_create_autocmd('BufEnter', { -- vim.api.nvim_create_autocmd('BufEnter', {
-- callback = function(event) -- callback = function(event)
-- local windows = vim.api.nvim_list_wins() -- local windows = vim.api.nvim_list_wins()
-- --
-- for _, window in ipairs(windows) do -- for _, window in ipairs(windows) do
-- local bufnr = vim.api.nvim_win_get_buf(window) -- local bufnr = vim.api.nvim_win_get_buf(window)
-- local ft = vim.api.nvim_get_option_value('filetype', { buf = bufnr }) -- local ft = vim.api.nvim_get_option_value('filetype', { buf = bufnr })
-- if vim.api.nvim_get_option_value('buflisted', { buf = bufnr }) -- if vim.api.nvim_get_option_value('buflisted', { buf = bufnr })
-- or ft == 'oil' -- or ft == 'oil'
-- or ft == 'snacks_dashboard' then -- or ft == 'snacks_dashboard' then
-- return -- return
-- end -- end
-- end -- end
-- vim.cmd 'qa' -- vim.cmd 'qa'
-- end, -- end,
-- }) -- })
local modes_group = vim.api.nvim_create_augroup('modes', { clear = true }) local modes_group = vim.api.nvim_create_augroup('modes', { clear = true })
vim.api.nvim_create_autocmd('FocusLost', { vim.api.nvim_create_autocmd('FocusLost', {
group = modes_group, group = modes_group,
pattern = '*', pattern = '*',
command = 'call feedkeys("\\<Esc>")', command = 'call feedkeys("\\<Esc>")',
}) })
vim.api.nvim_create_autocmd('BufNewFile', { vim.api.nvim_create_autocmd('BufNewFile', {
group = modes_group, group = modes_group,
pattern = '*', pattern = '*',
command = 'call feedkeys("i")', command = 'call feedkeys("i")',
}) })
-- Reload LuaSnip snippets when saving files in the snippets directory -- Reload LuaSnip snippets when saving files in the snippets directory
local snippets_dir = vim.fn.stdpath 'config' .. '/lua/snippets' local snippets_dir = vim.fn.stdpath 'config' .. '/lua/snippets'
vim.api.nvim_create_autocmd('BufWritePost', { vim.api.nvim_create_autocmd('BufWritePost', {
pattern = snippets_dir .. '/*.json', -- Adjust the path to match your snippets directory pattern = snippets_dir .. '/*.json', -- Adjust the path to match your snippets directory
desc = 'Reload LuaSnip snippets on save', desc = 'Reload LuaSnip snippets on save',
callback = function() callback = function()
require('luasnip.loaders.from_vscode').lazy_load { paths = { snippets_dir } } require('luasnip.loaders.from_vscode').lazy_load { paths = { snippets_dir } }
vim.notify('Snippets reloaded!', vim.log.levels.INFO) vim.notify('Snippets reloaded!', vim.log.levels.INFO)
end, end,
}) })
local configs = { local configs = {
{ {
path = os.getenv("HOME") .. "/.config/nixos", path = os.getenv 'HOME' .. '/.config/nixos',
worktree = nil, worktree = nil,
git_dir = nil, git_dir = nil,
track_untracked = false, track_untracked = false,
force_add = false force_add = false,
}, },
{ {
path = os.getenv("HOME") .. "/.config/nvim", path = os.getenv 'HOME' .. '/.config/nvim',
worktree = nil, worktree = nil,
git_dir = nil, git_dir = nil,
track_untracked = false, track_untracked = false,
force_add = false force_add = false,
}, },
{ {
path = os.getenv("HOME"), path = os.getenv 'HOME',
worktree = os.getenv("HOME"), worktree = os.getenv 'HOME',
git_dir = os.getenv("HOME") .. "/.config/dotfiles/.git", git_dir = os.getenv 'HOME' .. '/.config/dotfiles/.git',
track_untracked = true, track_untracked = true,
force_add = true, -- Handles ignored files in dotfiles force_add = true, -- Handles ignored files in dotfiles
include_dirs = { ".config", ".local/bin", ".local/share" } include_dirs = { '.config', '.local/bin', '.local/share' },
} },
} }
local function get_git_status(config) local function get_git_status(config)
local base = "git" local base = 'git'
if config.git_dir and config.worktree then if config.git_dir and config.worktree then
base = string.format("git --git-dir=%s --worktree=%s", config.git_dir, config.worktree) base = string.format('git --git-dir=%s --worktree=%s', config.git_dir, config.worktree)
end end
-- Check modified and untracked (including ignored if force_add is true) -- Check modified and untracked (including ignored if force_add is true)
local cmd = base .. " status --porcelain" local cmd = base .. ' status --porcelain'
if config.force_add then cmd = cmd .. " --ignored" end if config.force_add then
cmd = cmd .. ' --ignored'
end
local handle = io.popen(cmd) local handle = io.popen(cmd)
local result = handle:read("*a") local result = handle:read '*a'
handle:close() handle:close()
local has_changes = false local has_changes = false
for line in result:gmatch("[^\r\n]+") do for line in result:gmatch '[^\r\n]+' do
local status = line:sub(1, 2) local status = line:sub(1, 2)
local file = line:sub(4) local file = line:sub(4)
if status:match("[MAR]") then if status:match '[MAR]' then
has_changes = true has_changes = true
elseif (status == "??" or status == "!!") and config.track_untracked then elseif (status == '??' or status == '!!') and config.track_untracked then
if config.include_dirs then if config.include_dirs then
for _, dir in ipairs(config.include_dirs) do for _, dir in ipairs(config.include_dirs) do
if file:sub(1, #dir) == dir then if file:sub(1, #dir) == dir then
@@ -176,9 +180,9 @@ vim.api.nvim_create_autocmd('SwapExists', {
end end
end end
return has_changes, base return has_changes, base
end end
vim.api.nvim_create_autocmd("VimLeavePre", { vim.api.nvim_create_autocmd('VimLeavePre', {
callback = function() callback = function()
local cwd = vim.fn.getcwd() local cwd = vim.fn.getcwd()
@@ -187,24 +191,23 @@ vim.api.nvim_create_autocmd('SwapExists', {
local has_changes, git_base = get_git_status(config) local has_changes, git_base = get_git_status(config)
if has_changes then if has_changes then
local confirm = vim.fn.confirm("Uncommitted changes in managed path. Commit?", "&Yes\n&No", 2) local confirm = vim.fn.confirm('Uncommitted changes in managed path. Commit?', '&Yes\n&No', 2)
if confirm == 1 then if confirm == 1 then
local msg = vim.fn.input("Commit message: ", "chore: update files") local msg = vim.fn.input('Commit message: ', 'chore: update files')
if msg ~= "" then if msg ~= '' then
msg = "Update files" msg = 'Update files'
end end
local add_cmd = " add -A" local add_cmd = ' add -A'
os.execute(git_base .. add_cmd) os.execute(git_base .. add_cmd)
os.execute(git_base .. " commit -m " .. vim.fn.shellescape(msg)) os.execute(git_base .. ' commit -m ' .. vim.fn.shellescape(msg))
os.execute(git_base .. " push") os.execute(git_base .. ' push')
print("\nChanges committed.") print '\nChanges committed.'
end end
end end
break break
end end
end end
end, end,
}) })
require('helpers').edit_cf('a', '/lua/autocmd.lua')
require('helpers').edit_cf('a', '/lua/autocmd.lua')
+51 -1
View File
@@ -51,7 +51,57 @@ helpers.open_term = function(opts)
end end
helpers.has_copilot = function() helpers.has_copilot = function()
return vim.fn.getenv('COPILOT_API_KEY') ~= vim.NIL return vim.fn.getenv 'COPILOT_API_KEY' ~= vim.NIL
end
helpers.open_file_modal = function(path, title)
local width = math.floor(vim.o.columns * 0.85)
local height = math.floor(vim.o.lines * 0.85)
local row = math.floor((vim.o.lines - height) / 2)
local col = math.floor((vim.o.columns - width) / 2)
local buf = vim.api.nvim_create_buf(false, true)
vim.api.nvim_open_win(buf, true, {
relative = 'editor',
width = width,
height = height,
row = row,
col = col,
style = 'minimal',
border = 'rounded',
title = ' ' .. title .. ' ',
title_pos = 'center',
})
vim.api.nvim_buf_set_name(buf, path)
local lines = vim.fn.readfile(path)
vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
vim.bo[buf].filetype = 'markdown'
vim.bo[buf].buftype = 'nofile'
vim.bo[buf].bufhidden = 'wipe'
vim.bo[buf].swapfile = false
vim.bo[buf].modifiable = false
vim.bo[buf].readonly = true
vim.wo.wrap = false
vim.wo.number = false
vim.wo.relativenumber = false
vim.wo.cursorline = true
vim.keymap.set('n', 'q', '<cmd>close<CR>', {
buffer = buf,
silent = true,
desc = 'Close cheatsheet',
})
vim.keymap.set('n', '<Esc>', '<cmd>close<CR>', {
buffer = buf,
silent = true,
desc = 'Close cheatsheet',
})
end end
return helpers return helpers
+109 -90
View File
@@ -26,7 +26,7 @@ vim.keymap.set('v', 'p', '"zdP', { desc = 'Paste over selection without yanking
-- or just use <C-\><C-n> to exit terminal mode -- or just use <C-\><C-n> to exit terminal mode
vim.keymap.set('t', '<Esc><Esc>', '<C-\\><C-n>', { desc = 'Exit terminal mode' }) vim.keymap.set('t', '<Esc><Esc>', '<C-\\><C-n>', { desc = 'Exit terminal mode' })
vim.keymap.set('n', '<Leader>c', function() vim.keymap.set('n', '<Leader>z', function()
vim.treesitter.inspect_tree() vim.treesitter.inspect_tree()
end, { desc = 'Treesitter' }) end, { desc = 'Treesitter' })
@@ -259,101 +259,110 @@ vim.keymap.set('n', '<Leader>[', '<CMD>cprevious<CR>', { desc = 'Previous item i
vim.keymap.set('n', 'gd', '<CMD>Telescope lsp_definitions<CR>', { desc = 'Go to definition' }) vim.keymap.set('n', 'gd', '<CMD>Telescope lsp_definitions<CR>', { desc = 'Go to definition' })
vim.keymap.set('n', '<Leader>r', '<CMD>e!<CR>', { desc = 'Reload buffer' }) vim.keymap.set('n', '<Leader>r', '<CMD>e!<CR>', { desc = 'Reload buffer' })
local function open_test() local function open_test()
require('neotest').summary.open() require('neotest').summary.open()
require('neotest').output_panel.open() require('neotest').output_panel.open()
end end
-- Testing -- Testing
-- local test_maps = { local test_maps = {
-- { {
-- keys = { '<F12>', '<Leader>tn' }, keys = { '<Leader>tc' },
-- action = function() action = function()
-- require('neotest').run.run() require('neotest').summary.close()
-- open_test() require('neotest').output_panel.close()
-- end, end,
-- desc = 'Run nearest test', desc = 'Close [T]est panels',
-- }, },
-- { {
-- keys = { '<F9>', '<Leader>ta' }, keys = { '<Leader>tn' },
-- action = function() action = function()
-- require('neotest').run.run { suite = true } require('neotest').run.run()
-- open_test() open_test()
-- end, end,
-- desc = 'Run all tests in the project', desc = 'Run nearest [T]est',
-- }, },
-- { {
-- keys = { '<F11>', '<Leader>tp' }, keys = { '<Leader>ta' },
-- action = function() action = function()
-- require('neotest').run.run_last() require('neotest').run.run { suite = true }
-- open_test() open_test()
-- end, end,
-- desc = 'Run previous test again', desc = 'Run all [T]ests in the project',
-- }, },
-- { {
-- keys = { '<F10>', '<Leader>td' }, keys = { '<Leader>tp' },
-- action = function() action = function()
-- local dap = require 'dap' require('neotest').run.run_last()
-- if dap.session() == nil then open_test()
-- dap.continue() end,
-- end desc = 'Run previous [T]est again',
-- require('dapui').open() },
-- local neotest = require 'neotest' {
-- local bufnr = vim.api.nvim_get_current_buf() keys = { '<Leader>td' },
-- local row = vim.api.nvim_win_get_cursor(0)[1] - 1 action = function()
-- local dap = require 'dap'
-- local adapters = neotest.state.adapter_ids() if dap.session() == nil then
-- local found = false dap.continue()
-- end
-- for _, adapter_id in ipairs(adapters) do require('dapui').open()
-- local tree = neotest.state.positions(adapter_id, { buffer = bufnr }) local neotest = require 'neotest'
-- if tree then local bufnr = vim.api.nvim_get_current_buf()
-- local nearest = require('neotest.lib.positions').nearest(tree, row) local row = vim.api.nvim_win_get_cursor(0)[1] - 1
-- if nearest and nearest:data().type ~= 'file' then
-- neotest.run.run()
-- found = true
-- break
-- end
-- end
-- end
--
-- if not found then
-- neotest.run.run_last()
-- end
-- end,
-- desc = 'Run last test with debugger',
-- },
-- }
--
-- for _, map_info in ipairs(test_maps) do
-- for _, key in ipairs(map_info.keys) do
-- vim.keymap.set('n', key, map_info.action, { desc = map_info.desc })
-- end
-- end
-- vim.keymap.set('n', '<Leader>tf', function()
-- require('neotest').run.run(vim.fn.expand '%')
-- open_test()
-- end, { desc = 'Run all tests in the current file' })
-- vim.keymap.set('n', '<Leader>tc', function()
-- require('neotest').summary.close()
-- require('neotest').output_panel.close()
-- end, { desc = 'Close test panels' })
-- vim.keymap.set('i', '<Tab>', function() local adapters = neotest.state.adapter_ids()
-- local copilot = require 'copilot.suggestion' local found = false
-- local ls = require 'luasnip'
-- if copilot.is_visible() then vim.g.neotest_debug = true
-- vim.api.nvim_echo({{'Accepting copilot suggestion'}}, false, {}) for _, adapter_id in ipairs(adapters) do
-- copilot.accept() local tree = neotest.state.positions(adapter_id, { buffer = bufnr })
-- copilot.dismiss() if tree then
-- elseif ls.jumpable(1) then local nearest = require('neotest.lib.positions').nearest(tree, row)
-- vim.api.nvim_echo({{'Jumping in snippet'}}, false, {}) if nearest and nearest:data().type ~= 'file' then
-- ls.jump() neotest.run.run()
-- else found = true
-- vim.api.nvim_echo({{'Inserting tab'}}, false, {}) break
-- vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes('<Tab>', true, true, true), 'n', true) end
-- end end
-- end, { desc = 'Luasnip accept copilot or jump forward' }) end
if not found then
neotest.run.run_last()
end
vim.g.neotest_debug = nil
end,
desc = 'Run last [T]est with debugger',
},
}
for _, map_info in ipairs(test_maps) do
for _, key in ipairs(map_info.keys) do
vim.keymap.set('n', key, map_info.action, { desc = map_info.desc })
end
end
vim.keymap.set('n', '<Leader>tf', function()
require('neotest').run.run(vim.fn.expand '%')
open_test()
end, { desc = 'Run all tests in the current file' })
vim.keymap.set('n', '<Leader>tc', function()
require('neotest').summary.close()
require('neotest').output_panel.close()
end, { desc = 'Close test panels' })
vim.keymap.set('i', '<Tab>', function()
local copilot = require 'copilot.suggestion'
local ls = require 'luasnip'
if copilot.is_visible() then
vim.api.nvim_echo({ { 'Accepting copilot suggestion' } }, false, {})
copilot.accept()
copilot.dismiss()
elseif ls.jumpable(1) then
vim.api.nvim_echo({ { 'Jumping in snippet' } }, false, {})
ls.jump()
else
vim.api.nvim_echo({ { 'Inserting tab' } }, false, {})
vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes('<Tab>', true, true, true), 'n', true)
end
end, { desc = 'Luasnip accept copilot or jump forward' })
-- Leaving this commented out, I will try the format command instead -- Leaving this commented out, I will try the format command instead
-- "A command to properly indent json code -- "A command to properly indent json code
@@ -371,4 +380,14 @@ vim.keymap.set('n', '<Leader>es', function()
vim.cmd('tabedit ' .. snippets_file) vim.cmd('tabedit ' .. snippets_file)
end, { desc = 'Edit snippets file' }) end, { desc = 'Edit snippets file' })
vim.keymap.set('n', '<Leader>cz', function()
require('utils/cheatsheets').open 'zsh'
end, { desc = 'Open zsh cheat sheet' })
vim.keymap.set('n', '<Leader>cb', function()
require('utils/cheatsheets').open 'bash'
end, { desc = 'Open bash cheat sheet' })
vim.keymap.set('n', '<Leader>cr', function()
require('utils/cheatsheets').open 'regex'
end, { desc = 'Open RegExp cheat sheet' })
require('helpers').edit_cf('k', '/lua/keymap.lua') require('helpers').edit_cf('k', '/lua/keymap.lua')
+7
View File
@@ -0,0 +1,7 @@
return {
'ricardoramirezr/blade-nav.nvim',
dependencies = { -- totally optional
'saghen/blink.cmp', -- if using blink.cmp
},
ft = { 'blade', 'php' }, -- optional, improves startup time
}
+6
View File
@@ -56,6 +56,12 @@ return {
providers = { providers = {
lazydev = { module = 'lazydev.integrations.blink', score_offset = 100 }, lazydev = { module = 'lazydev.integrations.blink', score_offset = 100 },
-- avante = { module = 'blink-cmp-avante', name = 'Avante', opts = {} }, -- avante = { module = 'blink-cmp-avante', name = 'Avante', opts = {} },
-- ['blade-nav'] = {
-- module = 'blade-nav.blink',
-- opts = {
-- clost_tag_on_complete = false,
-- },
-- },
}, },
per_filetype = { per_filetype = {
codecompanion = { 'codecompanion' }, codecompanion = { 'codecompanion' },
+1
View File
@@ -32,6 +32,7 @@ return { -- Autoformat
formatters_by_ft = { formatters_by_ft = {
lua = { 'stylua' }, lua = { 'stylua' },
php = { 'pint' }, php = { 'pint' },
blade = { 'blade-formatter' },
-- Conform can also run multiple formatters sequentially -- Conform can also run multiple formatters sequentially
-- python = { "isort", "black" }, -- python = { "isort", "black" },
-- --
-34
View File
@@ -180,40 +180,6 @@ return {
vim.fn.sign_define(tp, { text = icon, texthl = hl, numhl = hl }) vim.fn.sign_define(tp, { text = icon, texthl = hl, numhl = hl })
end end
local function get_php_ini_dir()
local handle = io.popen 'php --ini 2>/dev/null'
if not handle then
return nil
end
local result = handle:read '*a'
handle:close()
local dir = result:match 'Scan for additional .ini files in:%s+([^\n]+)'
if dir and dir:find '%(none%)' == nil then
return vim.trim(dir)
end
return nil
end
local function enable_xdebug()
local ini_dir = get_php_ini_dir()
if not ini_dir then
return
end
os.execute(string.format('mv "%s/20-xdebug.ini.disabled" "%s/20-xdebug.ini" 2>/dev/null', ini_dir, ini_dir))
end
local function disable_xdebug()
local ini_dir = get_php_ini_dir()
if not ini_dir then
return
end
os.execute(string.format('mv "%s/20-xdebug.ini" "%s/20-xdebug.ini.disabled" 2>/dev/null', ini_dir, ini_dir))
end
dap.listeners.after.event_initialized['xdebug_enable'] = enable_xdebug
dap.listeners.before.event_terminated['xdebug_disable'] = disable_xdebug
dap.listeners.before.event_exited['xdebug_disable'] = disable_xdebug
-- dap.listeners.after.event_output['neotest_display'] = function(_, body) -- dap.listeners.after.event_output['neotest_display'] = function(_, body)
-- require('neotest').output.open { enter = true, last = true } -- require('neotest').output.open { enter = true, last = true }
-- end -- end
+16 -4
View File
@@ -13,9 +13,10 @@ return {
'saghen/blink.cmp', 'saghen/blink.cmp',
'folke/lazydev.nvim', 'folke/lazydev.nvim',
}, },
build = function() -- Might not be necessary for phpantom
vim.fn.system 'composer global require jetbrains/phpstorm-stubs friendsofphp/php-cs-fixer' -- build = function()
end, -- vim.fn.system 'composer global require jetbrains/phpstorm-stubs friendsofphp/php-cs-fixer'
-- end,
config = function() config = function()
-- This function gets run when an LSP attaches to a particular buffer. -- This function gets run when an LSP attaches to a particular buffer.
-- That is to say, every time a new file is opened that is associated with -- That is to say, every time a new file is opened that is associated with
@@ -115,6 +116,12 @@ return {
}, },
} }
-- vim.lsp.config['phpantom'] = {
-- filetypes = { 'php' },
-- cmd = { 'phpantom_lsp' },
-- root_markers = { 'composer.json', '.git' },
-- }
-- Enable the following language servers -- Enable the following language servers
-- --
-- Add any additional override configuration in the following tables. Available keys are: -- Add any additional override configuration in the following tables. Available keys are:
@@ -139,7 +146,11 @@ return {
}, },
}, },
}, },
phpactor = {}, phpantom_lsp = {
filetypes = { 'php' },
cmd = { 'phpantom_lsp' },
root_markers = { 'composer.json', '.git' },
},
vtsls = { vtsls = {
settings = { settings = {
vtsls = { vtsls = {
@@ -195,6 +206,7 @@ return {
local ensure_installed = vim.tbl_keys(servers or {}) local ensure_installed = vim.tbl_keys(servers or {})
vim.list_extend(ensure_installed, { vim.list_extend(ensure_installed, {
'stylua', -- Used to format Lua code 'stylua', -- Used to format Lua code
'blade-formatter',
}) })
-- LSP servers and clients are able to communicate to each other what features they support. -- LSP servers and clients are able to communicate to each other what features they support.
+11 -1
View File
@@ -5,6 +5,16 @@ return {
-- dependencies = { 'nvim-treesitter/nvim-treesitter', 'nvim-tree/nvim-web-devicons' }, -- if you prefer nvim-web-devicons -- dependencies = { 'nvim-treesitter/nvim-treesitter', 'nvim-tree/nvim-web-devicons' }, -- if you prefer nvim-web-devicons
---@module 'render-markdown' ---@module 'render-markdown'
---@type render.md.UserConfig ---@type render.md.UserConfig
opts = {},
ft = { 'markdown', 'codecompanion' }, ft = { 'markdown', 'codecompanion' },
config = function()
require('render-markdown').setup {
latex = {
enabled = true,
render_modes = true,
},
anti_conceal = {
enabled = false,
},
}
end,
} }
+27
View File
@@ -0,0 +1,27 @@
require('helpers').edit_cf('pt', '/lua/plugins/test.lua')
return {
'nvim-neotest/neotest',
dependencies = {
'V13Axel/neotest-pest',
},
config = function()
require('neotest').setup {
adapters = {
require 'neotest-pest' {
sail_enabled = function()
return false
end,
parallel = 8,
pest_cmd = function()
local cmd = vim.g.neotest_pest_cmd or { 'vendor/bin/pest' }
if vim.g.neotest_debug then
cmd = { 'sh', '-c', 'XDEBUG_MODE=debug exec ' .. table.concat(cmd, ' ') .. ' "$@"' }
end
return cmd
end,
},
},
}
end,
}
+3
View File
@@ -7,9 +7,11 @@ return {
config = function() config = function()
local langs = { local langs = {
'bash', 'bash',
'zsh',
'c', 'c',
'diff', 'diff',
'html', 'html',
'latex',
'lua', 'lua',
'luadoc', 'luadoc',
'markdown', 'markdown',
@@ -23,6 +25,7 @@ return {
'javascript', 'javascript',
'typescript', 'typescript',
'css', 'css',
'blade',
} }
require('nvim-treesitter').install(langs) require('nvim-treesitter').install(langs)
+40
View File
@@ -242,6 +242,46 @@ local PROJECTS = {
laravel_makes() laravel_makes()
map('yrn ', '!cd frontend && yarn ', { desc = 'Run yarn script' }, 'c') map('yrn ', '!cd frontend && yarn ', { desc = 'Run yarn script' }, 'c')
map('<Leader>pm', ':vendor/bin/sail composer migrate<CR>') map('<Leader>pm', ':vendor/bin/sail composer migrate<CR>')
vim.api.nvim_create_autocmd({ 'BufWritePost' }, {
pattern = { '*.php', '.env', '.graphql' },
callback = function()
vim.fn.jobstart('vendor/bin/sail artisan octane:reload', { stdout_buffered = true })
vim.fn.jobstart('vendor/bin/sail artisan horizon:terminate', { stdout_buffered = true })
end,
})
vim.api.nvim_create_autocmd({ 'BufWritePost' }, {
pattern = { '.graphql' },
callback = function()
vim.fn.jobstart('vendor/bin/sail artisan lighthouse:clear-cache', { stdout_buffered = true })
end,
})
end,
['server'] = function(dir)
map('<leader>pl', ':cexpr system("vendor/bin/phpstan analyse --no-progress --error-format=raw --memory-limit=2G -vv") <CR>', { desc = 'Run lint' })
map('<leader>pd', function()
helpers.open_term { cmd = 'lazysql pgsql://homestead:password@localhost:5432/homestead' }
end, { desc = 'Open database manager' })
laravel_keymaps()
laravel_makes()
map('yrn ', '!cd frontend && yarn ', { desc = 'Run yarn script' }, 'c')
map('<Leader>pm', ':vendor/bin/sail composer migrate<CR>')
vim.api.nvim_create_autocmd({ 'BufWritePost' }, {
pattern = { '*.php', '.env', '.graphql' },
callback = function()
vim.fn.jobstart('vendor/bin/sail artisan octane:reload', { stdout_buffered = true })
vim.fn.jobstart('vendor/bin/sail artisan horizon:terminate', { stdout_buffered = true })
end,
})
vim.api.nvim_create_autocmd({ 'BufWritePost' }, {
pattern = { '.graphql' },
callback = function()
vim.fn.jobstart('vendor/bin/sail artisan lighthouse:clear-cache', { stdout_buffered = true })
end,
})
end, end,
default = function() end, default = function() end,
+5 -1
View File
@@ -378,7 +378,11 @@ return {
{ i(1), i(0) } { i(1), i(0) }
) )
), ),
s(etr('nn ', 'Assert not null'), fmta('Assert::notNull(#~)', { i(0) })), s(etr('nn ', 'Assert not null'), fmta('Assert::notNull(#~);', { i(0) })),
s(etr('ast ', 'Assert string'), fmta('Assert::string(#~);', { i(0) })),
s(etr('ain ', 'Assert integer'), fmta('Assert::integer(#~);', { i(0) })),
s(etr('aio ', 'Assert instance of'), fmta('Assert::isInstanceOf(#~);', { i(0) })),
s(etr('at ', 'Assert true'), fmta('Assert::true(#~);', { i(0) })),
------------- -------------
-- LARAVEL -- -- LARAVEL --
------------- -------------
+16
View File
@@ -0,0 +1,16 @@
local M = {}
function M.open(name)
local titles = {
zsh = 'ZSH Cheat Sheet',
bash = 'Bash Cheat Sheet',
regex = 'RegExp Cheat Sheet',
}
local path = vim.fn.stdpath 'config' .. '/cheatsheets/' .. name .. '.md'
print('Opening cheat sheet: ' .. path)
require('../helpers').open_file_modal(path, titles[name] or name)
end
return M