raindown 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d8b4a4baae078b6b14f7ae6fd66dde441f97776e7107a07864ca4c12beebb74
-  data.tar.gz: 582a5012c02638f89991497cc789ef9513e7c13262445784c40ddb026b246574
+  metadata.gz: 6ea9df31d83ebabf0649ad353b75e2f2546aeb10c31aa97038bdd85f5e45fd2c
+  data.tar.gz: cc736f0d57e576c476629bfa7fe37405139cb1b880e86908e71e7e8d8b22926c
 SHA512:
-  metadata.gz: 1e8fc0825e5462616ce435e35188f5d41b45b23fdbbb59ff840c140cf46279de4a0e696def346a92f168dc6e04e97d1bcac9e309b1db3d9219fe59eeaadad52a
-  data.tar.gz: 5025d3381c0e0e2049a6b5fe462102438226feaa2d1a563c89b34dde74b1679163071d4df43e61d3a261e489ed71a107ae925db7f4cf08f1b9e83e773b45b46c
+  metadata.gz: 851438f9079a944aca1dc2f97d0c5081822d0ce31df12e536ca10dce8d471233ee0879fc91b7004fcf7949159554dec7cd0d1e4aa3d50b8cee4009dbd3180766
+  data.tar.gz: 27863d35bb59084303144bdc0b1ea3852028a55c854e8142456c3e1d8f9ee495a3d5489dc00c91ce474bcd9eda833deb42d4f3696118bb24c25e913dabb54372

data/lib/raindown/actions.rb

@@ -12,6 +12,7 @@ module Raindown
   # Each returns true when the file changed, and raises when it can't, for the tool to show.
   module Actions
     class NotAnEndpoint < StandardError; end
+    class FailedCheck < StandardError; end
 
     # Editors that open a file at a line with "path:line" rather than "+line path".
     PATH_LINE_EDITORS = %w[hx helix subl zed].freeze
@@ -23,20 +24,25 @@ module Raindown
     # Writes back the whole file, like saving it while it's watched, with bare directives allowed, and endpoints with no
     # response run, when asked, like with --bare and -x.
     def write_back(path, bare: false, execute: false)
-      Rewriter.update(path:, bare:, execute:, metadata: Pages.for(path))
+      Rewriter.update(path:, bare:, execute:, metadata: Pages.for(path)).changed?
     end
 
-    # Runs one endpoint's request and writes its response, replacing any response it had.
+    # Runs one endpoint's request and writes its response, replacing any response it had, then raises when the response
+    # fails its checks, like status: 200.
     def execute(path, directive)
-      raise NotAnEndpoint, "#{directive.name} on line #{directive.line} isn't an endpoint" unless directive.endpoint?
-      raise NotAnEndpoint, "The endpoint on line #{directive.line} only renders, so put it in comments to run it" unless directive.writes
-
+      check_runnable(directive)
       content = Utils.read_markdown(path)
-      rewritten = EndpointRunner.new(content:, path:, bare: BareDirectives.enabled?(path:, content:), only: directive.line - 1).rewrite
-      return false if rewritten == content
+      runner = EndpointRunner.new(content:, path:, bare: BareDirectives.enabled?(path:, content:), only: directive.line - 1)
+      rewritten = runner.rewrite
+      File.write(path, rewritten) unless rewritten == content
+      raise FailedCheck, runner.failures.join("\n") if runner.failures.any?
 
-      File.write(path, rewritten)
-      true
+      rewritten != content
+    end
+
+    def check_runnable(directive)
+      raise NotAnEndpoint, "#{directive.name} on line #{directive.line} isn't an endpoint" unless directive.endpoint?
+      raise NotAnEndpoint, "The endpoint on line #{directive.line} only renders, so put it in comments to run it" unless directive.writes
     end
 
     # The command that opens the file at a line in the person's editor, like ["vim", "+12", "notes.md"].

data/lib/raindown/bare_directives.rb

@@ -2,6 +2,7 @@
 
 require_relative 'code_blocks'
 require_relative 'directives'
+require_relative 'endpoint/schema_block'
 require_relative 'front_matter'
 
 module Raindown
@@ -10,6 +11,8 @@ module Raindown
   # matter, or with the --bare flag. Nodes like toc: and files: are handled by NodeBlocks, before the rest.
   # Template directives, like if: and for:, are always in Antlers' delimiters, so they're never bare.
   #
