raindown 0.5.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e35dfde9371c5f805bff304124c0abe22ca89254f14c5c70d2996e14d0dbb0f
-  data.tar.gz: 76774aa6b06fec8b50e0929b9ac86259511fb1ab9417ce48fcfa56afd20c90cf
+  metadata.gz: ad2e1df6e9cbfbac50533a9d6dd7f1d8bedb254aa6277a1889fb380871c52ec1
+  data.tar.gz: d32bbefdbcae559679033db6b1fc7e1dc4846f6a6356c0944e711cf50699eab0
 SHA512:
-  metadata.gz: 454c35bfd6c74cc2c125d8229ffe971cb178fb40f4d87affad0fc5d345301fd4d5a0e32a15852f05eb35231e0054b2a5b55ff2a4eb7253cc85aef17f4d17e178
-  data.tar.gz: 33b41ed491f7cc8238f3c3d99b2d72e2b0197dce29146dd14bdc704dd0ea6fa64788c97ed5d60bda60ef4602e9e6dedb2d22b02a1f8886a5c4592a522d96886e
+  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/cli.rb

@@ -23,8 +23,8 @@ module Raindown
 
       Commands:
         init [DIRECTORY]    Create a .raindown folder for the project's config and nodes (default: current directory)
-        tui [PATH]          Browse a project's files and outlines in the terminal, fold directives, run endpoints
-                            and open the editor at a line
+        tui [PATH]          Browse a project's files and outlines in the terminal, fold directives, run endpoints,
+                            open the editor at a line and see a dashboard of the project's charts
 
       Options:
         --html [OUTPUT]     Render FILE to HTML once, writing to OUTPUT or else printing to stdout

data/lib/raindown/document.rb

@@ -2,6 +2,7 @@
 
 require 'commonmarker'
 
+require_relative '../raindown'
 require_relative 'bare_directives'
 require_relative 'code_blocks'
 require_relative 'endpoint/endpoint_runner'
@@ -17,9 +18,10 @@ module Raindown
 
     # A content directive: a node, like toc: or a project's Changelog:, or an endpoint.
     # It spans line to end_line, its end tag, or the last line of a bare block.
+    # Body is the lines inside it, between it and its end tag, like an endpoint's request and response.
     # Output is the lines Raindown writes back, like a node's Markdown or an endpoint's response, and is nil
     # when nothing's written yet. A self-closing directive like <{ :toc }> only renders, so it never writes.
-    Directive = Data.define(:name, :args, :line, :end_line, :output, :writes) do
+    Directive = Data.define(:name, :args, :line, :end_line, :body, :output, :writes) do
       def endpoint? = name == 'endpoint'
     end
 
@@ -27,6 +29,7 @@ module Raindown
     TEXT_NODES = %i[text code].freeze
     BREAK_NODES = %i[softbreak linebreak].freeze
     ENDPOINT_END_TAG = /\A {0,3}<\{\s*:endpoint\s*\}>[ \t]*$/
+    END_TAG = /\A {0,3}<\{\s*:[\w:]+\s*\}>[ \t]*$/
 
     def self.parse(markdown, bare: false)
       new(markdown:, bare:)
@@ -46,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
@@ -68,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|
@@ -139,10 +138,18 @@ module Raindown
       first..last if first <= last
     end
 
-    # From a range of indexes to line numbers.
+    # From a range of indexes to line numbers. The body is the lines after the directive, up to its end tag,
+    # or to the end of a bare block, which has none.
     def directive(name, args, span, output:, writes:)
-      output = (output.begin + 1)..(output.end + 1) if output
-      Directive.new(name:, args:, line: span.begin + 1, end_line: span.end + 1, output:, writes:)
+      end_tag = span.end > span.begin && @lines[span.end].match?(END_TAG)
+      body = trimmed(span.begin + 1, end_tag ? span.end - 1 : span.end)
+
+      Directive.new(name:, args:, line: span.begin + 1, end_line: span.end + 1, body: lines(body), output: lines(output),
+                    writes:)
+    end
+
+    def lines(range)
+      (range.begin + 1)..(range.end + 1) if range
     end
   end
 end

data/lib/raindown/endpoint/curl.rb

@@ -10,6 +10,7 @@ module Raindown
   # are allowed: nothing that reads or writes local files, loads a config, or uses another protocol.
   module Curl
     class Error < StandardError; end
+    Request = Data.define(:method, :url)
 
     TIMEOUT = '30'
     # --disable must come first and skips ~/.curlrc. The protocol options stop redirects to file:// and the like.
@@ -64,6 +65,24 @@ module Raindown
       raise Error, 'curl is not installed'
     end
 
+    # The snippet's method and URL, like GET https://httpbin.org/uuid, or nil when it can't be read.
+    def request(snippet)
+      args = arguments(snippet)
+      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/projects.rb

@@ -35,14 +35,14 @@ module Raindown
       folder && File.dirname(folder)
     end
 
-    # The project's Markdown files, sorted. Ignored folders and the projects inside it are left out,
-    # since those projects have nodes of their own.
-    def files(root)
+    # The project's Markdown files, sorted, leaving out ignored folders. The projects inside it are left out too,
+    # since they have nodes of their own, unless they're asked for, like by the terminal UI, which lists them all.
+    def files(root, nested: false)
       files = []
 
       Find.find(root) do |path|
         if File.directory?(path)
