Today I Learned

hashrocket A Hashrocket project

Get Whodunnit Instance from PaperTrailGlobalId

I ran into an issue trying to get an instance of the User who made a change captured by paper_trail with the paper_trail-globalid gem.

With regular paper_trail, calling whodunnit will give you the id or name of the user who... dunnit.

post.versions.last.whodunnit
# => "Tony Yunker"

With the paper_trail-globalid gem, whodunnit is saved as, well, a global id.

post.versions.last.whodunnit
# => "gid://app/User/12345"

This isn't super helpful on it's own, but actor will resolve the global id and return an instance of the model it references.

post.versions.last.whodunnit
# => <User:0x000000015d618010...>

Delete/Drop a key-value pair from an object

In Javascript, if you want to drop or delete a key-value pair from an object you just pass the object.key to the delete keyword, like this:

// Assume we have an object like this
let object = {
  toyota: ['camry'], 
  honda:  ['accord', 'civic']
}

// It would display something like this
object
=> {toyota: ['camry'], honda: ['accord', 'civic'] }

// We can drop/delete the object value like this
delete object.toyota
=> true

// It would now display something like this
object
=> {honda: ['accord', 'civic']}

Get OS Details in Linux With os-release

You can find a bunch of details about your OS in /etc/os-release. You probably know most of these details if you're running it on your main machine, but it can come in handy if you're on a VM or in a container.

% cat /etc/os-release
NAME="Fedora Linux"
VERSION="43 (Sway)"
RELEASE_TYPE=stable
ID=fedora
VERSION_ID=43
VERSION_CODENAME=""
PRETTY_NAME="Fedora Linux 43 (Sway)"
REDHAT_BUGZILLA_PRODUCT="Fedora"
REDHAT_BUGZILLA_PRODUCT_VERSION=43
REDHAT_SUPPORT_PRODUCT="Fedora"
REDHAT_SUPPORT_PRODUCT_VERSION=43
SUPPORT_END=2026-12-02

The ID_LIKE field can be particularly useful if the distro is a derivative of another distro. For example, if the OS is Oracle Linux, the ID-LIKE value will be fedora, from which it's derived. Very useful for troubleshooting.

NAME="Oracle Linux Server"
ID="ol"
ID_LIKE="fedora"
VERSION_ID="8.9"

More info about os-release can be found here

Get Array's Min and Max with minmax

In ruby, you can get the minimum value in an array with #min and the maximum value with #max.

But sometimes you need both the min and max, and it feels a waste to make two separate calls. Turns out you can get both in one with #minmax - which will return a two element array with the min and max values.

pry(main)> [1, 2, 3].minmax
# => [1, 3]

You can also pass it a block for custom ordering criteria.

Docs

Run Explain (and Anaylze) in Rails Console

If you're troubleshooting some slow SQL queries, chances are you've used EXPLAIN or even EXPLAIN ANALYZE. But TIL, that you can actually run these in the Rails console on your Rails models (Active Model Relations). It looks something like this -

> User.active.explain

Or if you're on a more recent version of Rails, you can also pass arguments to .explain, such as :analyze -

> User.active.explain(:analyze)

You can also call it on other methods like pluck, etc. - 

> User.active.explain.pluck

Be warned that calling .explain will execute the query.

https://devdocs.io/rails~7.2/activerecord/relation#method-i-explain

https://guides.rubyonrails.org/active_record_querying.html#running-explain

TOON: Token-Efficient Data Format for LLMs

Today I discovered TOON (Token-Oriented Object Notation), a serialization format designed specifically for LLMs that achieves 30-60% token reduction compared to JSON.

Why It's Better

Unlike JSON, TOON eliminates redundant syntax (braces, brackets, most quotes). Unlike CSV, it supports nested fields. It also provides better accuracy through explicit lengths and fields before hand, this seems to make LLM better to understand the data that's comming.

Example

JSON:

{
  "users": [
    { "id": 1, "name": "Alice", "role": "admin" },
    { "id": 2, "name": "Bob", "role": "user" }
  ]
}

TOON:

users[2]{id,name,role}:
  1,Alice,admin
  2,Bob,user

Keys are declared once, then data flows as comma-separated rows with YAML-style indentation for nesting.

Filter RSpec Tests by Type

Sometimes I just want to run model rspec tests, or run everything except for those slow feature tests in my rails app. Today I learned you can do that with the --tag option.

To only run model specs:

$ bundle exec rspec --tag type:model

To exclude feature specs (using the ~):