+  # A bare schema: shows in bold, with its fields in a code block below it.
+  #
   # Bare directives have no end tag. A bare endpoint closes itself after its curl snippet and response, so where it
   # needs more than that, write it in comments with an end tag instead:
   #   <!-- endpoint: -->
@@ -65,6 +68,9 @@ module Raindown
     # Returns the index of the last line it handled. That's the directive itself, so the lines it holds
     # are expanded too, and a bare directive inside it closes before it does.
     def expand_line(lines, index)
+      schema = SchemaBlock.at(lines, index, bare: true)
+      return expand_schema(lines, index, schema) if schema
+
       match = lines[index].match(LINE)
       return index unless match
 
@@ -73,6 +79,14 @@ module Raindown
       index
     end
 
+    # Returns the index of the code block's last line.
+    def expand_schema(lines, index, schema)
+      indent = schema.fields.first.to_s[/\A[ \t]*/]
+      block = [Directives.marker(lines[index], shown: true), "\n```\n", *schema.fields.map { it.delete_prefix(indent) }, "```\n"]
+      lines[index..schema.last] = block
+      index + block.length - 1
+    end
+
     # The end tag after the block, then the end tag in bold, as a bare directive's shown.
     def close_block(lines, index, indent:, keyword:)
       last = public_send(BLOCK_KEYWORDS[keyword], lines, index + 1) || index

data/lib/raindown/blueprints.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'json'
 require 'time'
 require 'unicode/display_width'
 require_relative 'projects'
 
 module Raindown
-  # Blueprints from Claude Code's replies, kept in a project's .raindown/blueprints.md, which the terminal UI's Blueprints page
+  # Blueprints from Claude Code's replies, kept in a project's .raindown/data/blueprints.md, which the terminal UI's Blueprints page
   # shows, newest first. Each is a code block under a heading of when it was saved and its kind:
   #   ## 2026-10-30T03:14:07Z · mockup
   #
@@ -32,7 +33,7 @@ module Raindown
         "#{time.sub('T', ' ').sub(/:\d\dZ\z/, ' UTC')}#{SEPARATOR}#{kind}"
       end
 
-      # As it's saved in .raindown/blueprints.md, under when it was saved and its kind, then its description.
+      # As it's saved in .raindown/data/blueprints.md, under when it was saved and its kind, then its description.
       def markdown(saved_at)
         about = "#{description}\n\n" if description
         "## #{saved_at}#{SEPARATOR}#{kind}\n\n#{about}```#{kind}\n#{lines.join("\n")}\n```\n\n"
@@ -49,7 +50,7 @@ module Raindown
       def distance(other) = [(top - other.top).abs, (left + right - other.left - other.right).abs]
     end
 
-    FILE = File.join('.raindown', 'blueprints.md')
+    FILE = File.join('.raindown', 'data', 'blueprints.md')
     # The kinds a code block can be marked with to be a blueprint.
     KINDS = %w[mockup diagram chart table other].freeze
     # What a blueprint's drawn with: lines, like boxes' and arrows', and blocks, like charts' bars.
@@ -79,8 +80,7 @@ module Raindown
       return [] unless File.exist?(path)
 
       lines = File.readlines(path, chomp: true)
-      starts = lines.each_index.select { lines[it].start_with?('## ') }
-      starts.filter_map { |start| blueprint(lines, start) }.reverse
+      lines.each_index.select { lines[it].start_with?('## ') }.filter_map { blueprint(lines, it) }.reverse
     end
 
     # Saves the blueprints in Claude Code's last reply, from its Stop hook's JSON, to the project it's working in, if any,
@@ -91,7 +91,8 @@ module Raindown
       return if drawn.empty?
 
       time = Time.now.utc.iso8601
-      File.open(File.join(root, FILE), 'a') { |file| drawn.each { file.write(it.markdown(time)) } }
+      path = File.join(root, FILE).tap { FileUtils.mkdir_p(File.dirname(it)) }
+      File.open(path, 'a') { |file| drawn.each { file.write(it.markdown(time)) } }
     end
 
     # The text's code blocks that are blueprints, each with its kind and the paragraph above it.

data/lib/raindown/cli.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
 require 'fileutils'
+require 'open3'
+require 'tmpdir'
 require 'trees'
 require_relative '../raindown'
 require_relative '../version'
 require_relative 'blueprints'
+require_relative 'editing'
 require_relative 'rewriter'
