百科.dev
全部条目在线工具AI 编程趋势榜开源项目技术资讯提交条目
登录
< 返回工具列表
R

rubish

> 编程语言
开源

Rubish 是用纯 Ruby 编写的 UNIX 命令行解释器。命令行语法会被解析并编译为 Ruby 代码,然后由 Ruby VM 执行。概念 完全基于 Ruby 语言。

295 stars0 点赞3 次浏览
访问官网GitHub

工具介绍

Rubish 是用纯 Ruby 编写的 UNIX 命令行解释器。命令行语法会被解析并编译为 Ruby 代码,然后由 Ruby VM 执行。概念 完全基于 Ruby 语言。

Rubish

A UNIX shell written in pure Ruby.

Shell syntax is parsed and compiled to Ruby code, then executed by the Ruby VM.

Concept

Fully Bash-compatible

Rubish supports all the features of bash, and the shell syntax is fully compatible. You can run your existing bash scripts without modification. If you found any bash script that doesn't work in rubish, we consider it a bug, so please report it!

Deep Ruby integration

Rubish is not just a shell implemented in Ruby, but a shell that deeply integrates Ruby. You can seamlessly mix shell commands and Ruby code, and even use Ruby's powerful features like blocks, iterators, and libraries in your shell scripts.

Installation

Homebrew (macOS)

bash
brew tap amatsuda/rubish
brew install --HEAD rubish

From source

bash
git clone https://github.com/amatsuda/rubish.git
cd rubish
bundle install
bundle exec exe/rubish

bin/rubish is a small bash launcher that finds a usable Ruby on its own (probes ~/.rbenv/shims/ruby, /opt/homebrew/bin/ruby, /usr/local/bin/ruby, system Ruby; honors $ECHOES_RUBY, falling back to $RUBY for back-compat). Use it when bundler isn't around — for example as a login shell, from a .app bundle, or anywhere PATH may be minimal:

bash
./bin/rubish
ECHOES_RUBY=/opt/homebrew/opt/[email protected]/bin/ruby ./bin/rubish   # explicit override

Usage

Start an interactive shell:

bash
rubish

Run a single command:

bash
rubish -c 'echo hello'

Run a script:

bash
rubish script.sh

Or you can even use this as a login shell!

Set as login shell

bash
echo "$(which rubish)" | sudo tee -a /etc/shells
chsh -s "$(which rubish)"

Features beyond Bash

Ruby conditions

Use Ruby expressions as conditions in if, while, and until by wrapping them in { }. Shell variables are automatically bound as local variables in the Ruby expression:

bash
COUNT=5
if { count.to_i > 3 }
  echo 'count is greater than 3'
end

while { count.to_i > 0 }
  echo $COUNT
  COUNT=$((COUNT - 1))
done

Ruby method call style

Commands can be invoked using Ruby method call syntax with parentheses, in addition to the traditional UNIX style with spaces:

bash
# These are equivalent:
ls -la
ls('-la')

# Arguments can be passed as method arguments:
cat(file.txt)
grep('pattern', file.txt)

Method chaining

Commands can be chained with Ruby methods using dot notation, forming a pipeline. The chain has to be opened by a parenthesized call, an array literal, or a block — once you're in chain context, subsequent methods can be bare:

bash
# Equivalent to `ls | sort`
ls().sort

# Equivalent to `ls | sort | uniq`
ls().sort.uniq

# Equivalent to `cat file.txt | grep error`
cat(file.txt).grep(/error/)

# Chains can be combined with blocks (see "Ruby iterator blocks" below)
ls.select { it.end_with?('.rb') }.each { |f| puts f.upcase }

The first segment needs the parens because bare cmd.method is ambiguous with paths and dotted filenames (./script.sh, file.tar.gz) — once () confirms a method-call form, the lexer knows it's safe to chain.

Ruby iterator blocks

Ruby iterator methods (.each, .map, .select, .detect) can take blocks to process command output line by line:

bash
ls.each { |f| puts f.upcase }
cat(file.txt).map { |line| line.strip }
ls.select { it.end_with?('.rb') }

Inline Ruby evaluation

