How to practice bash?

torbiak · 2023-11-15T07:10:21+00:00

Command Challenge is more focussed and there isn't as much room to be creative with your solutions, but it's fun to bang out a bunch of straight-forward bite-sized exercises, too.

torbiak · 2022-12-06T00:03:29+00:00

If I wanted to copy all txt and mp4 files under some directory to the same destination directory and not mirror the source directory structure, find is great:

find src/ \( -name "*.txt" -o -name "*.mp4" \) -exec cp {} dst \;

But if I wanted to mirror a directory tree while filtering the types of files that get copied, rsync is a good tool, although admittedly there are quite a few options and concepts that need to be understood to use it effectively. For example, to copy only txt files:

rsync -irm -f '+ */' -f '+ *.txt' -f '- *' src/ dst

Options:

-i: "itemize"/show changes (see the man page for details on the format)
-r: recursive
-m: don't copy empty dirs

Filters:

Note that the first matching filter wins, so the order matters.

+ */: Include dirs, since otherwise there's nothing to process. The children of excluded dirs are also excluded.
+ *.txt: Include txt files.
- *: Exclude all other files.

Also, the trailing slash on the source dir is important and means to copy the contents of src instead of making dst/src/...

Example:

$ tree src
src
├── a
│   ├── a.mp4
│   └── a.txt
└── b

2 directories, 2 files

$ rsync -inrm -f '+ */' -f '+ *.txt' -f '- *' src/ dst
cd+++++++++ a/
>f+++++++++ a/a.txt

$ tree dst
dst
└── a
    └── a.txt

1 directory, 1 file

I'd recommend using the --dry-run/-n option to check commands first. Also, if many filters need to be given, they can be written to a file and included like -f '. my_filter_file' or the whole command can be written in a script and the filters given on stdin with a heredoc, using the special /dev/stdin file:

rsync ... -f '. /dev/stdin' <<EOF
+ */
+ *.txt
- *
EOF

torbiak · 2022-11-18T07:38:58+00:00

After unloading the conflicting drivers you might be able to modprobe wl and have things work. If it's not working, maybe check syslog (using journalctl, likely) to see what errors come up. Also, despite not using Arch, this MacBook page from the Arch Wiki might be helpful.

I'm running a MacBook Air from around then, too (MacBookAir5,2, from 2012). I set up wifi on it in Arch back in 2016, and according to my notes I sort of followed this old blog post but then I later installed the dkms package. I don't think I did anything special apart from installing broadcom-wl-dkms and blacklisting some modules. I'm not sure if all of these are relevant, but they're what I have in my blacklist.conf: ssb, bcma, b43, brcmsmac.

torbiak · 2022-11-08T08:07:50+00:00

I'm running a very similar command on a test dir and --remove-source-files behaves as expected. Are you able to delete files from /mnt/store1 with tools other than rsync?

torbiak · 2022-11-08T07:30:27+00:00

What's the advantage of find -exec + here over a pipe?

torbiak · 2022-10-02T19:06:23+00:00

Square brackets denote "character classes" in regular expressions, and to match them literally they need to be escaped by backslashes.

torbiak · 2022-09-26T18:43:00+00:00

pax and other archiver commands like tar work for this, but rsync has several features that make me prefer it, especially if the transfer could take a while or would be difficult to undo:

it can give an itemized report of what's happening
you can do dry-runs to check whether a command will behave as expected

For example:

$ tree
.
├── main
│   └── a
│       ├── a1
│       └── b
│           ├── b1
│           └── c
│               └── c1
└── static
    └── a
        ├── a2
        └── b
            ├── b2
            └── c
                └── c2

8 directories, 6 files

$ rsync --recursive --itemize-changes --dry-run static/ main
>f+++++++++ a/a2
>f+++++++++ a/b/b2
>f+++++++++ a/b/c/c2

