#!/bin/bash

# Git pre-push hook to check if CHANGELOG.md is included in the push and if the branch is develop

# Get the current branch name

current_branch=$(git rev-parse --abbrev-ref HEAD)

# Check if the branch is develop

if [ "$current_branch" == "main" ]; then
	echo "You are on the main branch. Skipping CHANGELOG.md check."
	exit 0
fi

# remote="$1"
# url="$2"

# Get the list of commits to be pushed
commits=$(git rev-list '@{u}..HEAD')

has_rust_files=$(false)

# TODO: We can iterate to get file list only once
# Get the list of files that are going to be pushed
for commit in $commits; do
	if git diff-tree --no-commit-id --name-only -r "${commit}" | grep -q "\\.rs$"; then
		has_rust_files=$(true)
	fi
done

if [[ ! $has_rust_files ]]; then
	echo "No .rs files in the push, no need to check CHANGELOG"
	exit 0
fi

# Check if CHANGELOG.md is among the files in the commits
for commit in $commits; do
	if git diff-tree --no-commit-id --name-only -r "${commit}" | grep -q "CHANGELOG.md"; then
		echo "CHANGELOG.md is included in the push."
		exit 0
	fi
done

echo "ERROR: CHANGELOG.md is not included in the push."
exit 1

Edit (2025-02-08): Added a check for when only code files are changed.

  In[1]: 10 + 10

 Out[1]: 20.0


           _____
  In[2]: ╲╱ 100

 Out[2]: 10.0


             ┌                  ┐
  In[3]: Max │ 10 , 1 , 21 , -3 │
             └                  ┘

 Out[3]: 21.0


  In[4]: ⟨Emre's Number⟩ ≡  79

 Out[4]: 79.0


           _______________
  In[5]: ╲╱ Emre's Number

 Out[5]: 8.888194417315589


                      2
  In[6]: Emre's Number

 Out[6]: 6241.0


                      Emre's Number
  In[7]: Emre's Number

 Out[7]: 8.1759873707105095e149

It looks a bit heavy for a CLI calculator, as it is written in Haskell and downloads 100+ MB of libraries, but when you need ASCII art to display your calculations or want to use spaces in variable names, it may prove useful.

• I began to use Intention to limit my Twitter time. It allows you to set a limited time (1, 5, 10, or 15 minutes) for yourself and tracks the total time you spend on addictive sites. When this total time is lower than your goal for a period, you get a streak. It looks visually and psychologically nicer than LeechBlock.

• I read the git reset section in the Git book. It details how git reset behaves with its --soft, --mixed, and --hard parameters. The first resets only the HEAD; the second resets both the index and HEAD; and the third resets the working tree and copies files back from the current HEAD to the working tree.

  One important point: Contrasting git checkout master and git reset master: the first moves HEAD to the master branch, while the second moves the current branch to master.

  git reset can also be used to squash commits. Basically, you git reset --mixed to an earlier commit like HEAD~3 and recommit. This creates a new commit, taking HEAD~3 as the parent and skipping HEAD~2 and HEAD~1, resulting in a new HEAD.

• Here are many useful pure Bash functions to be used in scripts. I’m a Zsh person, but writing Bash scripts is more portable, of course.

zenity --info --text="Merge complete. Updated 3 of 10 files."

I used to use Emacs for this—the One True Editor. Yet, it has one flaw that disrupted my writing routine: it has too many features. When I encountered writer’s block or an idea I couldn’t quite articulate, I would start tinkering with the editor instead. Emacs is like a friend, and one should keep friends away from the workplace; otherwise, no work gets done.

For this reason, I began writing with ed some time ago. ed is not my friend; it’s the standard editor. It’s also the grandfather of vi, but fathers should not bear the vices of their sons.

Note from 2024: Ten years after writing this post, I’m editing it with Neovim, the grandson of all these tools.

ed was very nice to write with. It doesn’t have many features. It prints a 0 when it opens, I type i to insert text, and then I write whatever I like. When I put a lonely . on a line, it understands that I’ve finished my words. Then, with w, I save the file to disk and see its length—length in bytes, as every true writer nowadays should know.

