dan/dotfiles
1
0
Fork 0
mirror of https://github.com/danbulant/dotfiles synced 2026-05-19 04:18:55 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

more nu config

Browse source
This commit is contained in:
Daniel Bulant 2025-04-07 22:44:51 +02:00
parent fcf9b89ba2
commit a3e3e468fc
No known key found for this signature in database
9 changed files with 1697 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
.config/carapace/init.nu Normal file
View file

@ -0,0 +1,30 @@
$env.PATH = ($env.PATH | split row (char esep) | prepend "/home/dan/.config/carapace/bin")
def --env get-env [name] { $env | get $name }
def --env set-env [name, value] { load-env { $name: $value } }
def --env unset-env [name] { hide-env $name }
let carapace_completer = {|spans|
# if the current command is an alias, get it's expansion
let expanded_alias = (scope aliases | where name == $spans.0 | get -i 0 | get -i expansion)
# overwrite
let spans = (if $expanded_alias != null {
# put the first word of the expanded alias first in the span
$spans | skip 1 | prepend ($expanded_alias | split row " " | take 1)
} else {
$spans
})
carapace $spans.0 nushell ...$spans
| from json
}
mut current = (($env | default {} config).config | default {} completions)
$current.completions = ($current.completions | default {} external)
$current.completions.external = ($current.completions.external
| default true enable
| default $carapace_completer completer)
$env.config = $current

19
.config/nushell/base-config.nu
View file

