eka/.dots
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Обновления 28.09.2021

Browse Source
This commit is contained in:
Дмитрий Рамазанов
2021-09-28 12:27:41 +05:00
parent 997c07e49f
commit 3d6a64111c
14 changed files with 370 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
zsh/plugins/archlinux/README.md
View File

@@ -143,8 +143,6 @@ upgrades were available. Use `pacman -Que` instead.
| yaupd | `yaourt -Sy` | Update and refresh local package, ABS and AUR databases |
| yaupg | `yaourt -Syua` | Sync with repositories before upgrading all packages (from AUR too) |
| yasu | `yaourt -Syua --no-confirm` | Same as `yaupg`, but without confirmation |
| yaclun | `yaourt -Yc` | Remove unneeded installed packages |
| yaclf | `yaourt -Scc` | Remove cache directories |
| upgrade[²](#f2) | `yaourt -Syu` | Sync with repositories before upgrading packages |
#### Yay[¹](#f1)
@@ -167,8 +165,6 @@ upgrades were available. Use `pacman -Que` instead.
| yaupd | `yay -Sy` | Update and refresh local package, ABS and AUR databases |
| yaupg | `yay -Syu` | Sync with repositories before upgrading packages |
| yasu | `yay -Syu --no-confirm` | Same as `yaupg`, but without confirmation |
| yaclun | `yay -Yc` | Remove unneeded installed packages |
| yaclf | `yay -Scc` | Remove cache directories |
| upgrade[²](#f2) | `yay -Syu` | Sync with repositories before upgrading packages |
---

4
zsh/plugins/archlinux/archlinux.plugin.zsh
View File

@@ -170,8 +170,6 @@ if (( $+commands[yaourt] )); then
alias yainsd='yaourt -S --asdeps'
alias yamir='yaourt -Syy'
alias yaupd="yaourt -Sy"
alias yaclun='yaourt -Yc'
alias yaclf='yaourt -Scc'
alias upgrade='yaourt -Syu'
fi
@@ -192,8 +190,6 @@ if (( $+commands[yay] )); then
alias yainsd='yay -S --asdeps'
alias yamir='yay -Syy'
alias yaupd="yay -Sy"
alias yaclun='yay -Yc'
alias yaclf='yay -Scc'
alias upgrade='yay -Syu'
fi

38
zsh/plugins/django/README.md
View File

@@ -1,36 +1,12 @@
# Django plugin
This plugin adds completion and hints for the [Django Project](https://www.djangoproject.com/) `manage.py` commands
and options.
This plugin adds completion for the [Django Project](https://www.djangoproject.com/) commands
(`manage.py`, `django-admin`, ...).
To use it, add `django` to the plugins array in your zshrc file:
## Deprecation (2021-09-22)
```zsh
plugins=(... django)
```
The plugin used to provide completion for `./manage.py` and `django-admin`, but Zsh already provides
a better, more extensive completion for those, so this plugin is no longer needed.
## Usage
```zsh
$> python manage.py (press <TAB> here)
```
Would result in:
```zsh
cleanup -- remove old data from the database
compilemessages -- compile .po files to .mo for use with gettext
createcachetable -- creates table for SQL cache backend
createsuperuser -- create a superuser
dbshell -- run command-line client for the current database
diffsettings -- display differences between the current settings and Django defaults
dumpdata -- output contents of database as a fixture
flush -- execute 'sqlflush' on the current database
inspectdb -- output Django model module for tables in database
loaddata -- install the named fixture(s) in the database
makemessages -- pull out all strings marked for translation
reset -- executes 'sqlreset' for the given app(s)
runfcgi -- run this project as a fastcgi
runserver -- start a lightweight web server for development
...
```
Right now a warning message is shown, but in the near future the plugin will stop working altogether.
So you can remove it from your plugins and you'll automatically start using Zsh's django completion.

3
zsh/plugins/django/django.plugin.zsh
View File

@@ -402,3 +402,6 @@ compdef _managepy django
compdef _managepy django-admin
compdef _managepy django-admin.py
compdef _managepy django-manage
print -P "%F{yellow}The django plugin is deprecated in favor of Zsh's Django completion.
%BPlease remove it from your plugins to stop using it.%b%f"

47
zsh/plugins/jsontools/README.md
View File

@@ -17,32 +17,63 @@ Usage is simple... just take your json data and pipe it into the appropriate jso
- `urlencode_json`: returns a url encoded string for the given json.
- `urldecode_json`: returns decoded json for the given url encoded string.
### Supports NDJSON (Newline Delimited JSON)
The plugin also supports [NDJSON](http://ndjson.org/) input, which means all functions
have an alternative function that reads and processes the input line by line. These
functions have the same name except using `ndjson` instead of `json`:
> `pp_ndjson`, `is_ndjson`, `urlencode_ndjson`, `urldecode_ndjson`.
### Examples
- **pp_json**:
```sh
```console
# curl json data and pretty print the results
curl https://coderwall.com/bobwilliams.json | pp_json
```
- **is_json**:
```sh
# Validate if file's content conforms to a valid JSON schema
less data.json | is_json
```console
# validate if file's content conforms to a valid JSON schema
$ is_json < data.json
true
# shows true / false and returns the proper exit code
$ echo $?
0
```
- **urlencode_json**:
```sh
```console
# json data directly from the command line
echo '{"b":2, "a":1}' | urlencode_json
$ echo '{"b":2, "a":1}' | urlencode_json
%7B%22b%22:2,%20%22a%22:1%7D
```
- **urldecode_json**:
```sh
```console
# url encoded string to decode
echo '%7B%22b%22:2,%20%22a%22:1%7D%0A' | urldecode_json
$ echo '%7B%22b%22:2,%20%22a%22:1%7D' | urldecode_json
{"b":2, "a":1}
```
- **pp_ndjson**:
```console
# echo two separate json objects and pretty print both
$ echo '{"a": "b"}\n{"c": [1,2,3]}' | pp_ndjson
{
"a": "b"
}
{
"c": [
1,
2,
3
]
}
```

139
zsh/plugins/jsontools/jsontools.plugin.zsh
View File

@@ -1,42 +1,113 @@
# JSON Tools
# Adds command line aliases useful for dealing with JSON
if [[ $(whence $JSONTOOLS_METHOD) = "" ]]; then
JSONTOOLS_METHOD=""
# Check that user-defined method is installed
if [[ -n "$JSONTOOLS_METHOD" ]]; then
(( $+commands[$JSONTOOLS_METHOD] )) || unset JSONTOOLS_METHOD
fi
if [[ $(whence node) != "" && ( "x$JSONTOOLS_METHOD" = "x" || "x$JSONTOOLS_METHOD" = "xnode" ) ]]; then
alias pp_json='xargs -0 node -e "console.log(JSON.stringify(JSON.parse(process.argv[1]), null, 4));"'
alias is_json='xargs -0 node -e "try {json = JSON.parse(process.argv[1]);} catch (e) { console.log(false); json = null; } if(json) { console.log(true); }"'
alias urlencode_json='xargs -0 node -e "console.log(encodeURIComponent(process.argv[1]))"'
alias urldecode_json='xargs -0 node -e "console.log(decodeURIComponent(process.argv[1]))"'
elif [[ $(whence python) != "" && ( "x$JSONTOOLS_METHOD" = "x" || "x$JSONTOOLS_METHOD" = "xpython" ) ]]; then
alias pp_json='python -c "import sys; del sys.path[0]; import runpy; runpy._run_module_as_main(\"json.tool\")"'
alias is_json='python -c "
import sys; del sys.path[0];
import json;
try:
json.loads(sys.stdin.read())
except ValueError, e:
print False
else:
print True
sys.exit(0)"'
alias urlencode_json='python -c "
import sys; del sys.path[0];
import urllib, json;
print urllib.quote_plus(sys.stdin.read())
sys.exit(0)"'
alias urldecode_json='python -c "
import sys; del sys.path[0];
import urllib, json;
print urllib.unquote_plus(sys.stdin.read())
sys.exit(0)"'
elif [[ $(whence ruby) != "" && ( "x$JSONTOOLS_METHOD" = "x" || "x$JSONTOOLS_METHOD" = "xruby" ) ]]; then
alias pp_json='ruby -e "require \"json\"; require \"yaml\"; puts JSON.parse(STDIN.read).to_yaml"'
alias is_json='ruby -e "require \"json\"; begin; JSON.parse(STDIN.read); puts true; rescue Exception => e; puts false; end"'
alias urlencode_json='ruby -e "require \"uri\"; puts URI.escape(STDIN.read)"'
alias urldecode_json='ruby -e "require \"uri\"; puts URI.unescape(STDIN.read)"'
# If method undefined, find the first one that is installed
if [[ ! -v JSONTOOLS_METHOD ]]; then
for JSONTOOLS_METHOD in node python ruby; do
# If method found, break out of loop
(( $+commands[$JSONTOOLS_METHOD] )) && break
# Otherwise unset the variable
unset JSONTOOLS_METHOD
done
# If no methods were found, exit the plugin
[[ -v JSONTOOLS_METHOD ]] || return 1
fi
# Define json tools for each method
case "$JSONTOOLS_METHOD" in
node)
# node doesn't make it easy to deal with stdin, so we pass it as an argument with xargs -0
function pp_json() {
xargs -0 node -e 'console.log(JSON.stringify(JSON.parse(process.argv[1]), null, 4));'
}
function is_json() {
xargs -0 node -e '
try {
json = JSON.parse(process.argv[1]);
console.log("true");
process.exit(0);
} catch (e) {
console.log("false");
process.exit(1);
}
'
}
function urlencode_json() {
xargs -0 node -e "console.log(encodeURIComponent(process.argv[1]))"
}
function urldecode_json() {
xargs -0 node -e "console.log(decodeURIComponent(process.argv[1]))"
}
;;
python)
function pp_json() {
python -c 'import sys; del sys.path[0]; import runpy; runpy._run_module_as_main("json.tool")'
}
function is_json() {
python -c '
import sys; del sys.path[0];
import json
try:
json.loads(sys.stdin.read())
print("true"); sys.exit(0)
except ValueError:
print("false"); sys.exit(1)
'
}
function urlencode_json() {
python -c '
import sys; del sys.path[0];
from urllib.parse import quote_plus
print(quote_plus(sys.stdin.read()))
'
}
function urldecode_json() {
python -c '
import sys; del sys.path[0];
from urllib.parse import unquote_plus
print(unquote_plus(sys.stdin.read()))
'
}
;;
ruby)
function pp_json() {
ruby -e '
require "json"
require "yaml"
puts JSON.parse(STDIN.read).to_yaml
'
}
function is_json() {
ruby -e '
require "json"
begin
puts !!JSON.parse(STDIN.read); exit(0)
rescue JSON::ParserError
puts false; exit(1)
end
'
}
function urlencode_json() {
ruby -e 'require "cgi"; puts CGI.escape(STDIN.read)'
}
function urldecode_json() {
ruby -e 'require "cgi"; puts CGI.unescape(STDIN.read)'
}
;;
esac
unset JSONTOOLS_METHOD
## Add NDJSON support
function {pp,is,urlencode,urldecode}_ndjson() {
local json jsonfunc="${0//ndjson/json}"
while read -r json; do
$jsonfunc <<< "$json"
done
}

20
zsh/plugins/vi-mode/README.md
View File

@@ -64,7 +64,7 @@ NOTE: some of these key bindings are set by zsh by default when using a vi-mode
- `vv` : Edit current command line in Vim
NOTE: this used to be bound to `v`. That is now the default (`visual-mode`)
NOTE: this used to be bound to `v`. That is now the default (`visual-mode`).
### Movement
@@ -107,3 +107,21 @@ NOTE: this used to be bound to `v`. That is now the default (`visual-mode`)
- `R` : Enter replace mode: Each character replaces existing one
- `x` : Delete `count` characters under and after the cursor
- `X` : Delete `count` characters before the cursor
## Known issues
### Low `$KEYTIMEOUT`
A low `$KEYTIMEOUT` value (< 15) means that key bindings that need multiple characters,
like `vv`, will be very difficult to trigger. `$KEYTIMEOUT` controls the number of
milliseconds that must pass before a key press is read and the appropriate key binding
is triggered. For multi-character key bindings, the key presses need to happen before
the timeout is reached, so on low timeouts the key press happens too slow, and therefore
another key binding is triggered.
We recommend either setting `$KEYTIMEOUT` to a higher value, or remapping the key bindings
that you want to trigger to a keyboard sequence. For example:
```zsh
bindkey -M vicmd 'V' edit-command-line # this remaps `vv` to `V` (but overrides `visual-mode`)
```

48
zsh/plugins/vim-interaction/vim-interaction.plugin.zsh
View File

@@ -4,8 +4,7 @@
# Derek Wyatt (derek@{myfirstnamemylastname}.org
#
function callvim
{
function callvim {
if [[ $# == 0 ]]; then
cat <<EOH
usage: callvim [-b cmd] [-a cmd] [-n name] [file ... fileN]
@@ -19,11 +18,20 @@ EOH
return 0
fi
local cmd=""
local before="<esc>"
local after=""
# Look up the newest instance
# Look up the newest instance or start one
local name="$(gvim --serverlist | tail -n 1)"
[[ -n "$name" ]] || {
# run gvim or exit if it fails
gvim || return $?
# wait for gvim instance to fully load
while name=$(gvim --serverlist) && [[ -z "$name" ]]; do
sleep 0.1
done
}
local before="<esc>" files after cmd
while getopts ":b:a:n:" option
do
case $option in
@@ -36,22 +44,20 @@ EOH
esac
done
shift $((OPTIND-1))
if [[ ${after#:} != $after && ${after%<cr>} == $after ]]; then
after="$after<cr>"
fi
if [[ ${before#:} != $before && ${before%<cr>} == $before ]]; then
before="$before<cr>"
fi
local files
if [[ $# -gt 0 ]]; then
# absolute path of files resolving symlinks (:A) and quoting special chars (:q)
files=':args! '"${@:A:q}<cr>"
fi
# If before or after commands begin with : and don't end with <cr>, append it
[[ ${after} = :* && ${after} != *\<cr\> ]] && after+="<cr>"
[[ ${before} = :* && ${before} != *\<cr\> ]] && before+="<cr>"
# Open files passed (:A means abs path resolving symlinks, :q means quoting special chars)
[[ $# -gt 0 ]] && files=':args! '"${@:A:q}<cr>"
# Pass the built vim command to gvim
cmd="$before$files$after"
gvim --servername "$name" --remote-send "$cmd"
if typeset -f postCallVim > /dev/null; then
postCallVim
fi
# Run the gvim command
gvim --servername "$name" --remote-send "$cmd" || return $?
# Run postCallVim if defined (maybe to bring focus to gvim, see README)
(( ! $+functions[postCallVim] )) || postCallVim
}
alias v=callvim