ed is minimal, and while I occasionally get frustrated by its modal behavior, that’s exactly why I was happy to write with it.

However, I eventually decided that even pressing those few command keys was too much. i, ., and w—one can forget them easily. And it seemed I had a tendency to learn more of its commands, which are passed down to its grandchildren. God save us from the vices of vi.

Then, I decided to concoct a script that uses cat. Everyone knows writers like cats, and I like cat too; it concatenates text into files and is also used to print their content. It’s much simpler than ed—much simpler. It is not an ambiguous dork like ed; it’s a simple animal that writes into files whatever I type into it.

It was easy to check the file size in words after I finished. I wrote a while loop to continue until I reached my daily quota. The script creates a new file, adds an Org-mode header, and includes the contents of the clipboard just after the title so I can include notes. cat exits with Ctrl-D, and when it finishes, the script checks the word count. If I’m still short of my daily target, it appends a ----- separator and opens the file again. You have to finish your words, whether your brain bleeds or your cat dies.

The effect? I began using it today, so I’m still not sure about the long-term impact, but there’s certainly nothing to distract me. When I used Emacs, the info pages were highly entertaining—I was just finishing the command-line options of GNU Backgammon when I decided to switch. Modern programs are so customizable that I can’t even finish reading their manuals.

The script is shown below. It asks for a filename; if you don’t provide one, it creates one based on the date. It has some minor changes from the version I use, as I tend to name my files differently and I haven’t tested this specific version thoroughly, but here it is. Copy and paste it into a file named write-with-cat, make it executable with chmod +x write-with-cat, and run it. You’ll need a Unix-like system (even my mom uses Debian, you know).

The second part of the script, which I’ve commented out, copies the written material to a repository and commits it using Mercurial.

#!/bin/bash

WORDSIZE=600

echo "Please set a (tentative) name?"
read response
if [ -z "$response" ] ; then
    dirname=work-`date +%y-%m-%d`-$RANDOM
else
    dirname=work-${response}
fi

tempdirname="/tmp/$dirname"
mkdir $tempdirname
docname="$tempdirname/index.org"

selection=`xsel -ob`
cat > $docname <<EOF
#+TITLE: $response
#+AUTHOR:
#+DATE: `date`

$selection
EOF

clear
cat $docname

while [ `wc -w "$docname" | cut -f 1 -d ' '` -le $WORDSIZE ] ; do
    cat >> $docname
    echo "\n-----" >> "$docname"
    wc -w "$docname"
done

Therefore, I decided that a small Bash script using rsync and find would work better. It monitors my entire home directory and backs up recent files.

The following script does exactly that:

#!/bin/bash

if [ "x$1" = "x" ] ; then
    TARGET=/media/augustus/backup-recent-`hostname`
else
    TARGET=$1
fi

PERIOD=15

mkdir -p $TARGET

# Delete files older than $PERIOD days
find $TARGET -ctime +$PERIOD -print -delete

# Copy files newer than $PERIOD under ~. Ignore files under .hg
for d in ~/*/ ; do
    find $d -path '*/.hg/*' -prune -o -type f -ctime -$PERIOD -print  -exec rsync -aRv {} $TARGET/ \;
done

It checks whether a command-line option is provided as the target; otherwise, it sets a default target. /media/augustus/ is an NFS mount in my case, but you can specify any path.

PERIOD is the number of days that the script considers recent. Currently, it backs up files changed in the last 15 days.

The script deletes older files from the backup. Since I use other solutions for long-term storage, I don’t want to keep them here, especially since this script runs via cron every two hours.

Note that the script only checks directories under the home directory, so files located directly in the home directory are not backed up.

It also skips files under .hg directories. You can add more -prune options to the find command to exclude other irrelevant directories from your backup.

I have used ~ several times in scripts, but it may not always expand as expected depending on the environment. Use $HOME to refer to the home directory; it is much more reliable and always works.