@ -174,12 +174,6 @@ let light_theme = {
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: false # true or false to enable or disable the welcome banner at startup
@ -256,7 +250,7 @@ $env.config = {
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
# completer: null # set by ../carapace/init.nu
}
}
@ -814,9 +808,20 @@ $env.config = {
# load oh-my-posh config
source ~/.oh-my-posh.nu
source cargo.nu
source git-completions.nu
source npm.nu
use sockets.nu
use jc.nu
$env.CARAPACE_BRIDGES = 'zsh,fish,bash,inshellisense'
source ../carapace/init.nu
print ""
print (fastfetch --pipe false)
hide-env TRANSIENT_PROMPT_COMMAND
alias l = lsd -l
alias g = git
alias gp = git push

586
.config/nushell/cargo.nu Normal file
View file

@ -0,0 +1,586 @@
## Written by lukexor, Improved by @Dan-Gamin
def "nu-complete cargo targets" [type: string] {
^cargo metadata --format-version=1 --offline --no-deps | from json | get packages.targets | flatten | where ($type in $it.kind) | get name
}
def "nu-complete cargo bins" [] { nu-complete cargo targets bin }
def "nu-complete cargo examples" [] { nu-complete cargo targets example }
def "nu-complete cargo packages" [] {
let metadata = (^cargo metadata --format-version=1 --offline --no-deps)
if $metadata == '' {
[]
} else {
$metadata | from json | get workspace_members | split column ' ' | get column1
}
}
def "nu-complete cargo color" [] {
['auto', 'always', 'never']
}
def "nu-complete cargo profiles" [] {
open Cargo.toml | get profile | transpose | get column0
}
def "nu-complete cargo features" [] {
open Cargo.toml | get features | transpose | get column0
}
# `cargo --list` is slow, `open` is faster.
# TODO: Add caching.
def "nu-complete cargo subcommands" [] {
^cargo --list | lines | skip 1 | str join "\n" | from ssv --noheaders | get column1
}
def "nu-complete cargo vcs" [] {
[
'git',
'hg',
'pijul',
'fossil',
'none'
]
}
#*> Core <*#
# Disabled due to messing with undefined cargo-subcommands
# # Rust's package manager
# export extern "cargo" [
# --version(-V) # Print version info and exit
# --list # List installed commands
# --explain: number # Run `rustc --explain CODE`
# --verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
# --quiet(-q) # Do not print cargo log messages
# --color: string@"nu-complete cargo color" # Control when colored output is used
# --frozen # Require Cargo.lock and cache are up to date
# --locked # Require Cargo.lock is up to date
# --offline # Run without accessing the network
# --config: string # Override a configuration value
# -Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
# -h, --help # Print help information
# ...args: any
# ]
#*> Common Commands (Sorted by order shown by running the `cargo` command) <*#
# Compile the current package
export extern "cargo build" [
--package(-p): string@"nu-complete cargo packages" # Build only the specified packages
--workspace # Build all members in the workspace
--exclude: string@"nu-complete cargo packages" # Exclude the specified packages
--lib # Build the package's library
--bin: string@"nu-complete cargo bins" # Build the specified binary
--bins # Build all binary targets
--example: string@"nu-complete cargo examples" # Build the specified example
--examples # Build all example targets
--test: string # Build the specified integration test
--tests # Build all targets in test mode that have the test = true manifest flag set
--bench: string # Build the specified benchmark
--benches # Build all targets in benchmark mode that have the bench = true manifest flag set
--all-targets # Build all targets
--features(-F): string@"nu-complete cargo features" # Space or comma separated list of features to activate
--all-features # Activate all available features of all selected packages
--no-default-features # Do not activate the default feature of the selected packages
--target: string # Build for the given architecture.
--release(-r) # Build optimized artifacts with the release profile
--profile: string@"nu-complete cargo profiles" # Build with the given profile
--ignore-rust-version # Ignore `rust-version` specification in packages
--timings: string # Output information how long each compilation takes
--target-dir: path # Directory for all generated artifacts and intermediate files
--out-dir: path # Copy final artifacts to this directory
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
--message-format: string # The output format for diagnostic messages
--build-plan # Outputs a series of JSON messages to stdout that indicate the commands to run the build
--manifest-path: path # Path to the Cargo.toml file
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
-h, --help # Print help information
--jobs(-j): number # Number of parallel jobs to run
--future-incompat-report # Displays a future-incompat report for any future-incompatible warnings
]
# Check the current package
export extern "cargo check" [
--package(-p): string@"nu-complete cargo packages" #Check only the specified packages
--workspace # Check all members in the workspace
--all # Alias for --workspace (deprecated)
--exclude: string@"nu-complete cargo packages" # Exclude the specified packages
--lib # Check the package's library
--bin: string@"nu-complete cargo bins" # Check the specified binary
--example: string@"nu-complete cargo examples" # Check the specified example
--examples # Check all example targets
--test: string # Check the specified integration test
--tests # Check all targets in test mode that have the test = true manifest flag set
--bench: string # Check the specified benchmark
--benches # Check all targets in benchmark mode that have the bench = true manifest flag set
--all-targets # Check all targets
--features(-F): string@"nu-complete cargo features" # Space or comma separated list of features to activate
--all-features # Activate all available features
--no-default-features # Do not activate the `default` feature
--target: string # Check for the given architecture
--release(-r) # Check optimized artifacts with the release profile
--profile: string@"nu-complete cargo profiles" # Check with the given profile
--ignore-rust-version # Ignore `rust-version` specification in packages
--timings: string # Output information how long each compilation takes
--target-dir: path # Directory for all generated artifacts and intermediate files
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
--message-format: string # The output format for diagnostic messages
--manifest-path: path # Path to the Cargo.toml file
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
-h, --help # Print help information
--jobs(-j): number # Number of parallel jobs to run
--keep-going # Build as many crates in the dependency graph as possible
--future-incompat-report # Displays a future-incompat report for any future-incompatible warnings
]
# Remove the target directory
export extern "cargo clean" [
--package(-p): string@"nu-complete cargo packages" # Clean only the specified packages
--doc # Remove only the doc directory in the target directory
--release # Remove all artifacts in the release directory
--profile # Remove all artifacts in the directory with the given profile name
--target-dir: path # Directory for all generated artifacts and intermediate files
--target: string # Clean for the given architecture
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
--message-format: string # The output format for diagnostic messages
--manifest-path: path # Path to the Cargo.toml file
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
-h, --help # Print help information
]
# Build a package's documentation
export extern "cargo doc" [
--open # Open the docs in a browser after building them
--no-deps # Do not build documentation for dependency
--document-private-items # Include non-public items in the documentation
--package(-p): string@"nu-complete cargo packages" # Document only the specified packages
--workspace # Document all members in the workspace
--exclude: string@"nu-complete cargo packages" # Exclude the specified packages
--lib: string # Document the package's library
--bin: string@"nu-complete cargo bins" # Document the specified binary
--bins # Document all binary targets
--example: string@"nu-complete cargo examples" # Document the specified example
--examples # Document all example targets
--features(-F): string@"nu-complete cargo features" # Space or comma separated list of features to activate
--all-features # Activate all available features of all selected packages
--no-default-features # Do not activate the default feature of the selected packages
--target: string # Document for the given architecture
--release(-r) # Document optimized artifacts with the release profile
--profile: string@"nu-complete cargo profiles" # Document with the given profile
--ignore-rust-version # Ignore `rust-version` specification in packages
--timings: string # Output information how long each compilation takes
--target-dir: path # Directory for all generated artifacts and intermediate files
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
--message-format: string # The output format for diagnostic messages
--manifest-path: path # Path to the Cargo.toml file
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
-h, --help # Print help information
--jobs(-j): number # Number of parallel jobs to run
--keep-going # Build as many crates in the dependency graph as possible
]
# Create a new cargo package
export extern "cargo new" [
path: path # The directory that will contain the project
--bin # Create a package with a binary target (src/main.rs) (default)
--lib # Create a package with a library target (src/lib.rs)
--edition: number # Specify the Rust edition to use (default: 2021)
--name: string # Set the package name. Defaults to the directory name.
--vcs: string@"nu-complete cargo vcs" # Initialize a new VCS repository for the given version control system
--registry: string # Name of the registry to use
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
-h, --help # Print help information
]
# Create a new cargo package in an existing directory
export extern "cargo init" [
path: path # The directory that will contain the project
--bin # Create a package with a binary target (src/main.rs) (default)
--lib # Create a package with a library target (src/lib.rs)
--edition: number # Specify the Rust edition to use (default: 2021)
--name: string # Set the package name. Defaults to the directory name.
--vcs: string@"nu-complete cargo vcs" # Initialize a new VCS repository for the given version control system
--registry: string # Name of the registry to use
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
-h, --help # Print help information
]
# Run the current cargo package
export extern "cargo run" [
...args: any # Arguments to be passed to your program
--bin: string@"nu-complete cargo bins" # Name of the bin target to run
--example: string@"nu-complete cargo examples" # Name of the example target to run
--quiet(-q) # Do not print cargo log messages
--package(-p): string@"nu-complete cargo packages" # Package with the target to run
--jobs(-j): number # Number of parallel jobs, defaults to # of CPUs
--release # Build artifacts in release mode, with optimizations
--profile: string@"nu-complete cargo profiles" # Build artifacts with the specified profile
--features(-F): string@"nu-complete cargo features" # Space or comma separated list of features to activate
--all-features # Activate all available features
--no-default-features # Do not activate the `default` feature
--target: string # Build for the target triple
--target-dir: path # Directory for all generated artifacts
--manifest-path: path # Path to Cargo.toml
--message-format: string # Error format
--unit-graph # Output build graph in JSON (unstable)
--ignore-rust-version # Ignore `rust-version` specification in packages
--verbose(-v) # Use verbose output (-vv very verbose/build.rs output)
--color: string@"nu-complete cargo color" # Control when colored output is used
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
--config: string # Override a configuration value (unstable)
-Z: string # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
--help(-h) # Prints help information
]
# Run the tests
export extern "cargo test" [
test_arg_separator?: string
...args: any # Arguments to be passed to the tests
--no-run # Compile, but don't run tests
--no-fail-fast # Run all tests regardless of failure
--package(-p): string@"nu-complete cargo packages" # Test only the specified packages
--workspace # Test all members in the workspace
--exclude: string@"nu-complete cargo packages" # Exclude the specified packages
--lib # Test the package's library
--bin: string@"nu-complete cargo bins" # Test only the specified binary
--bins # Test all binaries
--example: string@"nu-complete cargo examples" # Test only the specified example
--examples # Test all examples
--test: string # Test the specified integration test
--tests # Test all targets in test mode that have the test = true manifest flag set
--bench: string # Test the specified benchmark
--benches # Test all targets in benchmark mode that have the bench = true manifest flag set
--all-targets # Test all targets
--doc # Test ONLY the library's documentation
--features(-F): string@"nu-complete cargo features" # Space or comma separated list of features to activate
--all-features # Activate all available features of all selected packages
--no-default-features # Do not activate the default feature of the selected packages
--target: string # Test for the given architecture
--release(-r) # Test optimized artifacts with the release profile
--profile: string@"nu-complete cargo profiles" # Test with the given profile
--ignore-rust-version # Ignore `rust-version` specification in packages
--timings: string # Output information how long each compilation takes
--target-dir: path # Directory for all generated artifacts and intermediate files
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
--message-format: string # The output format for diagnostic messages
--manifest-path: path # Path to the Cargo.toml file
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
--help(-h) # Prints help information
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
--jobs(-j): number # Number of parallel jobs to run
--keep-going # Build as many crates in the dependency graph as possible
--future-incompat-report # Displays a future-incompat report for any future-incompatible warnings
]
# Execute benchmarks of a package
export extern "cargo bench" [
bench_option_separator?: string
...options: any # Options to be passed to the benchmarks
--no-run # Compile, but don't run benchmarks
--no-fail-fast # Run all benchmarks regardless of failure
--package(-p): string@"nu-complete cargo packages" # Benchmark only the specified packages
--workspace # Benchmark all members in the workspace
--exclude: string@"nu-complete cargo packages" # Exclude the specified packages
--lib # Benchmark the package's library
--bin: string@"nu-complete cargo bins" # Benchmark only the specified binary
--bins # Benchmark all binary targets
--example: string@"nu-complete cargo examples" # Benchmark only the specified example
--examples # Benchmark all example targets
--test: string # Benchmark the specified integration test
--tests # Benchmark all targets in test mode that have the test = true
--bench: string # Benchmark the specified benchmark
--benches # Benchmark all targets in benchmark mode that have the bench = true manifest flag set
--all-targets # Benchmark all targets
--features(-F): string@"nu-complete cargo features" # Space or comma separated list of features to activate
--all-features # Activate all available features of all selected packages
--no-default-features # Do not activate the default feature of the selected packages
--target: string # Benchmark for the given architecture
--profile: string@"nu-complete cargo profiles" # Build artifacts with the specified profile
--ignore-rust-version # Ignore `rust-version` specification in packages
--timings: string # Output information how long each compilation takes
--target-dir: path # Directory for all generated artifacts and intermediate files
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
--message-format: string # The output format for diagnostic messages
--build-plan # Outputs a series of JSON messages to stdout that indicate the commands to run the build
--manifest-path: path # Path to the Cargo.toml file
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
-h, --help # Print help information
--jobs(-j): number # Number of parallel jobs to run
--keep-going # Build as many crates in the dependency graph as possible
]
# Update dependencies listed in Cargo.lock
export extern "cargo update" [
--package(-p): string@"nu-complete cargo packages" # Update only the specified packages
--aggressive # Dependencies of the specified packages are forced to update as well
--precise: any # Allows you to specify a specific version number to set the package to
--workspace(-w) # Attempt to update only packages defined in the workspace
--dry-run # Displays what would be updated but doesn't write the lockfile
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
--manifest-path: path # Path to the Cargo.toml file
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
--help(-h) # Prints help information
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
]
# Search packages in crates.io
export extern "cargo search" [
query: string # The thing to search
--limit: number # Limit the number of results. (default: 10, max: 100)
--index: string # The URL of the registry index to use
--registry: string # Name of the registry to use
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
--help(-h) # Prints help information
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
]
# Package and upload a package to the registry
export extern "cargo publish" [
--dry-run # Perform all checks without uploading
--token: any # API token to use when authenticating
--no-verify # Don't verify the contents by building them
--allow-dirty # Allow working directories with uncommitted VCS changes to be packaged
--index: string # The URL of the registry index to use
--registry: string # Name of the registry to publish to
--package(-p): string@"nu-complete cargo packages" # The package to publish
--target: string # Publish for the given architecture
--target-dir: path # Directory for all generated artifacts and intermediate files
--features(-F): string@"nu-complete cargo features" # Space or comma separated list of features to activate
--all-features # Activate all available features of all selected packages
--no-default-features # Do not activate the default feature of the selected packages
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
--manifest-path: path # Path to the Cargo.toml file
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
--help(-h) # Prints help information
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
--jobs(-j): number # Number of parallel jobs to run
--keep-going # Build as many crates in the dependency graph as possible
]
# Build and install a Rust binary
export extern "cargo install" [
crate?: string # The crate to install
--version: string # Specify a version to install
--vers: string # Specify a version to install
--git: string # Git URL to install the specified crate from
--branch: string # Branch to use when installing from git
--tag: string # Tag to use when installing from git
--rev: string # Specific commit to use when installing from git
--path: path # Filesystem path to local crate to install
--list # List all installed packages and their versions
--force(-f) # Force overwriting existing crates or binaries
--no-track # Don't keep track of this package
--bin: string@"nu-complete cargo bins" # Install only the specified binary
--bins # Install all binaries
--example: string@"nu-complete cargo examples" # Install only the specified example
--examples # Install all examples
--root: path # Directory to install packages into
--registry: string # Name of the registry to use
--index: string # The URL of the registry index to use
--features(-F): string@"nu-complete cargo features" # Space or comma separated list of features to activate
--all-features # Activate all available features of all selected packages
--no-default-features # Do not activate the default feature of the selected packages
--target: string # Install for the given architecture
--target-dir: path # Directory for all generated artifacts and intermediate files
--debug # Build with the dev profile instead the release profile
--profile: string@"nu-complete cargo profiles" # Build artifacts with the specified profile
--timings: string # Output information how long each compilation takes
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
--jobs(-j): number # Number of parallel jobs to run
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
--message-format: string # The output format for diagnostic messages
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
-h, --help # Print help information
]
# Remove a Rust binary
export extern "cargo uninstall" [
package?: string@"nu-complete cargo packages" # Package to uninstall
--package(-p): string@"nu-complete cargo packages" # Package to uninstall
--bin: string@"nu-complete cargo bins" # Only uninstall the binary name
--root: path # Directory to uninstall packages from
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
-h, --help # Print help information
]
#*> Other Commands <*#
# Output the resolved dependencies of a package in machine-readable format
export extern "cargo metadata" [
--no-deps # Output information only about the workspace members and don't fetch dependencies
--format-version: number # Specify the version of the output format to use. Currently 1 is the only possible value
--filter-platform: string # This filters the resolve output to only include dependencies for the iven target triple
--features(-F): string@"nu-complete cargo features" # Space or comma separated list of features to activate
--all-features # Activate all available features of all selected packages
--no-default-features # Do not activate the default feature of the selected packages
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
--manifest-path: path # Path to the Cargo.toml file
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
--help(-h) # Prints help information
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
]
# Get the help of the given cargo subcommand
export extern "cargo help" [
subcommand: string@"nu-complete cargo subcommands"
--color: string@"nu-complete cargo color" # Control when colored output is used
--config: string # Override a configuration value
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
]
# A bunch of lints to catch common mistakes and improve your Rust code
export extern "cargo clippy" [
--no-deps # Run Clippy only on the given crate, without linting the dependencies
--fix # Automatically apply lint suggestions. This flag implies `--no-deps
--version(-V) # Prints version information
--help(-h) # Prints help information
--warn(-W): string # Set lint warnings
--allow(-A): string # Set lint allowed
--deny(-D): string # Set lint denied
--forbid(-F): string # Set lint forbidden
--package(-p): string@"nu-complete cargo packages" #Check only the specified packages
--workspace # Check all members in the workspace
--all # Alias for --workspace (deprecated)
--exclude: string@"nu-complete cargo packages" # Exclude the specified packages
--lib # Check the package's library
--bin: string@"nu-complete cargo bins" # Check the specified binary
--example: string@"nu-complete cargo examples" # Check the specified example
--examples # Check all example targets
--test: string # Check the specified integration test
--tests # Check all targets in test mode that have the test = true manifest flag set
--bench: string # Check the specified benchmark
--benches # Check all targets in benchmark mode that have the bench = true manifest flag set
--all-targets # Check all targets
--features(-F): string@"nu-complete cargo features" # Space or comma separated list of features to activate
--all-features # Activate all available features
--no-default-features # Do not activate the `default` feature
--target: string # Check for the given architecture
--release(-r) # Check optimized artifacts with the release profile
--profile: string@"nu-complete cargo profiles" # Check with the given profile
--ignore-rust-version # Ignore `rust-version` specification in packages
--timings: string # Output information how long each compilation takes
--target-dir: path # Directory for all generated artifacts and intermediate files
--verbose(-v) # Use verbose output. May be specified twice for "very verbose" output
--quiet(-q) # Do not print cargo log messages
--color: string@"nu-complete cargo color" # Control when colored output is used
--message-format: string # The output format for diagnostic messages
--manifest-path: path # Path to the Cargo.toml file
--frozen # Require Cargo.lock and cache are up to date
--locked # Require Cargo.lock is up to date
--offline # Run without accessing the network
-Z: any # Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details
-h, --help # Print help information
--jobs(-j): number # Number of parallel jobs to run
--keep-going # Build as many crates in the dependency graph as possible
--future-incompat-report # Displays a future-incompat report for any future-incompatible warnings
-Z: any
]
# Parameters from cargo update
export extern "cargo install-update" [
--all(-a) # Update all packages
--allow-no-update(-i) # Allow for fresh-installing packages
--downdate(-d) # Downdate packages to match latest unyanked registry version
--force(-f) # Update all packages regardless if they need updating
--git(-g) # Also update git packages
--help(-h) # Prints help information
--list(-l) # Don't update packages, only list and check if they need an update (all packages by default)
--quiet(-q) # No output printed to stdout
--version(-V) # Prints version information
--cargo-dir(-c) # The cargo home directory. Default: $CARGO_HOME or $HOME/.cargo
--filter(-s) # Specify a filter a package must match to be considered
--install-cargo(-r) # Specify an alternative cargo to run for installations
--temp-dir(-t) # The temporary directory. Default: $TEMP/cargo-update
]
# Parameters from cargo add
export extern "cargo add" [
--no-default-features # Disable the default features
--default-features # Re-enable the default features
--features(-F) # Space or comma separated list of features to activate
--optional # Mark the dependency as optional
--verbose(-v) # Use verbose output (-vv very verbose/build.rs output)
--no-optional # Mark the dependency as required
--color: string@"nu-complete cargo color" # Coloring: auto, always, never
--rename # Rename the dependency
--locked # Require Cargo.lock is up to date
--package(-p) # Package to modify
--offline # Run without accessing the network
--quiet(-q) # Do not print cargo log messages
--config # Override a configuration value
--dry-run # Don't actually write the manifest
--help(-h) # Print help information
--path # Filesystem path to local crate to add
--git # Git repository location
--branch # Git branch to download the crate from
--tag # Git tag to download the crate from
--rev # Git reference to download the crate from
--registry # Package registry for this dependency
--dev # Add as development dependency
--build # Add as build dependency
--target # Add as dependency to the given target platform
...args
]

976
.config/nushell/git-completions.nu Normal file
View file

@ -0,0 +1,976 @@
# nu-version: 0.102.0
module git-completion-utils {
export const GIT_SKIPABLE_FLAGS = ['-v', '--version', '-h', '--help', '-p', '--paginate', '-P', '--no-pager', '--no-replace-objects', '--bare']
# Helper function to append token if non-empty
def append-non-empty [token: string]: list<string> -> list<string> {
if ($token | is-empty) { $in } else { $in | append $token }
}
# Split a string to list of args, taking quotes into account.
# Code is copied and modified from https://github.com/nushell/nushell/issues/14582#issuecomment-2542596272
export def args-split []: string -> list<string> {
# Define our states
const STATE_NORMAL = 0
const STATE_IN_SINGLE_QUOTE = 1
const STATE_IN_DOUBLE_QUOTE = 2
const STATE_ESCAPE = 3
const WHITESPACES = [" " "\t" "\n" "\r"]
# Initialize variables
mut state = $STATE_NORMAL
mut current_token = ""
mut result: list<string> = []
mut prev_state = $STATE_NORMAL
# Process each character
for char in ($in | split chars) {
if $state == $STATE_ESCAPE {
# Handle escaped character
$current_token = $current_token + $char
$state = $prev_state
} else if $char == '\' {
# Enter escape state
$prev_state = $state
$state = $STATE_ESCAPE
} else if $state == $STATE_NORMAL {
if $char == "'" {
$state = $STATE_IN_SINGLE_QUOTE
} else if $char == '"' {
$state = $STATE_IN_DOUBLE_QUOTE
} else if ($char in $WHITESPACES) {
# Whitespace in normal state means token boundary
$result = $result | append-non-empty $current_token
$current_token = ""
} else {
$current_token = $current_token + $char
}
} else if $state == $STATE_IN_SINGLE_QUOTE {
if $char == "'" {
$state = $STATE_NORMAL
} else {
$current_token = $current_token + $char
}
} else if $state == $STATE_IN_DOUBLE_QUOTE {
if $char == '"' {
$state = $STATE_NORMAL
} else {
$current_token = $current_token + $char
}
}
}
# Handle the last token
$result = $result | append-non-empty $current_token
# Return the result
$result
}
# Get changed files which can be restored by `git checkout --`
export def get-changed-files []: nothing -> list<string> {
^git status -uno --porcelain=2 | lines
| where $it =~ '^1 [.MD]{2}'
| each { split row ' ' -n 9 | last }
}
# Get files which can be retrieved from a branch/commit by `git checkout <tree-ish>`
export def get-checkoutable-files []: nothing -> list<string> {
# Relevant statuses are .M", "MM", "MD", ".D", "UU"
^git status -uno --porcelain=2 | lines
| where $it =~ '^1 ([.MD]{2}|UU)'
| each { split row ' ' -n 9 | last }
}
export def get-all-git-branches []: nothing -> list<string> {
^git branch -a --format '%(refname:lstrip=2)%09%(upstream:lstrip=2)' | lines | str trim | filter { not ($in ends-with 'HEAD' ) }
}
# Extract remote branches which do not have local counterpart
export def extract-remote-branches-nonlocal-short [current: string]: list<string> -> list<string> {
# Input is a list of lines, like:
# ╭────┬────────────────────────────────────────────────╮
# │ 0 │ feature/awesome-1 origin/feature/awesome-1 │
# │ 1 │ fix/bug-1 origin/fix/bug-1 │
# │ 2 │ main origin/main │
# │ 3 │ origin/HEAD │
# │ 4 │ origin/feature/awesome-1 │
# │ 5 │ origin/fix/bug-1 │
# │ 6 │ origin/feature/awesome-2 │
# │ 7 │ origin/main │
# │ 8 │ upstream/main │
# │ 9 │ upstream/awesome-3 │
# ╰────┴────────────────────────────────────────────────╯
# and we pick ['feature/awesome-2', 'awesome-3']
let lines = $in
let long_current = if ($current | is-empty) { '' } else { $'origin/($current)' }
let branches = $lines | filter { ($in != $long_current) and not ($in starts-with $"($current)\t") }
let tracked_remotes = $branches | find "\t" | each { split row "\t" -n 2 | get 1 }
let floating_remotes = $lines | filter { "\t" not-in $in and $in not-in $tracked_remotes }
$floating_remotes | each {
let v = $in | split row -n 2 '/' | get 1
if $v == $current { null } else $v
}
}
export def extract-mergable-sources [current: string]: list<string> -> list<record<value: string, description: string>> {
let lines = $in
let long_current = if ($current | is-empty) { '' } else { $'origin/($current)' }
let branches = $lines | filter { ($in != $long_current) and not ($in starts-with $"($current)\t") }
let git_table: list<record<n: string, u: string>> = $branches | each {|v| if "\t" in $v { $v | split row "\t" -n 2 | {n: $in.0, u: $in.1 } } else {n: $v, u: null } }
let siblings = $git_table | where u == null and n starts-with 'origin/' | get n | str substring 7..
let remote_branches = $git_table | filter {|r| $r.u == null and not ($r.n starts-with 'origin/') } | get n
[...($siblings | wrap value | insert description Local), ...($remote_branches | wrap value | insert description Remote)]
}
# Get local branches, remote branches which can be passed to `git merge`
export def get-mergable-sources []: nothing -> list<record<value: string, description: string>> {
let current = (^git branch --show-current) # Can be empty if in detached HEAD
(get-all-git-branches | extract-mergable-sources $current)
}
}
def "nu-complete git available upstream" [] {
^git branch --no-color -a | lines | each { |line| $line | str replace '* ' "" | str trim }
}
def "nu-complete git remotes" [] {
^git remote | lines | each { |line| $line | str trim }
}
def "nu-complete git log" [] {
^git log --pretty=%h | lines | each { |line| $line | str trim }
}
# Yield all existing commits in descending chronological order.
def "nu-complete git commits all" [] {
^git rev-list --all --remotes --pretty=oneline | lines | parse "{value} {description}"
}
# Yield commits of current branch only. This is useful for e.g. cut points in
# `git rebase`.
def "nu-complete git commits current branch" [] {
^git log --pretty="%h %s" | lines | parse "{value} {description}"
}
# Yield local branches like `main`, `feature/typo_fix`
def "nu-complete git local branches" [] {
^git branch --no-color | lines | each { |line| $line | str replace '* ' "" | str replace '+ ' "" | str trim }
}
# Yield remote branches like `origin/main`, `upstream/feature-a`
def "nu-complete git remote branches with prefix" [] {
^git branch --no-color -r | lines | parse -r '^\*?(\s*|\s*\S* -> )(?P<branch>\S*$)' | get branch | uniq
}
# Yield local and remote branch names which can be passed to `git merge`
def "nu-complete git mergable sources" [] {
use git-completion-utils *
(get-mergable-sources)
}
def "nu-complete git switch" [] {
use git-completion-utils *
let current = (^git branch --show-current) # Can be empty if in detached HEAD
let local_branches = ^git branch --format '%(refname:short)' | lines | filter { $in != $current } | wrap value | insert description 'Local branch'
let remote_branches = (get-all-git-branches | extract-remote-branches-nonlocal-short $current) | wrap value | insert description 'Remote branch'
[...$local_branches, ...$remote_branches]
}
def "nu-complete git checkout" [context: string, position?:int] {
use git-completion-utils *
let preceding = $context | str substring ..$position
# See what user typed before, like 'git checkout a-branch a-path'.
# We exclude some flags from previous tokens, to detect if a branch name has been used as the first argument.
# FIXME: This method is still naive, though.
let prev_tokens = $preceding | str trim | args-split | where ($it not-in $GIT_SKIPABLE_FLAGS)
# In these scenarios, we suggest only file paths, not branch:
# - After '--'
# - First arg is a branch
# If before '--' is just 'git checkout' (or its alias), we suggest "dirty" files only (user is about to reset file).
if $prev_tokens.2? == '--' {
return (get-changed-files)
}
if '--' in $prev_tokens {
return (get-checkoutable-files)
}
# Already typed first argument.
if ($prev_tokens | length) > 2 and $preceding ends-with ' ' {
return (get-checkoutable-files)
}
# The first argument can be local branches, remote branches, files and commits
# Get local and remote branches
let branches = (get-mergable-sources) | insert style {|row| if $row.description == 'Local' { 'blue' } else 'blue_italic' } | update description { $in + ' branch' }
let files = (get-checkoutable-files) | wrap value | insert description 'File' | insert style green
let commits = ^git rev-list -n 400 --remotes --oneline | lines | split column -n 2 ' ' value description | insert style light_cyan_dimmed
{
options: {
case_sensitive: false,
completion_algorithm: prefix,
sort: false,
},
completions: [...$branches, ...$files, ...$commits]
}
}
# Arguments to `git rebase --onto <arg1> <arg2>`
def "nu-complete git rebase" [] {
(nu-complete git local branches)
| parse "{value}"
| insert description "local branch"
| append (nu-complete git remote branches with prefix
| parse "{value}"
| insert description "remote branch")
| append (nu-complete git commits all)
}
def "nu-complete git stash-list" [] {
git stash list | lines | parse "{value}: {description}"
}
def "nu-complete git tags" [] {
^git tag --no-color | lines
}
# See `man git-status` under "Short Format"
# This is incomplete, but should cover the most common cases.
const short_status_descriptions = {
".D": "Deleted"
".M": "Modified"
"!" : "Ignored"
"?" : "Untracked"
"AU": "Staged, not merged"
"MD": "Some modifications staged, file deleted in work tree"
"MM": "Some modifications staged, some modifications untracked"
"R.": "Renamed"
"UU": "Both modified (in merge conflict)"
}
def "nu-complete git files" [] {
let relevant_statuses = ["?",".M", "MM", "MD", ".D", "UU"]
^git status -uall --porcelain=2
| lines
| each { |$it|
if $it starts-with "1 " {
$it | parse --regex "1 (?P<short_status>\\S+) (?:\\S+\\s?){6} (?P<value>\\S+)"
} else if $it starts-with "2 " {
$it | parse --regex "2 (?P<short_status>\\S+) (?:\\S+\\s?){6} (?P<value>\\S+)"
} else if $it starts-with "u " {
$it | parse --regex "u (?P<short_status>\\S+) (?:\\S+\\s?){8} (?P<value>\\S+)"
} else if $it starts-with "? " {
$it | parse --regex "(?P<short_status>.{1}) (?P<value>.+)"
} else {
{ short_status: 'unknown', value: $it }
}
}
| flatten
| where $it.short_status in $relevant_statuses
| insert "description" { |e| $short_status_descriptions | get $e.short_status}
}
def "nu-complete git built-in-refs" [] {
[HEAD FETCH_HEAD ORIG_HEAD]
}
def "nu-complete git refs" [] {
nu-complete git local branches
| parse "{value}"
| insert description Branch
| append (nu-complete git tags | parse "{value}" | insert description Tag)
| append (nu-complete git built-in-refs)
}
def "nu-complete git files-or-refs" [] {
nu-complete git local branches
| parse "{value}"
| insert description Branch
| append (nu-complete git files | where description == "Modified" | select value)
| append (nu-complete git tags | parse "{value}" | insert description Tag)
| append (nu-complete git built-in-refs)
}
def "nu-complete git subcommands" [] {
^git help -a | lines | where $it starts-with " " | parse -r '\s*(?P<value>[^ ]+) \s*(?P<description>\w.*)'
}
def "nu-complete git add" [] {
nu-complete git files
}
def "nu-complete git pull rebase" [] {
["false","true","merges","interactive"]
}
def "nu-complete git merge strategies" [] {
['ort', 'octopus']
}
def "nu-complete git merge strategy options" [] {
['ours', 'theirs']
}
# Check out git branches and files
export extern "git checkout" [
...targets: string@"nu-complete git checkout" # name of the branch or files to checkout
--conflict: string # conflict style (merge or diff3)
--detach(-d) # detach HEAD at named commit
--force(-f) # force checkout (throw away local modifications)
--guess # second guess 'git checkout <no-such-branch>' (default)
--ignore-other-worktrees # do not check if another worktree is holding the given ref
--ignore-skip-worktree-bits # do not limit pathspecs to sparse entries only
--merge(-m) # perform a 3-way merge with the new branch
--orphan: string # new unparented branch
--ours(-2) # checkout our version for unmerged files
--overlay # use overlay mode (default)
--overwrite-ignore # update ignored files (default)
--patch(-p) # select hunks interactively
--pathspec-from-file: string # read pathspec from file
--progress # force progress reporting
--quiet(-q) # suppress progress reporting
--recurse-submodules # control recursive updating of submodules
--theirs(-3) # checkout their version for unmerged files
--track(-t) # set upstream info for new branch
-b # create and checkout a new branch
-B: string # create/reset and checkout a branch
-l # create reflog for new branch
]
export extern "git reset" [
...targets: string@"nu-complete git checkout" # name of commit, branch, or files to reset to
--hard # reset HEAD, index and working tree
--keep # reset HEAD but keep local changes
--merge # reset HEAD, index and working tree
--mixed # reset HEAD and index
--patch(-p) # select hunks interactively
--quiet(-q) # be quiet, only report errors
--soft # reset only HEAD
--pathspec-from-file: string # read pathspec from file
--pathspec-file-nul # with --pathspec-from-file, pathspec elements are separated with NUL character
--no-refresh # skip refreshing the index after reset
--recurse-submodules: string # control recursive updating of submodules
--no-recurse-submodules # don't recurse into submodules
]
# Download objects and refs from another repository
export extern "git fetch" [
repository?: string@"nu-complete git remotes" # name of the branch to fetch
--all # Fetch all remotes
--append(-a) # Append ref names and object names to .git/FETCH_HEAD
--atomic # Use an atomic transaction to update local refs.
--depth: int # Limit fetching to n commits from the tip
--deepen: int # Limit fetching to n commits from the current shallow boundary
--shallow-since: string # Deepen or shorten the history by date
--shallow-exclude: string # Deepen or shorten the history by branch/tag
--unshallow # Fetch all available history
--update-shallow # Update .git/shallow to accept new refs
--negotiation-tip: string # Specify which commit/glob to report while fetching
--negotiate-only # Do not fetch, only print common ancestors
--dry-run # Show what would be done
--write-fetch-head # Write fetched refs in FETCH_HEAD (default)
--no-write-fetch-head # Do not write FETCH_HEAD
--force(-f) # Always update the local branch
--keep(-k) # Keep downloaded pack
--multiple # Allow several arguments to be specified
--auto-maintenance # Run 'git maintenance run --auto' at the end (default)
--no-auto-maintenance # Don't run 'git maintenance' at the end
--auto-gc # Run 'git maintenance run --auto' at the end (default)
--no-auto-gc # Don't run 'git maintenance' at the end
--write-commit-graph # Write a commit-graph after fetching
--no-write-commit-graph # Don't write a commit-graph after fetching
--prefetch # Place all refs into the refs/prefetch/ namespace
--prune(-p) # Remove obsolete remote-tracking references
--prune-tags(-P) # Remove any local tags that do not exist on the remote
--no-tags(-n) # Disable automatic tag following
--refmap: string # Use this refspec to map the refs to remote-tracking branches
--tags(-t) # Fetch all tags
--recurse-submodules: string # Fetch new commits of populated submodules (yes/on-demand/no)
--jobs(-j): int # Number of parallel children
--no-recurse-submodules # Disable recursive fetching of submodules
--set-upstream # Add upstream (tracking) reference
--submodule-prefix: string # Prepend to paths printed in informative messages
--upload-pack: string # Non-default path for remote command
--quiet(-q) # Silence internally used git commands
--verbose(-v) # Be verbose
--progress # Report progress on stderr
--server-option(-o): string # Pass options for the server to handle
--show-forced-updates # Check if a branch is force-updated
--no-show-forced-updates # Don't check if a branch is force-updated
-4 # Use IPv4 addresses, ignore IPv6 addresses
-6 # Use IPv6 addresses, ignore IPv4 addresses
]
# Push changes
export extern "git push" [
remote?: string@"nu-complete git remotes", # the name of the remote
...refs: string@"nu-complete git local branches" # the branch / refspec
--all # push all refs
--atomic # request atomic transaction on remote side
--delete(-d) # delete refs
--dry-run(-n) # dry run
--exec: string # receive pack program
--follow-tags # push missing but relevant tags
--force-with-lease # require old value of ref to be at this value
--force(-f) # force updates
--ipv4(-4) # use IPv4 addresses only
--ipv6(-6) # use IPv6 addresses only
--mirror # mirror all refs
--no-verify # bypass pre-push hook
--porcelain # machine-readable output
--progress # force progress reporting
--prune # prune locally removed refs
--push-option(-o): string # option to transmit
--quiet(-q) # be more quiet
--receive-pack: string # receive pack program
--recurse-submodules: string # control recursive pushing of submodules
--repo: string # repository
--set-upstream(-u) # set upstream for git pull/status
--signed: string # GPG sign the push
--tags # push tags (can't be used with --all or --mirror)
--thin # use thin pack
--verbose(-v) # be more verbose
]
# Pull changes
export extern "git pull" [
remote?: string@"nu-complete git remotes", # the name of the remote
...refs: string@"nu-complete git local branches", # the branch / refspec
--rebase(-r): string@"nu-complete git pull rebase", # rebase current branch on top of upstream after fetching
--quiet(-q) # suppress output during transfer and merge
--verbose(-v) # be more verbose
--commit # perform the merge and commit the result
--no-commit # perform the merge but do not commit the result
--edit(-e) # edit the merge commit message
--no-edit # use the auto-generated merge commit message
--cleanup: string # specify how to clean up the merge commit message
--ff # fast-forward if possible
--no-ff # create a merge commit in all cases
--gpg-sign(-S) # GPG-sign the resulting merge commit
--no-gpg-sign # do not GPG-sign the resulting merge commit
--log: int # include log messages from merged commits
--no-log # do not include log messages from merged commits
--signoff # add Signed-off-by trailer
--no-signoff # do not add Signed-off-by trailer
--stat(-n) # show a diffstat at the end of the merge
--no-stat # do not show a diffstat at the end of the merge
--squash # produce working tree and index state as if a merge happened
--no-squash # perform the merge and commit the result
--verify # run pre-merge and commit-msg hooks
--no-verify # do not run pre-merge and commit-msg hooks
--strategy(-s): string # use the given merge strategy
--strategy-option(-X): string # pass merge strategy-specific option
--verify-signatures # verify the tip commit of the side branch being merged
--no-verify-signatures # do not verify the tip commit of the side branch being merged
--summary # show a summary of the merge
--no-summary # do not show a summary of the merge
--autostash # create a temporary stash entry before the operation
--no-autostash # do not create a temporary stash entry before the operation
--allow-unrelated-histories # allow merging histories without a common ancestor
--no-rebase # do not rebase the current branch on top of the upstream branch
--all # fetch all remotes
--append(-a) # append fetched refs to existing contents of FETCH_HEAD
--atomic # use an atomic transaction to update local refs
--depth: int # limit fetching to the specified number of commits
--deepen: int # deepen the history by the specified number of commits
--shallow-since: string # deepen or shorten the history since a specified date
--shallow-exclude: string # exclude commits reachable from a specified branch or tag
--unshallow # convert a shallow repository to a complete one
--update-shallow # update .git/shallow with new refs
--tags(-t) # fetch all tags from the remote
--jobs(-j): int # number of parallel children for fetching
--set-upstream # add upstream (tracking) reference
--upload-pack: string # specify non-default path for upload-pack on the remote
--progress # force progress status even if stderr is not a terminal
--server-option(-o): string # transmit the given string to the server
]
# Switch between branches and commits
export extern "git switch" [
switch?: string@"nu-complete git switch" # name of branch to switch to
--create(-c) # create a new branch
--detach(-d): string@"nu-complete git log" # switch to a commit in a detached state
--force-create(-C): string # forces creation of new branch, if it exists then the existing branch will be reset to starting point
--force(-f) # alias for --discard-changes
--guess # if there is no local branch which matches then name but there is a remote one then this is checked out
--ignore-other-worktrees # switch even if the ref is held by another worktree
--merge(-m) # attempts to merge changes when switching branches if there are local changes
--no-guess # do not attempt to match remote branch names
--no-progress # do not report progress
--no-recurse-submodules # do not update the contents of sub-modules
--no-track # do not set "upstream" configuration
--orphan: string # create a new orphaned branch
--progress # report progress status
--quiet(-q) # suppress feedback messages
--recurse-submodules # update the contents of sub-modules
--track(-t) # set "upstream" configuration
]
# Apply the change introduced by an existing commit
export extern "git cherry-pick" [
commit?: string@"nu-complete git commits all" # The commit ID to be cherry-picked
--edit(-e) # Edit the commit message prior to committing
--no-commit(-n) # Apply changes without making any commit
--signoff(-s) # Add Signed-off-by line to the commit message
--ff # Fast-forward if possible
--continue # Continue the operation in progress
--abort # Cancel the operation
--skip # Skip the current commit and continue with the rest of the sequence
]
# Rebase the current branch
export extern "git rebase" [
branch?: string@"nu-complete git rebase" # name of the branch to rebase onto
upstream?: string@"nu-complete git rebase" # upstream branch to compare against
--continue # restart rebasing process after editing/resolving a conflict
--abort # abort rebase and reset HEAD to original branch
--quit # abort rebase but do not reset HEAD
--interactive(-i) # rebase interactively with list of commits in editor
--onto?: string@"nu-complete git rebase" # starting point at which to create the new commits
--root # start rebase from root commit
]
# Merge from a branch
export extern "git merge" [
# For now, to make it simple, we only complete branches (not commits) and support single-parent case.
branch?: string@"nu-complete git mergable sources" # The source branch
--edit(-e) # Edit the commit message prior to committing
--no-edit # Do not edit commit message
--no-commit(-n) # Apply changes without making any commit
--signoff # Add Signed-off-by line to the commit message
--ff # Fast-forward if possible
--continue # Continue after resolving a conflict
--abort # Abort resolving conflict and go back to original state
--quit # Forget about the current merge in progress
--strategy(-s): string@"nu-complete git merge strategies" # Merge strategy
-X: string@"nu-complete git merge strategy options" # Option for merge strategy
--verbose(-v)
--help
]
# List or change branches
export extern "git branch" [
branch?: string@"nu-complete git local branches" # name of branch to operate on
--abbrev # use short commit hash prefixes
--edit-description # open editor to edit branch description
--merged # list reachable branches
--no-merged # list unreachable branches
--set-upstream-to: string@"nu-complete git available upstream" # set upstream for branch
--unset-upstream # remote upstream for branch
--all # list both remote and local branches
--copy # copy branch together with config and reflog
--format # specify format for listing branches
--move # rename branch
--points-at # list branches that point at an object
--show-current # print the name of the current branch
--verbose # show commit and upstream for each branch
--color # use color in output
--quiet # suppress messages except errors
--delete(-d) # delete branch
--list # list branches
--contains: string@"nu-complete git commits all" # show only branches that contain the specified commit
--no-contains # show only branches that don't contain specified commit
--track(-t) # when creating a branch, set upstream
]
# List or change tracked repositories
export extern "git remote" [
--verbose(-v) # Show URL for remotes
]
# Add a new tracked repository
export extern "git remote add" [
]
# Rename a tracked repository
export extern "git remote rename" [
remote: string@"nu-complete git remotes" # remote to rename
new_name: string # new name for remote
]
# Remove a tracked repository
export extern "git remote remove" [
remote: string@"nu-complete git remotes" # remote to remove
]
# Get the URL for a tracked repository
export extern "git remote get-url" [
remote: string@"nu-complete git remotes" # remote to get URL for
]
# Set the URL for a tracked repository
export extern "git remote set-url" [
remote: string@"nu-complete git remotes" # remote to set URL for
url: string # new URL for remote
]
# Show changes between commits, working tree etc
export extern "git diff" [
rev1_or_file?: string@"nu-complete git files-or-refs"
rev2?: string@"nu-complete git refs"
--cached # show staged changes
--name-only # only show names of changed files
--name-status # show changed files and kind of change
--no-color # disable color output
]
# Commit changes
export extern "git commit" [
--all(-a) # automatically stage all modified and deleted files
--amend # amend the previous commit rather than adding a new one
--message(-m): string # specify the commit message rather than opening an editor
--reuse-message(-C): string # reuse the message from a previous commit
--reedit-message(-c): string # reuse and edit message from a commit
--fixup: string # create a fixup/amend commit
--squash: string # squash commit for autosquash rebase
--reset-author # reset author information
--short # short-format output for dry-run
--branch # show branch info in short-format
--porcelain # porcelain-ready format for dry-run
--long # long-format output for dry-run
--null(-z) # use NUL instead of LF in output
--file(-F): string # read commit message from file
--author: string # override commit author
--date: string # override author date
--template(-t): string # use commit message template file
--signoff(-s) # add Signed-off-by trailer
--no-signoff # do not add Signed-off-by trailer
--trailer: string # add trailer to commit message
--no-verify(-n) # bypass pre-commit and commit-msg hooks
--verify # do not bypass pre-commit and commit-msg hooks
--allow-empty # allow commit with no changes
--allow-empty-message # allow commit with empty message
--cleanup: string # cleanup commit message
--edit(-e) # edit commit message
--no-edit # do not edit commit message
--include(-i) # include given paths in commit
--only(-o) # commit only specified paths
--pathspec-from-file: string # read pathspec from file
--pathspec-file-nul # use NUL character for pathspec file
--untracked-files(-u): string # show untracked files
--verbose(-v) # show diff in commit message template
--quiet(-q) # suppress commit summary
--dry-run # show paths to be committed without committing
--status # include git-status output in commit message
--no-status # do not include git-status output
--gpg-sign(-S) # GPG-sign commit
--no-gpg-sign # do not GPG-sign commit
...pathspec: string # commit files matching pathspec
]
# List commits
export extern "git log" [
# Ideally we'd allow completion of revisions here, but that would make completion of filenames not work.
-U # show diffs
--follow # show history beyond renames (single file only)
--grep: string # show log entries matching supplied regular expression
]
# Show or change the reflog
export extern "git reflog" [
]
# Stage files
export extern "git add" [
...file: string@"nu-complete git add" # file to add
--all(-A) # add all files
--dry-run(-n) # don't actually add the file(s), just show if they exist and/or will be ignored
--edit(-e) # open the diff vs. the index in an editor and let the user edit it
--force(-f) # allow adding otherwise ignored files
--interactive(-i) # add modified contents in the working tree interactively to the index
--patch(-p) # interactively choose hunks to stage
--verbose(-v) # be verbose
]
# Delete file from the working tree and the index
export extern "git rm" [
-r # recursive
--force(-f) # override the up-to-date check
--dry-run(-n) # Don't actually remove any file(s)
--cached # unstage and remove paths only from the index
]
# Show the working tree status
export extern "git status" [
--verbose(-v) # be verbose
--short(-s) # show status concisely
--branch(-b) # show branch information
--show-stash # show stash information
]
# Stash changes for later
export extern "git stash push" [
--patch(-p) # interactively choose hunks to stash
]
# Unstash previously stashed changes
export extern "git stash pop" [
stash?: string@"nu-complete git stash-list" # stash to pop
--index(-i) # try to reinstate not only the working tree's changes, but also the index's ones
]
# List stashed changes
export extern "git stash list" [
]
# Show a stashed change
export extern "git stash show" [
stash?: string@"nu-complete git stash-list"
-U # show diff
]
# Drop a stashed change
export extern "git stash drop" [
stash?: string@"nu-complete git stash-list"
]
# Create a new git repository
export extern "git init" [
--initial-branch(-b): string # initial branch name
]
# List or manipulate tags
export extern "git tag" [
--delete(-d): string@"nu-complete git tags" # delete a tag
]
# Prune all unreachable objects
export extern "git prune" [
--dry-run(-n) # dry run
--expire: string # expire objects older than
--progress # show progress
--verbose(-v) # report all removed objects
]
# Start a binary search to find the commit that introduced a bug
export extern "git bisect start" [
bad?: string # a commit that has the bug
good?: string # a commit that doesn't have the bug
]
# Mark the current (or specified) revision as bad
export extern "git bisect bad" [
]
# Mark the current (or specified) revision as good
export extern "git bisect good" [
]
# Skip the current (or specified) revision
export extern "git bisect skip" [
]
# End bisection
export extern "git bisect reset" [
]
# Show help for a git subcommand
export extern "git help" [
command?: string@"nu-complete git subcommands" # subcommand to show help for
]
# git worktree
export extern "git worktree" [
--help(-h) # display the help message for this command
...args
]
# create a new working tree
export extern "git worktree add" [
path: path # directory to clone the branch
branch: string@"nu-complete git available upstream" # Branch to clone
--help(-h) # display the help message for this command
--force(-f) # checkout <branch> even if already checked out in other worktree
-b # create a new branch
-B # create or reset a branch
--detach(-d) # detach HEAD at named commit
--checkout # populate the new working tree
--lock # keep the new working tree locked
--reason # reason for locking
--quiet(-q) # suppress progress reporting
--track # set up tracking mode (see git-branch(1))
--guess-remote # try to match the new branch name with a remote-tracking branch
...args
]
# list details of each worktree
export extern "git worktree list" [
--help(-h) # display the help message for this command
--porcelain # machine-readable output
--verbose(-v) # show extended annotations and reasons, if available
--expire # add 'prunable' annotation to worktrees older than <time>
-z # terminate records with a NUL character
...args
]
def "nu-complete worktree list" [] {
^git worktree list | to text | parse --regex '(?P<value>\S+)\s+(?P<commit>\w+)\s+(?P<description>\S.*)'
}
# prevent a working tree from being pruned
export extern "git worktree lock" [
worktree: string@"nu-complete worktree list"
--reason: string # reason because the tree is locked
--help(-h) # display the help message for this command
--reason # reason for locking
...args
]
# move a working tree to a new location
export extern "git worktree move" [
--help(-h) # display the help message for this command
--force(-f) # force move even if worktree is dirty or locked
...args
]
# prune working tree information
export extern "git worktree prune" [
--help(-h) # display the help message for this command
--dry-run(-n) # do not remove, show only
--verbose(-v) # report pruned working trees
--expire # expire working trees older than <time>
...args
]
# remove a working tree
export extern "git worktree remove" [
worktree: string@"nu-complete worktree list"
--help(-h) # display the help message for this command
--force(-f) # force removal even if worktree is dirty or locked
]
# allow working tree to be pruned, moved or deleted
export extern "git worktree unlock" [
worktree: string@"nu-complete worktree list"
...args
]
# clones a repo
export extern "git clone" [
--help(-h) # display the help message for this command
--local(-l) # cloning from the local machine
--no-local # use the git transport mechanism even if cloning from a local path
--no-hardlinks # force git to copy files when cloning from the local machine
--shared(-s) # setup .git/objects/info/alternates to share objects with the source local repo
--reference: string # setup .git/objects/info/alternates to share objects with the =<reference> local repo
--reference-if-able: string # same as --reference, but skips empty folders
--dissociate # borrow objects from the referenced repo (--reference)
--quiet(-q) # suppress progress reporting
--verbose(-v) # be verbose
--progress # report progress unless --quiet
--server-option: string # transmit the =<option> to the server
--no-checkout(-n) # no checkout of HEAD
--reject-shallow # reject shallow repository as source
--no-reject-shallow # do not reject shallow repository as source
--bare # make a bare git repo
--sparse # initialize the sparse-checkout file
--filter: string # partial clone using the given =<filter-spec>
--mirror # mirror the source repo
--origin(-o): string # use <name> as the name for the remote origin
--branch(-b): string # point HEAD to <name> branch
--upload-pack(-u): string # use <upload-pack> as the path in the other end when using ssh
--template: string # use <template-dir> as the templates directory
--config(-c): string # set a <key>=<value> config variable
--depth: int # shallow clone <depth> commits
--shallow-since: string # shallow clone commits newer than =<date>
--shallow-exclude: string # do not clone commits reachable from <revision> (branch or tag)
--single-branch # clone commit history from a single branch
--no-single-Branch # do not clone only one branch
--no-tags # do not clone any tags
--recurse-submodules # clone the submodules. Also accepts paths
--shallow-submodules # shallow clone submodules with depth 1
--no-shallow-submodules # do not shallow clone submodules
--remote-submodules # submodules are updating using their remote tracking branch
--no-remote-submodules # do not track submodules remote
--separate-git-dir: string # place the clone at =<git dir> and link it here
--jobs(-j): int # number of simultaneous submodules fetch
...args
]
# Restores files in working tree or index to previous versions
export extern "git restore" [
--help(-h) # Display the help message for this command
--source(-s) # Restore the working tree files with the content from the given tree
--patch(-p) # Interactively choose hunks to restore
--worktree(-W) # Restore working tree (default if neither --worktree or --staged is used)
--staged(-S) # Restore index
--quiet(-q) # Quiet, suppress feedback messages
--progress # Force progress reporting
--no-progress # Suppress progress reporting
--ours # Restore from index using our version for unmerged files
--theirs # Restore from index using their version for unmerged files
--merge(-m) # Restore from index and recreate the conflicted merge in unmerged files
--conflict: string # Like --merge but changes the conflict presentation with =<style>
--ignore-unmerged # Restore from index and ignore unmerged entries (unmerged files are left as is)
--ignore-skip-worktree-bits # Ignore sparse checkout patterns and unconditionally restores any files in <pathspec>
--recurse-submodules # Restore the contents of sub-modules in working tree
--no-recurse-submodules # Do not restore the contents of sub-modules in working tree (default)
--overlay # Do not remove files that don't exist when restoring from tree with --source
--no-overlay # Remove files that don't exist when restoring from tree with --source (default)
--pathspec-from-file: string # Read pathspec from file
--pathspec-file-nul # Separate pathspec elements with NUL character when reading from file
...pathspecs: string@"nu-complete git files" # Target pathspecs to restore
]
# Print lines matching a pattern
export extern "git grep" [
--help(-h) # Display the help message for this command
--cached # Search blobs registered in the index file instead of worktree
--untracked # Include untracked files in search
--no-index # Similar to `grep -r`, but with additional benefits, such as using pathspec patterns to limit paths; Cannot be used together with --cached or --untracked
--no-exclude-standard # Include ignored files in search (only useful with --untracked)
--exclude-standard # No not include ignored files in search (only useful with --no-index)
--recurse-submodules # Recursively search in each submodule that is active and checked out
--text(-a) # Process binary files as if they were text
--textconv # Honor textconv filter settings
--no-textconv # Do not honor textconv filter settings (default)
--ignore-case(-i) # Ignore case differences between patterns and files
-I # Don’t match the pattern in binary files
--max-depth: int # Max <depth> to descend down directories for each pathspec. A value of -1 means no limit.
--recursive(-r) # Same as --max-depth=-1
--no-recursive # Same as --max-depth=0
--word-regexp(-w) # Match the pattern only at word boundary
--invert-match(-v) # Select non-matching lines
-H # Suppress filename in output of matched lines
--full-name # Force relative path to filename from top directory
--extended-regexp(-E) # Use POSIX extended regexp for patterns
--basic-regexp(-G) # Use POSIX basic regexp for patterns (default)
--perl-regexp(-P) # Use Perl-compatible regular expressions for patterns
--line-number(-n) # Prefix the line number to matching lines
--column # Prefix the 1-indexed byte-offset of the first match from the start of the matching line
--files-with-matches(-l) # Print filenames of files that contains matches
--name-only # Same as --files-with-matches
--files-without-match(-L) # Print filenames of files that do not contain matches
--null(-z) # Use \0 as the delimiter for pathnames in the output, and print them verbatim
--only-matching(-o) # Print only the matched (non-empty) parts of a matching line, with each such part on a separate output line
--count(-c) # Instead of showing every matched line, show the number of lines that match
--no-color # Same as --color=never
--break # Print an empty line between matches from different files.
--heading # Show the filename above the matches in that file instead of at the start of each shown line.
--show-function(-p) # Show the preceding line that contains the function name of the match, unless the matching line is a function name itself.
--context(-C): int # Show <num> leading and trailing lines, and place a line containing -- between contiguous groups of matches.
--after-context(-A): int # Show <num> trailing lines, and place a line containing -- between contiguous groups of matches.
--before-context(-B): int # Show <num> leading lines, and place a line containing -- between contiguous groups of matches.
--function-context(-W) # Show the surrounding text from the previous line containing a function name up to the one before the next function name
--max-count(-m): int # Limit the amount of matches per file. When using the -v or --invert-match option, the search stops after the specified number of non-matches.
--threads: int # Number of grep worker threads to use. Use --help for more information on grep threads.
-f: string # Read patterns from <file>, one per line.
-e: string # Next parameter is the pattern. Multiple patterns are combined by --or.
--and # Search for lines that match multiple patterns.
--or # Search for lines that match at least one of multiple patterns. --or is implied between patterns without --and or --not.
--not # Search for lines that does not match pattern.
--all-match # When giving multiple pattern expressions combined with --or, this flag is specified to limit the match to files that have lines to match all of them.
--quiet(-q) # Do not output matched lines; instead, exit with status 0 when there is a match and with non-zero status when there isn’t.
...pathspecs: string # Target pathspecs to limit the scope of the search.
]
export extern "git" [
command?: string@"nu-complete git subcommands" # Subcommands
--version(-v) # Prints the Git suite version that the git program came from
--help(-h) # Prints the synopsis and a list of the most commonly used commands
--html-path # Print the path, without trailing slash, where Git’s HTML documentation is installed and exit
--man-path # Print the manpath (see man(1)) for the man pages for this version of Git and exit
--info-path # Print the path where the Info files documenting this version of Git are installed and exit
--paginate(-p) # Pipe all output into less (or if set, $env.PAGER) if standard output is a terminal
--no-pager(-P) # Do not pipe Git output into a pager
--no-replace-objects # Do not use replacement refs to replace Git objects
--bare # Treat the repository as a bare repository
]

