Towards Freedom

Though it is unlikely we will actually use this technique, it is handy to know.

  echo "this is a block comment" 
  : '
      what is this
      actually
      '

All cap specific words in a file using perl|sed. Note that single quotes may work with sed, but not produce desired result with perl.

  # perl
  perl -pi -e "s/(Eliphas|Retha|Chastity)/\U$1/g" <filename>

  for n in  Chastity Retha Eliphas; do # or using loop
      perl -i -pe "s/$n/\U$n/g" <filename>
  done

  # sed
  for n in Cytheri Vaishob Chastity Retha Eliphas; do
          sed -i "s/$n/${(U)n}/g" <filename>
  done

What does zstyle :compinstall filename do?

It's for when you run compinstall again. It lets compinstall find where it has written out zstyle statements for you last time. This way, you can run compinstall again to update them. Read in source code.

Here are some ways to concat text files.

  ls -1 *.csv | while read filnam ; do cat "$filnam" >> output.csv.file; done
  ls -1 *.csv | sort | while read filnam ; do cat "$filnam" >> output.csv.file; done
  ls -1t *.csv | while read filnam ; do cat "$filnam" >> output.csv.file; done

• .zshrc - Should be used for the shell configuration and for executing commands.
• .zshenv - Should only contain user’s environment variables.
• .zprofile - Can be used to execute commands just after logging in.
• .zlogin - Can be used as .zprofile, but read just after .zshrc.
• .zlogout - Can be used to execute commands when a shell exit.

  arr=($(ls))

  # parsing ls is not a good idea usually so
  arr=(*)

  # if there are subdirectories
  shopt -s nullglob
  array=(*/)
  shopt -u nullglob # Turn off nullglob to make sure it doesn't interfere with anything later
  echo "${array[@]}"  # Note double-quotes to avoid extra parsing of funny characters in filenames

See How do I assign ls to array discussion.

this book contains a lot of useful stuff

From posting:

• .zshenv is always sourced. It often contains exported variables that should be available to other programs. For example, $PATH, $EDITOR, and $PAGER are often set in .zshenv. Also, you can set $ZDOTDIR in .zshenv to specify an alternative location for the rest of your zsh configuration.
• .zprofile is for login shells. It is basically the same as .zlogin except that it's sourced before .zshrc whereas .zlogin is sourced after .zshrc. According to the zsh documentation, ".zprofile is meant as an alternative to .zlogin for ksh fans; the two are not intended to be used together, although this could certainly be done if desired."
• .zshrc is for interactive shells. You set options for the interactive shell there with the setopt and unsetopt commands. You can also load shell modules, set your history options, change your prompt, set up zle and completion, et cetera. You also set any variables that are only used in the interactive shell (e.g. $LS_COLORS).
• .zlogin is for login shells. It is sourced on the start of a login shell but after .zshrc, if the shell is also interactive. This file is often used to start X using startx. Some systems start X on boot, so this file is not always very useful.
• .zlogout is sometimes used to clear and reset the terminal. It is called when exiting, not when opening.

Also, the configuration files of random Github users gives possibilities.

the o,O sort doesn't work for ls unless we disable ls sort with -U

Expanding Depending on a Predicate these things may be quite powerful if we learn what to do with them e: *<cmd>

Expansions Depending On the Permissions might be useful ls *(f755) would list only directories (usually) though ls -d */ simpler however, there are many other features for this

