raindown 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9a61e7a842dcd5dc4cc5f6d004db388173ef2d5c48af1a50e32fea6c317b678
-  data.tar.gz: 7bbae724e020d48a3f095ba1cc8e1c45b9ee5dd483daf0af5f8edd4333d83205
+  metadata.gz: ad2e1df6e9cbfbac50533a9d6dd7f1d8bedb254aa6277a1889fb380871c52ec1
+  data.tar.gz: d32bbefdbcae559679033db6b1fc7e1dc4846f6a6356c0944e711cf50699eab0
 SHA512:
-  metadata.gz: b8f312582ede3900be43490c52c54ce3df6292764c04c177f54510e397a4814c9a9184cbb0710113055bb0dd140f00ced0bcf309f59583d34485a900579ac64b
-  data.tar.gz: 932d51981cd38660a402a40bbf9b0015da35baf62bad04152cdfdc262287f9593643daf66d2b60b6282e4df8a3de553a9ebba1793b37bec0972c145ea275c5a0
+  metadata.gz: 0dd6247d9f49558b5dc53b9eae6860d841c34c1e03edbaca61ba02ff59ec59a932d647c7f70eff731b1fe195ece4f3d2e999be2a783e0e9f1b57f97a166a5b25
+  data.tar.gz: bfc9d3fed994284ae6f0ec94a51e6599a754e1064e648092e595bd80d6224f8f4acc4e258a790de9fe5bbb9e9cfe07ede3d4c6d7bd633c3574ff9f8ec9a3e90a

data/lib/raindown/chart/chart.rb

@@ -19,7 +19,8 @@ module Raindown
 
     # Label and value are the columns to chart, by name or index, and minus a column to chart against the values.
     # Width is in characters, for bars and lines, and height in lines, for columns and lines.
-    def initialize(data = nil, format: nil, label: nil, value: nil, minus: nil, width: 40, height: 8) # rubocop:disable Metrics/ParameterLists -- each is a prop
+    # Tail keeps only the last points, like the latest months of a file that grows.
+    def initialize(data = nil, format: nil, label: nil, value: nil, minus: nil, width: 40, height: 8, tail: nil) # rubocop:disable Metrics/ParameterLists -- each is a prop
       @data = data
       @format = format
       @label = label
@@ -27,6 +28,7 @@ module Raindown
       @minus = minus
       @width = width
       @height = height
+      @tail = tail
     end
 
     # The data is read every time, so the chart follows changes to its file.
@@ -45,7 +47,16 @@ module Raindown
       Points.new(label: @label, value: @value, minus: @minus, root:).from(@data)
     end
 
+    # The chart's lines, as a card on the terminal UI's Dashboard shows them, or that there's no data.
+    def card_lines(metadata: NoMetadata)
+      points = points(metadata:)
+      return ['No data'] if points.empty?
+
+      draw(points).map(&:rstrip)
+    end
+
     def draw(points)
+      points = points.last(@tail) if @tail
       format = @format || (points.any?(&:first) ? 'bars' : 'sparkline')
       drawing = FORMATS[format] || raise(Error, "format: is #{FORMATS.keys.join(', ')}, not #{format.inspect}")
 

data/lib/raindown/document.rb

@@ -49,7 +49,7 @@ module Raindown
 
     # The headings in the order they appear, with their source text, like "Notes for {name}" before it's rendered.
     def headings
-      @headings ||= nodes(:heading).map do |node|
+      @headings ||= root.walk.select { |node| node.type == :heading }.map do |node|
         Heading.new(level: node.header_level, text: text(node), line: node.source_position[:start_line])
       end
     end
@@ -71,10 +71,6 @@ module Raindown
       @root ||= Commonmarker.parse(@markdown, options: MARKDOWN_OPTIONS)
     end
 
-    def nodes(type)
-      [].tap { |nodes| root.walk { |node| nodes << node if node.type == type } }
-    end
-
     def text(heading)
       parts = []
       heading.walk do |node|

data/lib/raindown/endpoint/curl.rb

@@ -66,19 +66,23 @@ module Raindown
     end
 
     # The snippet's method and URL, like GET https://httpbin.org/uuid, or nil when it can't be read.
