Skip to content
Your comrade through the perilous world of UNIX.
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
benches
doc
scripts
src
tests
.gitignore
.travis.yml
Cargo.lock
Cargo.toml
LICENSE
README.md
build.rs
deploy.sh
rust-toolchain

README.md

oursh

Documentation Build Status Dependencies Gitter Chat

This shell should be both POSIX compatible and yet modern and exciting. Fancy features should not be prevented by POSIX compatibility. This will effect the design of the shell.

The name of the shell is oursh which is both somewhat unique, and memorable. It's also a nice name to play with pseudo-satirical themes... right comrade? It's short (ish) and sneakily fits rs in it, which is the extension of Rust programs, the language this will be written in.

Features

  • POSIX compatibility
    • Simple commands ls
    • Quotes echo "foo"; echo 'bar'
    • Variables echo $foo
    • Environment echo $TERM
    • Special variables echo $?; echo $1
    • Compound commands { ls; date; }
    • Boolean status syntax ! true && false || true
    • Conditionals if ; then ; elif ; then ; else ; fi
    • Subshells (sleep 1; date)
    • Background jobs { sleep 1; date; }& date
  • Shebang block programs
    • Alternate syntax {# ...}
    • Hashlang syntax {#lang; ...}, i.e. {#posix ls}
    • Shebang syntax {#!/usr/bin/env ruby; puts :sym}
  • bash/zsh autocomplete compatibility
    • Command completion
    • Path completion
    • Variable completion
    • Job completion
    • Syntax completion
    • man / -h / --help parsing
  • Multi-line input
  • Modern scripting language
    • Macros
    • Types
    • Higher-order functions
    • Threading?
  • Obfuscated strings (!'password'!)
  • mosh like remote session support
  • Smart history, sync'd across devices
  • Pipe old commands without rerunning
  • Package manager
  • Sane defaults
  • Fast

Usage

While this project is in early stages, there are no OS packages to use. However, you can compile and run directly from source easily. Just ensure you have rustup installed.

cargo build
cargo run

Testing

We have four kinds of tests in this program. Crate unit tests, Executable unit tests, subprocess based integration tests, and documentation tests.

# Run all tests.
cargo test

Previous Work

I've been using fish as my main shell for a few years now. Fish inspires a lot of the modern syntax.

POSIX compatibility comes from my desire to use this shell as my chsh -s ... shell on Arch Linux. See the full POSIX reference for more information.

Some of the shebang language interoperation was inspired by my time with the Northeastern University PL group, and generally from writing Racket. The beauty of of merging the UNIX style #!... with Racket's #lang ... here is very exciting to me. I might just have to make a {#lang ...} shortcut for Racket!

I've built and wrote a few things about shells before:

POSIX Reference

See the following sections for building the POSIX sh compliant program language, and interactive terminal based REPL.

  • 3§2 Shell Command Language
    • 10.2 Shell Grammar Rules
  • 2§2.5 Standard I/O Streams
  • 3§1.6 Built-In Utilities
  • 3§1.4 Utility Description Defaults
  • 2§2.3 Error Numbers
  • 1§11 General Terminal Interface
  • 2§2.4 Signal Concepts

Implementation

This shell will be written in Rust with minimal dependencies. Notably termios and libc will likely be used. The parsing library will be lalrpop, which should support the syntax we want somewhat easily, though grammar's in general can be a tricky beast.

We will want to create a few internal modules for the shell.

This design is subject to change.

  • job - sub-process execution management.
  • program - parser and interpreter for the syntax of the shell.
    • posix - POSIX (sh-like) syntax.
    • modern - Modified syntax for supporting "modern" features, like lambdas.
  • repl - syntax aware, read eval print loop for an underlying terminal.
    • history - records previous execution to a shared DB.
    • completion - searches for autocompletions based on partial syntax.
      • bash - bash completion support.
      • zsh - zsh completion support.
      • parse - dynamic completion generation, from man for example.
    • sync - remote session and DB synchronization.
  • config - loading for .ourshrc and others.
  • package - simplistic package manager support (builtin function).

Current modules as of: 2018-10-14

 oursh : crate
 ├── job : public
 ├── program : public
 │   ├── basic : public
 │   └── posix : public
 │       ├── ast : public
 │       │   └── tests : private @ #[cfg(test)]
 │       ├── builtin : public
 │       └── lex : public
 │           └── tests : private @ #[cfg(test)]
 ├── repl : public
 │   ├── completion : public @ #[cfg(feature = "completion")]
 │   └── history : public @ #[cfg(feature = "history")]
 └── tests : private @ #[cfg(test)]└── tests : private @ #[cfg(test)]
You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.