+require_relative 'server'
 require_relative 'watcher/file_watcher'
 require_relative 'watcher/supervisor'
 
@@ -28,34 +32,38 @@ module Raindown
                             PATH is a file, or a directory (default: current directory) whose projects with a
                             .raindown folder are watched
         init [DIRECTORY]    Create a .raindown folder for the project's config and nodes (default: current directory)
-        blueprints            Save the blueprints in Claude Code's last reply to .raindown/blueprints.md, for the terminal
+        server              Keep Raindown loaded for an editor, answering a JSON request a line on stdin with its HTML,
+                            or its Markdown as it would be written back, like --stdin and --stdin --rewrite
+        blueprints            Save the blueprints in Claude Code's last reply to .raindown/data/blueprints.md, for the terminal
                             UI's Blueprints page, as a Stop hook that's given the hook's JSON
 
       Options:
-        --html [OUTPUT]     Render FILE to HTML once, writing to OUTPUT or else printing to stdout
+        --html [OUTPUT]     Render FILE to HTML once, writing to OUTPUT, or to stdout without one or with -, then exit with 1
+                            if its endpoint responses fail their status: or schema: checks
         --stdin             Render Markdown from stdin to HTML once, without formatting FILE, which only needs
                             its extension (to allow bare directives) and can be unsaved. Add --html OUTPUT to write a file
+        --rewrite           With --stdin, print its Markdown as it would be written back to FILE, without writing
+                            FILE, for editors like Obsidian. Add -x to run its endpoints
         --bare              Allow bare directives like :toc in Markdown files
         -x, --execute       Run endpoint curl snippets that have no output yet, as files are written back
-        --env NAME          Fill endpoint snippets from the NAME environment in .raindown/environments.yml
+        --env NAME          Fill endpoint snippets from the NAME environment in .raindown/environments.yml and
+                            environments.local.yml
         -h, --help          Show this message
         -v, --version       Show the version
 
       Set RAINDOWN_DEBUG=1 to show where an error happened.
     TEXT
 
-    CONFIG = <<~YAML
-      # Raindown project settings. See https://raindown.dev/docs/config
-      #
-      # Leave code blocks unhighlighted, so the browser can highlight them instead:
-      # highlight_code: false
-    YAML
+    # The files "raindown init" puts in a project's .raindown folder, like "rain new" clones raindeer-template.
+    TEMPLATE_URL = 'https://github.com/rainpour/raindown-init'
 
     # A path opens the terminal UI, or after "watch" it's watched, and with --html or --stdin it's rendered. The flags
     # are keyword arguments, in any order, like -x for x:, and --html is the OUTPUT when it's given one.
-    line(':path') do |path, html: nil, stdin: false, bare: false, execute: false, x: false, env: nil| # rubocop:disable Metrics/ParameterLists -- each keyword is a flag
+    line(':path') do |path, html: nil, stdin: false, rewrite: false, bare: false, execute: false, x: false, env: nil| # rubocop:disable Metrics/ParameterLists -- each keyword is a flag
       execute do
         ENV['RAINDOWN_ENV'] = env if env
+        next rewrite_stdin(path, bare:, execute: execute || x) if stdin && rewrite
+
         open_path(path, html:, stdin:, bare:, execute: execute || x)
       end
     end
@@ -87,6 +95,7 @@ module Raindown
       if argv.intersect?(%w[-v --version]) then puts(VERSION)
       elsif argv.first == 'init' && argv.size <= 2 then init(argv[1])
       elsif argv == ['blueprints'] then Blueprints.save(JSON.parse($stdin.read))
+      elsif argv == ['server'] then serve
       else return false
       end
 
@@ -100,16 +109,22 @@ module Raindown
       abort("raindown: #{path}: #{error.message}")
     end
 
-    # Creates the .raindown folder that marks a project's root and holds its config.yml and nodes.
+    # Clones raindown-init into the .raindown folder that marks a project's root and holds its config.yml and nodes,
+    # keeping any files already there.
     def self.init(directory = nil)
       folder = File.join(directory || Dir.pwd, Nodes::FOLDER)
       config = File.join(folder, Config::FILE)
       return puts("#{config} already exists") if File.exist?(config)
 
-      FileUtils.mkdir_p(folder)
-      File.write(config, CONFIG)
+      Dir.mktmpdir do |clone|
+        clone_template(clone)
+        FileUtils.mkdir_p(folder)
+        (Dir.children(clone) - ['.git']).each do |name|
+          FileUtils.cp_r(File.join(clone, name), folder) unless File.exist?(File.join(folder, name))
+        end
+      end
       puts "Created #{config}"