-    # A snippet that sends data is a POST, unless it says otherwise, as with curl.
     def request(snippet)
       args = arguments(snippet)
-      url = args.find { it.match?(URL) }
-      method = args[args.index('--request') + 1] if args.include?('--request')
-      method ||= 'HEAD' if args.include?('--head')
-      method ||= 'POST' if args.intersect?(VALUE_CHECKS.keys.grep(/data|json/))
-
-      Request.new(method: (method || 'GET').upcase, url:) if url
+      Request.new(method: request_method(args), url: args.find { it.match?(URL) })
     rescue Error
       nil
     end
 
+    # A snippet that sends data is a POST, unless it says otherwise, as with curl.
+    def request_method(args)
+      index = args.index('--request')
+      return args[index + 1].upcase if index
+      return 'HEAD' if args.include?('--head')
+      return 'POST' if args.intersect?(VALUE_CHECKS.keys.grep(/data|json/))
+
+      'GET'
+    end
+
     def arguments(snippet)
       words = Shellwords.split(snippet.gsub(/\\\r?\n/, ' ').strip.delete_prefix('$ '))
       raise Error, 'Endpoint snippets must start with curl' unless words.first == 'curl'

data/lib/raindown/node_blocks.rb

@@ -77,13 +77,16 @@ module Raindown
     end
 
     def rendered_lines(lines, block, markdown:, metadata:, bare:)
-      node = block[:node]
-      output = if Nodes.html?(node) then ["#{Nodes.placeholder(node)}\n"]
-               else "#{Nodes.call(node, :replace, document: markdown, metadata:, bare:).to_s.chomp}\n".lines
-               end
-      output = [] if output == ["\n"]
+      output = node_markdown(block[:node], markdown:, metadata:, bare:).chomp
+      close = marker(lines[block[:close]]) if block[:close]
 
-      [marker(lines[block[:open]]), *output, *(marker(lines[block[:close]]) if block[:close])]
+      [marker(lines[block[:open]]), *("#{output}\n".lines unless output.empty?), *close]
+    end
+
+    def node_markdown(node, markdown:, metadata:, bare:)
+      return Nodes.placeholder(node) if Nodes.html?(node)
+
+      Nodes.call(node, :replace, document: markdown, metadata:, bare:).to_s
     end
 
     def marker(line)

data/lib/raindown/nodes.rb

@@ -3,6 +3,7 @@
 require_relative 'chart/chart'
 require_relative 'files'
 require_relative 'node'
+require_relative 'stat'
 require_relative 'toc'
 
 module Raindown

data/lib/raindown/stat.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+module Raindown
+  # The base of a project's stats: one big number in block digits, above its label, written into the Markdown as code,
+  # and shown on the terminal UI's Dashboard as a card, like a chart:
+  #    ▀█  ▀▀█
+  #     █  █▀▀
+  #    ▀▀▀ ▀▀▀
+  #   open issues
+  # A stat's a node in .raindown that says its value, and its label:
+  #   class Issues < Raindown::Stat
+  #     def value(metadata:) = Issue.open.count
+  #     def label = 'open issues'
+  #   end
+  class Stat < Node
+    # Each character's three lines in block digits, which end on the top half of the third, where a point sits too.
+    # Others are left as they are, on the middle line.
+    DIGITS = { '0' => ['█▀█', '█ █', '▀▀▀'], '1' => ['▀█ ', ' █ ', '▀▀▀'], '2' => ['▀▀█', '█▀▀', '▀▀▀'],
+               '3' => ['▀▀█', ' ▀█', '▀▀▀'], '4' => ['█ █', '▀▀█', '  ▀'], '5' => ['█▀▀', '▀▀█', '▀▀▀'],
+               '6' => ['█▀▀', '█▀█', '▀▀▀'], '7' => ['▀▀█', '  █', '  ▀'], '8' => ['█▀█', '█▀█', '▀▀▀'],
+               '9' => ['█▀█', '▀▀█', '▀▀▀'], '-' => ['   ', '▀▀▀', '   '], '+' => [' ▄ ', '▀█▀', '   '],
+               '.' => [' ', ' ', '▀'], ',' => [' ', ' ', '▀'] }.freeze
+
+    def replace(metadata: NoMetadata) = "```\n#{card_lines(metadata:).join("\n")}\n```"
+
+    # The number in block digits, then the label, as a card on the Dashboard shows them.
+    def card_lines(metadata: NoMetadata)
+      characters = number(value(metadata:)).chars.map { digit(it) }
+      [*Array.new(3) { |line| characters.map { it[line] }.join(' ').rstrip }, label]
+    end
+
+    def value(metadata: NoMetadata) = raise(NotImplementedError, "#{self.class} needs a value")
+
+    def label = ''
+
+    # How the value's written, which a stat can change, like with a sign.
+    def number(value) = value.to_s
+
+    private
+
+    # The character's three lines in block digits, or itself on the middle line.
+    def digit(character) = DIGITS.fetch(character) { [' ', character, ' '] }
+
+    # The project's folder, from the page being rendered, or else the current one.
+    def root(metadata)
+      return metadata.root if metadata.respond_to?(:root)
+
+      Dir.pwd
+    end
+  end
+end