Expansions Depending on Date or Size ls **/*(L0) list all empty files ls **/*(LG+1) list all files >1G ls **/*(mh-1) list all files modified within last hour

var=$(<stuff.txt)

this is a strange syntax but worth learning. the following finds all .org in the fireworks/ and replaces localhost:1313 with tf.com find . -name "*.org" -exec perl -pi -e 's/localhost:1313/towardsfreedom.com/g' {} \;

find . -name ".pdf" -exec wc {} \; find . -name ".pdf" -exec wc {} \+ find . -name "*.pdf" -print0 | xargs -0 wc (same as above) print0 and xargs -0 handles spaces in filename which is bad idea anyway

exec Really Means exec! "It uses Linux’s built-in exec to run the command, replacing the current process—your shell—with the command. So the command that is launched isn’t running in a shell at all." which is why exec ls wipes out the shell!

chaining (instead of piping?) example find . -name "*.page" -type f -exec bash -c "basename "{}" && words-only "{}"" \;

for i in {1..9}; do echo $i; done for ((i=1; i<10; i++)); echo $i

https://www.youtube.com/watch?v=Zuwa8zlfXSY

disown -a && exit

cat contacts.org | tee -a log.txt | cat > /dev/null

mkdir /mnt/ram
mount -t tmpfs tmpfs /mnt/ram -o size=8192M
dd if=/dev/zero of=test.iso bs=1M count=8000

mkdir -p folder/{sub1,sub2}/{sub1,sub2,sub3}
mkdir -p folder/{1..100}/{1..10}

touch a{01..99}.txt works touch a[01-99].txt doesn't work

x a{2..4}* works x a[2-4]* works

seq -w 1 11

or for more control

  for i in {2..11};
  do
      echo $u1${(l:2::0:)i}$u2$i
  done

and can get something like this

https://tubitv.com/tv-shows/524508/s01-e02-episode-2
https://tubitv.com/tv-shows/524508/s01-e03-episode-3
https://tubitv.com/tv-shows/524508/s01-e04-episode-4

add these to .zshrc:

autoload -Uz promptinit
promptinit
prompt bart (or whatever)

5 prompts:

$PS1
$RPS1 rightside
$PS2 waiting for more input
$PS3 making choices
$PS4 debugging scripts

find ~/bin -type l -ls | tr -s " " "\t" | cut -f11,13

couldn't do tr with sed for some reason

https://unix.stackexchange.com/questions/188057/update-symlinks-by-scripting
though the ideas using realpath will work, it doesn't do what we are trying to accomplish which is to replace 'ba' with 'sh' in the softlink

rmdir --verbose **/*(/^F)
rmdir --verbose **/*(/od)

https://www.zsh.org/mla/users/2005/msg01375.html

rmdir --verbose **/*(/^F)
rmdir --verbose **/*(/od)

https://www.zsh.org/mla/users/2005/msg01375.html

Use M-h on a command

Setup properly in .zshrc unalias run-help 2>/dev/null autoload -U run-help

this is a bit weird, but it works

#setup L1 directories
L1dirs=(Iwrter Issays Ithngs Ibrary Ictvty Inotes)
for d in "${L1dirs[@]}"; do
    echo $d
done

though just this will work too:

for d in Iwrter Issays Ithngs Ibrary Ictvty Inotes; do
    echo $d
done

A-Za-z <==> :alpha: ascii,lower,upper,digit,alnum,print,blank(space,tab),space,punct

<-> numeric x a<70-90>.txt

The zsh sh_word_split option is a compatibility feature that makes zsh behave like other shells when it comes to word splitting. Word splitting is the process of breaking a string into words based on some delimiter characters, such as spaces or colons. This is often done when passing arguments to a command or looping over a list of values.

By default, zsh does not perform word splitting on unquoted parameter expansions. This means that if you have a variable that contains multiple words separated by spaces, such as `str="foo bar baz"`, and you use it as an argument to a command, such as `echo $str`, zsh will treat it as a single word and pass it as one argument to echo. This is different from other shells, such as bash or ksh, which would split the variable into three words and pass them as three arguments to echo.

The sh_word_split option makes zsh emulate the behavior of other shells and perform word splitting on unquoted parameter expansions. This means that if you set this option, `echo $str` will print `foo bar baz` on three separate lines, as if you had written `echo "$ { (@s: :)str}"`. The option also affects other forms of parameter expansion, such as command substitution and arithmetic expansion.

The sh_word_split option is useful when you want to write scripts that are compatible with other shells, or when you want to use variables that contain lists of values separated by some delimiter. However, it can also introduce unexpected behavior and errors if you are not careful with quoting. For example, if you have a variable that contains spaces in its values, such as `str="foo 'bar baz' qux"`, and you use it in a for loop, such as `for x in $str; do echo $x; done`, zsh will split the variable into four words and print them on four lines, even though you might have intended to treat `bar baz` as a single word.

A better way to handle lists of values in zsh is to use arrays, which are variables that can store multiple values without relying on delimiters. You can create an array by enclosing a list of words in parentheses, such as `arr=(foo 'bar baz' qux)`, and access its elements by using the subscript notation, such as `echo $arr[2]`. You can also use the `typeset -T` builtin command to tie an array variable to a scalar variable, so that any changes to one are reflected in the other. For example, `typeset -T str str_array` will create an array variable `str_array` that is tied to the scalar variable `str`. If you assign a value to `str`, such as `str="foo:bar:baz"`, the array variable will be updated accordingly, and vice versa.

For more information about word splitting and arrays in zsh, you can refer to the following sources:

• [What is word splitting? Why is it important in shell programming?](^1^)
• [How to split a string by ':' character in bash/zsh?](^2^)
• [Z-Shell Frequently-Asked Questions](^3^)
• [Re: Word splitting with zsh fix](^4^)

Source: Conversation with Bing, 9/12/2023 (1) zsh - What is word splitting? Why is it important in shell programming …. https://unix.stackexchange.com/questions/26661/what-is-word-splitting-why-is-it-important-in-shell-programming. (2) How to split a string by ':' character in bash/zsh?. https://unix.stackexchange.com/questions/614299/how-to-split-a-string-by-character-in-bash-zsh. (3) Z-Shell Frequently-Asked Questions - SourceForge. https://zsh.sourceforge.io/FAQ/zshfaq03.html. (4) Re: Word splitting with zsh fix. https://www.zsh.org/mla/workers/2006/msg00139.html.

paru -S sshfs sshfs <computer>: /home/mnts/<computer> umount /home/mnts/<computer>

reads from the standard input and writes to both standard output and one or more files at the same time (it helped to solve the rejects.sh issue we were having)

it can be used to write to multiple files as well as append:

command | tee file1.out file2.out file3.out
command | tee -a file.out

very useful when combined with sudo:

echo "newline" | sudo tee -a /etc/file.conf

or remotely:

for e in $@; do
    echo "$e REJECT" | ssh REMOTE sudo tee -a /etc/postfix/access
done

setopt sh_word_split otherwise $s="sleep 2" is non-functional or $e="emacsclient -c" is not found

We should use this since it is zsh perl-rename may be better in some situations rename is rather limited except for very straightforward stuff

Very powerful commands though the syntax may be difficult to remember unless we get used to it through regular practice which is unlikely since we don't do this too often. So looking it up is better.

This is a multiple move based on zsh pattern matching. To get the full power of it, you need a postgraduate degree in zsh. However, simple tasks work OK, so if that's all you need, here are some basic examples:

  zmv '(*).txt' '$1.lis'

  zmv '(**/)(*).txt '$1$2.lis'

  noglob zmv -W **/*.txt **/*.lis
  zmv -w '**/*.txt' '$1$2.lis'

  zmv -C '**/(*).txt' ~/save/'$1'.lis

  zmv '([a-z])(*).txt' '${(C)1}$2.txt'

  zmv -w '[[:upper:]]*' '${(L)1}$2'

  zmv '(*)' '${1//(#m)[aeiou]/${(U)MATCH}}'