-      puts 'Put your own nodes in the same folder. See https://raindown.dev/docs/nodes'
+      puts 'Put your own nodes in the same folder. See https://raindown.dev/docs/components'
     end
 
     # The terminal UI loads curses, so it's only required when it starts. Without a terminal, the path's watched instead.
@@ -123,9 +138,14 @@ module Raindown
     class << self
       private
 
-      # Endpoints run while formatting, which --stdin skips, so -x can't go with it.
+      def clone_template(directory)
+        output, status = Open3.capture2e('git', 'clone', '--quiet', '--depth', '1', TEMPLATE_URL, directory)
+        abort("Couldn't clone #{TEMPLATE_URL}:\n#{output}") unless status.success?
+      end
+
+      # Endpoints run while formatting, which --stdin skips, so -x can't go with it. --html - prints, like --html.
       def open_path(path, html:, stdin:, bare:, execute:)
-        output = html unless html == true
+        output = html unless [true, '-'].include?(html)
         abort("-x runs endpoints as the file's formatted, which --stdin doesn't do\n\n#{USAGE}") if stdin && execute
         return render_stdin(path, output, bare:) if stdin
         return render(path, output, bare:, execute:) if html
@@ -139,14 +159,29 @@ module Raindown
         Nodes.load(path)
 
         metadata = Pages.for(path)
-        Rewriter.update(path:, bare:, execute:, metadata:)
+        failures = Rewriter.update(path:, bare:, execute:, metadata:).failures
         write(output, Raindown.render_file(path:, bare:, metadata:))
+        check_endpoints(failures)
+      end
+
+      # Endpoint responses that fail their checks, like status: 200, are listed, and fail the command, for CI.
+      def check_endpoints(failures)
+        return if failures.empty?
+
+        warn(*failures.map { "Endpoint check failed: #{it}" })
+        exit 1
+      end
+
+      # The Markdown from stdin written back as it would be to the file, and its failed endpoint checks, for an editor
+      # to apply to what it's editing.
+      def rewrite_stdin(path, bare:, execute:)
+        rewritten = Editing.rewrite_markdown($stdin.read, path:, bare:, execute:)
+        $stdout.write(rewritten[:output])
+        warn(*rewritten[:warnings])
       end
 
       def render_stdin(path, output = nil, bare: false, **)
-        Nodes.load(path)
-        write(output, Raindown.render(markdown: $stdin.read, metadata: Pages.for(path), bare: bare || BareDirectives.file?(path),
-                                      **Config.render_options(path)))
+        write(output, Editing.render_markdown($stdin.read, path:, bare:))
       end
 
       # Watching only writes back to the files, while --html and --stdin render HTML.
@@ -158,6 +193,13 @@ module Raindown
         Watcher::FileWatcher.new(path:, bare:, execute:).start
       end
 
+      # The answers have stdout to themselves, so what nodes print goes to stderr.
+      def serve
+        output = $stdout.dup
+        $stdout.reopen($stderr)
+        Server.new(output:).start
+      end
+
       def write(output, html)
         output ? File.write(output, html) : puts(html)
       end

data/lib/raindown/code_blocks.rb

