To prevent this, you can place the liquid markup inside raw and endraw tags:

{% raw %} {{ liquid_goes_here }} {% endraw %}.

You can use the absolute_url filter to fix that: {{ page.url | absolute_url }}

* Table of Contents
{:toc}

The line that starts with * is required but will not be displayed. The above markup will generate a table of contents that links to each header within the post.

You can see an example here.

This is usually called “Save As” in other editors.

Running lsb_release -a will show the version along with some other information. It looks like this:

$ lsb_release -a
No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 18.04.6 LTS
Release:	18.04
Codename:	bionic

CTRL + SHIFT + T will reopen the last tab that was closed. Subsequent uses will open the next closed tab in the stack.

You probably shouldn’t do this.

(function w(){var u=$(".unvoted.up.arrow");if(u.length-1){setTimeout(w,500);u.trigger('click')()}})()

(setq calendar-week-start-day 1)

Setting the value to 0 will start the week on Sunday.

Altering org-export-headline-levels will change this behaviour.

Adding the following to your init.el will wrap level 4 in a <h5> tag:

(setq org-export-headline-levels 4)

Alternatively this can be done on a per-file basis using #+OPTIONS somewhere in the org file. The same headline export settings as above would look like this:

#+OPTIONS: H:4

* level 1
** level 2
*** level 3
**** level 4

The org-mode manual has more information on org-mode export settings.

The -f flag allows us to specify a file that contains a list of words/phrases to search for (one on each line) which makes it much easier to read.

For example:

grep -v -e "phrase one" -e "phrase two" -e "phrase three" <filename>

Can be rewritten as follows:

grep -v -f words.txt <filename>

where words.txt looks like:

phrase one
phrase two
phrase three

Removing the -v flag would search for only the words in the file.

BRANCH := $(shell git rev-parse --abbrev-ref HEAD)

BRANCH will then contain the branch name and can be used like a normal Makefile variable.