data/lib/raindown/tui/events.rb

@@ -7,6 +7,12 @@ module Raindown
     # Keys are their events' names, like :down or :enter.
     Click = Data.define(:pane, :index, :action)
 
+    # The mouse moving over what a click there would send, if anything, to show it, like a method's cells in bold.
+    Hover = Data.define(:target)
+
+    # A character typed while typing, like in the search, which other keys' events would take, like "j" for :down.
+    Type = Data.define(:text)
+
     # What the Screen does after an event, other than drawing again, or stopping for :quit.
     # Leaves the screen for a command, like the editor, then tells the Navigator it ran.
     Run = Data.define(:command)
@@ -15,7 +21,8 @@ module Raindown
     Wait = Data.define(:message, :task)
 
     # Steps a row or a view asks of the Navigator, which each takes on it, returning what the Screen does next: to open
-    # a view right of the files, or a file in the outline at a directive, to edit a file at a line, or to run an endpoint.
+    # a view right of the files, or a file in the outline at a directive, to edit a file at a line, to run an endpoint,
+    # to draw the page a feeling was noted down in, or to ask Claude Code to fix a method.
     OpenView = Data.define(:view) do
       def take(navigator) = navigator.open_view(view)
     end
@@ -31,5 +38,13 @@ module Raindown
     Execute = Data.define(:path, :line, :name) do
       def take(navigator) = navigator.run(path, line, name)
     end
+
+    Felt = Data.define(:feeling) do
+      def take(navigator) = navigator.felt(feeling)
+    end
+
+    Fix = Data.define(:feeling) do
+      def take(navigator) = navigator.fix_with_agent(feeling)
+    end
   end
 end

