blending sam with the shell experiment
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.
cliutil
cmd
lex
parser
parsetest
.gitignore
LICENSE
README.md
address.go
buffer.go
errors.go
go.mod
go.sum
range.go

README.md

usam

micro-sam

An experiment in blending sam with the shell.

After the experiment is done, the plan is to build a shell around structural regular expressions.

Mode of operation

Each sam command is implemented as a stand-alone command line tool.

The commands are chained together via pipes.

Many commands accept a new dot as an argument. The argument dot is evaluated relative to the current dot. Works for loops (x commands) too.

Tools

e <filename>

Opens the file for editing. Dot is set to 0. It is the start of the pipe chain.

Example:

e file.txt | further editing

po and pc

If you want to manipulate text from a pipe, you can use po (pipe open) and pc (pipe close).

pc writes the resulting text to stdout.

po reads all the pipe's content before continuing the command chain.

Example:

dmesg | po | further editing | pc > new_dmesg.txt

el <new_dot>

Sets the dot to a new address. When used in a loop, it ends the loop and sets the dot relative to the last dot of the loop.

Example:

e file.txt | el 2,3 | p

p [dot]

Prints the content of the dot.

Example:

e file.txt | p 2,3 # does the exact thing as the above example

c <text> [dot]

Changes the dot's value with text. Sets dot to the changed text.

Example:

<<EOF > file.txt
Happy 2018!
EOF

e file.txt | c 2019 '/2018/' | p ,
# Prints: Happy 2019!

i <text> [dot]

Like c, but inserts text right before the dot.

a <text> [dot]

Like c, but inserts text right after the dot.

d [dot]

Deletes the dot's content.

Example:

<<EOF > file.txt
We live in a different society.
EOF

e file.txt | d '/ different/' | p ,
# Prints: We live in a society.

s <regexp> <text> [n|g] [dot]

Substitute text for the first match to the regexp in the dot. Set dot to the modified range. In text, $ signs are interpreted as in Go's Expand. If you want to change dot and substitute the first match, you must call it like so:

s <regexp> <text> 1 <dot>

Example:

<<EOF > file.txt
y y a x y y
EOF

e file.txt | s '(a) (x)' '$2 $1' 1 1 | p ,
# Prints: y y x a y y

x [regexp]

For each regexp match in the dot, sets dot to that and execute the next command on that dot.

Because x doesn't accept a dot argument, you must use el first. Ironically, el comes from "end loop".

You can also compose x commands.

Example:

e vim.1 | el , | x 'vim' | p +-
# Prints all lines that contain the word 'vim'.
# If a line has 'vim' in it more than once, the line will pe printed each time.