$ bundle exec rspec --tag ~type:feature

What's convenient is rspec-rails will infer the type of the spec based on it's location in the spec/ directory, so even if you don't explicitly tag your tests with type: :model these filters will still work.

rspec --tag option docs

Delete Lines with Patterns and Ex Commands

Today I learned some cool ways to delete lines of text in (n)vim. Josh TIL'ed that you can execute an Ex command on a buffer with the :g command. So if you want to delete any lines that match pattern, you can run 

:g/pattern/d

Which is pretty neat! But you can also flip it - to delete any lines that don't match the pattern, you can use :v or :g!

:v/pattern/d
:g!/pattern/d

You can also restrict to a range of lines - if you want to only delete lines matching pattern between lines 40 and 50, you can do so with:

:40,50 g/pattern/d

React Activity component

Today I learned about React 19.2’s new <Activity> component.

<Activity mode={isShowingSidebar ? "visible" : "hidden"}>
  <Sidebar />
</Activity>

When mode="hidden", React unmounts all useEffect, it keeps state cached and yet the DOM stays rendered via display: none.

Switching back to mode="visible" restores the view instantly with its previous state and fire all useEffect again.

This is perfect for tabs, modals, and any UI you want ready-to-go.

reference: React Activity docs

Filter Fields and Associations When Rendering JSON

Today I learned you can modify a json payload in a rails controller to include associated models and filter attributes in the payload with the include and only options.

Say I have a controller that returns all blog Post records as json:

def index
  respond_to do |format|
    format.json do
      render json: Post.all
    end
  end
end

Now, say I want to include attributes for an associated Author model, but only their first and last name and exclude all other attributes. I can include the authors, and only include first and last name:

def index
  respond_to do |format|
    format.json do
      render json: Post.all, include: {author: {only: [:last_name, :first_name]}}
    end
  end
end

Private gitignore with .git/info/exclude

While .gitignore is great for team-wide ignore patterns, sometimes you need to ignore files just for your local setup without affecting other developers. Instead of modifying the shared .gitignore or creating a global ignore file, you can use .git/info/exclude.

This file works exactly like .gitignore but is private to your local repository and won't be committed or pushed to remote.

Example:

# git ls-files --others --exclude-from=.git/info/exclude
# Lines that start with '#' are comments.
# For a project mostly in C, the following would be a good set of
# exclude patterns (uncomment them if you want to use them):
# *.[oa]
# *~
Makefile

This keeps your ignores clean and avoids polluting the shared .gitignore with personal preferences.

List Postgres Databases

Today I learned how to list postgres databases from the command line. I use createdb and dropdb all the time to create and drop databases respectively, but alas listdb is not a valid command.

Instead, you can list the databases with psql -l.

$ psql -l
             Name             |  Owner   | Encoding |   Collate   |    Ctype    | ICU Locale | Locale Provider |   Access privileges
-----------------------------+----------+----------+-------------+-------------+------------+-----------------+-----------------------
 postgres                    | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | en-US      | icu             |
 template0                   | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | en-US      | icu             | =c/postgres          +
                             |          |          |             |             |            |                 | postgres=CTc/postgres
 template1                   | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | en-US      | icu             | =c/postgres          +
                             |          |          |             |             |            |                 | postgres=CTc/postgres
...

Docs

React 19.2 new useEffectEvent hook

React 19.2 added a new hook useEffectEvent that lets us to extract event handlers from effects, so they use the latest props/state without triggering effect re-runs.

Problem: You want an effect to depend on roomId but not theme:

function ChatRoom({ roomId, theme }) {
  useEffect(() => {
    const connection = createConnection(roomId).then(() => {
      showNotification('Connected!', theme);
    });

    return connection.disconnect;
  }, [roomId, theme]);
}

Solution with useEffectEvent:

function ChatRoom({ roomId, theme }) {
  const onConnected = useEffectEvent(() => {
    showNotification('Connected!', theme);
  });

  useEffect(() => {
    const connection = createConnection(roomId).then(() => {
      onConnected();
    });

    return connection.disconnect;
  }, [roomId]);
}

This way if the theme changes nothing happens, but if the roomId changed then a notification is fired with the latest theme value.

Setting Up MCP in Claude Code with Auth Headers

Adding MCP Servers with Authorization

Today I learned that you can configure MCP servers in Claude Code with http headers for authentication/authorization using the CLI:

claude mcp add \
  --scope user \
  --transport http \
  --header "Authorization: Bearer your-token" \
  my-mcp http://example.com/mcp;