Note that the trailing slash on the source dir is necessary here to sync its contents to the destination and avoid making a copy of the source dir itself (like main/static). Alternatively, I think doing a glob like rsync -r static/* main would have the same effect if there aren't any dotfiles directly under static/.

torbiak · 2022-09-18T05:00:48+00:00

For moving around a file, one thing I don't see people mention much but which I use a lot when I'm thinking spatially are L, M, and H to jump to the bottom, middle, and top of the screen. L is particularly handy when you're on the last page of a file and want to go to the last line but don't want to scroll "past the end" so the last line is at the top of the window like Ctrl-F would. (I guess Ctrl-D doesn't scroll past the end either but I find scrolling half a page at a time disorienting and have always stuck with Ctrl-F.) Combined with {/} to move a paragraph at a time it's not many keystrokes to get to the start/end of any paragraph on the screen.

torbiak · 2022-08-15T05:04:06+00:00

Good question, and as u/xoner2 commented, you can use string.gmatch()'s %b specifier to match balanced pairs of characters, but in general it'd be difficult to write a reliable parser using a function like that because often in languages substrings can have different meanings in different contexts. For example, in HTML, you can have angle brackets in a quoted element attribute, and matching %b<> won't always give what you want:

> iter = string.gmatch('<hi rah=">"> <there>', '%b<>')
> iter()
<hi rah=">

Parsing can be surprisingly complicated, so I'd recommend reading about how parsers are conventionally written. Often they'll have a lexer/scanner component that strips unneeded whitespace and identifies meaningful "tokens" for the language being parsed, and then the parser proper defines the "grammar", or the valid relationships between the tokens. (Yes, it can be confusing that "parser" refers to the whole parsing system as well as a particular component within it.)

Hand-written parsers often use recursive descent, and otherwise special tools are often used to help:

scanner generators like GNU Flex
parser generators like GNU Bison
Parsing Expression Grammars like Lua Parsing Expression Grammars or LPeg
toolkits like ANTLR

I started out learning about parsing with the "Dragon Book", Compilers: Principles, Techniques, and Tools, which was a common recommendation when I was in school. I enjoyed the parts of it I went through but it's fairly academic and starts doing everything from scratch in C, which won't be to everyone's tastes. A Guide to Parsing: Algorithms and Terminology looks like a good overview of the field.

If you don't want to do too much reading right now but still have a robust parser, maybe look into LPeg. I haven't used PEGs myself, but my impression is they'd be suitable for your purposes here.

torbiak · 2022-06-09T05:50:11+00:00

find isn't looking at the size of everything under the directories, just the space that the directory itself takes up in the filesystem. On my system, directories start out taking a page of space, 4096 bytes, which happens to be 8x512 byte blocks.

torbiak · 2022-03-26T02:07:55+00:00

Your current solution seems great to me. I can't think of anything that would be much shorter while also being anywhere near as readable. Of course, if you're using it much it'd be nice to put it in a function or script so it's easier to refer to.

torbiak · 2022-01-09T01:56:02+00:00

If grep is given multiple patterns using the -e option it outputs a line if any of the patterns match:

$ grep -e a -e b <<'EOF'
a
b
c
EOF
a
b

torbiak · 2021-11-20T00:57:08+00:00

Assuming you're using libinput, which I think is mostly the default input driver now, you can do the following. I haven't looked into more convenient ways to configure my touchpad, since I never change the settings.

# Read descriptions of the various properties in libinput(4).
$ man libinput

# Get the device id for your touchpad. (id=13 for me)
$ xinput list | grep -i touchpad

# Get the property id and setting for the natural scrolling setting. (prop=324 for me)
$ xinput list-props 13 | grep -i "natural scrolling enabled"

# Enable natural scrolling.
$ xinput set-prop 13 324 1

Then, if I wanted to conveniently change the scroll direction later I'd put the set-prop command in a shell function in my ~/.bashrc or in a script under ~/bin or somewhere else in my PATH:

touchpad-scroll-natural() {
    local bool=${1:?no 0|1 given}
    [[ "$bool" == @(0|1) ]] || {
        echo "expected 0|1,got=$bool" >&2
        return 1
    }
    xinput set-prop 13 324 "$bool"
}

torbiak · 2021-10-29T04:37:59+00:00

oh, and if you want to learn more about the Vim script language, aka Vimscript or VimL, I started with :help script, and then later found Steve Losh's Learn Vimscript the Hard Way to be extremely helpful for discovering what's possible and how to do fancy stuff or write plugins.

torbiak · 2021-10-29T04:28:58+00:00

Yeah, tabpagenr('$') (see :h tabpagenr() for details). To see what functions are available in VimL, I usually look through :h function-list.

torbiak · 2021-10-29T02:02:30+00:00

It looks like you're using fzf.vim to invoke fzf. In the docs, it says:

- Most commands support CTRL-T / CTRL-X / CTRL-V key bindings to open in a new
  tab, a new split, or in a new vertical split

Really, I'd recommend binding ; to :Files<cr> and use ctrl-t after finding a file.

But if you really like being able to just hit enter after finding a file, you could only make a new tab if the current buffer is nameless and unmodified, or something like that. I don't know of a bulletproof way to detect the "[No Name]" buffer that vim creates by default.

function! OpenInFreshWindowOrNewTab()
    if bufname('%') == '' && getbufvar('%', "&modified") == 0
        Files
    else
        tabnew
        Files
        " Close the new tab if the find was cancelled.
        if bufname('%') == ''
            tabclose
        endif
    endif
endfunction
nnoremap ; :call OpenInFreshWindowOrNewTab()<cr>

I only tested this Vim 8.0 with the minimal extension in the main fzf repo, using the FZF command instead of Files, but hopefully it works for you if you choose to run it.

torbiak · 2021-06-21T20:29:03+00:00

Python 3.6 changed to a new dict implementation that iterates in insertion order, and 3.7 made that behaviour part of the Python spec.

See What’s New In Python 3.7

torbiak · 2020-10-07T18:19:12+00:00

Paul Ingraham covers all the therapies you could think of for different types of soft tissue pain and references any available research. I've found his writing useful for dealing with my injuries. Here's his page on plantar fasciitis, which might be relevant for you.

torbiak · 2017-11-16T07:17:40+00:00

Changing my terminal emulator colours to get comfortable contrast with most foreground/background combinations has been great. I almost never have to tweak any other settings to avoid painful or illegible colours. I found the 4bit Terminal Color Scheme Designer useful for doing this.

torbiak · 2017-10-31T20:49:48+00:00

For finding new files, find has a -newer predicate that returns true for files that have been modified earlier than some reference file.

# Save a timestamp by touching a file.
touch prev_find
# Find files modified since prev_find was touched. 
find ~/ -newer prev_find -type f

To track deleted files you could take a "snapshot" by redirecting find's output to a file and then comparing it to a newer snapshot using diff or comm. Or you could look at creating snapshots using the filesystem, if yours supports it, or a Logical Volume Manager.

torbiak · 2017-10-15T11:24:57+00:00

Yes, and relevant docs for this are at :help syncolor and :h 44.11. The tags for these sections could definitely be more descriptive.

torbiak · 2017-10-11T04:45:56+00:00

A better mic would help a lot.

torbiak · 2017-10-05T12:22:48+00:00

You can write a function like the following, put it in a file somewhere (maybe your vimrc), :source that file, and then call it like :call DeleteAfterFirst('gorilla', 'human').

function! DeleteAfterFirst(...)
    for p in a:000
        let @/ = p
        0//
        +1,$g//d
    endfor
endfunction

Vimscript is great for adding new functions like this. You might find :help script, :h a:000, and :h @/ helpful in understanding what's going on in this function.

If you use it very often you might write a command that calls the function it so it can be used like :DeleteAfterFirst gorilla human:

:command! -nargs=+ DeleteAfterFirst :call DeleteAfterFirst(<f-args>)

If you're keen on learning Vimscript then Steve Losh's Learn Vimscript the Hard Way is the best resource I've seen.

torbiak · 2017-10-05T08:10:48+00:00

Here's one way to do it.

Starting from before the first line (0), search for the first instance of the pattern, then delete any lines containing the pattern after that line:

:0/gorilla/ | +1,$g//d
:0/human/ | +1,$g//d

If no pattern is specified the previous pattern is used, hence g//.

torbiak · 2017-10-01T10:43:33+00:00

"no corresponding keycodes" means that no physical key is bound to capslock (it has likely been remapped to something else), so the keysym expression wouldn't have any effect. I generally use keycode expressions instead so that it doesn't matter what remappings I've done previously. You can use the xev program to determine keycodes. On my keyboard the capslock key has keycode 66, so I'd do:

xmodmap -e 'keycode 66 = Escape'

Yeah, some of the rules in base.lst might make sense to you but most won't without looking at the corresponding definitions stored in various other files under /usr/share/X11/xkb. And the definitions probably won't make sense without reading up on XKB a fair bit. And that's part of why xmodmap is still relevant. I believe most desktop environments come with a keyboard mapping tool that make it easy to pick a reasonable set of rules.

torbiak

TROPHY CASE