thundercli 0.2.0

data/lib/thunder/cli/commands/spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+require 'open3'
+require 'rbconfig'
+
+module Thunder
+  module CLI
+    module Commands
+      # A process runs one chunk, so each chunk's specs run in a process of their own, all at the same time; each
+      # one's output is printed whole when it ends. With one chunk (-c, or paths all inside one), it runs here.
+      class Spec < Command
+        EXECUTABLE = File.expand_path('../../../../exe/thunder', __dir__)
+
+        desc 'Run the specs of the chunks, each chunk in its own process, in parallel'
+
+        argument :paths, type: :array, required: false, desc: 'Spec files or folders; their chunks run'
+        option :chunk, aliases: ['-c'], desc: 'Only this chunk'
+
+        def call(paths: [], chunk: nil, **)
+          runs = runs_for(paths, chunk)
+          return out.puts('no chunk has a spec/ folder') if runs.empty?
+          return exit(run_here(*runs.first)) if runs.one?
+
+          exit(run_apart(runs))
+        end
+
+        private
+
+        # { chunk => paths }; no paths means the chunk's spec/, and a chunk without one is left out.
+        def runs_for(paths, chunk_name)
+          return { Thunder.application.chunk(chunk_name) => paths } if chunk_name
+          if paths.empty?
+            return Thunder.application.chunks.select { |chunk| chunk.root_path.join('spec').directory? }.to_h { |chunk| [chunk, []] }
+          end
+
+          paths.group_by { |path| chunk_of(path) }
+        end
+
+        def chunk_of(path)
+          full = Pathname(path).expand_path
+          Thunder.application.chunks.find { |chunk| full.ascend.include?(chunk.root_path.expand_path) } ||
+            raise(Error, "#{path} is not inside a chunk")
+        end
+
+        def run_here(chunk, paths)
+          begin
+            require 'thunderspec'
+          rescue LoadError
+            raise Error, "thunderspec is not in the bundle; add `gem 'thunderspec'` to the Gemfile's test group"
+          end
+
+          ThunderSpec::Runner.new(chunk, paths).run
+        end
+
+        def run_apart(runs)
+          threads = runs.map do |chunk, paths|
+            Thread.new do
+              output, status = Open3.capture2e(RbConfig.ruby, EXECUTABLE, 'spec', '-c', chunk.identifier.to_s, *paths)
+              [chunk, output, status]
+            end
+          end
+
+          results = threads.map(&:value)
+          results.each { |chunk, output, status| print_run(chunk, output, status) }
+          results.all? { |_, _, status| status.success? } ? 0 : 1
+        end
+
+        def print_run(chunk, output, status)
+          out.puts "== #{chunk.identifier} (#{status.success? ? 'passed' : 'failed'})"
+          out.puts output
+          out.puts
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli/commands/version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Thunder
+  module CLI
+    module Commands
+      # Not a Thunder::CLI::Command: it needs no application, env or chunk.
+      class Version < Dry::CLI::Command
+        desc 'Print the version'
+
+        def call(**)
+          out.puts "thunder #{Thunder::VERSION}"
+        end
+      end
+    end
+  end
+end

