tforgione/dotfiles
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: tforgione:nushell
Branches Tags
tforgione:main tforgione:dev-ssh tforgione:dev tforgione:nushell tforgione:terry tforgione:update-sudo tforgione:master
..
compare: tforgione:terry
Branches Tags
tforgione:main tforgione:dev-ssh tforgione:dev tforgione:nushell tforgione:terry tforgione:update-sudo tforgione:master

2 Commits
nushell ... terry

Author SHA1 Message Date
tforgione
7bbf9b8c9b Update init.vim 2023-10-11 10:01:55 +02:00
Thomas Forgione
f1ee5b1aff Restore old init.vim 2022-12-07 12:45:51 +01:00
27 changed files with 198 additions and 2802 deletions
Expand all files Collapse all files

2
.gitignore vendored
View File

@@ -1,7 +1,5 @@
zsh/extraconfig.zsh
zsh/env.zsh
bash/extraconfig.bash
nushell/history.*
nushell/config/extra.nu
.data
bin-extra

501
alacritty.yml
View File

@@ -1,501 +0,0 @@
# Configuration for Alacritty, the GPU enhanced terminal emulator.
# Any items in the `env` entry below will be added as
# environment variables. Some entries may override variables
# set by alacritty itself.
#env:
# TERM variable
#
# This value is used to set the `$TERM` environment variable for
# each instance of Alacritty. If it is not present, alacritty will
# check the local terminfo database and use 'alacritty' if it is
# available, otherwise 'xterm-256color' is used.
#TERM: xterm-256color
window:
# Window dimensions (changes require restart)
#
# Specified in number of columns/lines, not pixels.
# If both are `0`, this setting is ignored.
dimensions:
columns: 0
lines: 0
# Window padding (changes require restart)
#
# Blank space added around the window in pixels. This padding is not scaled
# by DPI and the specified value is always added at both opposing sides.
padding:
x: 0
y: 0
# Window decorations
#
# Values for `decorations`:
# - full: Borders and title bar
# - none: Neither borders nor title bar
decorations: none
dynamic_title: false
opacity: 0.8
scrolling:
# Maximum number of lines in the scrollback buffer.
# Specifying '0' will disable scrolling.
history: 10000
# Number of lines the viewport will move for every line scrolled when
# scrollback is enabled (history > 0).
multiplier: 3
# Font configuration (changes require restart)
#
# Important font attributes like antialiasing, subpixel aa, and hinting can be
# controlled through fontconfig. Specifically, the following attributes should
# have an effect:
# - hintstyle
# - antialias
# - lcdfilter
# - rgba
#
# For instance, if you wish to disable subpixel antialiasing, you might set the
# rgba property to `none`. If you wish to completely disable antialiasing, you
# can set antialias to `false`.
#
# Please see these resources for more information on how to use fontconfig:
# - https://wiki.archlinux.org/index.php/font_configuration#Fontconfig_configuration
# - file:///usr/share/doc/fontconfig/fontconfig-user.html
font:
# Normal (roman) font face
normal:
# family: Ubuntu Mono Nerd Font
family: custom monospace
# family: Ubuntu Mono derivative Powerline
# family: Inconsolata for Powerline
# The `style` can be specified to pick a specific face.
#style: Regular
# # Bold font face
# bold:
# family: Inconsolata for Powerline
# # The `style` can be specified to pick a specific face.
# #style: Bold
# # Italic font face
# italic:
# family: Inconsolata for Powerline
# # The `style` can be specified to pick a specific face.
# #style: Italic
# Point size
size: 8.0
# Offset is the extra space around each character. `offset.y` can be thought of
# as modifying the line spacing, and `offset.x` as modifying the letter spacing.
offset:
x: 0
y: 0
# Glyph offset determines the locations of the glyphs within their cells with
# the default being at the bottom. Increasing `x` moves the glyph to the right,
# increasing `y` moves the glyph upwards.
glyph_offset:
x: 0
y: 0
# If `true`, bold text is drawn using the bright color variants.
draw_bold_text_with_bright_colors: true
# Colors (Tomorrow Night Bright)
colors:
# Default colors
primary:
background: '0x000000'
foreground: '0xeaeaea'
# Bright and dim foreground colors
#
# The dimmed foreground color is calculated automatically if it is not present.
# If the bright foreground color is not set, or `draw_bold_text_with_bright_colors`
# is `false`, the normal foreground color will be used.
#dim_foreground: '0x9a9a9a'
#bright_foreground: '0xffffff'
# Cursor colors
#
# Colors which should be used to draw the terminal cursor. If these are unset,
# the cursor color will be the inverse of the cell color.
#cursor:
# text: '0x000000'
# cursor: '0xffffff'
# Normal colors
normal:
black: '0x000000'
red: '0xcd0000'
green: '0x00cd00'
yellow: '0xcdcd00'
blue: '0x7aa6da'
magenta: '0xcd00cd'
cyan: '0x3465a4'
white: '0xe5e5e5'
# Bright colors
bright:
black: '0x666666'
red: '0xff0000'
green: '0x00ff00'
yellow: '0xffff00'
blue: '0x5c5cff'
magenta: '0xff00ff'
cyan: '0x00ffff'
white: '0xffffff'
# Dim colors
#
# If the dim colors are not set, they will be calculated automatically based
# on the `normal` colors.
dim:
black: '0x333333'
red: '0xf2777a'
green: '0x99cc99'
yellow: '0xffcc66'
blue: '0x6699cc'
magenta: '0xcc99cc'
cyan: '0x66cccc'
white: '0xdddddd'
# # Colors (Tomorrow Night Bright)
# colors:
# # Default colors
# primary:
# background: '0xffffff'
# foreground: '0x000000'
#
# # Bright and dim foreground colors
# #
# # The dimmed foreground color is calculated automatically if it is not present.
# # If the bright foreground color is not set, or `draw_bold_text_with_bright_colors`
# # is `false`, the normal foreground color will be used.
# #dim_foreground: '0x9a9a9a'
# #bright_foreground: '0xffffff'
#
# # Cursor colors
# #
# # Colors which should be used to draw the terminal cursor. If these are unset,
# # the cursor color will be the inverse of the cell color.
# #cursor:
# # text: '0x000000'
# # cursor: '0xffffff'
#
# # Normal colors
# normal:
#
# black: '0x000000'
# red: '0xcd0000'
# green: '0x00cd00'
# yellow: '0xcdcd00'
# blue: '0x0000cd'
# magenta: '0xcd00cd'
# cyan: '0x00cdcd'
# white: '0xfaebd7'
#
# # Bright colors
# bright:
# black: '0x000000'
# red: '0xcd0000'
# green: '0x00cd00'
# yellow: '0xcdcd00'
# blue: '0x0000cd'
# magenta: '0xcd00cd'
# cyan: '0x00cdcd'
# white: '0xfaebd7'
#
# # Dim colors
# #
# # If the dim colors are not set, they will be calculated automatically based
# # on the `normal` colors.
# dim:
# black: '0x333333'
# red: '0xf2777a'
# green: '0x99cc99'
# yellow: '0xffcc66'
# blue: '0x6699cc'
# magenta: '0xcc99cc'
# cyan: '0x66cccc'
# white: '0xdddddd'
#
# background_opacity: 1.0
# Visual Bell
#
# Any time the BEL code is received, Alacritty "rings" the visual bell. Once
# rung, the terminal background will be set to white and transition back to the
# default background color. You can control the rate of this transition by
# setting the `duration` property (represented in milliseconds). You can also
# configure the transition function by setting the `animation` property.
#
# Values for `animation`:
# - Ease
# - EaseOut
# - EaseOutSine
# - EaseOutQuad
# - EaseOutCubic
# - EaseOutQuart
# - EaseOutQuint
# - EaseOutExpo
# - EaseOutCirc
# - Linear
#
# Specifying a `duration` of `0` will disable the visual bell.
bell:
animation: EaseOutExpo
duration: 0
# Mouse bindings
#
# Available fields:
# - mouse
# - action
# - mods (optional)
#
# Values for `mouse`:
# - Middle
# - Left
# - Right
# - Numeric identifier such as `5`
#
# All available `mods` and `action` values are documented in the key binding
# section.
mouse_bindings:
- { mouse: Middle, action: PasteSelection }
mouse:
# Click settings
#
# The `double_click` and `triple_click` settings control the time
# alacritty should wait for accepting multiple clicks as one double
# or triple click.
double_click: { threshold: 300 }
triple_click: { threshold: 300 }
# If this is `true`, the cursor is temporarily hidden when typing.
hide_when_typing: false
selection:
semantic_escape_chars: ",│`|:\"' ()[]{}<>"
# When set to `true`, selected text will be copied to both the primary and
# the selection clipboard. Otherwise, it will only be copied to the selection
# clipboard.
save_to_clipboard: false
cursor:
# Cursor style
#
# Values for 'style':
# - ▇ Block
# - _ Underline
# - | Beam
style: Block
# If this is `true`, the cursor will be rendered as a hollow box when the
# window is not focused.
unfocused_hollow: true
# Live config reload (changes require restart)
live_config_reload: true
# Shell
#
# You can set `shell.program` to the path of your favorite shell, e.g. `/bin/fish`.
# Entries in `shell.args` are passed unmodified as arguments to the shell.
#shell:
# program: /bin/bash
# args:
# - --login
# Key bindings
#
# Key bindings are specified as a list of objects. Each binding will specify
# a key and modifiers required to trigger it, terminal modes where the binding
# is applicable, and what should be done when the key binding fires. It can
# either send a byte sequnce to the running application (`chars`), execute
# a predefined action (`action`) or fork and execute a specified command plus
# arguments (`command`).
#
# Example:
# `- { key: V, mods: Command, action: Paste }`
#
# Available fields:
# - key
# - mods (optional)
# - chars | action | command (exactly one required)
# - mode (optional)
#
# Values for `key`:
# - `A` -> `Z`
# - `F1` -> `F12`
# - `Key1` -> `Key0`
#
# A full list with available key codes can be found here:
# https://docs.rs/glutin/*/glutin/enum.VirtualKeyCode.html#variants
#
# Instead of using the name of the keys, the `key` field also supports using
# the scancode of the desired key. Scancodes have to be specified as a
# decimal number.
# This command will allow you to display the hex scancodes for certain keys:
# `showkey --scancodes`
#
# Values for `mods`:
# - Command
# - Control
# - Shift
# - Alt
#
# Multiple `mods` can be combined using `|` like this: `mods: Control|Shift`.
# Whitespace and capitalization is relevant and must match the example.
#
# Values for `chars`:
# The `chars` field writes the specified string to the terminal. This makes
# it possible to pass escape sequences.
# To find escape codes for bindings like `PageUp` ("\x1b[5~"), you can run
# the command `showkey -a` outside of tmux.
# Note that applications use terminfo to map escape sequences back to
# keys. It is therefore required to update the terminfo when
# changing an escape sequence.
#
# Values for `action`:
# - Paste
# - PasteSelection
# - Copy
# - IncreaseFontSize
# - DecreaseFontSize
# - ResetFontSize
# - ScrollPageUp
# - ScrollPageDown
# - ScrollToTop
# - ScrollToBottom
# - ClearHistory
# - Hide
# - Quit
#
# Values for `command`:
# The `command` field must be a map containing a `program` string and
# an `args` array of command line parameter strings.
#
# Example:
# `command: { program: "alacritty", args: ["-e", "vttest"] }`
#
# Values for `mode`:
# - ~AppCursor
# - AppCursor
# - ~AppKeypad
# - AppKeypad
key_bindings:
# Custom
- { key: E, mods: Control|Shift, action: SpawnNewInstance }
# Already present
- { key: V, mods: Control|Shift, action: Paste }
- { key: C, mods: Control|Shift, action: Copy }
- { key: Paste, action: Paste }
- { key: Copy, action: Copy }
- { key: Insert, mods: Shift, action: PasteSelection }
- { key: Key0, mods: Control, action: ResetFontSize }
- { key: Equals, mods: Control, action: IncreaseFontSize }
- { key: Home, chars: "\x1bOH", mode: AppCursor }
- { key: Home, chars: "\x1b[H", mode: ~AppCursor }
- { key: End, chars: "\x1bOF", mode: AppCursor }
- { key: End, chars: "\x1b[F", mode: ~AppCursor }
- { key: PageUp, mods: Shift, chars: "\x1b[5;2~" }
- { key: PageUp, mods: Control, chars: "\x1b[5;5~" }
- { key: PageUp, chars: "\x1b[5~" }
- { key: PageDown, mods: Shift, chars: "\x1b[6;2~" }
- { key: PageDown, mods: Control, chars: "\x1b[6;5~" }
- { key: PageDown, chars: "\x1b[6~" }
- { key: Tab, mods: Shift, chars: "\x1b[Z" }
- { key: Back, chars: "\x7f" }
- { key: Back, mods: Alt, chars: "\x1b\x7f" }
- { key: Insert, chars: "\x1b[2~" }
- { key: Delete, chars: "\x1b[3~" }
- { key: Left, mods: Shift, chars: "\x1b[1;2D" }
- { key: Left, mods: Control, chars: "\x1b[1;5D" }
- { key: Left, mods: Alt, chars: "\x1b[1;3D" }
- { key: Left, chars: "\x1b[D", mode: ~AppCursor }
- { key: Left, chars: "\x1bOD", mode: AppCursor }
- { key: Right, mods: Shift, chars: "\x1b[1;2C" }
- { key: Right, mods: Control, chars: "\x1b[1;5C" }
- { key: Right, mods: Alt, chars: "\x1b[1;3C" }
- { key: Right, chars: "\x1b[C", mode: ~AppCursor }
- { key: Right, chars: "\x1bOC", mode: AppCursor }
- { key: Up, mods: Shift, chars: "\x1b[1;2A" }
- { key: Up, mods: Control, chars: "\x1b[1;5A" }
- { key: Up, mods: Alt, chars: "\x1b[1;3A" }
- { key: Up, chars: "\x1b[A", mode: ~AppCursor }
- { key: Up, chars: "\x1bOA", mode: AppCursor }
- { key: Down, mods: Shift, chars: "\x1b[1;2B" }
- { key: Down, mods: Control, chars: "\x1b[1;5B" }
- { key: Down, mods: Alt, chars: "\x1b[1;3B" }
- { key: Down, chars: "\x1b[B", mode: ~AppCursor }
- { key: Down, chars: "\x1bOB", mode: AppCursor }
- { key: F1, chars: "\x1bOP" }
- { key: F2, chars: "\x1bOQ" }
- { key: F3, chars: "\x1bOR" }
- { key: F4, chars: "\x1bOS" }
- { key: F5, chars: "\x1b[15~" }
- { key: F6, chars: "\x1b[17~" }
- { key: F7, chars: "\x1b[18~" }
- { key: F8, chars: "\x1b[19~" }
- { key: F9, chars: "\x1b[20~" }
- { key: F10, chars: "\x1b[21~" }
- { key: F11, chars: "\x1b[23~" }
- { key: F12, chars: "\x1b[24~" }
- { key: F1, mods: Shift, chars: "\x1b[1;2P" }
- { key: F2, mods: Shift, chars: "\x1b[1;2Q" }
- { key: F3, mods: Shift, chars: "\x1b[1;2R" }
- { key: F4, mods: Shift, chars: "\x1b[1;2S" }
- { key: F5, mods: Shift, chars: "\x1b[15;2~" }
- { key: F6, mods: Shift, chars: "\x1b[17;2~" }
- { key: F7, mods: Shift, chars: "\x1b[18;2~" }
- { key: F8, mods: Shift, chars: "\x1b[19;2~" }
- { key: F9, mods: Shift, chars: "\x1b[20;2~" }
- { key: F10, mods: Shift, chars: "\x1b[21;2~" }
- { key: F11, mods: Shift, chars: "\x1b[23;2~" }
- { key: F12, mods: Shift, chars: "\x1b[24;2~" }
- { key: F1, mods: Control, chars: "\x1b[1;5P" }
- { key: F2, mods: Control, chars: "\x1b[1;5Q" }
- { key: F3, mods: Control, chars: "\x1b[1;5R" }
- { key: F4, mods: Control, chars: "\x1b[1;5S" }
- { key: F5, mods: Control, chars: "\x1b[15;5~" }
- { key: F6, mods: Control, chars: "\x1b[17;5~" }
- { key: F7, mods: Control, chars: "\x1b[18;5~" }
- { key: F8, mods: Control, chars: "\x1b[19;5~" }
- { key: F9, mods: Control, chars: "\x1b[20;5~" }
- { key: F10, mods: Control, chars: "\x1b[21;5~" }
- { key: F11, mods: Control, chars: "\x1b[23;5~" }
- { key: F12, mods: Control, chars: "\x1b[24;5~" }
- { key: F1, mods: Alt, chars: "\x1b[1;6P" }
- { key: F2, mods: Alt, chars: "\x1b[1;6Q" }
- { key: F3, mods: Alt, chars: "\x1b[1;6R" }
- { key: F4, mods: Alt, chars: "\x1b[1;6S" }
- { key: F5, mods: Alt, chars: "\x1b[15;6~" }
- { key: F6, mods: Alt, chars: "\x1b[17;6~" }
- { key: F7, mods: Alt, chars: "\x1b[18;6~" }
- { key: F8, mods: Alt, chars: "\x1b[19;6~" }
- { key: F9, mods: Alt, chars: "\x1b[20;6~" }
- { key: F10, mods: Alt, chars: "\x1b[21;6~" }
- { key: F11, mods: Alt, chars: "\x1b[23;6~" }
- { key: F12, mods: Alt, chars: "\x1b[24;6~" }
- { key: F1, mods: Super, chars: "\x1b[1;3P" }
- { key: F2, mods: Super, chars: "\x1b[1;3Q" }
- { key: F3, mods: Super, chars: "\x1b[1;3R" }
- { key: F4, mods: Super, chars: "\x1b[1;3S" }
- { key: F5, mods: Super, chars: "\x1b[15;3~" }
- { key: F6, mods: Super, chars: "\x1b[17;3~" }
- { key: F7, mods: Super, chars: "\x1b[18;3~" }
- { key: F8, mods: Super, chars: "\x1b[19;3~" }
- { key: F9, mods: Super, chars: "\x1b[20;3~" }
- { key: F10, mods: Super, chars: "\x1b[21;3~" }
- { key: F11, mods: Super, chars: "\x1b[23;3~" }
- { key: F12, mods: Super, chars: "\x1b[24;3~" }