Any line starting with a capital letter is evaluated as Ruby code directly. This means you can use Ruby classes, methods, and expressions right from the shell prompt without any special syntax:

rubish$ Time.now
=> 2025-01-01 12:00:00 +0900

rubish$ Dir.glob('*.rb').sort
=> ["Gemfile", "Rakefile"]

rubish$ ENV['HOME']
=> "/Users/you"

Multi-line blocks work too — rubish detects unfinished Ruby (open do, missing end, unterminated strings, etc.) and prompts for continuation lines, both at the interactive prompt and inside sourced rcfiles. Only single-line interactive expressions get the IRB-style => … value printed; multi-line blocks and sourced statements run silently for their side effects.

Ruby array and regexp literals

Ruby array literals can be used directly in shell context. Rubish distinguishes them from glob patterns like [a-z] automatically:

rubish$ [1, 2, 3].map { |x| x * x }
=> [1, 4, 9]

Lambda expressions

You can execute any Ruby code by surrounding it with a lambda expression (-> { }):

rubish$ -> { 2 ** 10 }
=> 1024

Ruby-style function definitions

In addition to the standard shell function syntax, rubish supports Ruby-style def...end with named parameters and splat args:

bash
def greet(name)
  echo "Hello, $name"
end

def log(level, *messages)
  echo "[$level] $messages"
end

greet world    # => Hello, world

Custom Ruby prompts

Define your prompt as a Ruby function for full programmatic control. The function is called on every prompt render, so it can include dynamic content:

bash
def rubish_prompt
  branch = `git branch --show-current 2>/dev/null`.strip
  dir = Dir.pwd.sub(ENV['HOME'], '~')
  "\e[36m#{dir}\e[0m \e[33m#{branch}\e[0m $ "
end

def rubish_right_prompt
  Time.now.strftime('%H:%M:%S')
end

You can also use the traditional PS1/RPROMPT variables with bash (\X) or zsh (%X) escape codes.

Tab completion

Rubish tab-completes most commands out of the box, with no per-tool setup files to install. The completer derives subcommands and flags from each tool's own --help output, on demand:

rubish$ git              # add  branch  checkout  clone  commit  …
rubish$ gh pr            # checkout  close  create  diff  edit  list  …
rubish$ rails generate   # scaffold  model  controller  channel  mailer  …
rubish$ kubectl get      # pods  services  deployments  …
rubish$ cargo build --   # --release  --target  --verbose  …

It walks arbitrarily deep — rails generate scaffold -- parses scaffold's own flags, aws s3 cp -- reaches AWS sub-sub-commands, and so on.

How it stays correct, fast, and side-effect-free:

  • For a list of well-known tools (gem, brew, cargo, aws, npm, gh, kubectl, pyenv, rbenv, launchctl, composer, hg, …) rubish curates the right help invocation (gem help commands, cargo --list, launchctl help, etc.), so the cleanest output is used. For anything else it falls back to --help then -h.
  • Each result is cached for 30 minutes; repeat ``s against the same chain are instant.
  • On macOS the help command runs inside a sandbox-exec profile with no network access and writes restricted to /tmp. Completing on an unfamiliar binary can never modify your filesystem — touch help won't accidentally create a file.
  • When zsh has a _ completion file in $fpath, rubish reads it too — improving completion for tools whose own --help is sparse.

Other completion features:

  • Inline auto-suggestion (fish style) is on by default: as you type, the most likely completion appears in dim text after the cursor — press to accept it. opens the full popup; see Completion dialog colors to style it.
  • Abbreviated path completion (zsh style): a/c/a expands to app/controllers/application_controller.rb — each component matches by prefix.
  • Slow help commands: framework CLIs like rails boot their full app just to print --help, which may exceed the default 5-second timeout. Bump it via RUBISH_HELP_TIMEOUT=10.
  • Debugging: RUBISH_DEBUG_COMPLETION=1 prints each help-command invocation, its duration, and whether it produced parseable output on stderr.

Bash- and zsh-style programmable completion (complete -F, compgen, compdef, compinit, autoload) is supported too, for tools where the auto-help path isn't enough. Existing completion scripts Just Work.

Completion dialog colors