30
.config/nushell/jc.nu Normal file
View file

@ -0,0 +1,30 @@
# Run `jc` (Json Converter)
#
# This module provides a wrapper around the `jc` command line tool and automatically
# parses its output into a structured data format.
#
# Dependencies:
# * `jc`
#
# Installation:
# 1. Install the `jc` command line: https://kellyjonbrazil.github.io/jc/#installation
# 2. Import this module in your `config.nu`: `import ~/.local/share/nu_scripts/modules/jc/`
export def --wrapped main [...args]: [any -> table, any -> record, any -> string] {
let run = (^jc ...$args | complete)
if $run.exit_code != 0 {
error make {
msg: $run.stderr,
label: {
text: "jc execution failed",
span: (metadata $args).span
}
}
}
if '--help' in $args or '-h' in $args {
$run.stdout
} else {
$run.stdout | from json
}
}

28
.config/nushell/npm.nu Normal file
View file

@ -0,0 +1,28 @@
def "nu-complete pnpm" [] {
^npm -l
|lines
|find 'Run "'
|str trim
|split column -c ' '
|get column4
|str replace '"' ''
}
export extern "pnpm" [
command?: string@"nu-complete pnpm"
]
def "nu-complete pnpm run" [] {
open ./package.json
|get scripts
|columns
}
export extern "pnpm run" [
command?: string@"nu-complete pnpm run"
--workspace(-w)
--include-workspace-root
--if-present
--ignore-scripts
--script-shell
]