In this case I decided to use the scope user because I want that MCP being configured for all my projects.

Check Your Shell Scripts with ShellCheck

Today I learned about shellcheck, a static analysis tool for shell scripts. I'll be the first to admit that my bash scripts contain a multitude of sins, so a too like this is invaluable to help clean them up.

It can be installed through Homebrew (brew install shellcheck), but also has a web editor available at https://www.shellcheck.net/ if you don't want to install it.

$ shellcheck my_script

Count occurrences

You can use Enumerable#tally to get a hash of element counts

["apple", "banana", "apple", "orange", "banana"].tally
=> {"apple"=>2, "banana"=>2, "orange"=>1}

We can even make it work for nested arrays

outfits = [
  ["Red Shirt"],
  ["Red Shirt", "Blue Pants"],
  ["Blue Pants"],
  ["Red Shirt"],
]

outfits.tally.map { |k, v| [*k, v] }
=> 
[
  ["Red Shirt", 2],
  ["Red Shirt", "Blue Pants", 1],
  ["Blue Pants", 1]
]

Use iwd to Connect to a Network on Linux

If you're in a fresh install of linux and stuck on the command line but need to connect to wifi, you can use the iNet Wireless Daemon (iwd) by interacting with it via it's client iwctl. Once you start up the iwctl command prompt, you can scan and connect to a wireless network.

$ iwctl
[iwd]# device list # find the name of your device, likely wlan0 for wifi
[iwd]# station wlan0 scan # scan for networks
[iwd]# station wlan0 get-networks # list available networks from the scan
[iwd]# station wlan0 connect [SSID] # connect to your network

Docs

Linewise Searching in Vim

Today I learned about the \%l atom, which can be used to search on the current line, or a specific line, and also above or below the current or specific line. That's kind of a lot in one sentence, so lets break it down:

Say you want to search for a search_term on line 23 of your buffer, you can do this by

/\%23lsearch_term

If you want to search for search_term only on the current line, you can use . instead of a line number

/\%.lsearch_term

You can use the <and > modifiers to match above (<) or below (>) the current line

/\%<.lsearch_term

/\%>.lsearch_term

But you can also replace . with a line number to match above or below that line:

/\%<23lsearch_term

/\%>23lsearch_term

Search within Selection in Vim