M-: (byte-recompile-directory package-user-dir nil 'force)

Emacs will need to be restarted for the compiled changes to load.

This is a really simple tweak to add a homepage file to zetteldeft. Although I usually use the main search page, adding a homepage makes zetteldeft act more like a wiki.

Once this code is added to the Emacs init, running C-c z h will open the home file. The home.org file can be any file in your deft notes directory. It should be the local filename within the deft directory, not the full path.

(defun sodaware/zd-homepage ()
  "Open Zetteldeft home file."
  (interactive)
  (zetteldeft-find-file "home.org"))
(global-set-key (kbd "C-c z h") #'sodaware/zd-homepage)

(defun sodaware/agenda-for-my-file ()
  "Run org-agenda on a single file."
  (interactive)
  (let ((org-agenda-files '("/full/path/to/my.org")))
    (org-agenda)))

The following version also creates an agenda for a single file, but prompts for the file name first:

(defun sodaware/agenda-for-single-file (file)
  "Run org-agenda on FILE."
  (interactive "FEnter a file name: ")
  (let ((org-agenda-files (list file)))
    (org-agenda)))

Call using M-x match-emacs-theme-to-system. Replace 'dark-theme and 'light-theme with appropriate theme names.

(defun match-emacs-theme-to-system ()
  "Automatically set the theme to match if OSX is in dark mode."
  (interactive)

  (if (system-dark-mode-enabled-p)
      (load-theme 'dark-theme  t)
      (load-theme 'light-theme t)))

(defun system-dark-mode-enabled-p ()
  "Check if dark mode is currently enabled on OSX."
  (if (string= system-type "darwin")
      (string=
       (shell-command-to-string "printf %s \"$( osascript -e \'tell application \"System Events\" to tell appearance preferences to return dark mode\' )\"")
       "true")
      nil))

(match-emacs-theme-to-system)

I tried a couple of approaches, such as setting text properties in the buffer and then searching at the current point when RET was pressed. But those solutions didn’t feel right.

Finally, I discovered the insert-button function which does what I wanted.

The previous code looked a little like this:

(insert "View all data")
(put-text-property (line-beginning-position)
                   (line-end-position)
                   'beeminder-is-read-more
                   t)

(defun beeminder-handle-view-all-data-link ()
  "Handle a click on the 'Read more data' text."
  (when (get-text-property (point) 'beeminder-is-read-more)
        (beeminder-view-data-for-current-goal)))

;; Bind to <RET>
(define-key beeminder-mode-map
            (kbd "<RET>")
            #'beeminder-handle-view-all-data-link)

It’s not the cleanest code ever, and it’s a lot of effort for a simple button. By using insert-button, it now looks like this:

(insert-button "View all data"
               'action (lambda (_arg) (beeminder-view-data-for-current-goal)))

Much better!

Read more: Buttons - GNU Emacs Lisp Reference Manual.

Adding the following to the Emacs config limits the reading with to 80 columns:

(setq shr-width 80)

(list :property1 "value1" :property2 "value2")

I’m currently working on beeminder.el and wanted to add some optional parameters to a function. Emacs Lisp doesn’t support &key named parameters, so normally there isn’t a way to do something like this:

(my-function "required" "also-required" :optional "value")

I settled on passing a plist, but wanted a way to whitelist keys. The following function will filter the options list to only include keys that are in allowed.

It will probably re-order the list, but for a property list that usually isn’t an issue.

(defun filter-plist (options allowed)
  "Filter a symbol and values list OPTIONS to online include ALLOWED symbols.

For example, filtering (:key value :other-key value) with allowed
list of (:key) will return (:key value)."
  (let ((filtered-list))
    (dolist (key allowed)
      (when (plist-member options key)
        (setq filtered-list
              (plist-put filtered-list key (plist-get options key)))))
    filtered-list))

This allows us to do this:

;; List of parameters. Only want the :valid key/value pair.
(setq test-list (list :valid "value" :invalid "bad"))

(filter-plist test-list (list :valid))
;; => (:valid "value")

smartparens can disable a global pair by setting :actions nil when using sp-local-pair. For blitzmax-mode, my config looks like this:

(use-package smartparens
  :diminish smartparens-mode
  :commands (smartparens-mode sp-local-pair)
  :hook
  ((blitzmax-mode . smartparens-mode))
  :config
  (require 'smartparens-config)

  ;; Disable ' auto-pair in blitzmax-mode.
  (sp-local-pair 'blitzmax-mode "'" nil :actions nil))

Now smartparens inserts a single ' character when I comment a line, but still inserts matching ( and [ characters. Perfect!

One thing I missed was automatic testing when files are saved. I use Guard when developing Rails projects and wanted to hook it into my Emacs setup.

The following Guardfile uses guard-shell to run ert-runner whenever an .el file is modified. I added a workaround for ignoring flycheck files, which Emacs saves when a file is modified and can trigger a huge amount of builds.

guard :shell do
  watch (/(.*)\.el$/) do |file|
    # Ugly fix but I couldn't spend time messing around with regex.
    unless file[0].to_s.include? 'flycheck'
      if system('cask exec ert-runner')
        n 'Tests succeeded', 'ERT', :success
      else
        n 'Tests failed', 'ERT', :failed
      end

      ''
    end
  end
end

Using :success and :failed with the process result also means Guard’s notifier works correctly, so it’s possible to use the Emacs notifier to get realtime test pass & fail colours whenever a file is saved. Pretty neat!

Each projectile project can have its own TODO.org, but sometimes projects don’t have one (or don’t need one) and these empty files are still added to the agenda.

The following function filters the org-projectile list of TODO files and removes any file that doesn’t actually exist.

(defun sodaware/org-projectile-todo-files () 
  "Fetch a list of org TODO files for projects that actually exist."
  (seq-filter #'file-exists-p (org-projectile-todo-files)))

;; Add org-projectile files to org.
(setq org-agenda-files (append org-agenda-files (sodaware/org-projectile-todo-files)))

1. Should only submit data at the end of the day
2. Only wanted a single data-point in my Beeminder graph
3. Wanted each entry to be rounded up to the nearest 15 minutes

Let’s take them in order.

1 - Only submit data at the end of the day

I use cron to run the script every night at 10:55pm. I thought about running it at midnight, but the deadline stops me from working too late.

55 22 * * * cd <script directory> && ./log_time > /<script directory>/bee.log

2 - Only want a single data point in my graph

Nothing too complex here, the script fetches all individual entries for the day and adds them together.

client = Harvest.client(
  subdomain: ENV['HARVEST_SUBDOMAIN'],
  username:  ENV['HARVEST_USERNAME'],
  password:  ENV['HARVEST_PASSWORD']
)

todays_entries = client.time.all
total_time     = 0

todays_entries.each do |entry|
  total_time += entry.hours
end

I’d like to replace the each loop with something more Ruby-ish, but for now it works.

3 - Round all entries up to the nearest 15 minutes

# Round up a floating point time value to the nearest quarter hour.
def round_to_quarter_hour(time)
  (time * 4).ceil / 4.0
end

# Update the sum loop
todays_entries.each do |entry|
  total_time += round_to_quarter_hour(entry.hours)
end

The finished script

All configuration details are stored in a .env file in the script directory.

# frozen_string_literal: true

require 'beeminder'
require 'dotenv/load'
require 'harvested'

# Round up a floating point time value to the nearest quarter hour.
def round_to_quarter_hour(time)
  (time * 4).ceil / 4.0
end

puts 'Fetching data...'

client = Harvest.client(
  subdomain: ENV['HARVEST_SUBDOMAIN'],
  username:  ENV['HARVEST_USERNAME'],
  password:  ENV['HARVEST_PASSWORD']
)

# Get all entries for today.
todays_entries = client.time.all
total_time     = 0

# Round up each entry to nearest 0.25.
todays_entries.each do |entry|
  total_time += round_to_quarter_hour(entry.hours)
end

# Submit the value to beeminder.
beeminder = Beeminder::User.new(
  ENV['BEEMINDER_TOKEN'],
  auth_type: :personal
)

puts 'Sending data...'

beeminder.send(
  ENV['BEEMINDER_GOAL'],
  total_time,
  "AUTO: #{total_time} hours billed for day"
)

puts 'Done'

I’m not sure this is actually something I’ll keep using, but it was a fun exercise.

(add-hook 'enh-ruby-mode-hook #'sodaware/enable-lsp-for-solargraph-projects)

(defun sodaware/enable-lsp-for-solargraph-projects ()
  "Enable lsp-mode if the current project has solargraph installed."
  (when (sodaware/has-solargraph-p)
    (lsp)))

(defun sodaware/has-solargraph-p ()
  "Check if the current Rails project has solargraph installed."
  (let* ((root    (sodaware/get-closest-gemfile-root))
         (gemfile (concat root "/Gemfile")))
    (unless nil
      (with-temp-buffer
        (insert-file-contents gemfile)
        (search-forward "solargraph" nil t)))))

(defun* sodaware/get-closest-gemfile-root (&optional (file "Gemfile"))
  "Determine the pathname of the first instance of FILE starting from the current directory towards root.

This may not do the correct thing in presence of links. If it does not find
FILE, then it shall return the name of FILE in the current directory, suitable
for creation."
  (let ((root (expand-file-name "/")))
    (loop
     for d = default-directory then (expand-file-name ".." d)
     if (file-exists-p (expand-file-name file d))
     return d
     if (equal d root)
     return nil)))

It’s not particularly elegant, and I think there will be performance problems for with larger Gemfiles.

A compilation command is make up of three parts:

• The action to take
• Optional flags
• The file or module to compile

Allowed actions are:

• makeapp : Create an application (e.g. an exe file on Windows)
• makemods : Compile a BlitzMax module

The following flags are supported:

• -h : Compile in threaded mode.
• -d : Compile in debug mode.
• -r : Compile in release mode.
• -a : Rebuild all files during compilation.
• -t gui : Compile in GUI mode. Applications compiled with this argument will not display a console window when run.
• -o <file> : Write the compiled application to <file>

The final argument should be the file or module to compile.

Examples:

1. Compile a module in release mode

bmk makemods -r my_module

2. Compile a threaded, non-console application

bmk makeapp -h -t gui -o output.exe src/my_file.bmx

The following code configures Emacs to show the *dashboard* buffer after launch. It works with emacsclient as well.

(setq initial-buffer-choice #'(lambda () (get-buffer-create "*dashboard*")))

(defun get-json (uri)
  "Fetch the contents of URI and parse."
  (with-current-buffer (url-retrieve-synchronously uri)
    (goto-char (point-min))
    (goto-char url-http-end-of-headers)
    (prog1 (json-read)
      (kill-buffer))))

Something like:

{
   "field" : "value"
}

will return an object like this:

'((field . "value"))

function print_error($text) {
    fwrite(STDERR, $text . PHP_EOL);
}

It’s handy for scripts that output things to STDOUT that may be redirected or saved to a file (e.g. a script that outputs CSV or JSON data).

protected function my_helper() {
	if ( empty( $this->my_helper ) ) {
		$this->my_helper = new MyHelper();
	}

	return $this->my_helper;
}

The following bit of YASnippet code expands wrap_helper into the above code and automatically sets the field name once the function name has been entered.

# -*- mode: snippet -*-
# name: Wrap a helper or model
# key: wrap_helper
# group: templates
# --
protected function $1() {
	if ( empty( $this->$1 ) ) {
		$this->$1 = new ${2:ClassName}();
	}

	return $this->$1;
}
$0

grep --include="*.bmx" -hri "^import [^\"]" <SOURCE FILE> |
    sort |
    uniq |
    sed 's/[Ii]mport //g'

This will give output something like the following:

brl.linkedlist
brl.map
brl.reflection
brl.retro
sodaware.blitzmax_array
sodaware.blitzmax_ascii
sodaware.file_fnmatch

The snippet is broken into a couple of parts:

• grep --include="*.bmx" -hri "^import [^\"]" <SOURCE FILE>
  • --include="*.bmx*" Instructs grep to search only bmx files.
  • -h Removes the file name from results
  • -r is a recursive search
  • -i ignores case
  • "^import [^\"]" will search for lines that start with “import” that are not followed by a " character (i.e. a file import).
• sort - Sorts lines A to Z
• uniq - Removes duplicate lines from the results
• sed 's/[Ii]mport//g' strips the starting Import .

The problem is that I need to update the IP whitelist when someone new wants access, which isn’t always practical.

This solution will check for a whitelisted IP first. If that fails, it will prompt for a username and password.

satisfy any;

# Authenticate via IP address.
allow 127.0.0.1; # Should be an actual IP
deny all;

# Try a password if IP didn't match.
auth_basic           "Private";
auth_basic_user_file /path/to/.htpasswd;

It took me a while to find keyboard shortcuts for navigating the different areas.

Navigating main sections

“Organize” menu shortcuts

Call these after opening the “organize” menu with CTRL+3:

“Reflect” menu shortcuts

Call these after opening the “reflect” menu with CTRL+4:

---
title: 2019
layout: log
---

## 2019-04-15

* This is a log entry.

I wanted to try writing a little bit of elisp code to streamline the process of adding new entries. It’s not exactly time-consuming to add a few new lines by hand, but reducing friction means I’m more likely to keep things updated.

Each log file is stored in _logs inside the jekyll source directory:

- src
  - _posts
  - _notes
  - _logs
    - 2019.md

In the end I came up with the following code:

(defvar sodaware/sdf-logs-path "/path/to/jekyll/src/_logs/")

(defun sodaware/sdf-log ()
  "Add a new entry to the current sodaware.sdf.org log."
  (interactive)
  (let* ((current-year (format-time-string "%Y"))
         (current-date (format-time-string "%Y-%m-%d"))
         (log-file     (format "%s%s.md" sodaware/sdf-logs-path current-year)))
    ;; Find the log file.
    (find-file log-file)

    ;; Add Jekyll markup if file is empty.
    (when (= 0 (buffer-size))
      (insert "---" "\n")
      (insert "title: " current-year "\n")
      (insert "layout: log\n")
      (insert "---" "\n\n")
      (insert (format "## %s\n\n" current-date)))

    ;; Attempt to find the current heading. If not found, insert it.
    (sodaware/find-or-insert-heading (format "## %s" current-date) "## ")

    ;; Insert after.
    (forward-line 2)
    (insert "* \n")
    (forward-line -1)
    (move-end-of-line 1)))

(defun sodaware/find-or-insert-heading (heading start-of-heading)
  "Find or insert HEADING before START-OF-HEADING in the current buffer."
  ;; Go to the start of the file.
  (goto-char (point-min))

  ;; Search for the heading. If not found, find the start of the first heading
  ;; and insert before that.
  (unless (search-forward heading nil t)
    (goto-char (point-min))
    (search-forward start-of-heading)
    (move-beginning-of-line 1)
    (insert "\n\n")
    (forward-line -2)
    (insert heading "\n")
    (forward-line -1))

  (move-beginning-of-line 1))

Notes

• sodaware/sdf-logs-path

  The full path of the log directory.

• sodaware/find-or-insert-heading

  A utility function function that searches for a headline in the current buffer. If the headline is not found, it will be inserted above the first headline in the file. It’s not Markdown specific, so something like (sodaware/find-or-insert-heading "** heading" "** ") would work for org-mode headlines.

• sodaware/sdf-log

  The main function to call when adding a new entry. It opens the log file for the current year and inserts a timestamp heading before the first headline. If the file does not exist, it is created and filled with Jekyll markup and the first headline.

Future improvements

I’m not 100% happy with how things currently work. I’d like to split things up further so I can reuse the main note creation function for other projects. I often keep project development logs in markdown format and it would be handy to use the same skeleton code for adding entries to them.

The built-in XFCE terminal can be opened in drop-down mode by calling xfce4-terminal with the --drop-down flag.

The following steps will bind opening a terminal window to a keyboard shortcut without installing additional packages.

1. Open XFCE keyboard settings

This can be found under “Settings” > “Keyboard” in the menu, or by running xfce4-keyboard-settings directly.

2. Add a new command

Switch to the “Application Shortcuts” tab and use the “Add” button to create a new shortcut.

Enter xfce4-terminal --drop-down as the shortcut.

3. Enter the shortcut

XFCE will prompt for a shortcut once the command has been added. I went with SUPER+`, but F12 is another popular shortcut.

Once set up the shortcut key will show a terminal window at the top of the screen. Pressing it again will hide the window - the window keeps its previous contents so it can be hidden without losing anything.

Adding the following to /etc/default/locale did the trick:

LC_TIME="en_GB.UTF-8"

Running xfce4-panel -r from the terminal will restart all XFCE panels and fix any frozen ones.

Although Emacs is my primary editor 99% of the time, I still use nano when I need to edit something quickly (and especially if I need root priveleges).

I recently found out about zile, an extremely lightweight editor that uses Emacs key-bindings and has a similar buffer mode.

It’s not a replacement for Emacs, but it does support scripting and is a decent alternative to nano.

 39 141 853 sorting-directories-by-size.md

This gives 3 values: The number of lines, the number of words and the number of bytes. wc also supports flags for getting just one of these values.

For example:

$ wc -w my-file.md
123 my-file.md

However, that still includes the filename. To get just the word count (or byte count/line count) without parsing the file takes an extra step:

cat my-file.md | wc -w

Which will echo the number of words without any extra data.

I’ve used this to keep track of a text file’s wordcount over time with the following snippet:

echo "$(date '+%Y-%m-%d %H:%M:%S'),file.org,$(cat file.org | wc -w)" >> wordcount.csv

This appends a line to “wordcount.csv” containing the current time and date, the file name and the number of words.

du --max-depth=1 . | sort -nr

Which will return a list something like this:

8204	./.cache
1829	./.git
1416	./_site
785	./source
384	./.sass-cache
8	./plugins
4	./raw
0	./images

There are two parts to the command:

du –max-depth=1 .

du displays a list of directory sizes. The --max-depth=1 parameter limits the list to top-level directories. Their size will still include files in their sub-directories, but these sub-directories will not be included in the results list.

sort -nr

Sorts the results. The n parameter sorts by numerical data (in this case size rather than the name) and r reverses the list so newer smallest items show at the bottom.

Here’s the original example I used.

$my_array = array(
    'key' => 'Value',
    'key_two' => 'Another value',
    'really_long_key' => 'Value',
    'k' => 'Value',
);

To align this with align-regexp, highlight the contents of the array and then:

1. Run the align-regexp command (i.e. M-x align-regexp)
2. Enter => at the “Align regexp” prompt

Which converts it into this:

$my_array = array(
    'key'             => 'Value',
    'key_two'         => 'Another value',
    'really_long_key' => 'Value',
    'k'               => 'Value',
);

As the name suggests, align-regexp takes a regular expression for alignment. This means it can also be used to align pretty much anything.

e.g.

{
    "key" : "Value",
    "key_two" : "Another value",
    "really_long_key" : 200,
    "k" : "Value",
}

With align-regexp using : becomes:

{
    "key"             : "Value",
    "key_two"         : "Another value",
    "really_long_key" : 200,
    "k"               : "Value",
}

The quickest is to set doom-modeline-icon to t during initialization. This works fine, but if you connect emacs from the terminal using emacsclient -nw things can look a little weird.

Adding the following to my “init.el” file does the same thing, but only enables icons the first time a window frame is opened:

(defun enable-doom-modeline-icons (_frame)
  (setq doom-modeline-icon t))
  
(add-hook 'after-make-frame-functions 
          #'enable-doom-modeline-icons)

I’m still looking for a way to switching icons on and off when switching between a terminal and windowed session. This does things well enough for now.

The following function converts a binary string (i.e. a string made up of “0” and “1” characters) into a regular PHP string:

function bin_to_ascii($data) {
    $output = '';
    for ( $i = 0; $i < strlen( $data ); $i += 8 ) {
        $chunk = substr( $data, $i, 8 );
        $output .= pack('H*', base_convert($chunk, 2, 16));
    }
    return $output;
}

// Example:
$data  = '01001000011001010110110001101100011011110010110000100000';
$data .= '010101110110111101110010011011000110010000100001';

// Prints "Hello, World!"
echo bin_to_ascii($data);

The function slices the input string into chunks of 8 characters, because each ASCII character is 8 bits long.

pack is a nifty PHP function for converting binary data into other forms.

In this example, the chunk of data is converted into actual binary data using base_convert. base_convert is used to convert a base 2 (i.e. binary) number into base 16 (hexadecimal). pack then converts the hex value into a readable string. Each character is converted before being returned in one string.

Important:

The input string should be valid binary - it should only contain 1s and 0s, and the length should be a multiple of 8. Weird things will happen otherwise.

For example, the following will output “ONE”:

Const my_constant:Int = 1

If MY_CONSTANT = 1 Then Print "ONE"

The same result occurs even in SuperStrict mode.

filter_var($value, FILTER_VALIDATE_BOOLEAN);

Passing a value to filter_var with the FILTER_VALIDATE_BOOLEAN flag will return true for the following values:

• true
• 'true'
• 1
• '1'
• 'on'
• 'yes'

Anything else will return false.

It can’t be used to import the local contents into the remote one (deliberately to prevent me from making mistakes). I use it to keep my local development copy of a site up-to-date with the production version.

Important: Running this script will OVERWRITE the contents of the local database.

Configuration

To use the script, replace the variables in the “Configuration” section with your own values.

Code

#!/bin/bash

# ------------------------------
# -- Configuration.

SSH_USER="<value goes here>"
SSH_HOST="<value goes here>"

REMOTE_DB_HOST="localhost"
REMOTE_DB_NAME="<value goes here>"
REMOTE_DB_USER="<value goes here>"
REMOTE_DB_PW="<value goes here>"

LOCAL_DB_HOST="localhost"
LOCAL_DB_NAME="<value goes here>"
LOCAL_DB_USER="<value goes here>"
LOCAL_DB_PW="<value goes here>"

# ------------------------------
# -- Syncing.

# Remove any existing dumps.
rm /tmp/$REMOTE_DB_NAME.sql

# Fetch the remote database.
echo 'Fetching remote database'
ssh $SSH_USER@$SSH_HOST "mysqldump -u$REMOTE_DB_USER --password='$REMOTE_DB_PW' -h $REMOTE_DB_HOST $REMOTE_DB_NAME" > /tmp/$REMOTE_DB_NAME.sql

# Load it into the local database.
echo 'Importing database dump'
mysql -u$LOCAL_DB_USER --password=$LOCAL_DB_PW -h $LOCAL_DB_HOST $LOCAL_DB_NAME < /tmp/$REMOTE_DB_NAME.sql

require 'json'

json = JSON.parse(raw_text)
puts JSON.pretty_generate(json)

The pretty_generate function will add line breaks where needed and fix any alignment issues.

Adding in syntax highlighting using rouge requires only a few more steps:

require 'json''
require 'rouge'

def prettify_json(raw_text)
  json = JSON.parse(raw_text)
  JSON.pretty_generate(json)
end

def highlight_json(text)
  formatter = Rouge::Formatters::HTML.new(css_class: 'highlight')
  lexer = Rouge::Lexer.find('json')
  formatter.format(lexer.lex(text))
end

Calling highlight_json will return HTML markup to display json with syntax highlighting.

One of the most helpful features of Guard is the display of notifications to indicate a test’s success (or failure). There are a few different types available, but I find the popup ones to be a little annoying after a while.

However, Guard comes with an Emacs notifier that changes the colour of the modeline depending on the result of the latest test. This makes getting feedback from tests extremely quick, and also means I don’t have to leave the editor.

Adding the following to .guard.rb in your home directory will enable the Emacs notifier on the local machine.

notification :emacs

The default colours didn’t work so well for my current theme (aurora), but thankfully Guard supports configuring colours:

notification :emacs,
  fontcolor: '#263238',
  default:   '#546d7a',
  success:   '#396c00',
  failed:    '#640900',
  pending:   '#776600'

Alternatively these can go in a Guardfile, but I prefer to leave notification settings up to individuals.

To get a better idea of how large things needed to be in the new design, I wanted to know the the longest value stored for each column.

Thankfully MySQL has the length function that can be used for this. The following query qill return a single result containing the longest value, as well as its length:

SELECT <column>, LENGTH(<column>) as col_length 
FROM <table> 
ORDER BY col_length DESC
LIMIT 1

Just replace <column> and <table> with the column and table name to query.

Thankfully, Emacs lisp provides the variable system-type.

For example, it can be used to set a different font depending on the os:

;; Windows only font
(when (string= "windows-nt" system-type)
  (set-face-font 'default "Consolas"))

;; Mac OS only font
(when (string= "darwin" system-type)
  (set-face-font 'default "Monaco"))
  
;; Linux only font
(when (string= "gnu/linux" system-type)
  (set-face-font 'default "Ubuntu"))

More info: Gnu Emacs: Operating System Environment

I use org-mode to track time worked on projects, and I’ve been using org-ruby to extract the data to make graphs and things.

One issue I’ve bumped into is that org-ruby hard-codes the list of keywords that can start a headline and only supports TODO and DONE. This meant some headlines got ignored and didn’t show up in reports.

To get around this I needed to override the constants org-ruby uses. In the end I went with the following approach:

##
# Monkey patch
module Orgmode
  class Headline
    remove_const(:Keywords) if defined?(Keywords)
    remove_const(:KeywordsRegexp) if defined?(KeywordsRegexp)

    Keywords       = %w[TODO IN-PROGRESS TESTING DONE CANCELLED].freeze
    KeywordsRegexp = Regexp.new("^(#{Keywords.join('|')})\$")
  end
end

1. Load a properly-formatted file into a buffer
2. Enable the major mode for the buffer
3. Indent the entire file
4. Compare the indented buffer with the original file and fail the test if they don’t match

The problem with the above approach is that buffer-string also returns formatting information for the buffer. This causes all comparisons to fail as the indented buffer contains highlight information.

Luckily the solution is quite simple:

(defun cleaned-buffer-string ()
  "Get \"buffer-string\" without any fontification data."
  (let ((buffer (buffer-string)))
    (set-text-properties 0 (length buffer) nil buffer)
    buffer))

This returns the entire contents of the buffer as a clean string.

It adds functions that can be called using M-x or bound to a shortcut. All of them can select the word at the current point, so no region needs to be marked before using them.

Conversion Functions

string-inflection-upcase

Converts text to UPPER_SNAKE_CASE.

• ExampleName becomes EXAMPLE_NAME
• another-name becomes ANOTHER_NAME

string-inflection-camelcase

Converts text to CamelCase.

• EXAMPLE_NAME becomes ExampleName
• another-name becomes AnotherName

string-inflection-underscore

Converts text to underscore_case. Pretty much the same as string-inflection-upcase but with lowercase letters.

• ExampleName becomes example_name
• another-name becomes another_name

string-inflection-kebab-case

Converts text to kebab-case. Also known as lisp-case or dash-case.

• ExampleName becomes example-name
• ANOTHER_NAME becomes another-name

string-inflection-lower-camelcase

Converts to lowerCamelCase.

• EXAMPLE_NAME becomes exampleName
• another-name becomes anotherName

Cycling Cases

There are a few additional functions that cycle between cases.

string-inflection-ruby-style-cycle

Cycles between:

• Lower snake case
• Upper snake case
• Upper camel case

emacs_lisp => EMACS_LISP => EmacsLisp => emacs_lisp

string-inflection-python-style-cycle

Cycles between:

• Lower snake case
• Upper snake case
• Upper camel case

emacs_lisp => EMACS_LISP => EmacsLisp => emacs_lisp

string-inflection-java-style-cycle

Cycles between:

• Lower camel case
• Upper snake case
• Upper camel case

emacsLisp => EMACS_LISP => EmacsLisp => emacsLisp

string-inflection-all-cycle

Cycles between all available cases:

• Lower snake case
• Upper snake case
• Upper camel case
• Lower camel case
• Kebab case

emacs_lisp => EMACS_LISP => EmacsLisp => emacsLisp => emacs-lisp => emacs_lisp

View string-inflection on GitHub

Note

emacs-php-align has been merged into the main php-mode extension.

PHP doesn’t require arrays to be aligned in a specific way, but certain coding standards will raise a warning if they’re aren’t aligned correctly. Doing this by hand can be a pain.

emacs-php-align is a small extension that can automatically align arrays. It’s not available on Melpa, but it’s fairly quick to setup.

Once it’s installed, calling M-x align-current will align an array and turn this:

$my_array = array(
    'key' => 'Value',
    'key_two' => 'Another value',
    'really_long_key' => 'Value',
    'k' => 'Value',
);

into this:

$my_array = array(
    'key'             => 'Value',
    'key_two'         => 'Another value',
    'really_long_key' => 'Value',
    'k'               => 'Value',
);

For example, cloning a private repository from one account may not work, even if both keys are currently being used by the SSH agent.

To workaround this limitation, the SSH agent can be configured to use a specific key when accessing a domain. In this case the same domain requires different keys, so an alias is used instead.

This alias needs to be used when checking out repositories, but once the initial step is complete everything else happens automatically.

Modifying ~/.ssh/config with the following:

# Work GitHub Account
Host github.com-work
    HostName github.com
    User git
    IdentityFile ~/.ssh/work_public_key

Will now tell the SSH agent to use ~/.ssh/work_public_key when trying to access anything on github.com-work.

Cloning a repository

To use the alias when cloning a reposiory, replace github.com with the configured alias.

For example, cloning the ruby repository with the work alias from earlier looks like this:

git clone git@github.com-work:ruby/ruby.git

Standard git commands like git push will work just the same as any other repository.

Existing repositories

To update an existing repository to use a new alias, modify the .git/config file in the project’s working directory. It should look something like this:

[remote "origin"]
	url = git@github.com-work:ruby/ruby.git

Normally Ubuntu will try to paste the contents of the clipboard when you click your middle mouse button. If you’re currently in Firefox and you do this it will try to open what you pasted as a URL.

To revert to middle-click scrolling:

1. Go the the advanced preferences page. To get there, type about:config in the Address Bar and hit enter.

2. In the preferences search bar type middlemouse
   1. Change middlemouse.contentLoadURL to false.
   2. Change middlemouse.paste to false.
3. Type autoScroll into the preferences search bar.
   1. Change general.autoScroll to true.
4. Close the browser and restart.

Middle-click scrolling will now be enabled again.

The following command shows a list of all local branch names, along with the date of their last commit:

git for-each-ref --sort=committerdate refs/heads/ --format='%(committerdate:short) %(refname:short)'

Produces output like:

2015-10-12 feature-branch-name
2016-01-15 another-feature-branch
2016-03-16 one-last-feature-branch
2017-05-24 master

For example, a file called my_file.json with the following contents:

{ "some_field" :
"value"
}

When called like this:

python -m json.tool my_file.json

Will output:

{
    "some_field": "value"
}

default_url_options[:trailing_slash] = true

For example, the application MyApplicationName will look something like this:

module MyApplicationName
  class Application < Rails::Application
    default_url_options[:trailing_slash] = true
  end
end

The Rails server will need restarting for the new settings to take effect.

This solution works for Rails 5 and will add a trailing slash to all urls automatically.

This function searches a directory (and its parents) for a named file. The file is loaded if found. An error is raised if the file is not found.

For the sodaware/file-search-upward function see “Emacs Lisp - Searching parent folders for a file”.

(defun sodaware/load-custom-config (filename directory)
  "Loads a configuration FILENAME from DIRECTORY.

If not found in the current directory, will search upwards until one is found."
  (let ((config-file-path (sodaware/file-search-upward directory filename)))
    (unless (and config-file-path
                 (file-exists-p config-file-path))
      (error (format "Could not find configuration file '%s'" filename)))
    (message (format "Loading configuration file: %s" config-file-path))
    (load-file config-file-path)))

Example usage

1. Loading a configuration

Assuming .config.el exists in /some/dir/:

(sodaware/load-custom-config ".config.el" "/some/dir/")
=> t

Assuming .invalid.el does not exist in /some/dir/:

(sodaware/load-custom-config ".invalid.el" "/some/dir/")
;; => Could not find configuration file '.bad.el'

2. Loading a configuration based on the current file

Emacs provides the variable buffer-file-name which contains the full path of the currently edited buffer.

This example searches for a configuration file using the current buffer’s path:

(sodaware/load-custom-config ".config.el" (file-name-directory buffer-file-name))

Without error raising

This is a modified version of the original function. It still searches parent directories for the configuration file, but will return NIL if the file is not found instead of raising an error.

(defun sodaware/load-custom-config (filename directory)
  "Loads a configuration FILENAME from DIRECTORY.

If not found in the current directory, will search upwards until one is found."
  (let ((config-file-path (sodaware/file-search-upward directory filename)))
    (when (and config-file-path
               (file-exists-p config-file-path))
      (load-file config-file-path))))

If the file is found its full path is returned, otherwise NIL is returned.

(defun sodaware/file-search-upward (directory file)
  "Search DIRECTORY for FILE and return its full path if found, or NIL if not.

If FILE is not found in DIRECTORY, the parent of DIRECTORY will be searched."
  (let ((parent-dir (file-truename (concat (file-name-directory directory) "../")))
        (current-path (if (not (string= (substring directory (- (length directory) 1)) "/"))
                         (concat directory "/" file)
                         (concat directory file))))
    (if (file-exists-p current-path)
        current-path
        (when (and (not (string= (file-truename directory) parent-dir))
                   (< (length parent-dir) (length (file-truename directory))))
          (sodaware/file-search-upward parent-dir file)))))

Example usage

Given the following directory structure:

|-- dir1
    |-- my_file.txt
    |-- dir2
        |-- dir3

Searching dir3 will also search dir2 and dir1:

;; Finding a file that exists in a parent directory.
(sodaware/file-search-upward "/dir1/dir2/dir3/" "my_file.txt")
=> "/dir1/my_file.txt"

;; Failing to find a file.
(sodaware/file-search-upward "/dir1/dir2/dir3/" "not_found.txt")
=> NIL

Here’s a simple function that marks all RSS items as read before fetching new posts:

(defun sodaware/elfeed-all-read-refresh ()
  (interactive)
  (when (y-or-n-p "Really mark all items as read?")
    (elfeed-mark-all-as-read)
    (elfeed-search-fetch nil)))

The following code will read an org-mode file and list all major headlines:

require 'org-ruby'
document = Orgmode::Parser.new(File.read('TODO.org'))

document.headlines.each do |headline|
  puts headline.headline_text
end

Here’s a more advanced example. This will read all headlines that are marked as “DONE” along with any list items they contain.

require 'org-ruby'
document = Orgmode::Parser.new(File.read('TODO.org'))

doc.headlines.each do |headline|
  next unless headline.keyword == 'DONE'

  puts headline.headline_text

  headline.body_lines.each do |line|
    next if line.nil?
    next unless line.paragraph_type == :list_item

    task_line = line.output_text.strip
    puts ' -> ' + task_line[4..-1]
  end
end

Using this file:

#+TITLE: TODO.org
DONE Top Level Task 1
  - [X] Checkbox one
  - [X] Checkbox two
TODO Top Level Task 2
  - [ ] Checkbox three

will output:

Top Level Task 1
 -> Checkbox one
 -> Checkbox two

The Mini Shinobi development page is a good example of what this can be used to create. The “daily activity” and “milestones” sections are both built entirely using org data.

(defun sodaware/autocompile-emacs-configuration ()
  "Automatically compile changes to ~/.emacs"
  (when (eq major-mode 'emacs-lisp-mode)
    (sodaware/compile-elisp-file "~/emacs")))

(defun sodaware/compile-elisp-file (file-name)
  "Byte-compile FILE-NAME if it exists."
  (let ((elisp-file (expand-file-name file-name)))
    (if (string= (buffer-file-name) (file-chase-links elisp-file))
        (byte-compile-file elisp-file))))

;; Run the auto-compile function when an Elisp file is saved
(add-hook 'after-save-hook #'sodaware/autocompile-emacs-configuration)

I have a couple of different files in my ~/.emacs.d/ directory, but it’s easy to modify the sodaware/autocompile-emacs-configuration function to support multiple files:

(defun sodaware/autocompile-emacs-configuration ()
  "Automatically compile changes to ~/.emacs"
  (when (eq major-mode 'emacs-lisp-mode)
    (mapc #'sodaware/compile-elisp-file
          (list "~/.emacs"
                "~/.emacs.d/init.el"
                "~/.emacs.d/my-email.el"
                ;; ... and more
                "~/.emacs.d/my-news.el"))))

From the ParEdit page:

ParEdit (paredit.el) is a minor mode for performing structured editing of S-expression data. The typical example of this would be Lisp or Scheme source code.

ParEdit helps keep parentheses balanced and adds many keys for moving S-expressions and moving around in S-expressions.

Seeing it in action makes it much clearer how useful it is. Here’s two great visual guides to ParEdit and what it can do:

1. Emacs Rocks! Paredit
2. The Animated Guide to Paredit

Like most things Emacs, it takes a while to get used to. But once over the initial learning curve it’s indespensible.

There are some binaries available, but none for CentOS. The following will get Roswell up and running on a fresh CentOS 7.2 installation:

Setting up CentOS

Run the following as root to install dependencies required for building Roswell:

yum install git automake gcc gcc-c++ make openssl-devel curl-devel bzip2

Fetching and installing Roswell

These can be run as any user:

git clone -b release https://github.com/roswell/roswell.git
cd roswell
sh bootstrap
./configure
make

And as root

make install

And finally (as the original user)…

ros setup

Roswell will now be installed and available globally.

Installing and running a Lisp

To install a Lisp binary, such as SBCL, run:

ros install sbcl-bin

SBCL can then be started using ros run.

Thankfully Jekyll can accept multiple configuration files at a time.

The following command will start a Jekyll server with the standard _config.yml configuration as well as _config.development.yml.

bundle exec jekyll serve --drafts --watch --config=_config.yml,_config.development.yml

Anything in the development configuration will override the base values in _config.yml.

Examples

The production & development configurations for this site look like this:

_config.production.yml

gems:
  - jekyll-minifier

_config.development.yml

livereload: true
gems:
  - jekyll-livereload

Cutting jekyll-minifier from development cuts page generation times from 10 seconds to about 0.8. Coupled with jekyll-livereload it makes previewing site changes much easier.

Updated Makefile

This changes the build and serve parts of the Makefile¹ to look like this:

build:
	bundle exec jekyll build --config=_config.yml,_config.production.yml

serve:
	bundle exec jekyll serve --drafts --watch --config=_config.yml,_config.development.yml

(defun list->alist (items)
  "Convert a list into an alist."
  (loop for item from 0 to (1- (length items)) by 2
     for key = (nth item items)
     for data = (nth (1+ item) items)
     nconc (acons key data nil)))

Basic example

Running list->alist on this input:

(list :key1 "value1" :key2 "value2" :key3 "value3")

produces the following output:

((:key1 . "value1")
 (:key2 . "value2")
 (:key3 . "value3"))

A little bit of work needs to be done after extracting code, but it’s slightly quicker than doing the whole thing manually.

(defun php-extract-function (start end name)
  "Moves the currently marked text to a new function"

  ;; Prompt for new method name
  (interactive "r\nsNew Function Name: ")

  ;; Kill selected region
  (kill-region start end)

  ;; Insert call to new function
  (insert "\n" name "();\n")

  ;; Set a marker so we can jump back to this line
  (point-to-register 1)

  ;; Move to end of current function
  (php-end-of-defun)

  ;; Insert new function
  (insert "\n\nfunction " name "() {\n"
	  (car kill-ring-yank-pointer)
	  "\n}\n")

  ;; Jump back to where function was snipped from
  (jump-to-register 1))

(defun file-get-contents (filename)
  (with-open-file (stream filename)
    (let ((contents (make-string (file-length stream))))
      (read-sequence contents stream)
      contents)))

To return the file as a list of lines instead, the loop macro can be used:

(defun file-get-lines (filename)
  (with-open-file (stream filename)
    (loop for line = (read-line stream nil)
          while line
          collect line)))

REMOTE ?= "<connection info here>"
build:
	bundle exec jekyll build

push:
	rsync -avrz --delete-excluded _site/* $(REMOTE)

deploy: build push

serve:
	bundle exec jekyll serve --drafts --watch

REMOTE should be something like this username@server:path, where:

• username is your username on the remote server
• server is the remote server to deploy to
• path is the remote directory files should be copied to

If rsync is unavailable on the remote machine, scp can also be used by changing push to the following:

push:
	scp -r _site/* $(REMOTE)

Running make deploy will build the site and upload it in one command.

The following markup will add a CSS class to the generated image.

![Alt Text](http://example.org/image.jpg){:class="image-class"}

Will produce this:

<img src="http://example.org/image.jpg" alt="Alt Text" class="image-class" />

There should no space around the = sign.

This technique can also be used to add multiple HTML attributes. Adding them all in a single pair of {} does not work; each attribute needs to be in its own set.

![Alt Text](/whatever){:class="something-else"}{:style="border: 2px solid red;"}

It also works on links:

[Link Example](http://example.org/){:class="big-link"}