Rubish uses Reline's inline completion dialog (the fish-style suggestions popup) for tab-completion. Its colors are configured via Reline::Face. Drop a regular Ruby block in your rcfile:

ruby
# In ~/.rubishrc or ~/.config/rubish/config
Reline::Face.config(:completion_dialog) do |conf|
  conf.define :default,   foreground: :cyan,  background: :black
  conf.define :enhanced,  foreground: :black, background: :cyan, style: :bold
  conf.define :scrollbar, foreground: :white, background: :black
end

The three face names map to different parts of the dialog: :default for the unselected rows, :enhanced for the currently highlighted row, and :scrollbar for the scrollbar (visible when results overflow the popup). Colors can be a Reline symbol (:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white, plus :bright_* / :gray variants) or a hex truecolor string like '#abcdef'. :style accepts :bold, :faint, :italicized, :underlined, :blinking, :negative, :concealed, :crossed_out — or an array of those for multiple effects.

This works because rubish's inline Ruby evaluation handles multi-line blocks (see Inline Ruby evaluation), so the natural do … end form is fine in both rcfiles and at the interactive prompt — no need for one-line reformatting.

Lazy loading

Slow shell initializations (e.g., rbenv init, nvm, pyenv) can be deferred to a background thread using lazy_load. The block runs immediately in the background, and its result (a string of shell code) is applied before the next prompt. This keeps shell startup instant:

bash
# In ~/.rubishrc
lazy_load {
  `rbenv init - --no-rehash bash`
}

lazy_load {
  `nodenv init - bash`
}

Multiple lazy_load blocks run in parallel. By the time you type your first command, they're usually done.

Restricted mode

Running rubish -r disables all Ruby integration features (inline evaluation, lambdas, blocks, Ruby conditions, and array literals) for executing untrusted scripts safely. Only standard shell syntax is allowed.

Zsh compatibility

In addition to full Bash compatibility, rubish also supports zsh-style features:

  • setopt/unsetopt
  • compdef/compinit
  • autoload with fpath
  • %X prompt codes and RPROMPT/RPS1
  • Abbreviated path expansion (see Tab completion)

Configuration files

Login shells load (in order):

  1. /etc/profile
  2. ~/.config/rubish/profile or ~/.rubish_profile (or ~/.bash_profile / ~/.bash_login / ~/.profile)

Interactive shells load:

  1. ~/.config/rubish/config or ~/.rubishrc (or ~/.bashrc)
  2. ./.rubishrc (project-local)

Logout:

  1. ~/.config/rubish/logout or ~/.rubish_logout (or ~/.bash_logout)

Embedding in a Ruby program

Rubish exposes a public API so other Ruby programs (terminal emulators, IDE plugins, GUI front-ends) can drive a rubish session in-process — no fork+exec, no JSON serialization, just method calls. The sibling Echoes terminal emulator uses this to render syntax-highlighted prompts and decide command-execution shape ahead of time.

…

Custom I/O backend

The default Rubish::Frontend::Tty wraps Reline + stdin/stdout. Hosts that own their own line editor can subclass Rubish::Frontend::Base and pass an instance into the REPL:

ruby
class MyFrontend  {
  Process.setsid
  # ...ioctls, signal handlers, etc.
}

Builtins

Category Commands
Directory cd, pwd, pushd, popd, dirs
I/O echo, printf, read, mapfile, readarray
Variables export, declare, typeset, readonly, unset, local, shift, set
Process exit, logout, exec, kill, wait, times
Job control jobs, fg, bg, disown, suspend
Functions function, return, caller
Aliases alias, unalias
History history, fc
Execution eval, source, ., command, builtin
Testing test, [, [[

Issues· 10 开放

查看全部 Issues在 GitHub 打开

暂无开放 Issues,或尚未同步最近议题。

> 标签

Ruby

暂无评论,来聊聊你的看法吧

> 工具信息

发布日期2026年8月1日
最后更新2026年9月18日
分类编程语言
定价开源

> 相关工具

T
TypeScript
JavaScript 的超集,为前端与全栈提供静态类型
P
Python
通用编程语言,广泛用于 Web、数据与 AI
G
Go
Google 推出的简洁高效系统语言