@@ -5,6 +5,8 @@ module Raindown
   module CodeBlocks
     FENCE = /\A {0,3}(`{3,}|~{3,})[ \t]*(\S*)/
     SNIPPET_LANGUAGES = %w[sh bash shell zsh console curl].freeze
+    # The line closing a fence, like ``` or ~~~~, compiled once per fence.
+    CLOSINGS = Hash.new { |closings, fence| closings[fence] = /\A {0,3}#{fence[0]}{#{fence.length},}[ \t]*$/ }
 
     module_function
 
@@ -13,7 +15,7 @@ module Raindown
       fence, language = lines[index]&.match(FENCE)&.captures
       return unless fence
 
-      close = (index + 1...lines.length).find { |i| lines[i].match?(/\A {0,3}#{fence[0]}{#{fence.length},}[ \t]*$/) }
+      close = (index + 1...lines.length).find { |i| lines[i].match?(CLOSINGS[fence]) }
       { open: index, close:, language:, body: lines[index + 1...close].join } if close
     end
 

data/lib/raindown/directives.rb

@@ -31,16 +31,20 @@ module Raindown
     # Whether the directive's line is bare, without delimiters, so it shows in bold.
     def bare?(line) = text(line) == line.strip
 
-    # A directive's line as a marker: in bold when it's shown, like a bare directive, or else hidden.
+    # A directive's line as a marker: in bold when it's shown, like a bare directive, or else hidden. Its braces are
+    # hidden from Antlers like code's, so a shown chart: {stats} shows as it's written.
     def marker(line, shown: bare?(line))
-      text = text(line).gsub('--', '- -')
+      text = text(line).gsub('--', '- -').gsub(/[{}]/, CODE_BRACES)
       return "<!-- raindown:hidden #{text} -->" unless shown
 
       "<!-- raindown:directive #{text} -->"
     end
 
+    # The braces' entities, like code's, are kept as they are.
     def render(html)
-      html.gsub(HIDDEN, '').gsub(MARKER) { "<p><strong>#{CGI.escapeHTML(::Regexp.last_match(1).to_s)}</strong></p>" }
+      html.gsub(HIDDEN, '').gsub(MARKER) do
+        "<p><strong>#{CGI.escapeHTML(::Regexp.last_match(1).to_s).gsub(/&amp;(#12[35];)/, '&\1')}</strong></p>"
+      end
     end
   end
 end

data/lib/raindown/editing.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../raindown'
+require_relative 'rewriter'
+
+module Raindown
+  # What an editor asks of Raindown about Markdown it's editing, which needn't be saved: its HTML, or the Markdown as it
+  # would be written back to the file, with its failed endpoint checks. "raindown FILE --stdin" and "raindown server"
+  # both answer with it.
+  module Editing
+    module_function
+
+    def render_markdown(markdown, path:, bare: false)
+      Nodes.load(path)
+      Raindown.render(markdown:, metadata: Pages.for(path), bare: bare || BareDirectives.file?(path), **Config.render_options(path))
+    end
+
+    def rewrite_markdown(markdown, path:, bare: false, execute: false)
+      Nodes.load(path)
+      rewrite = Rewriter.rewrite(content: markdown, path:, bare:, execute:, metadata: Pages.for(path))
+      { output: rewrite.content, warnings: rewrite.failures.map { "Endpoint check failed: #{it}" } }
+    end
+  end
+end

data/lib/raindown/endpoint/curl.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require 'ipaddr'
-require 'json'
 require 'open3'
 require 'shellwords'
 require 'socket'
 require 'uri'
+require_relative 'curl_response'
 
 module Raindown
   # Runs a curl snippet with the curl binary. There's no shell, so pipes, redirects and variables don't apply.
@@ -48,28 +48,17 @@ module Raindown
       '--data-urlencode' => :no_urlencoded_file
     }.freeze
 
-    # Separates the response body from the content type that --write-out appends.
-    TYPE_MARKER = "\n--raindown-content-type--"
-    WRITE_OUT = "#{TYPE_MARKER}%{content_type}".freeze # rubocop:disable Style/FormatStringToken -- curl's syntax, not Ruby's
-    LANGUAGES = {
-      /json/ => 'json', /xml/ => 'xml', /html/ => 'html', /javascript/ => 'javascript',
-      /css/ => 'css', /yaml/ => 'yaml', %r{\Atext/plain} => 'text'
-    }.freeze
-
     module_function
 
-    # Returns the response body and the code block language for its content type.
+    # Returns the Response, with the code block language for its content type.
     # Placeholders like {base_url} are replaced from the variables, word by word, so a value can't add options.
     def run(snippet, variables = nil)
       args = arguments(snippet, variables)
       stdout, stderr, status = Open3.capture3('curl', *SAFE_OPTIONS, '--silent', '--show-error', '--max-time', TIMEOUT,
-                                              *resolve_options(args), *args, '--write-out', WRITE_OUT)
+                                              *resolve_options(args), *args, '--write-out', Response::WRITE_OUT)
       raise Error, stderr.strip.empty? ? "curl exited with #{status.exitstatus}" : stderr.strip unless status.success?
 
-      body, _, content_type = stdout.rpartition(TYPE_MARKER)
-      language = language(content_type)
-
-      [language == 'json' ? pretty_json(body) : body, language]
+      Response.parse(stdout)
     rescue Errno::ENOENT
       raise Error, 'curl is not installed'
     end
@@ -213,15 +202,5 @@ module Raindown
     rescue SocketError => e
       raise Error, "Can't resolve #{host}: #{e.message}"
     end
-
-    def language(content_type)
-      LANGUAGES.find { |pattern, _| content_type.match?(pattern) }&.last || ''
-    end
-
-    def pretty_json(body)
-      JSON.pretty_generate(JSON.parse(body))
-    rescue JSON::ParserError
-      body
-    end
   end
 end

data/lib/raindown/endpoint/curl_response.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Raindown
+  module Curl
+    # A response's body, its code block language, and its status code and time, like 200 in 142 milliseconds,
+    # read from what curl prints with --write-out WRITE_OUT.
+    class Response < Data.define(:body, :language, :status, :milliseconds)
+      # Separates the response body from the status, time and content type that --write-out appends.
+      INFO_MARKER = "\n--raindown-response-info--"
+      WRITE_OUT = "#{INFO_MARKER}%{http_code} %{time_total} %{content_type}".freeze # rubocop:disable Style/FormatStringToken -- curl's syntax, not Ruby's
+      LANGUAGES = {
+        /json/ => 'json', /xml/ => 'xml', /html/ => 'html', /javascript/ => 'javascript',
+        /css/ => 'css', /yaml/ => 'yaml', %r{\Atext/plain} => 'text'
+      }.freeze
+
+      # JSON is pretty-printed, and other bodies are kept as they are.
+      def self.parse(stdout)
+        body, _, info = stdout.rpartition(INFO_MARKER)
+        status, seconds, content_type = info.split(' ', 3)
+        language = LANGUAGES.find { |pattern, _| content_type.to_s.match?(pattern) }&.last || ''
+
+        new(body: language == 'json' ? pretty_json(body) : body, language:, status: status.to_i,
+            milliseconds: (seconds.to_f * 1000).round)
+      end
+
+      def self.pretty_json(body)
+        JSON.pretty_generate(JSON.parse(body))
+      rescue JSON::ParserError
+        body
+      end
+    end
+  end
+end

data/lib/raindown/endpoint/endpoint_args.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'schema_block'
+
+module Raindown
+  # An endpoint directive's arguments: as: names its response for later snippets, and status: and schema: are what its
+  # response is checked against, like "as: user status: 200 schema: Schema[id: Integer, email: String | nil]".
+  # A schema is a LowType type, read without running it, and is written with Schema[] rather than {}, which Antlers reads,
+  # or names a SchemaBlock, like schema: 'User' or schema: Array[User].
+  class EndpointArgs < Data.define(:name, :status, :schema)
+    KEYWORDS = %w[as: status: schema:].freeze
+
+    def self.parse(text, schemas: {})
+      values = keyword_values(text.to_s)
+      new(name: values['as'], status: values['status']&.then { Integer(it, exception: false) },
+          schema: values['schema']&.then { SchemaBlock.resolve(it, schemas) })
+    end
+
+    # Each keyword's words, up to the next keyword outside brackets, so a schema's own keys, like Schema[status: Integer],
+    # stay in it.
+    def self.keyword_values(text)
+      values = {}
+      key = nil
+      depth = 0
+
+      text.split.each do |word|
+        next values[key = word.delete_suffix(':')] = [] if depth.zero? && KEYWORDS.include?(word)
+        next unless key
+
+        values[key] << word
+        depth += word.count('[(') - word.count('])')
+      end
+
+      values.transform_values { it.join(' ') }
+    end
+
+    # What's wrong with a response, like "expected status 200, received 404" or "id: expected Integer, received "1"".
+    # A response fetched before statuses were kept has no status to check.
+    def failures(body:, status:)
+      failures = []
+      failures << "expected status #{self.status}, received #{status}" if self.status && status && status != self.status
+      failures.concat(schema_failures(body)) if schema
+      failures
+    end
+
+    private
+
+    # LowType is only loaded for an endpoint with a schema.
+    def schema_failures(body)
+      require 'lowtype'
+
+      Low::TypeParser.parse(schema).errors(data(body)).map do |node|
+        "#{node.path.to_s.empty? ? 'response' : node.path}: expected #{node.expected}, received #{node.received}"
+      end
+    rescue Low::ParseError => e
+      ["schema: #{e.message}"]
+    end
+
+    def data(body)
+      JSON.parse(body)
+    rescue JSON::ParserError
+      body.strip
+    end
+  end
+end