mirror of
https://github.com/Cian-H/dotfiles.git
synced 2026-02-05 08:23:25 +00:00
Cian Hughes
896af887ca
This change allows the dotfiles to work with chezmoi (e.g: on windows) and improves grepability with neovim/telescope
619 lines
17 KiB
Nu
619 lines
17 KiB
Nu
### pwd
|
|
def related [sub dir] {
|
|
if $sub == $dir {
|
|
return { related: '=', path: '' }
|
|
}
|
|
let suffix = (do --ignore-errors { $sub | path relative-to $dir })
|
|
if ($suffix | is-empty) {
|
|
{ related: '>', path: '' }
|
|
} else {
|
|
{ related: '<', path: $suffix}
|
|
}
|
|
}
|
|
|
|
export def "pwd_abbr" [] {
|
|
{|bg|
|
|
let pwd = ($env.PWD)
|
|
|
|
let to_home = (related $pwd $nu.home-path)
|
|
|
|
let cwd = if $to_home.related == '=' {
|
|
"~"
|
|
} else if $to_home.related == '>' {
|
|
$pwd
|
|
} else {
|
|
$'~(char separator)($to_home.path)'
|
|
}
|
|
|
|
mut dir_comp = ($cwd | split row (char separator))
|
|
|
|
if ($dir_comp | length) > 5 {
|
|
let first = ($dir_comp | first)
|
|
let last = ($dir_comp | last)
|
|
let body = (
|
|
$dir_comp
|
|
|range 1..-2
|
|
|each {|x| $x | str substring ..2 }
|
|
)
|
|
$dir_comp = ([$first $body $last] | flatten)
|
|
}
|
|
|
|
let theme = $env.NU_POWER_THEME.pwd
|
|
let style = if $to_home.related == '>' {
|
|
$theme.out_home
|
|
} else {
|
|
$theme.default
|
|
}
|
|
[$bg $"($style)($dir_comp | str join (char separator))"]
|
|
}
|
|
}
|
|
|
|
### proxy
|
|
export def proxy_stat [] {
|
|
{|bg|
|
|
let theme = $env.NU_POWER_THEME.proxy
|
|
if not (($env.https_proxy? | is-empty) and ($env.http_proxy? | is-empty)) {
|
|
[$bg '']
|
|
} else {
|
|
[$bg null]
|
|
}
|
|
}
|
|
}
|
|
|
|
### host
|
|
def host_abbr [] {
|
|
{|bg|
|
|
let theme = $env.NU_POWER_THEME.host
|
|
let n = (hostname | str trim)
|
|
let ucl = if (is-admin) {
|
|
$theme.is_admin
|
|
} else {
|
|
$theme.default
|
|
}
|
|
[$bg $"($ucl)($n)"]
|
|
}
|
|
}
|
|
|
|
### time
|
|
def time_segment [] {
|
|
{|bg|
|
|
let config = $env.NU_POWER_CONFIG.time
|
|
let theme = $env.NU_POWER_THEME.time
|
|
let format = match $config.style {
|
|
"compact" => { $'($theme.fst)%y%m%d($theme.snd)%w($theme.fst)%H%M%S' }
|
|
"rainbow" => {
|
|
let fmt = [w y m d H M S]
|
|
let color = ['1;93m' '1;35m' '1;34m' '1;36m' '1;32m' '1;33m' '1;91m']
|
|
$fmt
|
|
| enumerate
|
|
| each { |x| $"(ansi -e ($color | get $x.index))%($x.item)" }
|
|
| str join
|
|
}
|
|
_ => { $'($theme.fst)%y-%m-%d[%w]%H:%M:%S' }
|
|
}
|
|
[$bg $"(date now | format date $format)"]
|
|
}
|
|
}
|
|
|
|
### utils
|
|
def logtime [msg act] {
|
|
let start = (date now)
|
|
let result = (do $act)
|
|
# HACK: serialization
|
|
let period = ((date now) - $start | format duration ns | str replace ' ' '')
|
|
|
|
echo $'($start | format date '%Y-%m-%d_%H:%M:%S%z')(char tab)($period)(char tab)($msg)(char newline)'
|
|
| save -a ~/.cache/nushell/power_time.log
|
|
|
|
$result
|
|
}
|
|
|
|
export def wraptime [message action] {
|
|
if $env.NU_POWER_BENCHMARK? == true {
|
|
{|| logtime $message $action }
|
|
} else {
|
|
$action
|
|
}
|
|
}
|
|
|
|
def get_component [schema] {
|
|
let component = ($env.NU_PROMPT_COMPONENTS | get $schema.source)
|
|
if $env.NU_POWER_BENCHMARK? == true {
|
|
{|bg| logtime $'component ($schema.source)' {|| do $component $bg } }
|
|
} else {
|
|
$component
|
|
}
|
|
}
|
|
|
|
export def timelog [] {
|
|
open ~/.cache/nushell/power_time.log
|
|
| from tsv -n
|
|
| rename start duration message
|
|
| each {|x|
|
|
$x
|
|
| update start ($x.start | into datetime -f '%Y-%m-%d_%H:%M:%S%z')
|
|
| update duration ($x.duration | into duration)
|
|
}
|
|
}
|
|
|
|
export def analyze [] {
|
|
timelog
|
|
| group-by message
|
|
| transpose component metrics
|
|
| each {|x| $x | upsert metrics ($x.metrics | get duration | math avg)}
|
|
}
|
|
|
|
### prompt
|
|
def decorator [ ] {
|
|
match $env.NU_POWER_DECORATOR {
|
|
'plain' => {
|
|
{|s, direction?: string, color?: string = 'light_yellow', next_color?: string|
|
|
match $direction {
|
|
'|>'|'>' => {
|
|
let r = $'(ansi light_yellow)|'
|
|
$"($s)($r)"
|
|
}
|
|
'>>'|'<<' => {
|
|
$s
|
|
}
|
|
'<' => {
|
|
let l = $'(ansi light_yellow)|'
|
|
$"($l)($s)"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
'power' => {
|
|
{|s, direction?: string, color?: string = 'light_yellow', next_color?: string|
|
|
match $direction {
|
|
'|>' => {
|
|
let l = (ansi -e {bg: $color})
|
|
let r = $'(ansi -e {fg: $color, bg: $next_color})(char nf_left_segment)'
|
|
$'($l)($s)($r)'
|
|
}
|
|
'>' => {
|
|
let r = $'(ansi -e {fg: $color, bg: $next_color})(char nf_left_segment)'
|
|
$'($s)($r)'
|
|
}
|
|
'>>' => {
|
|
let r = $'(ansi reset)(ansi -e {fg: $color})(char nf_left_segment)'
|
|
$'($s)($r)'
|
|
}
|
|
'<'|'<<' => {
|
|
let l = $'(ansi -e {fg: $color})(char nf_right_segment)(ansi -e {bg: $color})'
|
|
$'($l)($s)'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
def left_prompt [segment] {
|
|
let decorator = (decorator)
|
|
let segment = ($segment
|
|
| each {|x|
|
|
[$x.color (get_component $x)]
|
|
})
|
|
{||
|
|
let segment = ($segment
|
|
| reduce -f [] {|x, acc|
|
|
let y = (do $x.1 $x.0)
|
|
if $y.1 == null {
|
|
$acc
|
|
} else {
|
|
$acc | append [$y]
|
|
}
|
|
})
|
|
let stop = ($segment | length) - 1
|
|
let cs = ($segment | each {|x| $x.0 } | append $segment.0.0 | range 1..)
|
|
$segment
|
|
| zip $cs
|
|
| enumerate
|
|
| each {|x|
|
|
if $x.index == $stop {
|
|
do $decorator $x.item.0.1 '>>' $x.item.0.0 $x.item.1
|
|
} else if $x.index == 0 {
|
|
do $decorator $x.item.0.1 '|>' $x.item.0.0 $x.item.1
|
|
} else {
|
|
do $decorator $x.item.0.1 '>' $x.item.0.0 $x.item.1
|
|
}
|
|
}
|
|
| str join
|
|
}
|
|
}
|
|
|
|
def right_prompt [segment] {
|
|
let decorator = (decorator)
|
|
let segment = ($segment
|
|
| each {|x|
|
|
[$x.color (get_component $x)]
|
|
})
|
|
{||
|
|
$segment
|
|
| reduce -f [] {|x,acc|
|
|
let y = (do $x.1 $x.0)
|
|
if $y.1 == null {
|
|
$acc
|
|
} else {
|
|
$acc | append [$y]
|
|
}
|
|
}
|
|
| enumerate
|
|
| each {|x|
|
|
if $x.index == 0 {
|
|
do $decorator $x.item.1 '<<' $x.item.0
|
|
} else {
|
|
do $decorator $x.item.1 '<' $x.item.0
|
|
}
|
|
}
|
|
| str join
|
|
}
|
|
}
|
|
|
|
def decorator_gen [
|
|
direction?: string
|
|
color?: string = 'light_yellow'
|
|
next_color?: string
|
|
] {
|
|
match $env.NU_POWER_DECORATOR {
|
|
'plain' => {
|
|
match $direction {
|
|
'|>'|'>' => {
|
|
let r = $'(ansi light_yellow)|'
|
|
{|s| $"($s)($r)" }
|
|
}
|
|
'>>' => {
|
|
{|s| $s }
|
|
}
|
|
'<'|'<<' => {
|
|
let l = $'(ansi light_yellow)|'
|
|
{|s| $"($l)($s)" }
|
|
}
|
|
}
|
|
}
|
|
'power' => {
|
|
match $direction {
|
|
'|>' => {
|
|
let l = $'(ansi -e {bg: $color})'
|
|
let r = $'(ansi -e {fg: $color, bg: $next_color})(char nf_left_segment)'
|
|
{|s| $'($l)($s)($r)' }
|
|
}
|
|
'>' => {
|
|
let r = $'(ansi -e {fg: $color, bg: $next_color})(char nf_left_segment)'
|
|
{|s| $'($s)($r)' }
|
|
}
|
|
'>>' => {
|
|
let r = $'(ansi reset)(ansi -e {fg: $color})(char nf_left_segment)'
|
|
{|s| $'($s)($r)' }
|
|
}
|
|
'<'|'<<' => {
|
|
let l = $'(ansi -e {fg: $color})(char nf_right_segment)(ansi -e {bg: $color})'
|
|
{|s| $'($l)($s)' }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
def squash [thunk] {
|
|
mut r = ""
|
|
for t in $thunk {
|
|
let v = (do $t.0 null)
|
|
if ($v.1 != null) {
|
|
$r += (do $t.1 $v.1)
|
|
}
|
|
}
|
|
$r
|
|
}
|
|
|
|
def left_prompt_gen [segment] {
|
|
let stop = ($segment | length) - 1
|
|
let vs = ($segment | each {|x| [$x.color (get_component $x)]})
|
|
let cs = ($segment | each {|x| $x.color } | append $segment.0.color | range 1..)
|
|
let thunk = ($vs
|
|
| zip $cs
|
|
| enumerate
|
|
| each {|x|
|
|
if $x.index == $stop {
|
|
[$x.item.0.1 (decorator_gen '>>' $x.item.0.0 $x.item.1)]
|
|
} else if $x.index == 0 {
|
|
[$x.item.0.1 (decorator_gen '|>' $x.item.0.0 $x.item.1)]
|
|
} else {
|
|
[$x.item.0.1 (decorator_gen '>' $x.item.0.0 $x.item.1)]
|
|
}
|
|
})
|
|
{|| squash $thunk }
|
|
}
|
|
|
|
def right_prompt_gen [segment] {
|
|
let thunk = ( $segment
|
|
| each {|x| [$x.color (get_component $x)]}
|
|
| enumerate
|
|
| each {|x|
|
|
if $x.index == 0 {
|
|
[$x.item.1 (decorator_gen '<<' $x.item.0)]
|
|
} else {
|
|
[$x.item.1 (decorator_gen '<' $x.item.0)]
|
|
}
|
|
})
|
|
{|| squash $thunk }
|
|
}
|
|
|
|
def up_prompt [segment] {
|
|
let thunk = ($segment
|
|
| each {|y| $y | each {|x| get_component $x }
|
|
})
|
|
{ ||
|
|
let ss = ($thunk
|
|
| each {|y|
|
|
$y
|
|
| reduce -f [] {|x, acc|
|
|
let y = (do $x null)
|
|
if $y.1 == null {
|
|
$acc
|
|
} else {
|
|
$acc | append $y.1
|
|
}
|
|
}
|
|
| str join $'(ansi light_yellow)|'
|
|
})
|
|
# TODO: length of unicode char is 3
|
|
let fl = (((term size).columns - ($ss | str join ''| ansi strip | str length)) | math abs)
|
|
$ss | str join $"(ansi xterm_grey)('' | fill -c '-' -w $fl)(ansi reset)"
|
|
}
|
|
}
|
|
|
|
export def default_env [name value] {
|
|
if ($name in $env) {
|
|
$env | get $name
|
|
} else {
|
|
$value
|
|
}
|
|
}
|
|
|
|
export def --env init [] {
|
|
match $env.NU_POWER_FRAME {
|
|
'default' => {
|
|
match $env.NU_POWER_MODE {
|
|
'power' => {
|
|
$env.PROMPT_COMMAND = (wraptime
|
|
'dynamic left'
|
|
(left_prompt $env.NU_POWER_SCHEMA.0)
|
|
)
|
|
$env.PROMPT_COMMAND_RIGHT = (wraptime
|
|
'dynamic right'
|
|
(right_prompt $env.NU_POWER_SCHEMA.1)
|
|
)
|
|
}
|
|
'fast' => {
|
|
$env.PROMPT_COMMAND = (wraptime
|
|
'static left'
|
|
(left_prompt_gen $env.NU_POWER_SCHEMA.0)
|
|
)
|
|
$env.PROMPT_COMMAND_RIGHT = (wraptime
|
|
'static right'
|
|
(right_prompt_gen $env.NU_POWER_SCHEMA.1)
|
|
)
|
|
}
|
|
}
|
|
}
|
|
'fill' => {
|
|
$env.PROMPT_COMMAND = (up_prompt $env.NU_POWER_SCHEMA)
|
|
}
|
|
}
|
|
|
|
$env.PROMPT_INDICATOR = {||
|
|
match $env.NU_POWER_DECORATOR {
|
|
'plain' => { "> " }
|
|
_ => { " " }
|
|
}
|
|
}
|
|
$env.PROMPT_INDICATOR_VI_INSERT = {|| ": " }
|
|
$env.PROMPT_INDICATOR_VI_NORMAL = {|| "> " }
|
|
$env.PROMPT_MULTILINE_INDICATOR = {||
|
|
match $env.NU_POWER_DECORATOR {
|
|
'plain' => { "::: " }
|
|
_ => { $"(char haze) " }
|
|
}
|
|
}
|
|
|
|
$env.config = ( $env.config | update menus ($env.config.menus
|
|
| each {|x|
|
|
if ($x.marker in $env.NU_POWER_MENU_MARKER) {
|
|
let c = ($env.NU_POWER_MENU_MARKER | get $x.marker)
|
|
$x | upsert marker $'(ansi -e {fg: $c})(char nf_left_segment_thin) '
|
|
} else {
|
|
$x
|
|
}
|
|
}
|
|
))
|
|
|
|
hook
|
|
}
|
|
|
|
export def --env set [name theme config?] {
|
|
$env.NU_POWER_THEME = (if ($theme | is-empty) {
|
|
$env.NU_POWER_THEME
|
|
} else {
|
|
$env.NU_POWER_THEME
|
|
| upsert $name ($theme
|
|
| transpose k v
|
|
| reduce -f {} {|it, acc|
|
|
$acc | insert $it.k (ansi -e {fg: $it.v})
|
|
})
|
|
})
|
|
|
|
$env.NU_POWER_CONFIG = (if ($config | is-empty) {
|
|
$env.NU_POWER_CONFIG
|
|
} else {
|
|
$env.NU_POWER_CONFIG
|
|
| upsert $name ($config
|
|
| transpose k v
|
|
| reduce -f {} {|it, acc|
|
|
$acc | insert $it.k $it.v
|
|
})
|
|
})
|
|
}
|
|
|
|
export def --env register [name source theme config?] {
|
|
set $name $theme $config
|
|
|
|
$env.NU_PROMPT_COMPONENTS = (
|
|
$env.NU_PROMPT_COMPONENTS | upsert $name {|| $source }
|
|
)
|
|
}
|
|
|
|
export def --env inject [pos idx define theme? config?] {
|
|
let prev = ($env.NU_POWER_SCHEMA | get $pos)
|
|
let next = if $idx == 0 {
|
|
$prev | prepend $define
|
|
} else {
|
|
[
|
|
($prev | range 0..($idx - 1))
|
|
$define
|
|
($prev | range $idx..)
|
|
] | flatten
|
|
}
|
|
|
|
$env.NU_POWER_SCHEMA = (
|
|
$env.NU_POWER_SCHEMA
|
|
| update $pos $next
|
|
)
|
|
|
|
let kind = $define.source
|
|
|
|
if not ($theme | is-empty) {
|
|
let prev_theme = ($env.NU_POWER_THEME | get $kind)
|
|
let prev_cols = ($prev_theme | columns)
|
|
let next_theme = ($theme | transpose k v)
|
|
for n in $next_theme {
|
|
if $n.k in $prev_cols {
|
|
$env.NU_POWER_THEME = (
|
|
$env.NU_POWER_THEME | update $kind {|conf|
|
|
$conf | get $kind | update $n.k (ansi -e {fg: $n.v})
|
|
}
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
if not ($config | is-empty) {
|
|
let prev_cols = ($env.NU_POWER_CONFIG | get $kind | columns)
|
|
for n in ($config | transpose k v) {
|
|
if $n.k in $prev_cols {
|
|
$env.NU_POWER_CONFIG = (
|
|
$env.NU_POWER_CONFIG | update $kind {|conf|
|
|
$conf | get $kind | update $n.k $n.v
|
|
}
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
export def --env eject [] {
|
|
"power eject not implement"
|
|
}
|
|
|
|
export def --env hook [] {
|
|
$env.config = ( $env.config | upsert hooks.env_change { |config|
|
|
let init = [{|before, after| if not ($before | is-empty) { init } }]
|
|
$config.hooks.env_change
|
|
| upsert NU_POWER_MODE $init
|
|
| upsert NU_POWER_SCHEMA $init
|
|
| upsert NU_POWER_FRAME $init
|
|
| upsert NU_POWER_DECORATOR $init
|
|
| upsert NU_POWER_MENU_MARKER $init
|
|
| upsert NU_POWER_BENCHMARK [{ |before, after|
|
|
if not ($before | is-empty) {
|
|
init
|
|
rm -f ~/.cache/nushell/power_time.log
|
|
}
|
|
}]
|
|
|
|
# NU_POWER_THEME
|
|
})
|
|
}
|
|
|
|
export-env {
|
|
$env.NU_POWER_BENCHMARK = false
|
|
|
|
$env.NU_POWER_MODE = (default_env
|
|
NU_POWER_MODE
|
|
'power' # power | fast
|
|
)
|
|
|
|
$env.NU_POWER_SCHEMA = (default_env
|
|
NU_POWER_SCHEMA
|
|
[
|
|
[
|
|
{source: pwd, color: '#353230'}
|
|
]
|
|
[
|
|
{source: proxy, color: 'dark_gray'}
|
|
{source: host, color: '#353230'}
|
|
{source: time, color: '#666560'}
|
|
]
|
|
]
|
|
)
|
|
|
|
$env.NU_POWER_FRAME = (default_env
|
|
NU_POWER_FRAME
|
|
'default' # default | fill
|
|
)
|
|
|
|
$env.NU_POWER_DECORATOR = (default_env
|
|
NU_POWER_DECORATOR
|
|
'power' # power | plain
|
|
)
|
|
|
|
$env.NU_POWER_MENU_MARKER = (default_env
|
|
NU_POWER_MENU_MARKER
|
|
{
|
|
"| " : 'green'
|
|
": " : 'yellow'
|
|
"# " : 'blue'
|
|
"? " : 'red'
|
|
}
|
|
)
|
|
|
|
$env.NU_POWER_THEME = (default_env
|
|
NU_POWER_THEME
|
|
{
|
|
pwd: {
|
|
default: (ansi light_green_bold)
|
|
out_home: (ansi xterm_gold3b)
|
|
}
|
|
proxy: {
|
|
on: (ansi yellow)
|
|
}
|
|
host: {
|
|
is_admin: (ansi yellow)
|
|
default: (ansi blue)
|
|
}
|
|
time: {
|
|
fst: (ansi xterm_tan)
|
|
snd: (ansi xterm_aqua)
|
|
}
|
|
}
|
|
)
|
|
|
|
$env.NU_POWER_CONFIG = (default_env
|
|
NU_POWER_CONFIG
|
|
{
|
|
time: {
|
|
style: null
|
|
}
|
|
}
|
|
)
|
|
|
|
$env.NU_PROMPT_COMPONENTS = {
|
|
pwd: (pwd_abbr)
|
|
proxy: (proxy_stat)
|
|
host: (host_abbr)
|
|
time: (time_segment)
|
|
}
|
|
}
|
|
|