zmv -nQ '*.html' "\${f//'/}"

zmv -vw '**/(*)/' '${f:l}'

  zmv '*' '$f[5,-1]' (where f is a zmv generated variable)

  i=0;zmv '(FILENAME-COMMON-PART)(*)' '$1$((i++)).mp4' #[] works too but may cause problems

  i=1; zmv -n '(img*.jpg)' '${(l:2::0:)$((i++))}$1' #[] results in weird stuff
  img[01,02,..].jpg

  i=0;zmv -n '(bind.*)' '$1${(l:2::0:)}$((i++))' on bind.c, bind.h, bind.o
  mv -- bind.c bind.c000
  mv -- bind.h bind.h001
  mv -- bind.o bind.o002

  zmv -p cp -o'-r' 'img/(*)' 'tmp/${1:u}'
  zmv -C -o '-r' 'img/(*)' 'tmp/${1:u}'
  either recursively copies contents of img/ to tmp/ uppercasing

  #  upcase the filename but not the extension
  zmW '*.jpg' '${*:u}.jpg'

  # pad left with zero
  zmW 'img*.jpg' 'img${(l:2::0:)*}.jpg'

  # replace spaces with hyphens
  zmW '*' '${*// /-}'
  better than
  zmv '*-*' '${f// /-}'
  zmv '*-*' '${f:gs/ /-}'

-f  force overwriting of destination files.  Not currently passed
    down to the mv/cp/ln command due to vagaries of implementations
    (but you can use -o-f to do that).
-i  interactive: show each line to be executed and ask the user whether
    to execute it.  Y or y will execute it, anything else will skip it.
    Note that you just need to type one character.
-n  no execution: print what would happen, but don't do it.
-q  Turn bare glob qualifiers off:  now assumed by default, so this
    has no effect.
-Q  Force bare glob qualifiers on.  Don't turn this on unless you are
    actually using glob qualifiers in a pattern (see below).
-s  symbolic, passed down to ln; only works with zln or z?? -L.
-v  verbose: print line as it's being executed.
-o <optstring>
    <optstring> will be split into words and passed down verbatim
    to the cp, ln or mv called to perform the work.  It will probably
    begin with a `-'.
-p <program>
    Call <program> instead of cp, ln or mv.  Whatever it does, it should
    at least understand the form '<program> -- <oldname> <newname>',
    where <oldname> and <newname> are filenames generated. <program>
    will be split into words.
-P <program>
    As -p, but the program doesn't understand the "--" convention.
    In this case the file names must already be sane.
-w  Pick out wildcard parts of the pattern, as described above, and
    implicitly add parentheses for referring to them.
-W  Just like -w, with the addition of turning wildcards in the
    replacement pattern into sequential ${1} .. ${N} references.
-C
-L
-M  Force cp, ln or mv, respectively, regardless of the name of the
    function.

• specific computers

  # broot setup for specific computers
  if [[$HOST = 'schnell' || $HOST = 'adagio']];
     then
         #code
  fi

• bd (using tarrasch function for zsh because bd install doesn't seem to work)
• fzf a good addition too and works rather like the fuzzy find on broot
• globbing seems to be inconsistent over the different versions of zsh
• operations on multiple extensions ls *.{jpg,png}
• list only directories (post) ls -d – *() ls -ld – *()