Kasper Timm Hansen

@kaspth.com

Rails core alumni, principle consultant at https://spinel.coop where we do https://rv.dev and help teams level up. Creator & maintainer of Oaken, and other next-gen Rails extensions.

4.0.5 ~/code/kaspth/oaken-demo oaken * rv ci
Archive /Users/kasperhansen/.cache/rv/ruby-v0/tarballs/49e7048cddefe3c4.tar.gz already exists, skipping download.
Installed Ruby version 3.4.5 to /Users/kasperhansen/.local/share/rv/rubies
4 gems already installed in /Users/kasperhansen/.local/share/rv/rubies/ruby-3.4.5/lib/ruby/gems/3.4.0, skipping installation. Use --force if you want to install these gems again.
68 gems installed to /Users/kasperhansen/.local/share/rv/rubies/ruby-3.4.5/lib/ruby/gems/3.4.0:
- 1.6s fetching 68 gems from gem servers (47 cached, 21 downloaded), 0 from git repos, 0 from local paths
- 0.5s unpacking 68 gems from gem servers
- 5.7s compiling 10 native extensions (0 cached)
- 7.7s total

class User::EmailVerification < ActiveRecord::AssociatedObject
has_mailer to: :user, subject: "Verify your email and sign in"
end

# Impromptu state machine for states that don't need to be represented forever?
# E.g. info.orchestrate_into :pending, key: 1 # or a date?
class Operation < ApplicationRecord
end

# Track moves on a given record? E.g. order -> pending -> shipping and back
class Statement::Move < ApplicationRecord
end

$default_scope { select(*column_names.without("versions_contents")) } def append(envelope) versions_contents << envelope save! end def versions_contents read_unloaded_attribute __method__ end$

class DigestedIO < Data.define(:buffer, :digest)
def initialize(buffer: StringIO.new, digest: Digest::MD5.new) = super
delegate :string, to: :buffer
delegate :hexdigest, to: :digest

def consume(enumerable, &)
enumerable.inject(self) { |buf, value| buf << yield(value) }
end

def <<(chunk)
buffer << chunk
digest << chunk
self
end
end

class ApplicationJob < ActiveJob::Base
class_attribute :discard_by_stale_value_proc
attr_accessor :discard_value

# performs :rebuild, wait: 1.minute, discard_stale: :updated_at
# wonder if we just use cache_version by default?
def self.discard_stale(discard_attribute)
self.discard_by_stale_value_proc = discard_attribute.to_proc
end

def serialize
if value = current_discard_value
super.merge("discard_value" => ActiveJob::Arguments.serialize_argument(value))
else
super
end
end

def deserialize(job_data)
super
self.discard_value = ActiveJob::Arguments.send :deserialize_argument, job_data["discard_value"]
end

before_perform :discard_by_stale_value, if: :discard_by_stale_value_proc

private
def discard_by_stale_value
p discard_value >= current_discard_value
throw :abort unless discard_value >= current_discard_value
end

def current_discard_value
discard_by_stale_value_proc&.call(arguments.first)
end
end

README

Clone the repo, cd into it and run bin/setup to get started:

bin/setup
Options:

--reset resets the database via bin/rails db:reset
--dev runs bin/dev to boot the development server.
Tip

bin/sq lets you query a running server a little more easily, click the link for samples.
Dependencies

homebrew, we're assuming a working Homebrew installation.
puma-dev, set it up and run puma-dev link from the root dir to setup accessing the app via http:peak.test.
Quick Start

We're using Oaken to use code as documentation for our domain model.

So what you see in db/seeds is both what gets run via db:prepare in bin/setup (which runs db:seed), and also the data we test with.

To get up to speed, start reading db/seeds

#!/usr/bin/env sh

# run a server-query like this:
# bin/sq versions

# forwards rest arguments onto curl, so stuff like `bin/sq versions --head` works.
curl http://peak.test/$1 ${@: 2}

$class StructureUpdatedJob < ApplicationJob def self.debounce_perform_later(structure, wait: 1.minute) debounce_for(structure, wait) { set(wait:).perform_later(structure) } end def self.debounce_for(structure, wait) debouncer = Kredis.counter "#{name.underscore}:#{structure.cache_key}", expires_in: wait yield if debouncer.increment == 1 # `increment` returns 1 on the first increment in an expiry period. end end$

$module ActiveModel::Attributes def self.define_on(owner, *strings, **attributes) owner.include self strings.index_with(:string).chain(attributes).each { owner.attribute _1, _2 } end end class Post ActiveModel::Attributes.define_on self, :name, :summary, starts_on: :date end$

$# include ActiveModel::Attributes(:name, :summary, starts_on: :date) def self.Attributes(*strings, **attributes) = Module.new do extend ActiveSupport::Concern; include ActiveModel::Attributes; included do strings.index_with(:string).chain(attributes).each { attribute _1, _2 } end end$