\%V is a useful atom (TIL it's called an atom - and there are a lot of them, see :h pattern-atoms) that can be used to match inside a Visual selection.

Say you have a large file open and want to search for something only within a single area of text, like a method. You can visually select that block of text, enter command mode with :, and prefix the search with \%V to scope the search so that you only get matches inside the selection:

:'<,'>/\%Vsearch_text

You can also use \%V to search and replace.

Switch Android emulator devices

If you want to switch which android device you are emulating on Android Studio,

  1. Open the app and click the dropdown menu More Actions
  2. Select Virtual Device Manager
  3. Click the + icon to add a new device, and select the android model you'd like to emulate
  4. Choose a system image
  5. After adding the device you should be able to click the play button to open the new emulator

Ensure Correct Redirect Action with 303 Status

Let's say I have a Post model, and send a PATCH XHR request for an instance of Post, handled by the PostsController. Normally, if I want to redirect to the posts_path at the end of the controller action I end the method like so:

def patch
  # patch-y things done here
  redirect_to posts_path
end # => redirects to PATCH /posts ❌

It's possible, depending on your browser, that instead of redirecting as a GET request to posts_path like you would expect, the original PATCH method is forwarded instead. Most times, this probably isn't what you want. To force the redirect to use the appropriate method for the path you're redirecting to, you can use the 303 See Other status code:

def patch
  # patch-y things done here
  redirect_to posts_path, status: :see_other
end # => redirects to GET /posts ✅

It's specifically called out in the docs (ActionController::Redirecting) so it seems to be fairly well-known/widespread, but it was a new to me occurrence.

Show Commit from Other Branch

I wanted to view a commit on a different branch without having to checkout/switch to that branch. It turns out git show can do that!

Say I'm on branch-a, but I want to see the latest commit I made on branch-b. It's actually really straightforward:

$ git show branch-b

This follows a lot of the git norms, too! git show branch-b~ will show the previous commit on branch-b (and git show branch-b~2 the commit before that). To view a single file in that commit, git show branch-b:path/to/file.rb!

Group together console logs

In Javascript you can group together console logs by using console.group()

This will output all of the following console logs in a nicer indented form.

console.group("Food");
console.log("Apple");
console.log("Banana");
console.log("Cookie");

image

You can nest groups inside of one another. To end a group just call console.groupEnd()

// ✨ indented for a better visual experience ✨
console.group("Food");
  console.group("Fruit");
    console.log("Apple");
    console.log("Banana");
  console.groupEnd();
  console.group("Dessert");
    console.log("Cookies");
  console.groupEnd();
console.groupEnd();

image

PostgreSQL conditional upserts

So in order to do an "upsert" we use an INSERT command with a CONFLICT statement. Then if we need to do some conditional setting in the case of existing data then we can use the "temp table" EXCLUDED that PostgreSQL provide to us. They have a nice example how to use that in their docs and here's mine example:

INSERT INTO users AS u (email, fullname) VALUES
  ('darth@example.com', 'Darth Vader'),
  ('luke@example.com', 'Luke Vader')
ON CONFLICT (email) DO UPDATE
SET fullname = EXCLUDED.fullname || ' (formerly known as ' || u.fullname || ')';

For this to work we have to have an unique constraint on the column email and the outcome of this could be:

SELECT email, fullname
FROM users;
| email              | fullname                                      |
| ---                | ---                                           |
| darth@example.com  | Darth Vader                                   |
| luke@example.com   | Luke Vader (formerly known as Luke Skywalker) |

Use git show-ref to Check for Branch Existence

Today I learned how to check in git if a branch exists on my local repo. I bounce between projects that use a main or master branch and wanted to automate away checking which to use.

git show-ref lists references in a local git repository. It can show any ref, be it tag or branch or whatever. But we want to use it for branches:

# let's say this repo has `main` branch, not `master`
$ git show-ref --branches master
$ git show-ref --branches main
2067645fb4d7b6ab07215c025dee95b872150db2 refs/heads/main

Note it's important to filter by branches, otherwise you can get false positives from remotes or tags

$ git show-ref main
2067645fb4d7b6ab07215c025dee95b872150db2 refs/heads/main
2067645fb4d7b6ab07215c025dee95b872150db2 refs/remotes/origin/main

You can use the existence of output from this command in scripts to, for example, determine which branch to rebase against:

#!/bin/sh

main_exists=`git show-ref --branches main`
if [ -n "$main_exists" ]; then
  branch="main"
else
  branch="master"
fi;

git rebase -i $branch

Create New Rails App with Old Rails Version

Sometimes you need to spin up a rails app using an older version of rails. Running rails new will spin up an app with the latest version (which is what you want most of the time). But if you have older gems of rails installed you can create new rails apps by specifying the version wrapped in underscores.

Say your rails entry in your gem list looks like this: rails (7.2.2.2, 7.2.1, 7.1.5.2, 7.1.2, 7.0.8.7). If you want to create a new rails app using 7.0.8.7, you can run (_ before and after the version number!):

$ rails _7.0.8.7_ new new_app

And boom, you've got a new_app created running rails 7.0.8.7.

Add/Subtract Months on a Date in Ruby

With ActiveSupport you can easily add months (or days, years, etc) to a date with:

pry(main)> Date.today
# => Fri, 05 Sep 2025
pry(main)> Date.today + 2.months
# => Wed, 05 Nov 2025
pry(main)> Date.today - 1.month
# => Tue, 05 Aug 2025

But what if you're working outside of Rails and without ActiveSupport? You can use the shovel (<<) operator on dates to return the date n months earlier.

pry(main)> Date.today
# => Fri, 05 Sep 2025
pry(main)> Date.today << 1
# => Tue, 05 Aug 2025

If you want to go forwards, you can use >>, or negate the value of n using <<:

pry(main)> Date.today
# => Fri, 05 Sep 2025
pry(main)> Date.today >> 2
# => Wed, 05 Nov 2025
pry(main)> Date.today << -2
# => Wed, 05 Nov 2025

Docs for << and docs for >>

Setup Your Rails Console with .pryrc

Sometimes there are variables I want to initialize or setup I want to run each time I enter a rails console, and I don't want to have to type it out every time. I'm using pry-rails, so my rails console is a pry session, and I can add ruby code to my .pryrc file to be run on console startup. Conveniently, this runs after the environment is loaded, so I have access to all my ActiveRecord models.

# .pryrc
author = Author.find(1)

If I put the above in my .pryrc, then I've got author available to me whenever I'm in a rails console (but not when I drop into a pry session in rails server (which is fine, I think it's less useful there)).

You can use a local .pryrc in your project's directory, or a global config in ~/.pryrc.

Add a Suffix to ActiveRecord Enums

Today I learned you can add suffixes to ActiveRecord Enums. I knew it was possible to prefix enums with the _prefix option:

class Answer < ApplicationRecord
  enum selection: {yes: "yes", no: "no", idk: "i don't know"}, _prefix: true
end

And you get helper methods like answer.selection_yes?, but that reads a little awkwardly. I think it reads better as answer.yes_selection?. Turns out you can do this with _suffix:

class Answer < ApplicationRecord
  enum selection: {yes: "yes", no: "no", idk: "i don't know"}, _suffix: true
end

answer = Answer.new selection: "yes"
answer.yes_selection? # => true
answer.no_selection? # => false

ActiveRecord::Enum Docs

Git Branch Completion in Bash

You can get git branch auto-completion in bash. Sometimes this is configured out of the box, but it didn't work for me using homebrew's git.

If you are using git installed via homebrew, git-completions.bash is located at /opt/homebrew/etc/bash_completion.d/git-completions.bash (or better yet $(brew --prefix)/etc/bash_completion.d/git-completions.bash for reliability). You just need to source it in your .bashrc or .bash_profile with:

test -f $(brew --prefix)/etc/bash_completion.d/git-completion.bash && . $_

(This is a cool shorthand syntax to test that the file exists, and if it does, source it. $_ refers to the last argument in the previous command, in this case the full path to git-completion.bash)

Now you can tab complete all your branch names in git checkout, git rebase, and more!

Normalization Attributes in Rails

In Rails 7.1, attribute normalization was introduced. This gives us an easy way to clean up data before persistence, or other actions.

class Contact < ApplicationRecord
  normalizes :phone, with: -> (phone) { phone.gsub(/\D/, "") } # remove non-number chars
end

The above ensures that before save, a phone number like 904-123-4567 gets converted to 9041234567.

In Rails 8, attribute normalization was backported to ActiveModel. So you can also use these methods in ActiveModels (re: Form objects) -

class ContactForm
  include ActiveModel::Attributes
  include ActiveModel::Attributes::Normalization

  attribute :phone
  
  normalizes :phone, with: -> (phone) { phone.gsub(/\D/, "") }
end

contact = ContactForm.new
contact.phone = "904-123-4567"
contact.phone # 9041234567

Ecto: Preload with Joins to Save Database Trips

Today I learned that you can combine preload with join in Ecto to fetch related data in a single query instead of making multiple database trips.

For example, instead of doing this:

from(
  u in User,
  where: u.status == :active,
  preload: [:emails]
) |> Repo.all()

Which runs 2 queries in db, you can do this in a single query:

from(
  u in User,
  join: e in assoc(u, :emails),
  where: u.status == :active,
  preload: [emails: e]
) |> Repo.all()

ActiveModel Error Details as a Hash

Today I Learned about a new way to list the errors for an invalid ActiveRecord model. Let's say I have a blog post class with title and author attributes, both of which are required:

class BlogPost < ApplicationRecord
  validates :title, presence: true
  validates :author, presence: true
end

Normally I interact with the errors in an invalid model through the nice ActiveModel Errors interface:

pry(main)> blog_post = BlogPost.new
pry(main)> blog_post.valid?
pry(main)> blog_post.errors
# => <ActiveModel::Errors [#<ActiveModel::Error attribute=title, type=blank, options={}>, #<ActiveModel::Error attribute=author, type=blank, options={}>]>

pry(main)> blog_post.errors.where(:title)
# => [#<ActiveModel::Error attribute=title, type=blank, options={}>]

But you can also return a hash of attributes containing arrays of their error details and use your favorite hash methods:

pry(main)> blog_post.errors.details
# => {:title=>[{:error=>:blank}], :author=>[{:error=>:blank}]}

pry(main)> blog.errors.details.dig(:title, 0, :error)
# => :blank

Git: Quickly Rebase Onto Previous Branch

Today I learned that you can use a dash - with git rebase to quickly rebase your current branch onto the previous branch you were on. This is a handy shortcut if you’re hopping between branches and want to rebase without typing the full branch name.

For example, after switching between branches:

git checkout main
git pull --rebase
git checkout new-feature-branch
git rebase -

The - here ^ refers to the last branch you were on (main in this case), so this command is equivalent to git rebase main.

It's funny that I used this all the time with git checkout but it never occurred to me that I could use for other git commands.