4
bashrc
View File

@@ -62,9 +62,9 @@ if [ "$color_prompt" = yes ]; then
else
color="\033[1;35m"
fi
PS1="${color}┌── \u\033[33m@\033[32m\H\033[33m::\033[34m\w\033[0m\n${color}└▷ \033[0m"
PS1="${color}┌── \u\033[33m::\033[34m\w\033[0m\n${color}└▷ \033[0m"
else
PS1='${debian_chroot:+($debian_chroot)}\u@\H:\w\$ '
PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
fi
unset color_prompt force_color_prompt color

262
bin/server
View File

@@ -1,262 +0,0 @@
#! /usr/bin/env python
# Shamefully copied from this gist :
# https://gist.github.com/pankajp/280596a5dabaeeceaaaa/
# Standard library imports.
import sys
if sys.version_info[0] < 3:
from SocketServer import ThreadingMixIn
import BaseHTTPServer
from SimpleHTTPServer import SimpleHTTPRequestHandler
from urllib import quote, unquote
from cStringIO import StringIO
else:
import http.server as BaseHTTPServer
from http.server import SimpleHTTPRequestHandler
from socketserver import ThreadingMixIn
from urllib.parse import quote, unquote
from io import BytesIO as cStringIO
import os
from os.path import (join, exists, abspath, split, splitdrive, isdir)
from os import makedirs, unlink, getcwd, chdir, curdir, pardir, rename, fstat
from shutil import copyfileobj, copytree
import glob
from zipfile import ZipFile
from posixpath import normpath
import re
import cgi
import threading
import socket
import errno
DATA_DIR = getcwd()
class ThreadingHTTPServer(ThreadingMixIn, BaseHTTPServer.HTTPServer):
pass
class RequestHandler(SimpleHTTPRequestHandler):
""" Handler to handle POST requests for actions.
"""
serve_path = DATA_DIR
def do_GET(self):
""" Overridden to handle HTTP Range requests. """
self.range_from, self.range_to = self._get_range_header()
if self.range_from is None:
# nothing to do here
return SimpleHTTPRequestHandler.do_GET(self)
f = self.send_range_head()
if f:
self.copy_file_range(f, self.wfile)
f.close()
def copy_file_range(self, in_file, out_file):
""" Copy only the range in self.range_from/to. """
in_file.seek(self.range_from)
# Add 1 because the range is inclusive
left_to_copy = 1 + self.range_to - self.range_from
buf_length = 64 * 1024
bytes_copied = 0
while bytes_copied < left_to_copy:
read_buf = in_file.read(min(buf_length, left_to_copy - bytes_copied))
if len(read_buf) == 0:
break
out_file.write(read_buf)
bytes_copied += len(read_buf)
return bytes_copied
def send_range_head(self):
"""Common code for GET and HEAD commands.
This sends the response code and MIME headers.
Return value is either a file object (which has to be copied
to the outputfile by the caller unless the command was HEAD,
and must be closed by the caller under all circumstances), or
None, in which case the caller has nothing further to do.
"""
path = self.translate_path(self.path)
f = None
if isdir(path):
if not self.path.endswith('/'):
# redirect browser - doing basically what apache does
self.send_response(301)
self.send_header("Location", self.path + "/")
self.end_headers()
return None
for index in "index.html", "index.htm":
index = join(path, index)
if exists(index):
path = index
break
else:
return self.list_directory(path)
if not exists(path) and path.endswith('/data'):
# FIXME: Handle grits-like query with /data appended to path
# stupid grits
if exists(path[:-5]):
path = path[:-5]
ctype = self.guess_type(path)
try:
# Always read in binary mode. Opening files in text mode may cause
# newline translations, making the actual size of the content
# transmitted *less* than the content-length!
f = open(path, 'rb')
except IOError:
self.send_error(404, "File not found")
return None
if self.range_from is None:
self.send_response(200)
else:
self.send_response(206)
self.send_header("Content-type", ctype)
fs = fstat(f.fileno())
file_size = fs.st_size
if self.range_from is not None:
if self.range_to is None or self.range_to >= file_size:
self.range_to = file_size - 1
self.send_header("Content-Range",
"bytes %d-%d/%d" % (self.range_from,
self.range_to,
file_size))
# Add 1 because ranges are inclusive
self.send_header("Content-Length",
(1 + self.range_to - self.range_from))
else:
self.send_header("Content-Length", str(file_size))
self.send_header("Last-Modified", self.date_time_string(fs.st_mtime))
self.end_headers()
return f
def list_directory(self, path):
"""Helper to produce a directory listing (absent index.html).
Return value is either a file object, or None (indicating an
error). In either case, the headers are sent, making the
interface the same as for send_head().
"""
try:
list = os.listdir(path)
except os.error:
self.send_error(404, "No permission to list directory")
return None
list.sort(key=lambda a: a.lower())
f = StringIO()
displaypath = cgi.escape(unquote(self.path))
f.write('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">')
f.write("<html>\n<title>Directory listing for %s</title>\n" % displaypath)
f.write("<body>\n<h2>Directory listing for %s</h2>\n" % displaypath)
f.write("<hr>\n<ul>\n")
for name in list:
fullname = os.path.join(path, name)
displayname = linkname = name
# Append / for directories or @ for symbolic links
if os.path.isdir(fullname):
displayname = name + "/"
linkname = name + "/"
if os.path.islink(fullname):
displayname = name + "@"
# Note: a link to a directory displays with @ and links with /
f.write('<li><a href="%s">%s</a>\n'
% (quote(linkname), cgi.escape(displayname)))
f.write("</ul>\n<hr>\n</body>\n</html>\n")
length = f.tell()
f.seek(0)
self.send_response(200)
encoding = sys.getfilesystemencoding()
self.send_header("Content-type", "text/html; charset=%s" % encoding)
self.send_header("Content-Length", str(length))
self.end_headers()
return f
def translate_path(self, path):
""" Override to handle redirects.
"""
path = path.split('?', 1)[0]
path = path.split('#', 1)[0]
path = normpath(unquote(path))
words = path.split('/')
words = filter(None, words)
path = self.serve_path
for word in words:
drive, word = splitdrive(word)
head, word = split(word)
if word in (curdir, pardir): continue
path = join(path, word)
return path
# Private interface ######################################################
def _get_range_header(self):
""" Returns request Range start and end if specified.
If Range header is not specified returns (None, None)
"""
if sys.version_info[0] < 3:
range_header = self.headers.getheader("Range")
else:
range_header = self.headers.get("Range")
if range_header is None:
return (None, None)
if not range_header.startswith("bytes="):
return (None, None)
regex = re.compile(r"^bytes=(\d+)\-(\d+)?")
rangething = regex.search(range_header)
if rangething:
from_val = int(rangething.group(1))
if rangething.group(2) is not None:
return (from_val, int(rangething.group(2)))
else:
return (from_val, None)
else:
return (None, None)
def get_server(port=8000, next_attempts=0, serve_path=None):
Handler = RequestHandler
if serve_path:
Handler.serve_path = serve_path
while next_attempts >= 0:
try:
httpd = ThreadingHTTPServer(("", port), Handler)
return httpd
except socket.error as e:
if e.errno == errno.EADDRINUSE:
next_attempts -= 1
port += 1
else:
raise
def main(args=None):
if args is None:
args = sys.argv[1:]
PORT = 8000
if len(args) > 0:
PORT = int(args[-1])
serve_path = DATA_DIR
if len(args) > 1:
serve_path = abspath(args[-2])
httpd = get_server(port=PORT, serve_path=serve_path)
print("serving at port " + str(PORT))
httpd.serve_forever()
if __name__ == "__main__":
main()

