DEV Community: Caleb Hearth

Tell GitHub to Render Markdown Pages with .gitattributes

Caleb Hearth — Fri, 22 Nov 2024 00:00:00 +0000

Articles on Hearthside are written in Markdown (GitHub-flavored), but the file extension is .md.yaml as they also make use of Jekyll-style front matter. My Frontmatter gem requires that files it handles end in .yaml or .yml, so this is necessary.

Because of the file extension, GitHub until this week did not render the Markdown correctly. Instead articles have been highlighted if they were written in YAML completely, which really messes up the Syntax highlighting even beyond not giving a rendered preview.

I’m not sure why I never thought to look into it in the last several years of writing this way, but it turns out that you can tell GitHub’s Linguist tool what type of language a file type should match, so to do that I added this to my project’s .gitattributes:

*.md.y*ml linguist-language=markdown

Oxtail, and more Cooklang Exploration

Caleb Hearth — Thu, 21 Nov 2024 00:00:00 +0000

After yesterday’s post, it was time to finally try to handle a blog post and Cooklang recipe in one file. The solution to how to format things was simple: inline the recipe in a Markdown code fence and pre-process it. The file looks like:

 --- [yaml frontmatter] --- [markdown intro] ```

cooklang [cooklang recipe]

 ``` [markdown outro]

The code to do it is ugly and relies on a Regular Expression¹, CookCLI to generate some JSON that I use to render a partial during the view render. I didn’t bother building a nice data object, so I’m using a mess of {}.dig and case / in / else pattern-matching statements to generate the markup. It does properly handle marking up the recipe with the h-recipe microformat, so that’s a win. See below for Rails partial².

As you’ll see, the CLI doesn’t handle combining ingredients of the same name to amounts, and it isn’t able to parse ingredient aliases or comments. I’ll probably open an issue on the project’s GitHub repo, but ultimately it looks like the rust tool is the way to go.

How I Model SwiftUI Views

Caleb Hearth — Tue, 19 Nov 2024 00:00:00 +0000

The approach I take to defining ViewModels for SwiftUI was heavily inspired by Paul Hudson’s post Introducing MVVM into your SwiftUI project. In it, he advocates for defining class ViewModel inside an extension to the relevant view. By naming each view’s MVVM class ViewModel, it can always be referenced directly by that name instead of remembering to use ContentViewViewModel, UserListViewModel, etc. I take it a step further and simply name the class Model:

import SwiftUICore

extension ContentView {
 @MainActor @Observable class Model {
    // properties and functions
  }
}

And each view has an instance of its ViewModel, and hopefully nothing else.

struct ContentView: View {
  @State private var model: Model = .init()
}

In practice, useful property wrappers like @Binding or @Environment will get hoisted into the view. I’ve also had absolutely zero luck incorporating this fully with SwiftData. In theory you can build your own Query with Predicate<PersistentModel>

Truncate Date to Calendar.Component in Swift

Caleb Hearth — Mon, 18 Nov 2024 00:00:00 +0000

I’m frequently wanting to work with truncated dates in Swift apps, especially when dealing with Swift Charts. Foundation provides Calendar.startOfDay(for:) to get the first moment of a day, and that’s been really useful. The extension below will do something similar for an arbitrary¹ Calendar.Component to truncate that date to the first moment of that component.

