ruby · level 3 check

a rule-checking tool with its own DSL.

Time to ship a real tool. Sign-up forms send in records such as `name=Ana, age=30, email=ana@example.com`, one per line. Your checker reads them with `while (line = gets)`, which keeps going until `gets` hands back `nil`, checks each record against a rule book, and prints a verdict for every line, then a summary such as `2 of 3 records valid`.

The rules live in a small DSL at the top of the program: `field :age, required: true do` with `number 13..120` inside. `RuleBook.define` runs that block with `instance_eval`, each `field` gets its own `FieldBuilder`, and every rule becomes a `Rule` value made with `Data.define`. Pattern matching splits each `key=value` pair, and the finished rule book is frozen so nothing can change it later.

A shipped tool never falls over on bad input. Blank lines are skipped, a line it cannot read is quoted back, unknown fields are named, each field reports only its first problem, and no input at all gets a friendly message. Fill in each `____`, run it, then type some records of your own.

Your program

Rule = Data.define(:message, :test)

Field = Data.define(:name, :required, :rules) do
  def problem(value)
    if value.nil? || value.empty?
      return "#{name} is required" if required
      return nil
    end
    broken = rules.find { |rule| !rule.test.____(value) }
    "#{name} #{broken.message}" if broken
  end
end

class FieldBuilder
  attr_reader :rules

def initialize
    @rules = []
  end

def rule(message, &test)
    @rules << Rule.new(message: message, test: ____)
  end

def length(range)
    rule("must be #{range.min} to #{range.max} characters") { |value| range.include?(value.length) }
  end

def number(range)
    rule("must be a whole number") { |value| value.to_i.to_s == value }
    rule("must be from #{range.min} to #{range.max}") { |value| range.include?(value.to_i) }
  end

def contains(text)
    rule("must contain #{text}") { |value| value.include?(text) }
  end
end

class RuleBook
  def self.define(&block)
    book = new
    book.____(&block)
    book.fields.freeze
    book.freeze
  end

attr_reader :fields

def initialize
    @fields = []
  end

def field(name, required: false, &block)
    builder = FieldBuilder.new
    builder.instance_eval(&block) if block
    @fields << Field.new(name: name, required: required, rules: builder.rules.freeze)
  end

def problems(record)
    names = @fields.map(&:name)
    found = @fields.map { |field| field.problem(record[field.name]) }.reject(&:nil?)
    unknown = record.keys.reject { |key| names.include?(key) }
    found + unknown.map { |key| "#{key} is not a known field" }
  end
end

SIGNUP = RuleBook.define do
  field :name, required: true do
    length 2..20
  end
  field :age, required: true do
    number 13..120
  end
  field :email, required: true do
    contains "____"
  end
  field :town
end

def parse(line)
  record = {}
  line.split(",").each do |pair|
    case pair.split("=", 2).map(&:____)
    in [key, value] if !key.empty?
      record[key.to_sym] = value
    else
      return nil
    end
  end
  record
end

def verdict(book, line)
  record = parse(line)
  return "cannot read \"#{line.strip}\"" if record.nil?
  problems = book.problems(record)
  return "ok" if problems.empty?
  problems.join("; ")
end

def report(book, lines)
  filled = lines.each.with_index(1).reject { |line, number| line.strip.empty? }
  return ["No records to check."] if filled.____?
  verdicts = filled.map { |line, number| [number, verdict(book, line)] }
  valid = verdicts.count { |number, text| text == "____" }
  verdicts.map { |number, text| "Line #{number}: #{text}" } + ["#{valid} of #{verdicts.length} records valid"]
end

lines = []
while (line = gets)
  lines << line.chomp
end
puts report(SIGNUP, lines)

Fill in every ____ then run the checks.

1 It accepts a valid recorduses: DSL
2 It explains every broken fielduses: blocks and lambdas
3 It names missing fieldsuses: Data and validations
4 It copes with junk and blank linesuses: pattern matching
5 It flags unknown fields and counts the valid recordsuses: Enumerable
6 It handles no input at alluses: bad input

Take as long as you like and try as many times as you want.

a rule-checking tool with its own DSL.

level up.

playground