data/lib/raindown/tui/feelings/batch.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'zlib'
+
+module Raindown
+  module TUI
+    # Files to feel, like the files Severance's refiners work through: the first in the week's shuffled order, as many as
+    # fill the grid's cells, with their methods shuffled together. The order is random, but the same all week, so the
+    # grid stays put through reloads, edits and restarts, and once it's refined, that's the week's work done.
+    Batch = Data.define(:files, :code_methods, :log, :week) do
+      # Like 2026-W44, from the ISO year and week.
+      def self.this_week(date = Date.today) = "#{date.cwyear}-W#{date.cweek}"
+
+      def self.pick(every, log:, cells:, week: this_week)
+        files = filling(every.group_by(&:path).sort_by { |path, _| Zlib.crc32("#{week}:#{path}") }, cells)
+
+        new(files:, code_methods: [], log:, week:).reading(every)
+      end
+
+      # The files, in order, whose methods' cells fit in the grid's, passing over any too big for what's left, and
+      # at least the first.
+      def self.filling(files, cells)
+        used = 0
+        files.each_with_object([]) do |(path, methods), picked|
+          size = methods.sum(&:size)
+          next unless picked.empty? || used + size <= cells
+
+          picked << path
+          used += size
+        end
+      end
+
+      # The same files, with their methods read again, like after one's edited.
+      def reading(every)
+        with(code_methods: every.select { files.include?(it.path) }.sort_by { Zlib.crc32("#{week}:#{it.path}:#{it.label}") })
+      end
+
+      def felt?(method) = log.felt?(method)
+      def refined? = code_methods.all? { felt?(it) }
+
+      def progress
+        "#{code_methods.count { felt?(it) } * 100 / [code_methods.length, 1].max}% refined"
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/bins.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'feelings_log'
+
+module Raindown
+  module TUI
+    # Code feelings' bins below the code box, one for each temper, best to worst, each a box with its key's number, its
+    # temper and a bar of how many feelings it holds, highlighted when it's the chosen temper:
+    #    ╭─ 01 ────╮ ╭─ 02 ────╮ ╭─ 03 ────╮ ╭─ 04 ────╮ ╭─ 05 ────╮ ╭─ 06 ────╮
+    #    │ FROLIC  │ │ HOPE    │ │ NUMB    │ │ WOE     │ │ DREAD   │ │ MALICE  │
+    #    │ ███░  9 │ │ ██░░  5 │ │ ████ 41 │ │ ██░░  6 │ │ █░░░  3 │ │ █░░░  2 │
+    #    ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯
+    module Bins
+      # A bin's lines.
+      BIN_LINES = 4
+
+      private
+
+      # The six bins, each a box with its number, its temper, and a bar of how many feelings it holds.
+      def bins
+        counts = view.log.counts
+        most = [counts.values.max, 1].max
+        chosen = chosen_temper
+        boxes = counts.each_with_index.map { |(temper, count), index| bin(index + 1, temper, count, most, chosen) }
+
+        Array.new(BIN_LINES) do |line|
+          padded([segment('', :blank, width: 1), *boxes.flat_map { [it[line], segment(' ', :blank, width: 1)] }])
+        end
+      end
+
+      # The temper being noted, or else how the selected method felt, if it's been felt.
+      def chosen_temper = view.noting || view.log.temper(view.selected)
+
+      # As wide as they all fit, which cuts their borders short in a pane too narrow for them.
+      def bin_width = [(width - 1 - FeelingsLog::TEMPERS.length) / FeelingsLog::TEMPERS.length, 1].max
+
+      # A space inside a bin's sides, unless the longest temper would only fit without it.
+      def bin_inside
+        return '' if bin_width < FeelingsLog::TEMPERS.map(&:length).max + 4
+
+        ' '
+      end
+
+      # The bin's lines, highlighted when it's the chosen temper: the one being noted, or how the selected method felt.
+      def bin(number, temper, count, most, chosen)
+        style = :feelings
+        style = :selected if temper == chosen
+        bin_lines(number, temper, count, most).map { segment(it, style, width: bin_width) }
+      end
+
+      # Its key's number on its top line, its temper, the bar of its count, and its bottom.
+      def bin_lines(number, temper, count, most)
+        inside = bin_inside
+        name = temper.upcase.ljust(bin_width - 2 - (2 * inside.length))
+        ["╭─ 0#{number} #{'─' * [bin_width - 7, 0].max}╮", "│#{inside}#{name}#{inside}│",
+         "│#{inside}#{bar(count, most)} #{count}#{inside}│", "╰#{'─' * (bin_width - 2)}╯"]
+      end
+
+      # As long as there's room beside the count, and filled as far as its share of the fullest bin's.
+      def bar(count, most)
+        length = bin_width - 3 - (2 * bin_inside.length) - count.to_s.length
+        filled = (length * count / most.to_f).round
+        "#{'█' * filled}#{'░' * (length - filled)}"
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/celebration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # When a batch of code feelings is refined, like Severance's waffle party: rain, a frame each tick, for about five
+    # seconds of the Screen's 60 ms frames, then a waffle, until a key's pressed.
+    class Celebration
+      RAIN_FRAMES = 83
+
+      attr_reader :frame
+
+      def initialize
+        @frame = 0
+      end
+
+      def raining? = frame < RAIN_FRAMES
+
+      # Each tick's a frame, and any other key puts the waffle away, which is when it's over.
+      def over?(key)
+        @frame += 1 if key == :tick
+        key != :tick
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/code_box.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative '../highlighter'
+
+module Raindown
+  module TUI
+    # Code feelings' box below the grid: the selected method's code, highlighted, its first lines or, expanded, all that
+    # fit, then why it felt that way while that's typed, below a line:
+    #    ╭─ lib/text.rb:62 · Text#segments_between ──────────── changed 6× ─╮
+    #    │ def segments_between(line, from, to)                              │
+    #    │ [12 more lines]                                                   │
+    #    ├───────────────────────────────────────────────────────────────────┤
+    #    │ Why DREAD? > column maths, a character at a time▏                 │
+    #    ╰───────────────────────────────────────────────────────────────────╯
+    module CodeBox
+      # The most of a method's code that shows, until it's expanded, and the rows the grid keeps when it is.
+      CODE_LINES = 8
+      MIN_GRID_ROWS = 2
+      # The box's top and bottom, and the line of how many more lines there are.
+      BOX_LINES = 3
+
+      private
+
+      # The selected method's code in a box, then why it felt that way while that's typed, below a line.
+      def code_box
+        notes = []
+        notes = note_lines if view.typing?
+        [box_top(view.selected), *code_lines(height - Bins::BIN_LINES - BOX_LINES - MIN_GRID_ROWS - notes.length), *notes,
+         box_edge('╰', '╯')]
+      end
+
+      # The method's first lines, or all that fit in the room when it's expanded, highlighted and wrapped to fit the box,
+      # then how many more there are, clicked to show them, or a line to show fewer again.
+      def code_lines(room)
+        shown = CODE_LINES
+        shown = [room, CODE_LINES].max if view.expanded
+        lines = highlighted_code.map { wrapped(it) }
+        fitting = lines.take_while { (shown -= it.length) >= 0 }
+        code = fitting.flatten(1).map { boxed(it) }
+        return code if lines.sum(&:length) <= CODE_LINES
+
+        [*code, more_line(lines.length - fitting.length)]
+      end
+
+      def highlighted_code = Highlighter.lines(dedented(view.selected.lines), filename: view.selected.path)
+
+      # The highlighted line's [text, style] parts in as many lines as it takes to fit the box, like a note's, those
+      # after the first carrying on after an ellipsis.
+      def wrapped(parts)
+        room = width - 6
+        lead = [carried_lead(parts, room), :feelings]
+        rest = room - display_width(lead[0])
+        return [parts] if rest < 1
+
+        first, *others = line_breaks(parts.map { printable(it[0]) }.join, room, rest).each_cons(2).map { parts_between(parts, *it) }
+        [first, *others.map { [lead, *it] }]
+      end
+
+      # Where the text breaks into lines, the first fitting the room and the others the rest.
+      def line_breaks(text, room, rest)
+        breaks = [0]
+        fits = room
+        while text.length - breaks.last > fits
+          breaks << line_break(text, breaks.last, fits)
+          fits = rest
+        end
+        breaks << text.length
+      end
+
+      # Where a line from the column breaks: after the last space that fits, or where it's full when none does.
+      def line_break(text, from, fits)
+        space = text[from, fits].rindex(' ').to_i
+        return from + fits unless space.positive?
+
+        from + space + 1
+      end
+
+      # An ellipsis at the line's own indent, up to half the room, which the lines it's wrapped onto start with.
+      def carried_lead(parts, room) = "#{' ' * [parts.map(&:first).join[/\A */].length, room / 2].min}… "
+
+      # The parts' text between two columns, in their styles.
+      def parts_between(parts, from, to)
+        segments = parts.map { |text, style| Text::Segment.new(text: printable(text), style:, event: nil) }
+        segments_between(segments, from, to).map { [it.text, it.style] }
+      end
+
+      def more_line(hidden)
+        text = "[#{hidden} more lines]"
+        text = '[1 more line]' if hidden == 1
+        text = "[Fewer lines]#{" · #{hidden} more don't fit" if hidden.positive?}" if view.expanded
+        boxed([[text, :button]], event: Click.new(pane:, index: view.cursor, action: :expand))
+      end
+
+      # Why it felt that way, as it's typed, below a line, in as many lines as it takes.
+      def note_lines = [box_edge('├', '┤'), *hanging("Why #{view.noting.upcase}? > ", "#{view.note}▏").map { boxed([[it, :feelings]]) }]
+
+      # The text after the lead, wrapped to fit the box, with the lines after the first lined up under the text.
+      def hanging(lead, text)
+        indent = ' ' * display_width(lead)
+        lines = wrap(text, width - 6 - indent.length)
+        [lead, *Array.new(lines.length - 1, indent)].zip(lines).map(&:join)
+      end
+
+      # Where the method is, its name, and how many commits changed its file.
+      def box_top(method) = box_edge("╭─ #{where(method)} · #{method.label} ", " changed #{method.changes}× ─╮")
+
+      # The lines without the indent they share, like a method's in its class.
+      def dedented(lines)
+        indent = lines.reject { it.strip.empty? }.map { it[/\A */].length }.min.to_i
+        lines.map { it[indent..].to_s }
+      end
+
+      def where(method) = "#{navigator.relative(method.path)}:#{method.line}"
+
+      # A line of the box, a column in from each side of the pane, of [text, style] parts, like highlighted code's.
+      def boxed(parts, event: nil)
+        padded([segment(' │ ', :feelings, width: 3), *code_segments(parts, width - 6, event:), segment(' │', :feelings, width: 2)])
+      end
+
+      # The box's top or bottom, with the left text cut short, rather than the corner, when there isn't room.
+      def box_edge(left, right)
+        room = width - 2 - display_width(right)
+        left = "#{fit(left, room - 1)} " if display_width(left) > room
+        fill = [room - display_width(left), 0].max
+        padded([segment(" #{left}#{'─' * fill}#{right}", :feelings, width: width - 1)])
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/code_methods.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require 'zlib'
+
+module Raindown
+  module TUI
+    # A function or method in a project's code, to sort how it feels: where it is, its lines, how many commits changed
+    # its file, and how much it drifts, from 0 to 9, which is how it ranks among the project's by both of them.
+    CodeMethod = Data.define(:path, :owner, :name, :line, :lines, :changes, :drift) do
+      # Like Layout#lines, or lines alone outside a class or the like.
+      def label = [owner, name].compact.join('#')
+
+      # A cell for every few lines, up to 8.
+      def size = ((lines.length / 4) + 1).clamp(1, 8)
+
+      # What drift ranks: long methods in files that keep changing weigh most.
+      def weight = lines.length * (changes + 1)
+
+      # Its code's checksum, which changes when its code does, but not its indent, trailing spaces or blank lines.
+      def checksum = Zlib.crc32(lines.map(&:strip).reject(&:empty?).join("\n")).to_s(16)
+    end
+
+    # Every function and method in a project's code, in any language: from Universal Ctags when it's installed,
+    # which knows over 100 languages, or else from how the code's indented. Specs, tests, and folders a project
+    # doesn't write, like vendor, are left out.
+    module CodeMethods
+      SKIPPED = %w[.git spec test tests vendor tmp pkg node_modules].freeze
+      # The kinds Ctags gives functions and methods, across languages.
+      KINDS = %w[function method singletonMethod procedure subroutine func constructor].freeze
+      # The files the indentation fallback reads, by extension.
+      EXTENSIONS = %w[rb py js mjs ts tsx jsx go rs java kt swift c h cc cpp cs php ex exs lua sh scala].freeze
+      MODIFIERS = '(?:(?:export|default|async|static|public|private|protected|pub(?:\(\w+\))?|override|final)\s+)*'
+      # A line that starts a function, with its name, like "def area", "pub fn draw(" or "func (s *Square) Area(".
+      DEFINITION = /\A\s*#{MODIFIERS}(?:def|function|fn|func|sub|proc)\s+(?:\([^)]*\)\s*)?(?:self\.)?([\w?!=]+)/
+      # A line that starts a class or the like, with its name, which names the functions inside it.
+      OWNER = /\A\s*#{MODIFIERS}(?:class|module|struct|impl|interface|trait|object)\s+(\w+(?:::\w+)*)/
+      # A line that closes a block, at the indent of the line that opened it.
+      CLOSER = /\A\s*(?:end\b|[}\])])/
+
+      module_function
+
+      def list(root)
+        changes = file_changes(root)
+        drifting((tagged(root) || indented(root)).map { it.with(changes: changes.fetch(it.path, 0)) })
+      end
+
+      # Each method with its drift, from 0 for the lightest to 9 for the heaviest, where methods that weigh the same
+      # drift the same, so the digits spread out in any project, whatever its language or size.
+      def drifting(methods)
+        weights = methods.map(&:weight).sort
+        methods.map { |method| method.with(drift: weights.bsearch_index { it >= method.weight } * 9 / [weights.length - 1, 1].max) }
+      end
+
+      # From Universal Ctags, or nil when it isn't installed, or the ctags installed is another, without JSON.
+      def tagged(root)
+        json, status = Open3.capture2('ctags', '--output-format=json', '--fields=+ne', '-R', '-f', '-',
+                                      *SKIPPED.map { "--exclude=#{it}" }, '.', chdir: root, err: File::NULL)
+        return unless status.success?
+
+        sources = Hash.new { |hash, path| hash[path] = File.readlines(path, chomp: true) }
+        json.each_line.filter_map { tag_method(root, JSON.parse(it), sources) }.sort_by { [it.path, it.line] }
+      rescue SystemCallError, JSON::ParserError
+        nil
+      end
+
+      def tag_method(root, tag, sources)
+        return unless tag['_type'] == 'tag' && KINDS.include?(tag['kind']) && tag['end']
+
+        path = File.join(root, tag['path'].delete_prefix('./'))
+        lines = sources[path][(tag['line'] - 1)...tag['end']]
+        CodeMethod.new(path:, owner: tag['scope']&.split(/\.|::/)&.last, name: tag['name'], line: tag['line'], lines:, changes: 0, drift: 0)
+      end
+
+      def indented(root)
+        files(root).flat_map { indented_in(it) }
+      end
+
+      def files(root)
+        Dir.glob('**/*', File::FNM_DOTMATCH, base: root)
+           .select { EXTENSIONS.include?(File.extname(it).delete_prefix('.')) }
+           .reject { it.split('/').intersect?(SKIPPED) }.sort.map { File.join(root, it) }
+      end
+
+      # Each line that starts a function, to where the indent comes back to its own, named after the class it's in.
+      def indented_in(path)
+        lines = File.readlines(path, chomp: true)
+        lines.each_index.filter_map do |index|
+          name = lines[index][DEFINITION, 1]
+          next unless name
+
+          CodeMethod.new(path:, owner: owner_of(lines, index), name:, line: index + 1,
+                         lines: lines[index..block_end(lines, index)], changes: 0, drift: 0)
+        end
+      rescue SystemCallError, ArgumentError
+        []
+      end
+
+      # The block's last line: the last one indented further than its first, or the line closing it, like "end".
+      def block_end(lines, index)
+        start = indent(lines[index])
+        last = index
+        lines.each_with_index.drop(index + 1).each do |line, number|
+          next if line.strip.empty?
+          return number if indent(line) == start && line.match?(CLOSER)
+          return last if indent(line) <= start
+
+          last = number
+        end
+        last
+      end
+
+      # The class or the like that the line's inside, by the nearest line above that's indented less and starts one.
+      def owner_of(lines, index)
+        depth = indent(lines[index])
+        owner = lines[0...index].reverse_each.find { indent(it) < depth && it.match?(OWNER) }
+        owner && owner[OWNER, 1].split('::').last
+      end
+
+      def indent(line) = line[/\A\s*/].length
+
+      # How many commits changed each file, from git log, or none outside a repository.
+      def file_changes(root)
+        log, status = Open3.capture2('git', '-C', root, 'log', '--format=', '--name-only', '--relative', err: File::NULL)
+        return {} unless status.success?
+
+        log.split("\n").reject(&:empty?).tally.transform_keys { File.join(root, it) }
+      rescue SystemCallError
+        {}
+      end
+    end
+  end
+end