extension Date { /// Returns the first moment of a given Calendar.Component, as a Date. /// /// For example, pass in `.hour` called on `Date()`, if you want the start of /// the current hour of the current day. /// Supported Calendar.Components are .year, .month, .day, .hour, .minute, /// .second. Passing an unsupported component will cause `self` to be returned /// unchanged. /// Calling `.start(of: .day)` is equivalent to calling `.startOfDay`. /// - parameter to: The smallest component you want /// - returns: The first moment of the given date. func start(of component: Calendar.Component) -> Date { let allComponents =...

Using Starship for the Same Prompt, but Faster

Caleb Hearth — Fri, 15 Nov 2024 00:00:00 +0000

Starship is a highly-configurable, cross-shell prompt. I recently switched to using it and it sped up my prompt rendering from being noticably slow and taking probably half a second to render to an imperceptible 0.03s rendering time. It actually does slightly more than my old prompt did as well even in that time.

My previous prompt, one that I’d been rocking for about 10 years, was defined in the dual behemoths that are Git’s contrib prompt script and my former prompt.zsh which called it and added a few other bits like per-host emoji for when I was SSH’d into another machine and some custom shortening of $PWD. I dug it up so that I could show what it would look like:

hearthside(main *$%=)/app ❯

And the new one looks pretty similar. Mostly you’ll notice that I’ve changed color schemes to one inspired by the GitHub colorblind scheme, which I’ve really come to like. I’ve also swapped one set of funny symbols for another, and unfortunately you probably can’t see them in this text.

Send a From Header When You Crawl

Caleb Hearth — Thu, 14 Nov 2024 00:00:00 +0000

Sending a From header is part of building a polite crawler, along with respecting Robots.txt and sending a unique User-Agent. The From header simply contains an email address that can be used by the site’s owner to reach out if your bot is creating any issues for them.

RFC 9110 which describes HTTP Semantics says that a From header SHOULD be sent for robotic user-agents. MDN says that the From header “must” be sent in that circumstance, but doesn’t have a citation for a spec that defines that.

I’ve been sending From headers for a while now, and I’m even including it as a requirement in a Swift type-driven API client I’ve been using across a few projects. I’m probably sending it in more places than I need to or that it would be expected in, but as I use scraping and API requests to automate my /now page, it seems prudent in case that causes issues for the services I’m using.

Setting a From header is easy. Its syntax is From: <email>. If you’re building any kind of scraper.

Search and Sync Your Shell History With Atuin

Caleb Hearth — Tue, 12 Nov 2024 00:00:00 +0000

Atuin is a tool that runs in the background to capture commands you’ve entered. It stores these locally in a SQLite database and provides a great CLI tool to search through that history, provide stats of what commands you frequently run, and optionally syncs this history across devices.

Atuin is one of several cool Rust tools that I’ve found in the past year or so, and is my favorite addition to my terminal workflow in a long time. Other tools that I’ve found and would like to write up soon are: Hyperfine, ripgrep, and Starship.¹ I’ve added Atuin to my /uses page with a link back to this post.

Commands are grabbed via preexec and precmd hooks that allow it to get not only the command, but the current directory, hostname, session, duration of the command, and exit code. It stores these in its SQLite database along with a timestamp, so you’re free to introspect that data yourself as well. It also leaves the shell’s history file alone, so unless you disable it yourself you’ll still have that.

Decryption/CypherError on Rails 7.1 Apps with Encrypted Columns After Upgrading from Previous Versions

Caleb Hearth — Mon, 11 Nov 2024 00:00:00 +0000

When upgrading to Rails 7.1 with any models using the encrypts macro from ActiveRecord::Encryption, be wary of upgrading the config.load_defaults in config/application.rb from 7.0 to 7.1. The 7.1 defaults for ActiveRecord::Encryption include a combination of settings that can lead to your app being unable to decrypt data that it previously encrypted:

active_record.encryption.hash_digest_class = OpenSSL::Digest::SHA256 active_record.encryption.support_sha1_for_non_deterministic_encryption = false

While the exception backtrace will probably include lines from your app, they won’t be helpful in identifying or resolving the issue except that you might notice that they include the getter method for a database column that you’ve defined with encrypts. You’ll see an error with a backtrace ending something like:

.../encryptor.rb:58:in `rescue in decrypt': ActiveRecord::Encryption::Errors::Decryption (ActiveRecord::Encryption::Errors::Decryption) .../cipher/aes256_gcm.rb:79:in `rescue in...

I Use /uses

Caleb Hearth — Fri, 08 Nov 2024 00:00:00 +0000

Back in 2023 I quietly published my /uses slashpage. Today I gave it a pass to update things that had fallen out of date.

This is another of the slashpages that I think folks should have, though it’s probably less important than an /about, /links, or even /now. A /uses page lists out gear, apps, software, and other tools that its author uses. Having something on /uses is usually an implicit endorsement of that tool, though it’s totally possible that someone uses something but wishes that it were better, knows of a nicer alternative but the cost—monetary, of switching, or otherwise—is too high.

Also that year as part of NaBloPoMo 2023 I published Apps I Use in 2023 which is sort of an extension to my /uses page with the addition of a bit of historical context in case I update it (which might be upcoming this month).

According to Robb Knight on Slash Pages, Wes Bos created the first /uses page. I aspire to the quality of Wes’ page: mine is basically a list with sections.

How to Send a Webmention h-entry

Caleb Hearth — Thu, 07 Nov 2024 00:00:00 +0000

Webmentions are a useful way to notify a website that you have linked to it. Microformats like h-entry combined with u-in-reply-to, u-like-of, u-bookmark-of, or u-repost-of give context to the mentions.

Sending a Webmention means POST-ing to a Webmention endpoint with the data source and target. The source is the URL of the page that contains a link to the URL target. Note that a standards-compliant recipient will discard Webmentions if the content of the source page does not contain a “per-media-type” mention of the target URL. For example, and HTML source might contain an <a href> or <video src> matching target URL and a JSON source could contain any key whose value exactly matches target. A plain text document would need to contain the target URL verbatim.

While simply notifying a site that you’ve mentioned or linked to it is nice, without additional context the Webmention might not be very useful. Adding context using h-entry, ideally with embedded [h-card]s.(https://microformats.org/wiki/h-card)

Ask Git to Show a Method

Caleb Hearth — Tue, 05 Nov 2024 00:00:00 +0000

If you enjoy this article on Git, also check these other Git tips:

When coding, I often find myself wanting to quickly check the details of a function or method related to what I’m working on. For instance, I might need to understand how the function handles its arguments or recall its side effects.

If you just want to know how to do this, you can jump down and skip my story.

I usually use ctags with Vim for this. A quick ], a brief read, and a <Ctrl-o> and I’m back from whence I came and more informed for my effort. Still, sometimes would be more convenient to just have the code printed right to my terminal from the command line.

If you’re here, you might remember that we previously looked at Git’s ability to walk the history of a specific method using git log -L¹. What you might not know is that git log and git show are close siblings—actually defined in the same file.

Highlighting Text in Links with Text Fragments

Caleb Hearth — Sun, 03 Nov 2024 00:00:00 +0000

I’ve used URL text fragments in a few posts now and often use it outside of this blog to point someone to a particular piece of text on a page. They’re a really useful feature that allows you to create a URL that links not just to a page or an anchor on that page, but specifically to a bit of text that you’d like to call out to your audience.

The URL Fragment Text Directive is a W3C Draft, but has been around in at least some major browsers since 2020 and now has good support across Chrome, Edge, Safari, and Firefox as of this September. Firefox was the last straggler, with Safari joining the party in 2022.

Building URLs

Despite using Safari as my daily driver for various privacy, security, performance, and platform integration reasons, I still keep Chrome around for the occasional Google Meet call and for generating these links: highlight some text and right clip to copy a link to the highlight. Safari doesn’t have that feature yet unfortunately.