28
.config/nushell/sockets.nu Normal file
View file

@ -0,0 +1,28 @@
export def main [--abbreviate-java-class-paths (-j)] {
let input = (^lsof +c 0xFFFF -i -n -P)
let header = ($input | lines
| take 1
| each { str downcase | str replace ' name$' ' name state' })
let body = ($input | lines
| skip 1
| each { str replace '([^)])$' '$1 (NONE)' | str replace ' \((.+)\)$' ' $1' })
[$header] | append $body
| to text
| detect columns
| upsert 'pid' { |r| $r.pid | into int }
| rename --column { name: connection }
| reject 'command'
| join (ps -l) 'pid' 'pid'
| if $abbreviate_java_class_paths {
upsert 'classpath' { |r| $r.command | java-cmd classpath }
| upsert 'command' { |r| $r.command | java-cmd abbreviate-classpath }
} else { $in }
}
export def 'java-cmd classpath' [] {
str replace '.* -classpath +(.+\.jar) +.*' '$1' | split row ':'
}
export def 'java-cmd abbreviate-classpath' [] {
str replace '[^ ]*\.jar' '*.jar'
}

6
flake.lock
View file

@ -767,11 +767,11 @@
"nixpkgs": "nixpkgs_3"
},
"locked": {
"lastModified": 1743904111,
"narHash": "sha256-TuH6MkwWOmuPrR0IPQee2z/RB7c+fczFkoEM26zRLgk=",
"lastModified": 1743990663,
"narHash": "sha256-n7bzOLVlYvxgawlIl8fXIxaDjATKhYOhp2OyP61DxdI=",
"owner": "fufexan",
"repo": "nix-gaming",
"rev": "2fff10cf0e09d4a0d2b5c9379cc47accba3d3f1c",
"rev": "35e3aef6ebb7b27195586130175f1409cd71d7f7",
"type": "github"
},
"original": {

4
home.nix
View file

@ -186,6 +186,10 @@ in
oh-my-posh
libva-utils
atuin
jc
lsof
carapace
# (python312.withPackages (ps: with ps; [
# pyquery