data/lib/thunder/cli.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+
+require_relative 'cli/commands/version'
+require_relative 'cli/commands/console'
+require_relative 'cli/commands/serve'
+require_relative 'cli/commands/messaging/outbox'
+require_relative 'cli/commands/messaging/consumer'
+require_relative 'cli/commands/db/create'
+require_relative 'cli/commands/db/migrate'
+require_relative 'cli/commands/db/drop'
+require_relative 'cli/commands/db/reset'
+require_relative 'cli/commands/db/setup'
+# WARN: AI MADE
+require_relative 'cli/commands/new'
+require_relative 'cli/commands/generate/command'
+require_relative 'cli/commands/generate/chunk'
+require_relative 'cli/commands/generate/operation'
+require_relative 'cli/commands/generate/model'
+require_relative 'cli/commands/generate/event'
+require_relative 'cli/commands/generate/subscriber'
+require_relative 'cli/commands/generate/outbox'
+require_relative 'cli/commands/spec'
+
+module Thunder
+  module CLI
+    extend Dry::CLI::Registry
+
+    register 'version', Commands::Version, aliases: ['-v', '--version']
+    register 'console', Commands::Console, aliases: ['c']
+    register 'serve', Commands::Serve
+    # WARN: AI MADE
+    register 'new', Commands::New
+    register 'spec', Commands::Spec
+    register 'generate', aliases: ['g'] do |generate|
+      generate.register 'chunk', Commands::Generate::Chunk
+      generate.register 'operation', Commands::Generate::Operation
+      generate.register 'model', Commands::Generate::Model
+      generate.register 'event', Commands::Generate::Event
+      generate.register 'subscriber', Commands::Generate::Subscriber
+      generate.register 'outbox', Commands::Generate::Outbox
+    end
+    register 'messaging' do |messaging|
+      messaging.register 'outbox', Commands::Messaging::Outbox
+      messaging.register 'consumer', Commands::Messaging::Consumer
+    end
+    register 'database', aliases: ['db'] do |db|
+      db.register 'create', Commands::Db::Create
+      db.register 'migrate', Commands::Db::Migrate
+      db.register 'drop', Commands::Db::Drop
+      db.register 'reset', Commands::Db::Reset
+      db.register 'setup', Commands::Db::Setup
+    end
+
+    # WARN: AI MADE
+    # Completes the command names typed in part: `g op` and `gen ope` become `generate operation`. Stops at the
+    # command; its arguments and options are left as typed. A prefix of more than one name raises Error.
+    def self.expand(arguments)
+      expanded = []
+
+      arguments.each_with_index do |word, index|
+        result = get(expanded)
+        return expanded + arguments[index..] if result.found?
+
+        next expanded << word if get(expanded + [word]).names.size > expanded.size
+
+        matches = result.children.keys.select { |name| name.start_with?(word) }
+        return expanded + arguments[index..] if matches.empty?
+        raise Error, "'#{word}' is ambiguous: #{matches.join(', ')}" if matches.size > 1
+
+        expanded << matches.first
+      end
+
+      expanded
+    end
+  end
+end

data/lib/thunder/console/backtrace.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    # IRB's backtrace filter: keeps the lines of the application and of the framework, relative paths, and drops gems
+    # and the console and CLI that run the evaluation. When nothing is left, the first lines are kept as they were.
+    class Backtrace
+      FRAMEWORK = %r{/(thunder|thunderchunk|thunderoperation|thunderframe|thunderfoundation)(-[\d.]+)?/(lib/.*)\z}
+      RUNNER = %r{\Alib/thunder/(console|cli)}
+
+      def initialize(root)
+        @root = "#{root}/"
+      end
+
+      def call(lines)
+        kept = lines.filter_map { |line| shorten(line) }
+        hidden = lines.size - kept.size
+        return lines.first(5) if kept.empty?
+
+        hidden.positive? ? [*kept, "(#{hidden} lines hidden)"] : kept
+      end
+
+      private
+
+      def shorten(line)
+        return line if line.start_with?('(irb)')
+        return line.delete_prefix(@root) if line.start_with?(@root)
+
+        path, rest = line.split(':', 2)
+        match = path.match(FRAMEWORK)
+        "#{match[1]}/#{match[3]}:#{rest}" if match && !match[3].match?(RUNNER)
+      end
+    end
+  end
+end

