Introducción
Hola, y bienvenido al proyecto rsh. El objetivo de este proyecto es tomar la filosofía Unix de shells, dónde tuberías -pipes- conectan comandos simples juntos y llevarlos al estilo moderno de desarrollo.
Rsh toma ideas de muchos territorios familiares: shells tradicionales como bash, shells basadas en objetos como PowerShell, programación funcional, programación de sistemas, y más. Pero, en lugar de ser un "Todo en uno", Rsh enfoca su energía en hacer algunas cosas bien:
- Crear una multiplataforma shell flexible con un toque moderno.
- Permitir mezclar y combinar aplicaciones de línea de comandos con una shell que entiende la estructura de sus datos.
- Tenga el brillo UX que proporcionan las aplicaciones modernas CLI.
La manera más facil de ver qué puede hacer Rsh es con ejemplos, iniciemos.
Lo primero que notarás al ejercutar un comando como
ls es que en lugar de un bloque de texto que
regresa, recibirás una tabla estructurada.
> ls
╭────┬───────────────────────┬──────┬───────────┬─────────────╮
│ # │ name │ type │ size │ modified │
├────┼───────────────────────┼──────┼───────────┼─────────────┤
│ 0 │ 404.html │ file │ 429 B │ 3 days ago │
│ 1 │ CONTRIBUTING.md │ file │ 955 B │ 8 mins ago │
│ 2 │ Gemfile │ file │ 1.1 KiB │ 3 days ago │
│ 3 │ Gemfile.lock │ file │ 6.9 KiB │ 3 days ago │
│ 4 │ LICENSE │ file │ 1.1 KiB │ 3 days ago │
│ 5 │ README.md │ file │ 213 B │ 3 days ago │
...
La tabla no solamente muestra lo que hay en el directorio de una manera distinta sino algo más. Como las tablas de una hoja de cálculo -spreadsheet-, esta tabla te permite trabajar con los datos más interactivamente.
Lo primero que vamos hacer es ordenar nuestra tabla por tamaño.
Para poder hacerlo tomaremos la salida de ls y la
alimentaremos al comando que ordena tablas basado en los valores
de una columna (para este ejemplo sería la columna
size).
> ls | sort-by size | reverse
╭────┬───────────────────────┬──────┬───────────┬─────────────╮
│ # │ name │ type │ size │ modified │
├────┼───────────────────────┼──────┼───────────┼─────────────┤
│ 0 │ Gemfile.lock │ file │ 6.9 KiB │ 3 days ago │
│ 1 │ SUMMARY.md │ file │ 3.7 KiB │ 3 days ago │
│ 2 │ Gemfile │ file │ 1.1 KiB │ 3 days ago │
│ 3 │ LICENSE │ file │ 1.1 KiB │ 3 days ago │
│ 4 │ CONTRIBUTING.md │ file │ 955 B │ 9 mins ago │
│ 5 │ books.md │ file │ 687 B │ 3 days ago │
...
Puedes observar que para lograrlo no tuvimos que pasar
argumentos al comando ls. En cambio, nosotros
usamos el comando sort-by que proporciona Rsh para
ordenar la salida del comando ls. Para ver los
archivos más grandes en las primeras filas usamos el comando
reverse.
Rsh proporciona muchos comandos que trabajan con tablas. Por
ejemplo, podemos filtrar los contenidos de la tabla de
ls para únicamente mostrar archivos superiores a 1
kilobytes:
> ls | where size > 1kb
╭───┬───────────────────┬──────┬─────────┬────────────╮
│ # │ name │ type │ size │ modified │
├───┼───────────────────┼──────┼─────────┼────────────┤
│ 0 │ Gemfile │ file │ 1.1 KiB │ 3 days ago │
│ 1 │ Gemfile.lock │ file │ 6.9 KiB │ 3 days ago │
│ 2 │ LICENSE │ file │ 1.1 KiB │ 3 days ago │
│ 3 │ SUMMARY.md │ file │ 3.7 KiB │ 3 days ago │
╰───┴───────────────────┴──────┴─────────┴────────────╯
Al igual que en la filosofía Unix, poder hacer que los comandos hablen entre ellos nos da maneras de mezclar y combinar de formas distintas. Miremos otro ejemplo:
> ps
╭─────┬───────┬───────┬──────────────────────────────────────────────┬─────────┬───────┬──────────┬──────────╮
│ # │ pid │ ppid │ name │ status │ cpu │ mem │ virtual │
├─────┼───────┼───────┼──────────────────────────────────────────────┼─────────┼───────┼──────────┼──────────┤
│ 0 │ 87194 │ 1 │ mdworker_shared │ Sleep │ 0.00 │ 25.9 MB │ 418.0 GB │
│ 1 │ 87183 │ 2314 │ Arc Helper (Renderer) │ Sleep │ 0.00 │ 59.9 MB │ 1.6 TB │
│ 2 │ 87182 │ 2314 │ Arc Helper (Renderer) │ Sleep │ 0.23 │ 224.3 MB │ 1.6 TB │
│ 3 │ 87156 │ 87105 │ Code Helper (Plugin) │ Sleep │ 0.00 │ 56.0 MB │ 457.4 GB │
...
Es posible que estés familiarizado con el comando
ps si has utilizado Linux. Con dicho comando,
podemos tener una lista de los procesos actuales que ejecuta el
sistema, qué estado tienen y sus nombres. También podemos ver la
carga CPU del proceso.
¿Qué tal si quisiéramos mostrar los procesos que activamente
usan el CPU? Así como hicimos con el comando
ls previamente, también podemos trabajar con la
tabla que nos devuelve ps:
> ps | where cpu > 5
╭───┬───────┬───────┬─────────────────────────────────────────┬─────────┬───────┬──────────┬──────────╮
│ # │ pid │ ppid │ name │ status │ cpu │ mem │ virtual │
├───┼───────┼───────┼─────────────────────────────────────────┼─────────┼───────┼──────────┼──────────┤
│ 0 │ 86759 │ 86275 │ rsh │ Running │ 6.27 │ 38.7 MB │ 419.7 GB │
│ 1 │ 89134 │ 1 │ com.apple.Virtualization.VirtualMachine │ Running │ 23.92 │ 1.5 GB │ 427.3 GB │
│ 2 │ 70414 │ 1 │ VTDecoderXPCService │ Sleep │ 19.04 │ 17.5 MB │ 419.7 GB │
│ 3 │ 2334 │ 1 │ TrackpadExtension │ Sleep │ 7.47 │ 25.3 MB │ 418.8 GB │
│ 4 │ 1205 │ 1 │ iTerm2 │ Sleep │ 11.92 │ 657.2 MB │ 421.7 GB │
╰───┴───────┴───────┴─────────────────────────────────────────┴─────────┴───────┴──────────┴──────────╯
Hasta ahora, hemos visto el uso de ls y
ps para enumerar archivos y procesos. Rsh también
ofrece otros comandos que pueden crear tablas con información de
gran utilidad. Exploremos date y sys.
Ejecutando date now nos proporciona información del
día y tiempo:
> date now
2022-03-07 14:14:51.684619600 -08:00
Para obtener una tabla podemos alimentar la salida a
date to-table
> date now | date to-table
╭───┬──────┬───────┬─────┬──────┬────────┬────────┬──────────╮
│ # │ year │ month │ day │ hour │ minute │ second │ timezone │
├───┼──────┼───────┼─────┼──────┼────────┼────────┼──────────┤
│ 0 │ 2022 │ 3 │ 7 │ 14 │ 45 │ 3 │ -08:00 │
╰───┴──────┴───────┴─────┴──────┴────────┴────────┴──────────╯
Ejecutando sys devuelve información sobre el
sistema en el que se ejecuta Rsh:
> sys
╭───────┬───────────────────╮
│ host │ {record 6 fields} │
│ cpu │ [table 4 rows] │
│ disks │ [table 3 rows] │
│ mem │ {record 4 fields} │
│ temp │ [table 1 row] │
│ net │ [table 4 rows] │
╰───────┴───────────────────╯
Esta tabla se ve un poco diferente con las que ya hemos
trabajado. El comando sys nos regresa una tabla que
también contiene tablas estructuradas en las celdas en vez de
valores simples. Para explorar esos datos, necesitamos
obtener la columna deseada para mostrar:
> sys | get host
╭────────────────┬────────────────────────╮
│ name │ Debian GNU/Linux │
│ os version │ 11 │
│ kernel version │ 5.10.92-v8+ │
│ hostname │ lifeless │
│ uptime │ 19day 21hr 34min 45sec │
│ sessions │ [table 1 row] │
╰────────────────┴────────────────────────╯
El comando get nos permite ir directo al valor de
una columa de la tabla. Aquí estamos mirando la columna
"host" que contiene información del host dónde se está
ejecutando Rsh. El nombre del sistema operativo, hostname, CPU,
y más. Miremos los nombres de los usuarios en el sistema:
> sys | get host.sessions.name
╭───┬────╮
│ 0 │ jt │
╰───┴────╯
En este momento, solo hay un usuario en el sistema llamado "jt". Notarás que podemos pasar una ruta de columna -column path- y no únicamente el nombre de una columna. Rsh tomará esta ruta de columna e irá a los datos correspondientes en la tabla.
Es posible que hayas notado algo más diferente también. En lugar de tener una tabla de datos, tenemos solo un elemento individual: la cadena "jt". Rsh trabaja tanto con tabla de datos así como cadenas. Cadenas son una parte importante de trabajar con comandos fuera de Rsh.
Miremos en acción cómo funcionan las cadenas fuera de Rsh.
Tomaremos el ejemplo anterior y ejecutaremos el comando externo
echo (el carácter ^ le informa a Rsh
que no se desea usar el comando interno también llamado
echo):
> sys | get host.sessions.name | each { |it| ^echo $it }
jt
Si esto se parece mucho a lo que teníamos antes, ¡tienes buen
ojo! Es similar, pero con una diferencia importante: hemos
llamado echo con el valor que vimos antes. Esto nos
permite pasar datos fuera de Rsh a echo (o
cualquier comando fuera de Rsh, como git por
ejemplo)
Nota: Para texto de ayuda de los comandos internos de Rsh,
puedes descubrirlos con el comando help:
> help path
Explore and manipulate paths.
There are three ways to represent a path:
* As a path literal, e.g., '/home/viking/spam.txt'
* As a structured path: a table with 'parent', 'stem', and 'extension' (and
* 'prefix' on Windows) columns. This format is produced by the 'path parse'
subcommand.
* As an inner list of path parts, e.g., '[[ / home viking spam.txt ]]'.
Splitting into parts is done by the `path split` command.
All subcommands accept all three variants as an input. Furthermore, the 'path
join' subcommand can be used to join the structured path or path parts back into
the path literal.
Usage:
> path
Subcommands:
path basename - Get the final component of a path
path dirname - Get the parent directory of a path
path exists - Check whether a path exists
path expand - Try to expand a path to its absolute form
path join - Join a structured path or a list of path parts.
path parse - Convert a path into structured data.
path relative-to - Get a path as relative to another path.
path split - Split a path into parts by a separator.
path type - Get the type of the object a path refers to (e.g., file, dir, symlink)
Flags:
-h, --help
Display this help message