A US map showing the locations in the post with the text "XO Ruby is hitting the road!"

active_record-associated_object 51,992 downloads
active_job-performs 39,849 downloads
oaken 29,492 downloads
action_controller-stashed_redirects 7,035 downloads

$module PointFactory REFERENCE_SYSTEM = 4326 def self.build(...) = nil raw_point_factory = RGeo::Geographic.spherical_factory(srid: REFERENCE_SYSTEM) define_singleton_method(:raw_point_factory) { raw_point_factory } end$

A pull request showing about 70 lines saved by slimming the seeds down.

| gem | files | loc |
|--------------------|-------|------|
| activerecord-8.0.2 | 8 | 822 |
| factory_bot-6.5.1 | 52 | 1883 |
| fabrication-2.31.0 | 30 | 1141 |
| test_data-0.3.2 | 44 | 1297 |
| oaken-0.7.1 | 10 | 265 |

Gonzo sitting crosslegged on a stool wearing a red suit and looking stunned.

Kasper: How'd you like the deep-dive, was it helpful for what you're looking into with ERB + partials?

Garrett: Definitely. It helped provide a lot of context about how and why things are the way they are. The Rails documentation and source code is great for showing how something can be done, but there’s always a tinge of doubt in my head about whether I’m using a feature as intended or not.

A promotional image of my RailsConf talk Yes, You Can Work on Rails &
any other Gem

Fresh Willem Dafoe on the left with text "Ok I'll submit to the CFP"
Exhausted Willem Dafoe on the right with text "5 min into writing"

t ->/Applications/WezTerm.app
o ->
1 ->/Applications/1password.app
a ->/Applications/Arc.app
c ->/Applications/Google Chrome.app
s ->/Applications/Safari.app
e ->/System/Applications/Mail.app
z ->/Applications/Slack.app
i ->/System/Applications/Music.app
n ->/Applications/Notion.app
t ->/Applications/WezTerm.app
m ->/System/Applications/Messages.app
o ->/Applications/Obsidian.app
r ->
e ->raycast://extensions/raycast/emoji-symbols/search-emoji-symbols
p ->raycast://confetti
c ->raycast://extensions/raycast/system/open-camera
v ->raycast://extensions/raycast/clipboard-history/clipboard-history
s ->
l ->raycast://extensions/raycast/system/lock-screen
s ->raycast://extensions/raycast/system/sleep
a ->/Users/mikker/Applications/DarkMode.app
w ->
f ->raycast://extensions/raycast/window-management/maximize
h ->raycast://extensions/raycast/window-management/left-half
l ->raycast://extensions/raycast/window-management/right-half
o ->raycast://extensions/raycast/window-management/last-two-thirds
n ->raycast://extensions/raycast/window-management/first-third
- ->raycast://extensions/raycast/window-management/center
= ->raycast://extensions/raycast/window-management/maximize-height

$direct :record do |record| case record when then [:account_member, record] # … else url_for(record) end end resolve("Accounts::Member") { [:account_member] } # …$

active_record-associated_object 0.8.3 25,623 DOWNLOADS
active_job-performs 0.3.2 19,418 DOWNLOADS
oaken 0.7.1 7,958 DOWNLOADS

VERSIONS:
0.3.2 December 16, 2024 (11.5 KB)
0.3.1 May 27, 2024 (10.5 KB)
0.3.0 November 04, 2023 (9.5 KB)
0.2.0 January 12, 2023 (9 KB)
0.1.1 September 27, 2022 (8.5 KB)

$ActiveJob::Performs ActiveJob::Performs adds a performs class method to make the model + job loop vastly more conventional. You use it like this: class Post < ApplicationRecord performs :publish # Or `performs def publish`! def publish # Some logic to publish a post end end Then we build a job for the instance method and define a post.publish_later instance method, and more: class Post < ApplicationRecord class Job < ApplicationJob; end # We build a general Job class to share configuration between method jobs. # Individual method jobs inherit from the `Post::Job` defined above. class PublishJob < Job # We generate the required `perform` method passing in the `post` and calling `publish` on it. def perform(post, *, **) = post.publish(*, **) end # On Rails 7.1, where `ActiveJob.perform_all_later` exists, we also generate # a bulk method to enqueue many jobs at once. So you can do this: # # Post.unpublished.in_batches.each(&:publish_later_bulk) def self.publish_later_bulk ActiveJob.perform_all_later all.map { PublishJob.new(_1) } end # We generate `publish_later` to wrap the job execution forwarding arguments and options. def publish_later(*, **) = PublishJob.perform_later(self, *, **) def publish # Some logic to publish a post. end end$