50
bin/update
View File

@@ -162,13 +162,8 @@ update-system() {
return
fi
if [ -z "$password" ]; then
echo -e "\033[32;1m=== Starting system update, please enter your password ===\033[0m"
read -sep "Password: " password
fi
echo $password | sudo -Sp "" true > /dev/null 2>&1
echo -e "\033[32;1m=== Starting system update, please enter your password ===\033[0m"
sudo true
if [ $? -ne 0 ]; then
echo "Could not get sudo..."
return 1
@@ -180,48 +175,33 @@ update-system() {
# Debian based systems
command -v apt > /dev/null 2>&1
if [ $? -eq 0 ]; then
echo $password | sudo -Sp "" apt update -y
sudo apt update -y
if [ $? -eq 0 ]; then
echo $password | sudo -Sp "" apt upgrade -y
sudo apt upgrade -y
if [ $? -eq 0 ]; then
echo $password | sudo -Sp "" apt autoremove -y
sudo apt autoremove -y
fi
fi
fi
command -v snap > /dev/null 2>&1
if [ $? -eq 0 ]; then
echo $password | sudo -Sp "" snap refresh
fi
# Archlinux based systems
command -v paru > /dev/null 2>&1
command -v yay > /dev/null 2>&1
if [ $? -eq 0 ]; then
paru -Syu --noconfirm
yay -Syu --noconfirm
yay -Syua --noconfirm
else
command -v yay > /dev/null 2>&1
command -v pacman > /dev/null 2>&1
if [ $? -eq 0 ]; then
yay -Syu --noconfirm
yay -Syua --noconfirm
else
command -v pacman > /dev/null 2>&1
if [ $? -eq 0 ]; then
echo $password | sudo -Sp "" pacman -Syu --noconfirm
fi
sudo pacman -Syu --noconfirm
fi
fi
# Fedora based systems
command -v dnf > /dev/null 2>&1
if [ $? -eq 0 ]; then
echo $password | sudo -Sp "" dnf upgrade
sudo dnf upgrade
fi
local seconds=$((`date +%s` - $start))
@@ -483,12 +463,6 @@ partial-update() {
main() {
if [ "$1" == "--pass" ]; then
shift
password=$1
shift
fi
if [ $# -eq 0 ]; then
_lock_or_error_message
local error_code=$?
@@ -497,7 +471,7 @@ main() {
fi
local start=`date +%s`
echo -e "\033[32;1m=== Starting full update of $(whoami)@$(hostname) ===\033[0m"
echo -e "\033[32;1m=== Starting full update ===\033[0m"
# Update the system
_check_running

6
bin/video2gif
View File

@@ -12,10 +12,10 @@ fi
palette_dir=$(mktemp -d)
ffmpeg -y -ss $2 -to $3 -i $1 \
ffmpeg -y -ss $2 -t $3 -i $1 \
-vf fps=30,scale=320:-1:flags=lanczos,palettegen $palette_dir/palette.png > /dev/null 2>&1
ffmpeg -ss $2 -to $3 -i $1 -i $palette_dir/palette.png -filter_complex \
"fps=30,scale=640:-1:flags=lanczos[x];[x][1:v]paletteuse" -y output.gif > /dev/null 2>&1
ffmpeg -ss $2 -t $3 -i $1 -i $palette_dir/palette.png -filter_complex \
"fps=30,scale=320:-1:flags=lanczos[x];[x][1:v]paletteuse" -y output.gif > /dev/null 2>&1
rm -rf $palette_dir

4
coc-settings.json
View File

@@ -2,11 +2,11 @@
"languageserver": {
"rust": {
"command": "rustup",
"args": ["run", "stable", "rust-analyzer"],
"args": ["run", "nightly", "rust-analyzer"],
"filetypes": ["rust"],
"rootPatterns": ["Cargo.toml"]
},
"elmLS": {
"elm": {
"command": "elm-language-server",
"filetypes": ["elm"],
"rootPatterns": ["elm.json"]

86
init.vim
View File

@@ -4,19 +4,16 @@ set nocompatible
" PLUGNIS ###########################################################{{{
call plug#begin()
" Conquer of Completion
Plug 'neoclide/coc.nvim', {'branch': 'release'}
" General plugins
Plug 'vim-airline/vim-airline'
Plug 'vim-airline/vim-airline-themes'
Plug 'https://gitea.tforgione.fr/tforgione/peach.git'
Plug 'scrooloose/nerdtree'
Plug 'tpope/vim-abolish'
Plug 'lambdalisue/suda.vim'
" Language specific plugins
" Rust
Plug 'rust-lang/rust.vim'
@@ -29,9 +26,6 @@ Plug 'cespare/vim-toml'
" Pug
Plug 'digitaltoad/vim-pug'
" Typst
Plug 'kaarmu/typst.vim'
call plug#end()
" Line numbers and syntaxic coloration
@@ -46,10 +40,6 @@ set expandtab
set tabstop=4
set shiftwidth=4
set autoindent
set tw=120
if !empty($NVIM_TEXT_WIDTH)
execute 'set tw=' . $NVIM_TEXT_WIDTH
endif
" }}}
" UI CONFIG #########################################################{{{
@@ -83,9 +73,6 @@ elseif executable('make')
vnoremap <silent><F12> :wa \|!make -p %:p<CR>
endif
" SudaWrite with W
command W SudaWrite
" Escape on F1
map <F1> <Esc>
imap <F1> <Esc>
@@ -154,71 +141,22 @@ let g:markdown_composer_browser = 'firefox'
let g:instant_markdown_autostart = 0
" }}}
" COC CONFIG ########################################################{{{
" Use `[g` and `]g` to navigate diagnostics
" Use `:CocDiagnostics` to get all diagnostics of current buffer in location list.
nmap <silent> gp <Plug>(coc-diagnostic-prev)
nmap <silent> gn <Plug>(coc-diagnostic-next)
" GoTo code navigation.
nmap <silent> gd <Plug>(coc-definition)
nmap <silent> gy <Plug>(coc-type-definition)
nmap <silent> gi <Plug>(coc-implementation)
nmap <silent> gr <Plug>(coc-references)
" Add `:Format` command to format current buffer.
command! -nargs=0 Format :call CocAction('format')
" Use K to show documentation in preview window.
nnoremap <silent> K :call <SID>show_documentation()<CR>
function! s:show_documentation()
if (index(['vim','help'], &filetype) >= 0)
execute 'h '.expand('<cword>')
elseif (coc#rpc#ready())
call CocActionAsync('doHover')
else
execute '!' . &keywordprg . " " . expand('<cword>')
endif
endfunction
" Having longer updatetime (default is 4000 ms = 4 s) leads to noticeable
" delays and poor user experience.
set updatetime=300
" Highlight the symbol and its references when holding the cursor.
autocmd CursorHold * silent call CocActionAsync('highlight')
" Symbol renaming.
nmap <leader>rn <Plug>(coc-rename)
" Formatting selected code.
xmap <leader>f <Plug>(coc-format-selected)
nmap <leader>f <Plug>(coc-format-selected)
" Autoclose preview
autocmd CursorMovedI * if pumvisible() == 0|pclose|endif
autocmd InsertLeave * if pumvisible() == 0|pclose|endif
" Complete on tab
" inoremap <expr><TAB> pumvisible() ? "\<C-n>" : "\<TAB>"
function! s:check_back_space() abort
let col = col('.') - 1
return !col || getline('.')[col - 1] =~ '\s'
endfunction
" Insert <tab> when previous text is space, refresh completion if not.
inoremap <silent><expr> <TAB>
\ coc#pum#visible() ? coc#pum#next(1):
\ <SID>check_back_space() ? "\<Tab>" :
\ coc#refresh()
inoremap <expr><S-TAB> coc#pum#visible() ? coc#pum#prev(1) : "\<C-h>"
" }}}
" CUSTOM THINGS DEPENDING ON ENV ####################################{{{
let g:rustfmt_autosave = 1
" Apprently some people don't use vim
" set autoread | au CursorHold * checktime | call feedkeys("lh")
let g:ale_linters = {}
let g:ale_c_parse_compile_commands=1
let g:ale_elm_ls_use_global = 1
let g:ale_linters_ignore = { 'elm': ['make'] }
let g:ale_lint_on_text_changed = 0
if $NVIM_DISABLE_PYTHON_LINTER == '1'
let g:ale_linters.python = []
endif
if $NVIM_DISABLE_JAVA_LINTER == '1'
let g:ale_linters.java = []
endif

14
nushell/config.nu
View File

@@ -1,14 +0,0 @@
source ~/.config/nushell/config/init.nu
source ~/.config/nushell/config/extra.nu
source ~/.config/nushell/config/mount.nu
source ~/.config/nushell/config/config.nu
source ~/.config/nushell/config/aliases.nu
source ~/.config/nushell/config/git.nu
source ~/.config/nushell/config/ssh.nu
source ~/.config/nushell/config/update.nu
source ~/.config/nushell/config/gclone.nu
source ~/.config/nushell/config/pass.nu
source ~/.config/nushell/config/docker.nu
source ~/.config/nushell/config/xrandr.nu
source ~/.config/nushell/config/tfetch.nu

137
nushell/config/aliases.nu
View File

@@ -1,137 +0,0 @@
# replace /home/$USER by ~
def tildize [] {
if ($in | path split | zip ($env.HOME | path split) | all { $in.0 == $in.1 }) {
($in | str replace $env.HOME "~")
} else {
$in
}
}
# remove extension shortcut
def rm-ext [] {
$in | path parse | udpate extension "" | get parent stem | str join "/"
}
# ls builtin
alias _ls = ls
# shortcut for ls builtin
alias l = _ls
def _ls_format_mode [mode: string] {
let chars = $mode | split chars
let r1 = if ($chars | get 0) == "r" { [(ansi yellow_bold), "r", (ansi reset)] } else { [(ansi grey), "-"] }
let w1 = if ($chars | get 1) == "w" { [(ansi red_bold), "w", (ansi reset)] } else { [(ansi grey), "-"] }
let x1 = if ($chars | get 2) == "x" { [(ansi green_bold), "x", (ansi reset)] } else { [(ansi grey), "-"] }
let r2 = if ($chars | get 3) == "r" { [(ansi yellow), "r", (ansi reset)] } else { [(ansi grey), "-"] }
let w2 = if ($chars | get 4) == "w" { [(ansi red), "w"] } else { [(ansi grey), "-"] }
let x2 = if ($chars | get 5) == "x" { [(ansi green), "x"] } else { [(ansi grey), "-"] }
let r3 = if ($chars | get 6) == "r" { [(ansi yellow), "r", (ansi reset)] } else { [(ansi grey), "-"] }
let w3 = if ($chars | get 7) == "w" { [(ansi red), "w"] } else { [(ansi grey), "-"] }
let x3 = if ($chars | get 8) == "x" { [(ansi green), "x"] } else { [(ansi grey), "-"] }
[$r1, $w1, $x1, $r2, $w2, $x2, $r3, $w3, $x3] | each { $in | str join } | str join
}
# quick and easy ls
def ls [dir?: string] {
let output = _ls (if $dir == null { "" } else { $dir }) | sort-by type name -i
if ($output | length) == 0 { "" | cat } else { $output | grid -c -s " " | cat }
}
# ls with hidden files
def la [dir?: string] {
_ls -al (if $dir == null { "" } else { $dir })
| sort-by type name -i
| each { $in | update mode (_ls_format_mode $in.mode) }
| select mode name target user size modified
}
# ls with details
def ll [dir?: string] {
_ls -l (if $dir == null { "" } else { $dir })
| each { $in | update mode (_ls_format_mode $in.mode) }
| sort-by type name -i
| select mode name target user size modified
}
# du builtin
alias _du = du
# non recursive du
def du [...args] {
let parsed_args = if ($args | is-empty) { ["*"] } else { $args }
$parsed_args | each { _du -a $in | select path apparent physical } | flatten
}
# df
def df [] {
^df -h
| str replace "Sys. de fichiers" "@"
| str replace "Monté sur" "@"
| detect columns
| rename "filesystem" "size" "used" "available" "used%" "mountpoint"
}
# easy markdown formamtter
def to-md [] {
let arg = $in
$env.config.table.mode = markdown;
echo $arg
}
# Useful aliases
# colored ip
alias ip = ip -c
# neovim
alias v = nvim
# quit
alias :q = exit
# evince in background
def pdf [arg: string] {
pueue add evince ($arg | str replace ' ' '\ ')
}
# ripgrep
alias rg = rg -uu
# mkdir && cd
def --env mkcd [dir: string] { mkdir $dir; cd $dir }
# run command in background
alias pa = pueue add --immediate
# show background commands
def pst [] {
pueue status -j
| from json
| get tasks
| transpose
| each { $in | get column1 }
| each {
let stdin = $in
$stdin | update status (
if $stdin.status == "Running" {
((ansi yellow) + "Running")
} else if not (echo $stdin.status | get -i Done | is-empty) {
let exit_value = $stdin.status | get "Done"
if ($exit_value == "Success") {
((ansi green) + "Success")
} else {
(ansi red) + "Failed (" + ($exit_value | get "Failed" | into string) + ")"
}
} else {
"Unknown???"
}
)
| update path ($in.path | tildize)
| update start ((ansi magenta) + ($in.start | date humanize))
| update end ((ansi magenta) + ($in.end | date humanize))
}
| select status command path start end
}

16
nushell/config/config.nu
View File

@@ -1,16 +0,0 @@
# Change default config
$env.config.keybindings = (echo $env.config.keybindings | append {
name: newline_or_run_command_2
modifier: CONTROL
keycode: char_j
mode: emacs
event: {send: enter}
})
$env.config.show_banner = false
$env.config.use_grid_icons = false
$env.config.cursor_shape.emacs = block
$env.config.history.max_size = 1_000_000_000_000_000
$env.config.history.file_format = "sqlite"
$env.config.history.isolation = true
$env.config.filesize.metric = false

81
nushell/config/docker.nu
View File

@@ -1,81 +0,0 @@
# docker aliases
# lazydocker
alias ld = lazydocker
# docker-compose
alias dc = docker-compose
# docker-compose build
alias dcb = docker-compose build
# docker-compose build and push
def dcp [] { docker-compose build; docker-compose push }
# docker-compose up with build and remove-orphans
alias dcu = docker-compose up -d --build --remove-orphans
# docker-compose down
alias dcd = docker-compose down
# docker-compose down and up
def dcr [] { docker-compose down; docker-compose up -d --build --remove-orphans }
# kubernetes aliases
$env.KUBECONFIG = if ([$env.HOME, .kubes, current-cube] | path join | path exists) {
open ([$env.HOME, .kubes, current-cube] | path join)
} else {
""
}
def _kube_kubes [] {
_ls ~/.kubes | where type == dir | get name | path basename
}
# easily switch kube config
def --env kube [name?: string@_kube_kubes] {
use assert
let kubes_path = [$env.HOME, .kubes] | path join
if $name == null {
rm ([$kubes_path, current-cube] | path join)
$env.KUBECONFIG = ""
return
}
let kube_config = [$kubes_path, $name, config] | path join
if not ($kube_config | path exists) {
error make {msg: ($kube_config + " does not exist")}
}
$kube_config | save -f ([$kubes_path, current-cube] | path join)
$env.KUBECONFIG = $kube_config
}
# k9s
alias kns = k9s -n all
# lazydocker / k9s shortcut for each compose / cluster
alias mnemosyne = ssh phoenix -t "cd infra && /home/polymny/.local/bin/lazydocker"
alias zeus = k9s -n all --kubeconfig ($env.HOME + '/.kubes/zeus/config')
alias safir = k9s -n all --kubeconfig ($env.HOME + '/.kubes/safir/config')
# start minikube with test kube
def "minikube start" [] {
$env.KUBECONFIG = ([$env.HOME, '.kubes', 'test', 'config'] | path join)
^minikube start
}
# stop minikube with test kube
def "minikube stop" [] {
$env.KUBECONFIG = ([$env.HOME, '.kubes', 'test', 'config'] | path join)
^minikube stop
}
# delete minikube with test kube
def "minikube delete" [] {
$env.KUBECONFIG = ([$env.HOME, '.kubes', 'test', 'config'] | path join)
^minikube delete
}

141
nushell/config/gclone.nu
View File

@@ -1,141 +0,0 @@
# gclone aliases
def _gclone_dirs [] {
_ls ($env.GCLONE_PATH + "/*")
| append (_ls ($env.GCLONE_PATH + "/*/*"))
| append (_ls ($env.GCLONE_PATH + "/*/*/*"))
| each { $in.name | path basename }
| sort
| uniq
}
# cd to a git directory
def --env cdg [key: string@_gclone_dirs] {
let dir = _ls ($env.GCLONE_PATH + "/*")
| append (_ls ($env.GCLONE_PATH + "/*/*"))
| append (_ls ($env.GCLONE_PATH + "/*/*/*"))
| where { $in != null and ($in.name | path basename) == $key }
match ($dir | length) {
0 => {
print (
(ansi red_bold) + "error" +
(ansi reset) + (ansi attr_bold) + ":" +
(ansi reset) + " no such file or directory"
)
return
}
1 => {
cd $dir.0.name
}
_ => {
print (
(ansi attr_bold) + "info:" +
(ansi reset) + " multiple entries found, please select one"
)
echo $dir
print (
(ansi --escape 'A') +
(ansi attr_bold) + "Enter your choice: " + (ansi reset)
)
let choice = input
if not ($choice =~ "^[0-9]*$") {
print (
(ansi red_bold) + "error" +
(ansi reset) + (ansi attr_bold) + ":" +
(ansi reset) + " couldn't parse integer"
)
return
}
let choice = $choice | into int
if $choice >= ($dir | length) {
print (
(ansi red_bold) + "error" +
(ansi reset) + (ansi attr_bold) + ":" +
(ansi reset) + " integer is outside range"
)
return
}
cd ($dir | get $choice | get name)
}
}
}
# clone repository in the right place
def gclone [repo_url: string] {
let attr = if ($repo_url | str starts-with "https://") {
$repo_url | parse "https://{server}/{owner}/{repo}" | get 0
} else if ($repo_url | str starts-with "http://") {
$repo_url | parse "http://{server}/{owner}/{repo}" | get 0
} else if ($repo_url | str starts-with "ssh://") {
$repo_url | parse "ssh://git@{server}/{owner}/{repo}" | get 0
} else if ($repo_url | str starts-with "git@") {
$repo_url | parse "git@{server}:{owner}/{repo}" | get 0
} else {
print (
(ansi red_bold) + "error" +
(ansi reset) + (ansi attr_bold) + ":" +
(ansi reset) + " failed to parse repo url"
)
return
}
let server = $attr.server
let server_portless = $attr.server | split row ':' | get 0
let owner = $attr.owner
let repo = $attr.repo
let target = [$env.GCLONE_PATH, $server_portless, $owner, $repo] | path join
let target = if ($target | str ends-with '.git') {
$target | path parse | update extension "" | get parent stem | str join "/"
} else {
$target
}
if ($target | path exists) {
print (
(ansi red_bold) + "error" +
(ansi reset) + (ansi attr_bold) + ":" +
(ansi reset) + " clone target already exists"
)
return
}
let clone_url = if $env.GCLONE_FORCE_SSH {
$attr | format "ssh://git@{server}/{owner}/{repo}"
} else {
$repo_url
}
print -n (
(ansi attr_bold) + "info:" +
(ansi reset) + " cloning " + $clone_url + "..."
)
let clone = do { git clone --recurse-submodules $clone_url $target } | complete
if $clone.exit_code == 0 {
print " done!"
} else {
print (
"\n" + (ansi red_bold) + "error" +
(ansi reset) + (ansi attr_bold) + ":" +
(ansi reset) + " clone failed:"
)
print -n $clone.stderr
}
}

46
nushell/config/git.nu
View File

@@ -1,46 +0,0 @@
# git aliases
# git
alias g = git
# git add
alias ga = git add
# git add --all
alias gaa = git add --all
# git checkout
alias gco = git checkout
# git checkout -b
alias gcb = git checkout -b
# git commit
alias gc = git commit --verbose
# git commit --all
alias gca = git commit --verbose --all
# git diff
alias gd = git diff
# git log
alias glog = git log --oneline --decorate --graph
# git pull
alias gl = git pull
# git push
alias gp = git push
# git status
alias gst = git status
# git status
alias gs = git status
# git merge
alias gm = git merge
# git push --set-upstream ...
def gpsup [] { git push --set-upstream origin (git rev-parse --abbrev-ref HEAD) }

757
nushell/config/init.nu
View File

@@ -1,757 +0,0 @@
# Nushell Config File
#
# version = "0.86.0"
# For more information on defining custom themes, see
# https://www.nushell.sh/book/coloring_and_theming.html
# And here is the theme collection
# https://github.com/nushell/nu_scripts/tree/main/themes
let dark_theme = {
# color for nushell primitives
separator: white
leading_trailing_space_bg: { attr: n } # no fg, no bg, attr none effectively turns this off
header: green_bold
empty: blue
# Closures can be used to choose colors for specific values.
# The value (in this case, a bool) is piped into the closure.
# eg) {|| if $in { 'light_cyan' } else { 'light_gray' } }
bool: light_cyan
int: white
filesize: cyan
duration: white
date: purple
range: white
float: white
string: white
nothing: white
binary: white
cell-path: white
row_index: green_bold
record: white
list: white
block: white
hints: dark_gray
search_result: {bg: red fg: white}
shape_and: purple_bold
shape_binary: purple_bold
shape_block: blue_bold
shape_bool: light_cyan
shape_closure: green_bold
shape_custom: green
shape_datetime: cyan_bold
shape_directory: cyan
shape_external: cyan
shape_externalarg: green_bold
shape_filepath: cyan
shape_flag: blue_bold
shape_float: purple_bold
# shapes are used to change the cli syntax highlighting
shape_garbage: { fg: white bg: red attr: b}
shape_globpattern: cyan_bold
shape_int: purple_bold
shape_internalcall: cyan_bold
shape_list: cyan_bold
shape_literal: blue
shape_match_pattern: green
shape_matching_brackets: { attr: u }
shape_nothing: light_cyan
shape_operator: yellow
shape_or: purple_bold
shape_pipe: purple_bold
shape_range: yellow_bold
shape_record: cyan_bold
shape_redirection: purple_bold
shape_signature: green_bold
shape_string: green
shape_string_interpolation: cyan_bold
shape_table: blue_bold
shape_variable: purple
shape_vardecl: purple
}
let light_theme = {
# color for nushell primitives
separator: dark_gray
leading_trailing_space_bg: { attr: n } # no fg, no bg, attr none effectively turns this off
header: green_bold
empty: blue
# Closures can be used to choose colors for specific values.
# The value (in this case, a bool) is piped into the closure.
# eg) {|| if $in { 'dark_cyan' } else { 'dark_gray' } }
bool: dark_cyan
int: dark_gray
filesize: cyan_bold
duration: dark_gray
date: purple
range: dark_gray
float: dark_gray
string: dark_gray
nothing: dark_gray
binary: dark_gray
cell-path: dark_gray
row_index: green_bold
record: white
list: white
block: white
hints: dark_gray
search_result: {fg: white bg: red}
shape_and: purple_bold
shape_binary: purple_bold
shape_block: blue_bold
shape_bool: light_cyan
shape_closure: green_bold
shape_custom: green
shape_datetime: cyan_bold
shape_directory: cyan
shape_external: cyan
shape_externalarg: green_bold
shape_filepath: cyan
shape_flag: blue_bold
shape_float: purple_bold
# shapes are used to change the cli syntax highlighting
shape_garbage: { fg: white bg: red attr: b}
shape_globpattern: cyan_bold
shape_int: purple_bold
shape_internalcall: cyan_bold
shape_list: cyan_bold
shape_literal: blue
shape_match_pattern: green
shape_matching_brackets: { attr: u }
shape_nothing: light_cyan
shape_operator: yellow
shape_or: purple_bold
shape_pipe: purple_bold
shape_range: yellow_bold
shape_record: cyan_bold
shape_redirection: purple_bold
shape_signature: green_bold
shape_string: green
shape_string_interpolation: cyan_bold
shape_table: blue_bold
shape_variable: purple
shape_vardecl: purple
}
# External completer example
# let carapace_completer = {|spans|
# carapace $spans.0 nushell $spans | from json
# }
# The default config record. This is where much of your global configuration is setup.
$env.config = {
show_banner: true # true or false to enable or disable the welcome banner at startup
ls: {
use_ls_colors: true # use the LS_COLORS environment variable to colorize output
clickable_links: true # enable or disable clickable links. Your terminal has to support links.
}
rm: {
always_trash: false # always act as if -t was given. Can be overridden with -p
}
table: {
mode: rounded # basic, compact, compact_double, light, thin, with_love, rounded, reinforced, heavy, none, other
index_mode: always # "always" show indexes, "never" show indexes, "auto" = show indexes when a table has "index" column
show_empty: true # show 'empty list' and 'empty record' placeholders for command output
padding: { left: 1, right: 1 } # a left right padding of each column in a table
trim: {
methodology: wrapping # wrapping or truncating
wrapping_try_keep_words: true # A strategy used by the 'wrapping' methodology
truncating_suffix: "..." # A suffix used by the 'truncating' methodology
}
header_on_separator: false # show header text on separator/border line
# abbreviated_row_count: 10 # limit data rows from top and bottom after reaching a set point
}
error_style: "fancy" # "fancy" or "plain" for screen reader-friendly error messages
# datetime_format determines what a datetime rendered in the shell would look like.
# Behavior without this configuration point will be to "humanize" the datetime display,
# showing something like "a day ago."
datetime_format: {
# normal: '%a, %d %b %Y %H:%M:%S %z' # shows up in displays of variables or other datetime's outside of tables
# table: '%m/%d/%y %I:%M:%S%p' # generally shows up in tabular outputs such as ls. commenting this out will change it to the default human readable datetime format
}
explore: {
status_bar_background: {fg: "#1D1F21", bg: "#C4C9C6"},
command_bar_text: {fg: "#C4C9C6"},
highlight: {fg: "black", bg: "yellow"},
status: {
error: {fg: "white", bg: "red"},
warn: {}
info: {}
},
table: {
split_line: {fg: "#404040"},
selected_cell: {bg: light_blue},
selected_row: {},
selected_column: {},
},
}
history: {
max_size: 100_000 # Session has to be reloaded for this to take effect
sync_on_enter: true # Enable to share history between multiple sessions, else you have to close the session to write history to file
file_format: "plaintext" # "sqlite" or "plaintext"
isolation: false # only available with sqlite file_format. true enables history isolation, false disables it. true will allow the history to be isolated to the current session using up/down arrows. false will allow the history to be shared across all sessions.
}
completions: {
case_sensitive: false # set to true to enable case-sensitive completions
quick: true # set this to false to prevent auto-selecting completions when only one remains
partial: true # set this to false to prevent partial filling of the prompt
algorithm: "prefix" # prefix or fuzzy
external: {
enable: true # set to false to prevent nushell looking into $env.PATH to find more suggestions, `false` recommended for WSL users as this look up may be very slow
max_results: 100 # setting it lower can improve completion performance at the cost of omitting some options
completer: null # check 'carapace_completer' above as an example
}
}
filesize: {
metric: true # true => KB, MB, GB (ISO standard), false => KiB, MiB, GiB (Windows standard)
format: "auto" # b, kb, kib, mb, mib, gb, gib, tb, tib, pb, pib, eb, eib, auto
}
cursor_shape: {
emacs: line # block, underscore, line, blink_block, blink_underscore, blink_line, inherit to skip setting cursor shape (line is the default)
vi_insert: block # block, underscore, line, blink_block, blink_underscore, blink_line, inherit to skip setting cursor shape (block is the default)
vi_normal: underscore # block, underscore, line, blink_block, blink_underscore, blink_line, inherit to skip setting cursor shape (underscore is the default)
}
color_config: $dark_theme # if you want a more interesting theme, you can replace the empty record with `$dark_theme`, `$light_theme` or another custom record
use_grid_icons: true
footer_mode: "25" # always, never, number_of_rows, auto
float_precision: 2 # the precision for displaying floats in tables
buffer_editor: "" # command that will be used to edit the current line buffer with ctrl+o, if unset fallback to $env.EDITOR and $env.VISUAL
use_ansi_coloring: true
bracketed_paste: true # enable bracketed paste, currently useless on windows
edit_mode: emacs # emacs, vi
shell_integration: false # enables terminal shell integration. Off by default, as some terminals have issues with this.
render_right_prompt_on_last_line: false # true or false to enable or disable right prompt to be rendered on last line of the prompt.
use_kitty_protocol: false # enables keyboard enhancement protocol implemented by kitty console, only if your terminal support this
hooks: {
pre_prompt: [{ null }] # run before the prompt is shown
pre_execution: [{ null }] # run before the repl input is run
env_change: {
PWD: [{|before, after| null }] # run if the PWD environment is different since the last repl input
}
display_output: "if (term size).columns >= 100 { table -e } else { table }" # run to display the output of a pipeline
command_not_found: { null } # return an error message when a command is not found
}
menus: [
# Configuration for default nushell menus
# Note the lack of source parameter
{
name: completion_menu
only_buffer_difference: false
marker: "| "
type: {
layout: columnar
columns: 4
col_width: 20 # Optional value. If missing all the screen width is used to calculate column width
col_padding: 2
}
style: {
text: green
selected_text: green_reverse
description_text: yellow
}
}
{
name: history_menu
only_buffer_difference: true
marker: "? "
type: {
layout: list
page_size: 10
}
style: {
text: green
selected_text: green_reverse
description_text: yellow
}
}
{
name: help_menu
only_buffer_difference: true
marker: "? "
type: {
layout: description
columns: 4
col_width: 20 # Optional value. If missing all the screen width is used to calculate column width
col_padding: 2
selection_rows: 4
description_rows: 10
}
style: {
text: green
selected_text: green_reverse
description_text: yellow
}
}
]
keybindings: [
{
name: completion_menu
modifier: none
keycode: tab
mode: [emacs vi_normal vi_insert]
event: {
until: [
{ send: menu name: completion_menu }
{ send: menunext }
{ edit: complete }
]
}
}
{
name: history_menu
modifier: control
keycode: char_r
mode: [emacs, vi_insert, vi_normal]
event: { send: menu name: history_menu }
}
{
name: help_menu
modifier: none
keycode: f1
mode: [emacs, vi_insert, vi_normal]
event: { send: menu name: help_menu }
}
{
name: completion_previous_menu
modifier: shift
keycode: backtab
mode: [emacs, vi_normal, vi_insert]
event: { send: menuprevious }
}
{
name: next_page_menu
modifier: control
keycode: char_x
mode: emacs
event: { send: menupagenext }
}
{
name: undo_or_previous_page_menu
modifier: control
keycode: char_z
mode: emacs
event: {
until: [
{ send: menupageprevious }
{ edit: undo }
]
}
}
{
name: escape
modifier: none
keycode: escape
mode: [emacs, vi_normal, vi_insert]
event: { send: esc } # NOTE: does not appear to work
}
{
name: cancel_command
modifier: control
keycode: char_c
mode: [emacs, vi_normal, vi_insert]
event: { send: ctrlc }
}
{
name: quit_shell
modifier: control
keycode: char_d
mode: [emacs, vi_normal, vi_insert]
event: { send: ctrld }
}
{
name: clear_screen
modifier: control
keycode: char_l
mode: [emacs, vi_normal, vi_insert]
event: { send: clearscreen }
}
{
name: search_history
modifier: control
keycode: char_q
mode: [emacs, vi_normal, vi_insert]
event: { send: searchhistory }
}
{
name: open_command_editor
modifier: control
keycode: char_o
mode: [emacs, vi_normal, vi_insert]
event: { send: openeditor }
}
{
name: move_up
modifier: none
keycode: up
mode: [emacs, vi_normal, vi_insert]
event: {
until: [
{send: menuup}
{send: up}
]
}
}
{
name: move_down
modifier: none
keycode: down
mode: [emacs, vi_normal, vi_insert]
event: {
until: [
{send: menudown}
{send: down}
]
}
}
{
name: move_left
modifier: none
keycode: left
mode: [emacs, vi_normal, vi_insert]
event: {
until: [
{send: menuleft}
{send: left}
]
}
}
{
name: move_right_or_take_history_hint
modifier: none
keycode: right
mode: [emacs, vi_normal, vi_insert]
event: {
until: [
{send: historyhintcomplete}
{send: menuright}
{send: right}
]
}
}
{
name: move_one_word_left
modifier: control
keycode: left
mode: [emacs, vi_normal, vi_insert]
event: {edit: movewordleft}
}
{
name: move_one_word_right_or_take_history_hint
modifier: control
keycode: right
mode: [emacs, vi_normal, vi_insert]
event: {
until: [
{send: historyhintwordcomplete}
{edit: movewordright}
]
}
}
{
name: move_to_line_start
modifier: none
keycode: home
mode: [emacs, vi_normal, vi_insert]
event: {edit: movetolinestart}
}
{
name: move_to_line_start
modifier: control
keycode: char_a
mode: [emacs, vi_normal, vi_insert]
event: {edit: movetolinestart}
}
{
name: move_to_line_end_or_take_history_hint
modifier: none
keycode: end
mode: [emacs, vi_normal, vi_insert]
event: {
until: [
{send: historyhintcomplete}
{edit: movetolineend}
]
}
}
{
name: move_to_line_end_or_take_history_hint
modifier: control
keycode: char_e
mode: [emacs, vi_normal, vi_insert]
event: {
until: [
{send: historyhintcomplete}
{edit: movetolineend}
]
}
}
{
name: move_to_line_start
modifier: control
keycode: home
mode: [emacs, vi_normal, vi_insert]
event: {edit: movetolinestart}
}
{
name: move_to_line_end
modifier: control
keycode: end
mode: [emacs, vi_normal, vi_insert]
event: {edit: movetolineend}
}
{
name: move_up
modifier: control
keycode: char_p
mode: [emacs, vi_normal, vi_insert]
event: {
until: [
{send: menuup}
{send: up}
]
}
}
{
name: move_down
modifier: control
keycode: char_t
mode: [emacs, vi_normal, vi_insert]
event: {
until: [
{send: menudown}
{send: down}
]
}
}
{
name: delete_one_character_backward
modifier: none
keycode: backspace
mode: [emacs, vi_insert]
event: {edit: backspace}
}
{
name: delete_one_word_backward
modifier: control
keycode: backspace
mode: [emacs, vi_insert]
event: {edit: backspaceword}
}
{
name: delete_one_character_forward
modifier: none
keycode: delete
mode: [emacs, vi_insert]
event: {edit: delete}
}
{
name: delete_one_character_forward
modifier: control
keycode: delete
mode: [emacs, vi_insert]
event: {edit: delete}
}
{
name: delete_one_character_forward
modifier: control
keycode: char_h
mode: [emacs, vi_insert]
event: {edit: backspace}
}
{
name: delete_one_word_backward
modifier: control
keycode: char_w
mode: [emacs, vi_insert]
event: {edit: backspaceword}
}
{
name: move_left
modifier: none
keycode: backspace
mode: vi_normal
event: {edit: moveleft}
}
{
name: newline_or_run_command
modifier: none
keycode: enter
mode: emacs
event: {send: enter}
}
{
name: move_left
modifier: control
keycode: char_b
mode: emacs
event: {
until: [
{send: menuleft}
{send: left}
]
}
}
{
name: move_right_or_take_history_hint
modifier: control
keycode: char_f
mode: emacs
event: {
until: [
{send: historyhintcomplete}
{send: menuright}
{send: right}
]
}
}
{
name: redo_change
modifier: control
keycode: char_g
mode: emacs
event: {edit: redo}
}
{
name: undo_change
modifier: control
keycode: char_z
mode: emacs
event: {edit: undo}
}
{
name: paste_before
modifier: control
keycode: char_y
mode: emacs
event: {edit: pastecutbufferbefore}
}
{
name: cut_word_left
modifier: control
keycode: char_w
mode: emacs
event: {edit: cutwordleft}
}
{
name: cut_line_to_end
modifier: control
keycode: char_k
mode: emacs
event: {edit: cuttoend}
}
{
name: cut_line_from_start
modifier: control
keycode: char_u
mode: emacs
event: {edit: cutfromstart}
}
{
name: swap_graphemes
modifier: control
keycode: char_t
mode: emacs
event: {edit: swapgraphemes}
}
{
name: move_one_word_left
modifier: alt
keycode: left
mode: emacs
event: {edit: movewordleft}
}
{
name: move_one_word_right_or_take_history_hint
modifier: alt
keycode: right
mode: emacs
event: {
until: [
{send: historyhintwordcomplete}
{edit: movewordright}
]
}
}
{
name: move_one_word_left
modifier: alt
keycode: char_b
mode: emacs
event: {edit: movewordleft}
}
{
name: move_one_word_right_or_take_history_hint
modifier: alt
keycode: char_f
mode: emacs
event: {
until: [
{send: historyhintwordcomplete}
{edit: movewordright}
]
}
}
{
name: delete_one_word_forward
modifier: alt
keycode: delete
mode: emacs
event: {edit: deleteword}
}
{
name: delete_one_word_backward
modifier: alt
keycode: backspace
mode: emacs
event: {edit: backspaceword}
}
{
name: delete_one_word_backward
modifier: alt
keycode: char_m
mode: emacs
event: {edit: backspaceword}
}
{
name: cut_word_to_right
modifier: alt
keycode: char_d
mode: emacs
event: {edit: cutwordright}
}
{
name: upper_case_word
modifier: alt
keycode: char_u
mode: emacs
event: {edit: uppercaseword}
}
{
name: lower_case_word
modifier: alt
keycode: char_l
mode: emacs
event: {edit: lowercaseword}
}
{
name: capitalize_char
modifier: alt
keycode: char_c
mode: emacs
event: {edit: capitalizechar}
}
]
}

65
nushell/config/mount.nu
View File

@@ -1,65 +0,0 @@
# startx checks if disks are mounted
def startx [] {
# I'm used to running startx right after I login, to this first mount my
# disks and then runs startx.
mount-disk
# Then I run startx
/bin/startx
}
# mount my encrypted disks
def mount-disk [] {
# If there is no $env.PRIMARY_DISK_UUID, we don't have to decrypt / mount anything
if not ("PRIMARY_DISK_UUID" in $env) {
return
}
# In my home on my encrypted partition, I have an empty file in ~/.mounted,
# this way, I can easily check if my encrypted partition is mounted or not.
if ("~/.mounted"| path exists) {
print -en "already mounted\n"
return
}
mut passphrase = ""
# On my computer, I have two disks, one NVMe with my OS, and one HDD with
# more space. I want three attempts at typing the passphrase.
for retry in [1, 2, 3] {
# Because they're encrypted with the same passphrase, I read the
# passphrase once, and then decrypt both disks.
sudo echo -n
let local_passphrase = (input -s "Enter your passphrase: ")
print -en "\n"
# Mount the NVMe encrypted partition
let mounted = do { $local_passphrase | sudo cryptsetup luksOpen ("/dev/disk/by-uuid/" + $env.PRIMARY_DISK_UUID) luks } | complete
# If mounted correctly, break this loop and mount other partitions.
if $mounted.exit_code == 0 {
print -en (ansi green_bold) "Passphrase correct\n" (ansi reset)
$passphrase = $local_passphrase
break
} else if $retry == 3 {
# If the third attempt failed, exit
error make {msg: "couldn't decrypt disk"}
} else {
print -en (ansi red_bold) "Passphrase incorrect, please try again\n" (ansi reset)
}
}
sudo mount /dev/mapper/luks /home
if ("SECONDARY_DISK_UUID" in $env) {
$passphrase | sudo cryptsetup luksOpen ("/dev/disk/by-uuid/" + $env.SECONDARY_DISK_UUID) luks2
sudo mount /dev/mapper/luks2 /mnt
}
# Some services cannot be started on boot because my encrypted drives are
# not mounted yet, so I mount them here.
systemctl start --user pueued
sudo systemctl start docker
}

38
nushell/config/pass.nu
View File

@@ -1,38 +0,0 @@
# pass aliases / completion
def _pass_completion [] {
_ls ~/.password-store/**/* | each { |x|
if $x.type == "file" {
$x.name
| path parse
| update extension ""
| get parent stem
| str join "/"
} else {
$x.name + "/"
}
| split row '/'
| skip 4
| str join "/"
}
| prepend git
| prepend insert
}
export extern "pass" [ host?: string@_pass_completion ]
# pass shortcut
def p [ ...arg: string@_pass_completion ] {
for a in $arg {
pass $a
}
}
# pass with copy
def pc [ arg: string@_pass_completion ] { pass --clip $arg }
# open pdf encrypted file
def ppdf [p: string] {
pc thomas/key/pdf
pueue add evince $p
}

11
nushell/config/ssh.nu
View File

@@ -1,11 +0,0 @@
# ssh completion
def _ssh_hosts [] {
open ~/.ssh/config
| lines
| find -ir "host "
| each { $in | split row " " | get 1 }
}
export extern "ssh" [
host?: string@_ssh_hosts
]

16
nushell/config/tfetch.nu
View File

@@ -1,16 +0,0 @@
# nushell puts prompt at bottom of terminal on resize, so it's preferable to start on the bottom of the terminal
let has_tfetch = not (which tfetch | is-empty)
# tfetch takes 19 lines, 21 with prompt
let height = (stty size | split row " " | get 0 | into int) - (if $has_tfetch { 21 } else { 0 })
# skip lines so that the prompt starts at the bottom of the terminal
for i in 0..<$height {
print -n "\n"
}
# Start tfetch
if $has_tfetch {
tfetch
}

25
nushell/config/update.nu
View File

@@ -1,25 +0,0 @@
# update completion
def _update_args [] {
[
system
rust
wasm
npm
dotfiles
neovim
check
startup
last-update
postpone
force-unlock
]
}
# update system
def u [arg?: string@_update_args] {
if $arg == null {
^update
} else {
^update $arg
}
}

66
nushell/config/xrandr.nu
View File

@@ -1,66 +0,0 @@
# xrandr wrapper for nushell
def xrandr [] {
mut output = []
mut current_screen = {
name: ""
connected: false
on: false
primary: false
resolution: null
position: null
resolutions: []
}
let lines = ^xrandr | lines
let length = $lines | length
# We skip the first line
for i in 1..<$length {
let line = $lines | get $i
let split = $line | split row -r '\s+'
# This will be true whether the screen is connected or not
if $line =~ "connected" {
if $current_screen.name != "" {
$output = ($output | append $current_screen)
$current_screen.resolutions = []
$current_screen.on = false
$current_screen.resolution = null
$current_screen.position = null
}
$current_screen.name = ($split | get 0)
$current_screen.connected = (($split | get 1) != "disconnected")
$current_screen.primary = (($split | get 2) == "primary")
let resolution = if $current_screen.primary {
($split | get 3 | split column -c '+' | get column1 | get 0)
} else {
($split | get 2 | split column -c '+' | get column1 | get 0)
}
if not ($resolution | str starts-with "(") {
$current_screen.on = true
$current_screen.resolution = $resolution
$current_screen.position = if $current_screen.primary {
($split | get 3 | split column -c '+' | each { "+" + $in.column2 + "+" + $in.column3 } | get 0)
} else {
($split | get 2 | split column -c '+' | each { "+" + $in.column2 + "+" + $in.column3 } | get 0)
}
}
} else {
$current_screen.resolutions = ($current_screen.resolutions | append ($split | get 1))
}
}
if $current_screen.name != "" {
$output = ($output | append $current_screen)
}
$output
}

257
nushell/env.nu
View File

@@ -1,257 +0,0 @@
# Nushell Environment Config File
#
# version = "0.86.0"
def create_left_prompt [] {
let home = $nu.home-path
# Perform tilde substitution on dir
# To determine if the prefix of the path matches the home dir, we split the current path into
# segments, and compare those with the segments of the home dir. In cases where the current dir
# is a parent of the home dir (e.g. `/home`, homedir is `/home/user`), this comparison will
# also evaluate to true. Inside the condition, we attempt to str replace `$home` with `~`.
# Inside the condition, either:
# 1. The home prefix will be replaced
# 2. The current dir is a parent of the home dir, so it will be uneffected by the str replace
let dir = (
if ($env.PWD | path split | zip ($home | path split) | all { $in.0 == $in.1 }) {
($env.PWD | str replace $home "~")
} else {
$env.PWD
}
)
# Arrow of prompt
let arrow_color = if "SSH_CLIENT" in $env {
ansi green_bold
} else {
ansi magenta_bold
}
let first_line_arrow = "┌──"
let second_line_arrow = "└▷"
# Time
let time_color = ansi magenta_bold
let time_segment = date now | format date ' [%H:%M] '
# Name of the current user
let username_color = ansi magenta_bold
let username = $env.USER
# Delimiter between user and hostname, then hostname and cwd
let delimiter_color = ansi yellow_bold
let first_delimiter = "@"
let second_delimiter = "::"
# Hostname
let hostname_color = ansi green_bold
let hostname = (sys).host.hostname
# Current director
let dir_color = ansi blue_bold
let reset_ansi = ansi reset
# Current git branch, with * if things are not commited
let git_color = [(ansi reset), (ansi yellow)] | str join
let git_branch = do { git rev-parse --abbrev-ref HEAD }
| complete
| update stdout ($in.stdout | str trim -c "\n")
let git_status = do { git status -s } | complete | get stdout | str trim -c "\n"
let git_changed = if $git_status == "" {
""
} else {
"*"
}
let git_branch_content = if $git_branch.exit_code == 0 {
[$git_color, " ‹", $git_branch.stdout, $git_changed, "›"] | str join
} else {
""
}
# Current kube
let kube_color = ansi cyan_bold
let kube = if ("KUBECONFIG" in $env) {
let kube_name = $env.KUBECONFIG | path dirname | path basename
[$kube_color, " ‹", $kube_name, "›"] | str join
} else {
""
}
[
$arrow_color
$first_line_arrow
$time_color
$time_segment
$username_color
$username
$delimiter_color
$first_delimiter
$hostname_color
$hostname
$delimiter_color
$second_delimiter
$dir_color
$dir
$git_branch_content
$kube
"\n"
$reset_ansi
$arrow_color
$second_line_arrow
] | str join
}
def create_right_prompt [] {
let last_exit_code = if ($env.LAST_EXIT_CODE != 0) {([
"\e[B"
(ansi red_bold)
($env.LAST_EXIT_CODE)
" ↵ "
] | str join)
} else {([
"\e[B"
(ansi green_bold)
($env.LAST_EXIT_CODE)
" ↵ "
] | str join)
}
([$last_exit_code] | str join)
}
# Use nushell functions to define your right and left prompt
$env.PROMPT_COMMAND = {|| create_left_prompt }
# FIXME: This default is not implemented in rust code as of 2023-09-08.
$env.PROMPT_COMMAND_RIGHT = {|| create_right_prompt }
# The prompt indicators are environmental variables that represent
# the state of the prompt
$env.PROMPT_INDICATOR = {|| " " }
$env.PROMPT_INDICATOR_VI_INSERT = {|| ": " }
$env.PROMPT_INDICATOR_VI_NORMAL = {|| "> " }
$env.PROMPT_MULTILINE_INDICATOR = {|| "::: " }
# If you want previously entered commands to have a different prompt from the usual one,
# you can uncomment one or more of the following lines.
# This can be useful if you have a 2-line prompt and it's taking up a lot of space
# because every command entered takes up 2 lines instead of 1. You can then uncomment
# the line below so that previously entered commands show with a single `🚀`.
# $env.TRANSIENT_PROMPT_COMMAND = {|| "🚀 " }
# $env.TRANSIENT_PROMPT_INDICATOR = {|| "" }
# $env.TRANSIENT_PROMPT_INDICATOR_VI_INSERT = {|| "" }
# $env.TRANSIENT_PROMPT_INDICATOR_VI_NORMAL = {|| "" }
# $env.TRANSIENT_PROMPT_MULTILINE_INDICATOR = {|| "" }
# $env.TRANSIENT_PROMPT_COMMAND_RIGHT = {|| "" }
# Specifies how environment variables are:
# - converted from a string to a value on Nushell startup (from_string)
# - converted from a value back to a string when running external commands (to_string)
# Note: The conversions happen *after* config.nu is loaded
$env.ENV_CONVERSIONS = {
"PATH": {
from_string: { |s| $s | split row (char esep) | path expand --no-symlink }
to_string: { |v| $v | path expand --no-symlink | str join (char esep) }
}
"Path": {
from_string: { |s| $s | split row (char esep) | path expand --no-symlink }
to_string: { |v| $v | path expand --no-symlink | str join (char esep) }
}
}
# Directories to search for scripts when calling source or use
$env.NU_LIB_DIRS = [
# FIXME: This default is not implemented in rust code as of 2023-09-06.
($nu.default-config-dir | path join 'scripts') # add <nushell-config-dir>/scripts
]
# Directories to search for plugin binaries when calling register
$env.NU_PLUGIN_DIRS = [
# FIXME: This default is not implemented in rust code as of 2023-09-06.
($nu.default-config-dir | path join 'plugins') # add <nushell-config-dir>/plugins
]
# LS_COLORS so that ls mimics the colors of exa
$env.LS_COLORS = ([
# File types
"ex=1;32" # Executables
"di=1;34" # Directories
"ln=36" # Links
"or=31" # Orphan
# Media types
"*.pdf=32" # PDF files
# Images
"*.webp=35" # Webp image
"*.png=35" # PNG image
"*.jpg=35" # JPG image
# Music
"*.ogg=36" # OGG sound
"*.mp3=36" # MP3 sound
# Videos
"*.mp4=1;35" # MP4 video
"*.avi=1;35" # AVI video
"*.webm=1;35" # WebM video
# Bold yellow: source code
"*.c=1;33" # C source
"*.h=1;33" # C header
"*.cpp=1;33" # C++ source
"*.hpp=1;33" # C++ header
"*.inl=1;33" # C++ include
"*.cxx=1;33" # C++ include
"*.py=1;33" # Python
"*.js=1;33" # JavaScript
"*.ts=1;33" # TypeScript
"*.rs=1;33" # Rust
"*.elm=1;33" # Elm
"*.nu=1;33" # Nushell
# Build / doc files
"*Makefile=1;4;33" # Makefile
"*Dockerfile=1;4;33" # Dockerfile
"*.md=1;4;33" # Markdown
"*.toml=1;4;33" # Toml
] | str join ":")
# French by default
$env.LANG = fr_FR.UTF-8
# Gnome Keyring Daemon
$env.GNOME_KEYRING_DAEMON = '/run/user/1000/keyring'
# Text file editor
$env.EDITOR = nvim
# Backtrace for rust
$env.RUST_BACKTRACE = full
# Gclone env
$env.GCLONE_PATH = $env.HOME + '/git'
$env.GCLONE_FORCE_SSH = true
# Python virtual env
$env.VIRTUAL_ENV = $env.HOME + '/.venv'
# Don't put ugly go directory in my home
$env.GOPATH = $env.HOME + '/.go'
# To add entries to PATH (on Windows you might use Path), you can use the following pattern:
# $env.PATH = ($env.PATH | split row (char esep) | prepend '/some/path')
$env.PATH = ($env.PATH
| split row (char esep)
| prepend ($env.HOME + '/.config/polymny/bin')
| prepend ($env.HOME + '/.config/dotfiles/bin')
| prepend ($env.HOME + '/.config/dotfiles/bin-extra')
| prepend ($env.HOME + '/.cargo/bin')
| prepend ($env.HOME + '/.npmbin/bin')
| prepend ($env.HOME + '/.venv/bin')
)

74
zsh/aliases.zsh
View File

@@ -76,80 +76,6 @@ if [ $? -eq 0 ]; then
eval $(thefuck --alias)
fi
# Docker and kubernetes aliases
command -v k9s > /dev/null 2>&1
if [ $? -eq 0 ]; then
kns() {
local kube_config
if [ -z $KUBECONFIG ]; then
kube_config=$HOME/.kube/config
else
kube_config=$KUBECONFIG
fi
if [ -f $kube_config ]; then
k9s
else
echo >&2 error: $kube_config does not exist
return 1
fi
}
fi
command -v lazydocker > /dev/null 2>&1
if [ $? -eq 0 ]; then
alias ld="lazydocker"
fi
command -v docker-compose > /dev/null 2>&1
if [ $? -eq 0 ]; then
alias dc="docker-compose"
alias dcb="docker-compose build"
alias dcp="docker-compose build && docker-compose push"
alias dcu="docker-compose up -d --build --remove-orphans"
alias dcd="docker-compose down"
alias dcr="docker-compose down && docker-compose up -d --build --remove-orphans"
fi
command -v kubectl > /dev/null 2>&1
if [ $? -eq 0 ]; then
if [ -f $HOME/.kubes/current-cube ]; then
export KUBECONFIG=$(cat $HOME/.kubes/current-cube)
fi
# Sets the kube config
kube() {
local kube_config=$HOME/.kubes/$1/config
if [ $# -ne 1 ]; then
rm ~/.kubes/current-cube
export KUBECONFIG=""
elif [ ! -f $kube_config ]; then
echo >&2 error: no such kube config: $kube_config
return 1
else
echo $kube_config > ~/.kubes/current-cube
export KUBECONFIG=$kube_config
fi
}
# Shortcut for kubectl
kctl() {
local kube_config
if [ -z $KUBECONFIG ]; then
kube_config=$HOME/.kube/config
else
kube_config=$KUBECONFIG
fi
if [ -f $kube_config ]; then
kubectl $@
else
echo >&2 error: $kube_config does not exist
return 1
fi
}
fi
# change to git directory
cdg() {
local newdir

2
zsh/config.zsh
View File

@@ -20,7 +20,7 @@ DISABLE_AUTO_TITLE="true"
# Which plugins would you like to load? (plugins can be found in ~/.oh-my-zsh/plugins/*)
# Custom plugins may be added to ~/.oh-my-zsh/custom/plugins/me
# Example format: plugins=(rails git textmate ruby lighthouse)
plugins=(git myjump pass $ZSH_EXTRA_PLUGINS)
plugins=(git myjump pass)
source $ZSH/oh-my-zsh.sh

2
zsh/exports.zsh
View File

@@ -7,7 +7,7 @@ else
fi
# Parallel conpilation with make
export MAKEFLAGS="-j`nproc`"
export MAKEFLAGS="+j`nproc`"
# I want clang as default compiler if it exists
command -v clang > /dev/null 2>&1

31
zsh/ohmyzsh/themes/laptop-hostname.zsh-theme
View File

@@ -17,20 +17,20 @@ eval PR_BOLD="%{$terminfo[bold]%}"
if [[ $UID -ge 1000 ]]; then # normal user
# If ssh
if [[ -n "$SSH_CLIENT" || -n "$SSH2_CLIENT" ]]; then
eval PR_USER='${PR_GREEN}%n${PR_YELLOW}@${PR_GREEN}%M${PR_NO_COLOR}'
eval PR_USER='${PR_GREEN}%n@%M${PR_NO_COLOR}'
eval PR_USER_OP='${PR_GREEN}%#${PR_NO_COLOR}'
local PR_ARROW_UP='${PR_GREEN}┌── ${PR_NO_COLOR}'
local PR_ARROW_DOWN='${PR_GREEN}└${PR_NO_COLOR}'
local PR_PROMPT='$PR_GREEN▷$PR_NO_COLOR'
else
eval PR_USER='${PR_MAGENTA}%n${PR_YELLOW}@${PR_GREEN}%M${PR_NO_COLOR}'
eval PR_USER='${PR_MAGENTA}%n@%M${PR_NO_COLOR}'
eval PR_USER_OP='${PR_BLUE}%#${PR_NO_COLOR}'
local PR_PROMPT='$PR_MAGENTA▷$PR_NO_COLOR'
local PR_ARROW_UP='$PR_MAGENTA┌── ${PR_NO_COLOR}'
local PR_ARROW_DOWN='$PR_MAGENTA└${PR_NO_COLOR}'
fi
elif [[ $UID -eq 0 ]]; then # root
eval PR_USER='${PR_RED}%n${PR_YELLOW}@${PR_GREEN}%M${PR_NO_COLOR}'
eval PR_USER='${PR_RED}%n${PR_NO_COLOR}'
eval PR_USER_OP='${PR_RED}%#${PR_NO_COLOR}'
local PR_ARROW_UP='${PR_RED}┌── ${PR_NO_COLOR}'
local PR_ARROW_DOWN='${PR_RED}└${PR_NO_COLOR}'
@@ -76,36 +76,25 @@ else
fi
fi
git_prompt_info_no_space() {
local info=$(git_prompt_info)
if [ ! -z $info ]; then
echo " $info"
fi
}
local return_code=""
local git_branch='$(git_prompt_info_no_space)'
local git_branch='$(git_prompt_info)'
local PR_TEMP=""
command -v vcgencmd > /dev/null && PR_TEMP=' ${PR_GREEN}‹$(vcgencmd measure_temp | cut -d = -f 2)›${PR_NO_COLOR}'
local PR_DATE='${PR_BOLD}${PR_MAGENTA}[%D{%H:%M}]${PR_NO_COLOR}'
extract_kube() {
if [ ! -z $KUBECONFIG ]; then
echo " ${PR_BOLD}${PR_CYAN}‹$(echo $KUBECONFIG | rev | cut -d '/' -f 2 | rev)›${PR_NO_COLOR}"
fi
}
local kube='$(extract_kube)'
#PROMPT="${user_host} ${current_dir} ${rvm_ruby}${git_branch}$PR_PROMPT "
separator='${PR_YELLOW}::${PR_NO_COLOR}'
tty | read tty_value
if [[ $tty_value == *pts* ]]; then # if in a tty
PROMPT="$PR_ARROW_UP${PR_DATE} ${user_host}${separator}${PR_NO_COLOR}${current_dir}${rvm_ruby}${git_branch}${kube}
PROMPT="$PR_ARROW_UP${PR_DATE} ${user_host}${separator}${PR_NO_COLOR}${current_dir} ${rvm_ruby}${git_branch}${PR_TEMP}
$PR_ARROW_DOWN$PR_PROMPT ${PR_NO_COLOR}"
return_code="%(?.%{$PR_GREEN%}%? ↵%{$PR_NO_COLOR%}.%{$PR_RED%}%? ↵%{$PR_NO_COLOR%})"
else
eval PR_NO_COLOR="$PR_WHITE"
PROMPT="${user_host} ${current_dir} ${rvm_ruby}${git_branch}> ${PR_NO_COLOR}"
PROMPT="${user_host} ${current_dir} ${rvm_ruby} ${git_branch}> ${PR_NO_COLOR}"
return_code="%(?.%{$PR_GREEN%}%? <%{$PR_NO_COLOR%}.%{$PR_RED%}%? <%{$PR_NO_COLOR%})"
fi
RPS1=" ${return_code}"

6
zsh/ohmyzsh/themes/laptop.zsh-theme
View File

@@ -79,13 +79,17 @@ fi
local return_code=""
local git_branch='$(git_prompt_info)'
local PR_TEMP=""
command -v vcgencmd > /dev/null && PR_TEMP=' ${PR_GREEN}‹$(vcgencmd measure_temp | cut -d = -f 2)›${PR_NO_COLOR}'
local PR_DATE='${PR_BOLD}${PR_MAGENTA}[%D{%H:%M}]${PR_NO_COLOR}'
#PROMPT="${user_host} ${current_dir} ${rvm_ruby}${git_branch}$PR_PROMPT "
separator='${PR_YELLOW}::${PR_NO_COLOR}'
tty | read tty_value
if [[ $tty_value == *pts* ]]; then # if in a tty
PROMPT="$PR_ARROW_UP${PR_DATE} ${user_host}${separator}${PR_NO_COLOR}${current_dir} ${rvm_ruby}${git_branch}
PROMPT="$PR_ARROW_UP${PR_DATE} ${user_host}${separator}${PR_NO_COLOR}${current_dir} ${rvm_ruby}${git_branch}${PR_TEMP}
$PR_ARROW_DOWN$PR_PROMPT ${PR_NO_COLOR}"
return_code="%(?.%{$PR_GREEN%}%? ↵%{$PR_NO_COLOR%}.%{$PR_RED%}%? ↵%{$PR_NO_COLOR%})"
else