data/lib/thunder/console/banner.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    # Printed when the console opens: versions, then one row per fact (chunk, env, database, what the chunk
+    # registers) and the hints, each block separated by a blank line.
+    class Banner
+      include Theme
+
+      KIND_LABELS = { model: 'models', operation: 'operations', external_operation: 'external' }.freeze
+      # Any other env is a warning.
+      ENV_ROLES = { 'production' => %i[fail bold], 'development' => [:ok] }.freeze
+
+      # One row per kind the chunk registers; also how the inspector prints a chunk.
+      def self.registry_rows(chunk)
+        chunk.registry.hash.filter_map do |kind, items|
+          next if items.empty?
+
+          [KIND_LABELS.fetch(kind, kind.to_s), items.keys.sort.join(', ')]
+        end
+      end
+
+      def initialize(console)
+        @console = console
+      end
+
+      def lines(boot_error: nil)
+        rows = @console.chunk ? chunk_rows(boot_error) : no_chunk_rows
+        ['', title, '', *rows(rows), '', hints, '']
+      end
+
+      private
+
+      def title
+        root = @console.application.root
+        "#{paint('⚡ thunderbolt', :accent, :bold)} " +
+          paint("#{Thunder::VERSION} · ruby #{RUBY_VERSION} · #{root.basename}", :faint)
+      end
+
+      # Without a boot the chunk has no configuration, so the database is not asked about.
+      def chunk_rows(boot_error)
+        rows = [['chunk', paint(@console.chunk.identifier, :bold)], ['env', env]]
+        return [*rows, ['boot', failure(boot_error)]] if boot_error
+
+        [*rows, ['db', database], *registry]
+      end
+
+      def no_chunk_rows
+        [
+          ['chunks', @console.application.chunks.map(&:identifier).join(', ')],
+          ['env', env],
+          ['chunk', paint('none selected', :warn)]
+        ]
+      end
+
+      def env = paint(@console.env, *ENV_ROLES.fetch(@console.env, [:warn]))
+
+      def database
+        @console.chunk.database.connection_pool.with_connection { |connection| migration_state(connection) }
+      rescue ActiveRecord::NoDatabaseError
+        "#{paint("● #{@console.chunk.database.configuration[:database]} not created", :fail)}  " +
+          paint('thunder db create', :faint)
+      rescue ActiveRecord::ConnectionNotEstablished => e
+        "#{paint('● unreachable', :fail)}  #{paint(e.message.lines.first.to_s.strip, :faint)}"
+      rescue StandardError => e
+        "#{paint("● #{e.class}", :fail)}  #{paint(e.message.lines.first.to_s.strip, :faint)}"
+      end
+
+      # The database name, how many migrations the chunk has and whether any is pending.
+      def migration_state(connection)
+        migrations = ActiveRecord::MigrationContext.new(@console.chunk.root_path.join('database/migrate').to_s)
+        state = migrations.needs_migration? ? paint('pending migrations', :warn) : paint('up to date', :faint)
+        count = migrations.migrations.size
+        count = paint("#{count} #{count == 1 ? 'migration' : 'migrations'} · ", :faint)
+
+        "#{paint("● #{connection.current_database}", :ok)}  #{count}#{state}"
+      end
+
+      def registry = self.class.registry_rows(@console.chunk)
+
+      def failure(error)
+        "#{paint("✗ #{error.class}", :fail, :bold)}  #{error.message.lines.first.to_s.strip}\n" +
+          paint('fix it and reload!', :faint)
+      end
+
+      def hints
+        others = @console.application.chunks.map(&:identifier) - [@console.chunk&.identifier]
+        "  #{paint(['help', *others.first(2).map { |name| "chunk :#{name}" }].join(' · '), :faint)}"
+      end
+    end
+  end
+end