-          Find.prune if path != root && (ignored?(File.basename(path)) || File.directory?(File.join(path, Nodes::FOLDER)))
+          Find.prune if path != root && (ignored?(File.basename(path)) || (!nested && project?(path)))
         elsif markdown?(path, root:)
           files << path
         end
@@ -64,6 +64,10 @@ module Raindown
       File.expand_path(path).start_with?(File.join(root, Nodes::FOLDER, '')) && %w[.rb .rbx].include?(File.extname(path))
     end
 
+    def project?(folder)
+      File.directory?(File.join(folder, Nodes::FOLDER))
+    end
+
     def ignored?(folder)
       folder.start_with?('.') || IGNORED.include?(folder)
     end

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/card.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'unicode/display_width'
+
+module Raindown
+  module TUI
+    # A chart on the dashboard, drawn from its data by its project's Worker: a title of its file, from its project,
+    # and the heading above it, then its directive, then the chart, each line with its Layout style,
+    # in a border with rounded corners. It's as wide as the chart, so the title and directive are cut to fit it:
+    #    ╭───────────────────────────────────────╮
+    #    │ markdown.md › Charts                  │
+    #    │ chart: 'data/downloads.csv' width: 30 │
+    #    │ Jun  ██████▊                   640    │
+    #    ╰───────────────────────────────────────╯
+    class Card < Data.define(:project, :path, :line, :heading, :directive, :chart)
+      # The border's columns either side of a card's lines, "│ " and " │", and its lines above and below them.
+      BORDER_WIDTH = 4
+      BORDER_HEIGHT = 2
+
+      def title = [path.delete_prefix(File.join(project, '')), heading].compact.join(' › ')
+
+      def lines = parts.map(&:first)
+
+      # Each line, with its style.
+      def parts = [[title, :heading], [directive, :directive], *chart.map { [it, :chart] }]
+
+      # As wide as its chart.
+      def width = chart.map { Unicode::DisplayWidth.of(it) }.max || 0
+
+      def height = lines.length
+
+      # With its border, within a range of widths, like a pane's.
+      def box_width(within: nil) = within ? (width + BORDER_WIDTH).clamp(within) : width + BORDER_WIDTH
+      def box_height = height + BORDER_HEIGHT
+
+      # A line of the card in its border, as [text, style, width] parts, for a card the box width wide.
+      # The border's top is line 0, and below its bottom, the lines are blank, for a card shorter than its row.
+      # The title's style is title_style, like when the card's selected.
+      def format_line(line, box_width:, title_style: :heading)
+        width = [box_width - BORDER_WIDTH, 0].max
+        return [border(width, '╭', '╮')] if line.zero?
+        return [border(width, '╰', '╯')] if line == height + 1
+        return [['', :blank, width + BORDER_WIDTH]] if line > height + 1
+
+        text, style = parts[line - 1]
+        [['│ ', :border, 2], [text, style == :heading ? title_style : style, width], [' │', :border, 2]]
+      end
+
+      private
+
+      def border(width, left, right)
+        ["#{left}#{'─' * (width + 2)}#{right}", :border, width + BORDER_WIDTH]
+      end
+    end
+  end
+end

data/lib/raindown/tui/endpoint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # An endpoint in a project's files, listed in the nav pane by its request, like "GET httpbin.org/uuid",
+    # with its method in its style, like GET in :method_get.
+    Endpoint = Data.define(:project, :path, :line, :method, :url) do
+      def text = "#{method} #{address}"
+
+      # The URL without its scheme.
+      def address = url.sub(%r{\Ahttps?://}i, '')
+
+      def style = :"method_#{method.downcase}"
+    end
+  end
+end

data/lib/raindown/tui/endpoints.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'endpoint'
+require_relative 'views/endpoint_view'
+require_relative 'row'
+require_relative 'workers/worker'
+
+module Raindown
+  module TUI
+    # Every endpoint in the projects' files, found by each project's Worker, listed below the files.
+    # Like the dashboard, it can be narrowed to a project's own.
+    class Endpoints
+      # The project the endpoints are narrowed to, or nil for every project's.
+      attr_accessor :project
+
+      def initialize(workers:)
+        @workers = workers
+        load
+      end
+
+      # Finds the endpoints again, like after a file's changed.
+      def load
+        @endpoints = @workers.each.flat_map do |worker|
+          worker.call(:endpoints)
+        rescue Worker::Error
+          []
+        end
+      end
+
+      def all = project ? @endpoints.select { it.project == project } : @endpoints
+
+      def rows
+        all.map do
+          Row.new(text: it.address, tag: it, depth: 0, kind: :endpoint, target: it,
+                  open: OpenView.new(view: EndpointView.new(it, workers: @workers)))
+        end
+      end
+    end
+  end
+end

data/lib/raindown/tui/events.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # A click on the screen: the cursor moves to the pane's row, or the dashboard's card or the menu's item,
+    # then the action's done there, like :enter, or a button's, like :toggle or :execute.
+    # 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)
+
+    # Shows the message while the task runs, like an endpoint's request.
+    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, 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
+
+    Open = Data.define(:path, :line) do
+      def take(navigator) = navigator.open_at(path, line)
+    end
+
+    Edit = Data.define(:path, :line) do
+      def take(navigator) = navigator.edit_at(path, line)
+    end
+
+    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