ruby 41 lines · 7 steps

Coercing request params by schema in Ruby

A small class turns raw string params into typed values using a lambda-per-type lookup table and per-key options.

Explained by highlit

Intermediate lambdas type-coercion lookup-table error-handling schema

1class ParamCoercer
TYPES = {
  integer: ->(v) { Integer(v) },
  float:   ->(v) { Float(v) },
  boolean: ->(v) { %w[1 true yes on].include?(v.to_s.downcase) },
  string:  ->(v) { v.to_s.strip },
  date:    ->(v) { Date.iso8601(v) },
  array:   ->(v) { Array(v).map(&:to_s) }
}.freeze
10 
def initialize(schema)
  @schema = schema
end
14 
def coerce(params)
  @schema.each_with_object({}) do |(key, options), result|
    options = { type: options } unless options.is_a?(Hash)
    raw = params[key.to_s]
19 
    if raw.nil? || raw == ""
      result[key] = options[:default] if options.key?(:default)
      next
    end
24 
    coercer = TYPES.fetch(options[:type]) do
      raise ArgumentError, "unknown type #{options[:type].inspect} for #{key}"
    end
28 
    value = coercer.call(raw)
30 
    if (allowed = options[:in]) && !allowed.include?(value)
      result[key] = options[:default] if options.key?(:default)
      next
    end
35 
    result[key] = value
  rescue ArgumentError, TypeError, Date::Error
    result[key] = options[:default] if options.key?(:default)
  end
end
41end

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1A frozen hash of lambdas is a clean way to dispatch behavior by a symbol key instead of a case statement.
2Normalizing shorthand options into a full hash lets callers use either a bare type or a rich config.
3Wrapping coercion in a rescue turns conversion failures into graceful defaults rather than crashes.

Related explainers

python

import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path

Parallel file downloads with a thread pool

concurrency thread-pool streaming-io

Intermediate 8 steps

package validate
 
import (
	"fmt"

Struct validation with reflection in Go

reflection struct-tags validation

Intermediate 7 steps

rust

use std::env;
use std::time::Duration;
 
#[derive(Debug, Clone)]

Loading typed config from environment variables in Rust

configuration error-handling generics

Intermediate 7 steps

ruby

module Api
  module V2
    class ArticlesController < Api::BaseController
      before_action :set_article, only: %i[show update destroy]

Building a versioned JSON API controller in Rails

rest-api serialization pagination

Intermediate 10 steps

python

import shutil
import uuid
from pathlib import Path

Safe avatar uploads in FastAPI

file-upload validation streaming

Intermediate 8 steps

javascript

async function copyToClipboard(text) {
  if (navigator.clipboard && window.isSecureContext) {
    try {
      await navigator.clipboard.writeText(text);