data/lib/thunder/console/completion.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    # Prepended to IRB's completor. Inside the arguments of chunk, use and use! it offers only the chunk names, the
+    # kinds and the keys of the chunk's registry (none when nothing matches or no chunk is selected); everywhere else
+    # IRB completes as usual.
+    #   chunk :li<TAB>             -> chunk :library
+    #   use :mo<TAB>               -> use :model          (also with parentheses)
+    #   use :operation, 'bo<TAB>   -> use :operation, 'books.add'
+    #   use :operation, :bo<TAB>   -> use :operation, 'books.add'   (a dotted key is not a valid symbol)
+    module Completion
+      ARGUMENTS = '(?:\(\s*|\s+)'
+      CHUNK = /(?<![\w.])chunk#{ARGUMENTS}(['":]?)(\w*)\z/
+      KIND = /(?<![\w.])use!?#{ARGUMENTS}(['":]?)(\w*)\z/
+      KEY = /(?<![\w.])use!?#{ARGUMENTS}['":]?(\w+)['"]?\s*,\s*(['":]?)([\w.]*)\z/
+
+      def completion_candidates(preposing, target, postposing, bind:)
+        text = preposing + target
+
+        if (match = text.match(CHUNK))
+          chunk_candidates(target, match)
+        elsif (match = text.match(KEY))
+          key_candidates(target, match)
+        elsif (match = text.match(KIND))
+          kind_candidates(target, match)
+        else
+          super
+        end
+      end
+
+      private
+
+      def chunk_candidates(target, match)
+        names = Console.current.application.chunks.map { |chunk| chunk.identifier.to_s }
+        replace(target, names, match[1], match[2], symbol_by_default: true)
+      end
+
+      def kind_candidates(target, match)
+        replace(target, registry.keys.map(&:to_s), match[1], match[2], symbol_by_default: true)
+      end
+
+      def key_candidates(target, match)
+        keys = (registry[match[1].to_sym] || {}).keys
+        replace(target, keys, match[2], match[3], symbol_by_default: false)
+      end
+
+      # The registry of the console's chunk; empty without a chunk, so there is nothing to offer.
+      def registry
+        chunk = Console.current&.chunk
+        chunk ? chunk.registry.hash : {}
+      end
+
+      # Replaces the argument being typed with each name that starts with it, keeping the quote the user opened. A name
+      # that is not a valid symbol (books.add) becomes a string.
+      def replace(target, names, quote, prefix, symbol_by_default:)
+        default_mark = symbol_by_default ? ':' : "'"
+        names.sort.select { |name| name.start_with?(prefix) }.map do |name|
+          mark = quote.empty? ? default_mark : quote
+          mark = "'" if mark == ':' && !name.match?(/\A\w+\z/)
+          closing = mark == ':' ? '' : mark
+          target.sub(/['":]?[\w.]*\z/, "#{mark}#{name}#{closing}")
+        end
+      end
+    end
+  end
+end

data/lib/thunder/console/constants.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    # The constants use defines on Object. Only the ones defined here are replaced or reused: a path that hits an
+    # existing constant (process -> Process, kernel.parser -> Kernel) is refused.
+    class Constants
+      def initialize
+        @owned = Set.new
+      end
+
+      # 'books.add' -> Books::Add. The first existing constant of the path not defined here, as 'A::B', when refused;
+      # nil once defined.
+      def define(key, klass)
+        *namespaces, name = key.to_s.split('.').map { |part| part.camelize.to_sym }
+        taken = taken([*namespaces, name])
+        return taken if taken
+
+        owner = define_namespaces(namespaces)
+        owner.send(:remove_const, name) if owner.const_defined?(name, false)
+        owner.const_set(name, klass)
+        @owned << [owner, name]
+        nil
+      end
+
+      # Removes every constant defined here: a namespace as Reviews would collide with the chunk module on boot.
+      def clear
+        @owned.reverse_each { |owner, name| owner.send(:remove_const, name) if owner.const_defined?(name, false) }
+        @owned.clear
+      end
+
+      private
+
+      def taken(path)
+        owner = Object
+        path.each_with_index do |name, index|
+          return nil unless owner.const_defined?(name, false)
+          return path[0..index].join('::') unless @owned.include?([owner, name])
+
+          owner = owner.const_get(name, false)
+        end
+        nil
+      end
+
+      # Books::Add needs Books: reuses the one defined here before, creates it otherwise.
+      def define_namespaces(names)
+        names.reduce(Object) do |owner, name|
+          next owner.const_get(name, false) if owner.const_defined?(name, false)
+
+          @owned << [owner, name]
+          owner.const_set(name, Module.new)
+        end
+      end
+    end
+  end
+end

data/lib/thunder/console/evaluation.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    # Wraps each evaluation (IRB's measure callbacks): time, queries run, whether it failed. Repaints the prompt so the
+    # arrow turns red after a failure, and prints the queries inline while the SQL log is on.
+    class Evaluation
+      include Theme
+
+      SQL_KEYWORDS = /\b(SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|INTO|VALUES|SET|JOIN|LEFT|INNER|ON|AND|OR|ORDER BY|
+                       GROUP BY|LIMIT|OFFSET|RETURNING|BEGIN|COMMIT|ROLLBACK|COUNT|AS|IN|IS|NULL|NOT)\b/x
+      IGNORED_QUERIES = %w[SCHEMA TRANSACTION].freeze
+
+      attr_reader :elapsed, :queries
+      attr_accessor :sql_log
+
+      def initialize(prompt)
+        @prompt = prompt
+        @elapsed = 0
+        @queries = 0
+        @sql_log = false
+      end
+
+      def install
+        IRB.conf[:MEASURE] = true
+        IRB.conf[:MEASURE_CALLBACKS] = [[:THUNDER, method(:around).to_proc, nil]]
+        ActiveSupport::Notifications.subscribe('sql.active_record') { |event| on_sql(event) }
+      end
+
+      def around(context, _code, _line_no, _arg)
+        @queries = 0
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        failed = true
+        result = yield
+        failed = failure?(result)
+        result
+      ensure
+        @elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+        @prompt.apply(context, failed:)
+      end
+
+      # Empty when the evaluation took under 1ms and ran no query.
+      def summary
+        parts = []
+        parts << duration(elapsed) if elapsed >= 0.001
+        parts << "#{queries} #{queries == 1 ? 'query' : 'queries'}" if queries.positive?
+        parts.join(' · ')
+      end
+
+      private
+
+      # case/when rather than is_a?: the result can be a BasicObject (ThunderChunk::Configuration).
+      def failure?(result)
+        case result
+        when ThunderOperation::Response then result.failure?
+        else false
+        end
+      end
+
+      def on_sql(event)
+        return if IGNORED_QUERIES.include?(event.payload[:name]) || event.payload[:cached]
+
+        @queries += 1
+        return unless sql_log
+
+        sql = event.payload[:sql].gsub(SQL_KEYWORDS) { paint(Regexp.last_match(0), :warn) }
+        puts "  #{paint('↳', :faint)} #{sql}  #{paint(duration(event.duration / 1000.0), :muted)}"
+      end
+    end
+  end
+end

data/lib/thunder/console/help.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    # The console's `help`: its helpers, in place of IRB's command list.
+    class Help < IRB::Command::Base
+      include Theme
+
+      category 'Thunder'
+      description 'List the console helpers'
+
+      LINES = [
+        ['chunk', 'the chunk of this console'],
+        ['chunk :name', 'restart the console on another chunk'],
+        ['chunks', 'chunks of the application'],
+        ['use(kind, key)', "define the key's constant (use(:model, :book) -> Book); false when not registered"],
+        ['use!(kind, key)', 'the registered class; raises when not registered'],
+        ['reload!', 'boot the chunk again and repoint the constants of use'],
+        ['sql!', 'turn the inline SQL log on or off'],
+        ['exit', 'leave the console']
+      ].freeze
+
+      def execute(_arg)
+        width = LINES.map { |name, _| name.size }.max
+        puts('', *LINES.map { |name, text| "  #{paint(name.ljust(width), :accent)}  #{paint(text, :faint)}" }, '')
+      end
+    end
+  end
+end

data/lib/thunder/console/helpers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    # Methods of the IRB main object. Without a chunk selected they print how to select one instead of raising.
+    module Helpers
+      def chunk(name = nil) = name ? Console.current.change_chunk(name) : Console.current.chunk
+      def chunks = Console.current.application.chunks.map(&:identifier)
+      def use(kind, key) = Console.current.within_chunk { |console| console.use(kind, key) } || false
+      def use!(kind, key) = Console.current.within_chunk { |console| console.use!(kind, key) }
+      def reload! = Console.current.within_chunk(&:reload!)
+      def sql! = Console.current.toggle_sql_log
+    end
+  end
+end

data/lib/thunder/console/inspector.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'irb/color_printer'
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    # How values are printed. A Response becomes a block: a ✓ SUCCESS / ✗ FAILURE badge, the operation key, the failed
+    # step (params for a parameter error), time and queries, then │ rows in the state color: the payload, or the
+    # message, field, error, extras and the line of the chunk where it failed. Other values print through Pretty,
+    # with the time when the evaluation was slow. A block of several lines ends in a blank line, apart from the
+    # next prompt.
+    class Inspector
+      include Theme
+
+      SLOW = 0.1
+      # Columns a view printed as a Response's payload gives up: the rows' guide and label column, with room to spare.
+      NESTED_INSET = 'payload'.size + 10
+
+      def initialize(console)
+        @console = console
+      end
+
+      def call(value, colorize:)
+        # case/when rather than is_a?: a value can be a BasicObject (ThunderChunk::Configuration).
+        case value
+        when ThunderOperation::Response then return spaced(response(value, colorize:))
+        when ThunderChunk::Chunk then return spaced(chunk(value))
+        end
+
+        view = Views.for(value)
+        return spaced(view.call) if view
+
+        # Continuation lines start under the value, past IRB's "=> ".
+        text = pretty(value, colorize:).gsub("\n", "\n   ")
+        evaluation = @console.evaluation
+        slow = evaluation.elapsed >= SLOW || evaluation.queries.positive?
+        text = "#{text}\n#{paint("⏱ #{evaluation.summary}", :faint)}" if slow
+        text.include?("\n") ? spaced(text) : text
+      end
+
+      private
+
+      # IRB chomps one newline off the value; the second one is the blank line.
+      def spaced(text) = "#{text}\n\n"
+
+      def response(response, colorize:)
+        role = response.success? ? :ok : :fail
+        badge = paint(response.success? ? ' ✓ SUCCESS ' : ' ✗ FAILURE ', role, :bold, :reverse)
+        meta = [step(response), *@console.evaluation.summary.presence].compact.join(' · ')
+        header = "#{badge} #{paint(operation_key(response.operation_name), :bold)}"
+        header += "  #{paint(meta, :faint)}" unless meta.empty?
+        fields =
+          response.success? ? [['payload', pretty(response.payload, colorize:)]] : failure_fields(response, colorize:)
+
+        [header, *rows(fields, indent: 3, guide: role)].join("\n")
+      end
+
+      def step(response)
+        return if response.success?
+        return 'params' if response.error.is_a?(ThunderOperation::Exceptions::ParameterError)
+
+        "step #{response.failed_step}" if response.failed_step
+      end
+
+      def failure_fields(response, colorize:)
+        error = response.error
+        [
+          ['message', paint(response.failure_message.to_s.strip, :fail)],
+          (['field', paint(error.field, :bold)] if error.respond_to?(:field) && error.field),
+          ['error', paint(error.class.name.demodulize, :faint)],
+          (['extras', pretty(response.failure_extras, colorize:)] if response.failure_extras.present?),
+          (['at', paint(location(error), :faint)] if location(error))
+        ]
+      end
+
+      # The chunk as the banner shows it, in place of the dump of its configuration, loader and registries.
+      def chunk(chunk)
+        root = chunk.root_path.relative_path_from(@console.application.root)
+        header = "#{paint(" ⚡ #{chunk.identifier} ", :accent, :bold, :reverse)}  " +
+                 paint("#{chunk.booted? ? 'booted' : 'not booted'} · #{root}", :faint)
+        [header, *rows(Banner.registry_rows(chunk), indent: 3, guide: :accent)].join("\n")
+      end
+
+      def operation_key(name)
+        registry = @console.chunk&.registry
+        key = registry && registry.hash.each_value.lazy.filter_map do |items|
+          items.find { |_key, klass| klass.name == name }&.first
+        end.first
+        key || name
+      end
+
+      # The first line of the backtrace inside the chunk, relative to it.
+      def location(error)
+        backtrace = error&.backtrace
+        return unless @console.chunk && backtrace
+
+        root = "#{@console.chunk.root_path}/"
+        line = backtrace.find { |entry| entry.start_with?(root) }
+        line&.delete_prefix(root)&.sub(/:in .*\z/, '')
+      end
+
+      # A value inside a Response's rows. A view there loses the room the rows take (guide and label column) and the
+      # indent it has at the top level.
+      def pretty(value, colorize:)
+        view = Views.for(value)
+        return Pretty.new(colorize:).call(value) unless view
+
+        view.inset = NESTED_INSET
+        view.call.gsub(/^ {3}/, '')
+      end
+    end
+  end
+end