raindown 0.5.1 → 0.7.0

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative '../events'
+require_relative 'celebration'
+require_relative 'code_methods'
+require_relative 'feelings_log'
+require_relative 'weekly_batch'
+
+module Raindown
+  module TUI
+    # Code feelings, like Severance's macrodata refinement: the project's functions and methods, in any language,
+    # as clusters of digits in a grid, where long methods, and ones whose files keep changing, drift. The cursor moves
+    # between them, the selected one's code shows below the grid, its first lines or with Enter all that fits, and 1 to 6
+    # sort how it feels into a bin: frolic, hope, numb, woe, dread or malice, which notes it down in the FeelingsLog,
+    # staying on it. Woe, dread and malice ask why first, typed until Enter, or Esc to leave it out. E opens the method in the
+    # editor, and X asks Claude Code to fix it, and either way it's read again after, to be felt again.
+    class FeelingsView
+      # Best to worst, as CodeHealth scores them, so the keys rate the code.
+      BINS = { bin1: 'frolic', bin2: 'hope', bin3: 'numb', bin4: 'woe', bin5: 'dread', bin6: 'malice' }.freeze
+      # The tempers that ask why.
+      NOTED = %w[woe dread malice].freeze
+      # Its own keys, besides the bins: Enter and Space show all of the selected method's code, or its first lines again.
+      # Ctrl+T celebrates, to try the rain and the waffle, and isn't shown with the buttons.
+      KEYS = %i[up down left right edit execute tick enter toggle expand celebrate].freeze
+
+      # The temper being noted, and the note typed so far, while it's asking why, whether the selected method's code
+      # shows all that fits, until another's selected, and the rain then the waffle, once the batch is refined.
+      attr_reader :noting, :note, :cursor, :tick, :log, :expanded, :celebration
+
+      def initialize(root:)
+        @root = root
+        @log = FeelingsLog.new(root:)
+        @last_feelings = {}
+        @cursor = 0
+        @tick = 0
+        @week = WeeklyBatch.new(log: @log)
+      end
+
+      def renderer = FeelingsRenderer
+      def target = self
+      # It shows Ruby code, which isn't written back.
+      def path = nil
+      def changed? = false
+      def typing? = !noting.nil?
+      def animating? = celebration&.raining? == true
+      def status(_navigator) = [:info, "This week's code to feel, #{batch.week}"]
+
+      # Reads the code again, keeping the batch, like after a method's edited or fixed, and the selected method, by its
+      # file and name, even when the methods around it change, moving the feelings about code that's changed, or gone, to
+      # the memories.
+      def load
+        was = selected
+        every = CodeMethods.list(@root)
+        @log.move_stale_to_memories(every)
+        @week.read(every)
+        self.cursor = code_methods.index { [it.path, it.label] == [was&.path, was&.label] } || @cursor
+      end
+
+      # The Batch of files whose methods are in the grid.
+      def batch = @week.batch
+      def code_methods = batch.code_methods
+
+      def selected = code_methods[@cursor]
+
+      def cursor=(index)
+        index = index.clamp(0, [code_methods.length - 1, 0].max)
+        @expanded = false unless index == @cursor
+        @cursor = index
+      end
+
+      # Each cell's method, by its index, in reading order, in a grid as many cells across as the columns.
+      # They're kept, so up and down move a row.
+      # The first time the grid's drawn, with its rows, right after the view opens, the batch is picked to fill them.
+      def cells(columns, rows = nil)
+        @week.fill(columns * rows) if rows
+        @columns = columns
+        @cells = code_methods.each_with_index.flat_map { |method, index| [index] * method.size }
+      end
+
+      # Every key while it's asking why or celebrating, and otherwise its own, but Tab to the files, or left from the
+      # first method.
+      def next_step?(key)
+        return true if typing? || celebration
+
+        (KEYS.include?(key) || BINS.key?(key)) && !(key == :left && @cursor.zero?)
+      end
+
+      def next_step(key)
+        return note_step(key) if typing?
+        return @celebration = nil if celebration&.over?(key)
+        return (@tick += 1).then { nil } if key == :tick
+        return (@celebration = Celebration.new).then { nil } if key == :celebrate
+        return unless selected
+        return feel(BINS[key]) if BINS.key?(key)
+
+        method_step(key)
+      end
+
+      private
+
+      # Moves between the methods, or acts on the selected one.
+      def method_step(key)
+        case key
+        when :left then move(-1)
+        when :right then move(1)
+        when :up then move_row(-1)
+        when :down then move_row(1)
+        when :edit then Edit.new(path: selected.path, line: selected.line)
+        when :execute then fix
+        when :enter, :toggle, :expand then (@expanded = !@expanded).then { nil }
+        end
+      end
+
+      # Asks to fix the method, with how it last felt, by its file and name, which stay the same when its lines change.
+      def fix = Fix.new(feeling: @last_feelings[[selected.path, selected.label]] || Feeling.new(method: selected, temper: nil, note: nil))
+
+      def move(by)
+        self.cursor = @cursor + by
+        nil
+      end
+
+      # To the method in the cell above or below the selected one's first cell.
+      def move_row(by)
+        cell = @cells[@cells.index(@cursor).to_i + (by * @columns)]
+        self.cursor = cell if cell
+        nil
+      end
+
+      # Frolic and numb are noted down straight away, while the rest ask why first.
+      def feel(temper)
+        return note_down(temper, nil) unless NOTED.include?(temper)
+
+        @noting = temper
+        @note = +''
+        nil
+      end
+
+      def note_step(key)
+        case key
+        when Type then @note << key.text
+        when :backspace then @note.chop!
+        when :enter then return note_down(@noting, (@note unless @note.strip.empty?))
+        when :escape then return note_down(@noting, nil)
+        end
+        nil
+      end
+
+      # Notes the feeling down, staying on the method, so it can be fixed with what was just said about it. It rains
+      # when that refines the batch.
+      def note_down(temper, note)
+        feeling = Feeling.new(method: selected, temper:, note:)
+        @last_feelings[[selected.path, selected.label]] = feeling
+        @noting = nil
+        refined = batch.refined?
+        @log.add(feeling)
+        @celebration = Celebration.new if !refined && batch.refined?
+        Felt.new(feeling:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require_relative 'rain'
+
+module Raindown
+  module TUI
+    # Fireworks, like over the Rain when a batch of code feelings is refined: rockets rising from the bottom, a row a
+    # tick, that burst in a bright colour into sparks flying out eight ways, which fade, then another rises in their
+    # place. Sparks fly twice as far across as up or down, as the cells are about twice as tall as they're wide:
+    #     ·   ·   ·
+    #      +  +  +
+    #       * * *
+    #   · + * * * + ·
+    #       * * *
+    #      +  +  +
+    #     ·   ·   ·
+    #         ╵
+    #         ·
+    class Fireworks
+      # The columns for each rocket in the air at once.
+      COLUMNS_A_ROCKET = 20
+      # The sparks, a frame each, as they fly out from one in the middle and fade.
+      SPARKS = %w[* * * + + · ·].freeze
+      # The eight ways sparks fly, as columns and rows a frame.
+      WAYS = [[-2, -1], [0, -1], [2, -1], [-2, 0], [2, 0], [-2, 1], [0, 1], [2, 1]].freeze
+      # Where a rocket rises, the row it bursts on, and its colour.
+      Rocket = Data.define(:column, :top, :color)
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      # Draws the rockets and bursts at the tick into a Scene's cells, each rocket a tick apart from the others by a
+      # checksum of it.
+      def draw(cells, tick)
+        [width / COLUMNS_A_ROCKET, 1].max.times do |rocket|
+          launch, frame = (tick + Zlib.crc32("rocket #{rocket}")).divmod(height + SPARKS.length)
+          firework(cells, rocket(Zlib.crc32("rocket #{rocket} #{launch}")), frame)
+        end
+      end
+
+      private
+
+      # A rocket, from the seed, a checksum of it and how many it's launched, bursting in the top half or so.
+      def rocket(seed)
+        Rocket.new(column: seed % width, top: (height / 5) + ((seed >> 8) % [height / 3, 1].max),
+                   color: Rain::COLORS[(seed >> 16) % Rain::COLORS.length])
+      end
+
+      # The rocket rising, with a spark trailing it, or once it's as high as it goes, bursting.
+      def firework(cells, rocket, frame)
+        rising = height - 1 - rocket.top
+        return burst(cells, rocket, frame - rising) if frame >= rising
+
+        put(cells, rocket.column, height - 1 - frame, '╵', rocket.color)
+        put(cells, rocket.column, height - frame, '·', rocket.color)
+      end
+
+      def burst(cells, rocket, frame)
+        return unless (spark = SPARKS[frame])
+
+        WAYS.each { |across, down| put(cells, rocket.column + (across * frame), rocket.top + (down * frame), spark, rocket.color) }
+      end
+
+      def put(cells, column, row, char, color)
+        cells[row][column] = [char, color] if row.between?(0, height - 1) && column.between?(0, width - 1)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Raindown
+  module TUI
+    # Rain, like when a batch of code feelings is refined: drops falling down some of the columns, each at its own speed
+    # and in a bright colour of its own, that splash and spread when they hit the bottom, then fall again from the top
+    # in another colour:
+    #       │          ╎
+    #       ╎    │          │
+    #     │     ╎        │
+    #    · ·   ◦       .   .
+    class Rain
+      # One column in RAINY has a drop.
+      RAINY = 4
+      # The splash, a frame each after a drop hits the bottom, as its distance either side of the drop's column.
+      SPLASH = [[0, '◦'], [1, '·'], [2, '.']].freeze
+      COLORS = %i[bright_red bright_orange bright_yellow bright_green bright_cyan bright_blue bright_purple bright_pink].freeze
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      # Draws the drops at the tick into a Scene's cells.
+      def draw(cells, tick)
+        width.times { drop(cells, it, Zlib.crc32("rain #{it}"), tick) }
+      end
+
+      private
+
+      # The column's drop, if it has one, from the seed, a checksum of the column, like how fast it falls and when it
+      # starts.
+      def drop(cells, column, seed, tick)
+        return unless (seed % RAINY).zero?
+
+        falling = (height + speed(seed) - 1) / speed(seed)
+        fallen, frame = (tick + (seed >> 8)).divmod(falling + SPLASH.length)
+        color = color(column, fallen)
+        return splash(cells, column, frame - falling, color) if frame >= falling
+
+        fall(cells, column, frame * speed(seed), color)
+      end
+
+      # A row or two a tick.
+      def speed(seed) = ((seed >> 4) % 2) + 1
+
+      # A colour each time the column's drop falls, from a checksum of how many times it has.
+      def color(column, fallen) = COLORS[Zlib.crc32("#{column} #{fallen}") % COLORS.length]
+
+      # The drop at the row, and its tail above it.
+      def fall(cells, column, row, color)
+        cells[row][column] = ['│', color]
+        cells[row - 1][column] = ['╎', color] if row.positive?
+      end
+
+      def splash(cells, column, frame, color)
+        spread, char = SPLASH[frame]
+        [column - spread, column + spread].uniq.each { cells[height - 1][it] = [char, color] if it.between?(0, width - 1) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../text'
+require_relative 'fireworks'
+require_relative 'rain'
+
+module Raindown
+  module TUI
+    # Animations drawn over each other, each into the same cells, a character and its style each, in turn, so the later
+    # ones are on top, like Fireworks over the Rain.
+    class Scene
+      include Text
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:, animations: [Rain, Fireworks])
+        @width = width
+        @height = height
+        @animations = animations.map { it.new(width:, height:) }
+      end
+
+      # The lines at the tick, as segments.
+      def lines(tick)
+        cells = Array.new(height) { Array.new(width) { [' ', :blank] } }
+        @animations.each { it.draw(cells, tick) }
+        cells.map { segments(it) }
+      end
+
+      private
+
+      # The row's runs of cells in the same style, a segment each.
+      def segments(row)
+        row.chunk_while { |cell, after| cell[1] == after[1] }.map { Segment.new(text: it.map(&:first).join, style: it[0][1], event: nil) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # The waffle after the rain with a pat of butter, when a batch of code is refined, and the week's work is done:
+    #    ╔═══╦═══╦═══╦═══╦═══╗
+    #    ║   ║   ║   ║   ║   ║
+    #    ╠═══╬═══╬═══╬═══╬═══╣
+    #    ║   ║   ║███║   ║   ║
+    #    ╠═══╬═══╬═══╬═══╬═══╣
+    #    ║   ║   ║   ║   ║   ║
+    #    ╚═══╩═══╩═══╩═══╩═══╝
+    module Waffle
+      EDGE = :code_number
+      BUTTER = :button
+      WAFFLE = [
+        [['╔═══╦═══╦═══╦═══╦═══╗', EDGE]],
+        [['║   ║   ║   ║   ║   ║', EDGE]],
+        [['╠═══╬═══╬═══╬═══╬═══╣', EDGE]],
+        [['║   ║   ║', EDGE], ['███', BUTTER], ['║   ║   ║', EDGE]],
+        [['╠═══╬═══╬═══╬═══╬═══╣', EDGE]],
+        [['║   ║   ║   ║   ║   ║', EDGE]],
+        [['╚═══╩═══╩═══╩═══╩═══╝', EDGE]],
+        [['100% refined', :feelings]],
+        [['The work is mysterious and important.', :feelings]]
+      ].freeze
+
+      private
+
+      def waffle
+        top = [(height - WAFFLE.length) / 2, 0].max
+        lines = [*Array.new(top, []), *WAFFLE, *Array.new(height, [])].first(height)
+        lines.map { centred(it) }
+      end
+
+      # The parts in the middle of the width.
+      def centred(parts)
+        left = [(width - parts.sum { display_width(it[0]) }) / 2, 0].max
+        padded([segment('', :blank, width: left), *parts.map { |text, style| segment(text, style, width: display_width(text)) }])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'batch'
+
+module Raindown
+  module TUI
+    # This week's Batch of a project's code to feel, picked to fill the grid when the view first opens and draws it,
+    # then kept through reloads, like after a method's edited or fixed.
+    class WeeklyBatch
+      attr_reader :batch
+
+      def initialize(log:)
+        @log = log
+        @batch = Batch.new(files: [], code_methods: [], log:, week: Batch.this_week)
+      end
+
+      # The methods read again, keeping the batch's files.
+      def read(every)
+        @every = every
+        @batch = batch.reading(every)
+      end
+
+      # Picks the batch to fill the grid's cells, once they're known.
+      def fill(grid_cells)
+        return if @filled
+
+        @filled = true
+        @batch = Batch.pick(@every, log: @log, cells: grid_cells)
+      end
+    end
+  end
+end

data/lib/raindown/tui/file_tree.rb

@@ -1,54 +1,97 @@
 # frozen_string_literal: true
 
 require_relative '../projects'
+require_relative 'events'
+require_relative 'views/outline_view'
 require_relative 'row'
 
 module Raindown
   module TUI
-    # The files pane: a project's Markdown files as a tree, with folders before files, where folders fold.
+    # The nav pane's files: a project's Markdown files as a tree, with folders before files,
+    # including the files of the projects inside it, whose folders are marked with Raindown's cloud.
+    # Folders start folded, and open with Enter, or when a file in them opens.
+    # A scope narrows it to one project's own files, from the project's folder, like when it's chosen in the header.
     class FileTree
       attr_reader :root
+      # The project the files are narrowed to, or nil for all of them.
+      attr_accessor :scope
 
-      def initialize(root:)
+      def initialize(root:, workers:)
         @root = root
-        @folded = Set.new
+        @workers = workers
+        @expanded = Set.new
         load
       end
 
+      # The rain cloud without its emoji variation selector, which every terminal draws one column wide, so it lines up
+      # the files with the panes beside them. With the selector, as in the title, some terminals draw it two.
+      PROJECT = '🌧'
+
       def load
-        @files = Projects.files(root)
+        @files = Projects.files(root, nested: true)
+        @projects = Projects.roots(root).to_set
       end
 
+      # The folder the tree starts from: the scope's, or the root's.
+      def base = scope || root
+
       def rows
         tree = {}
-        @files.each { |path| relative(path).split('/').reduce(tree) { |node, part| node[part] ||= {} } }
+        files.each { |path| relative(path).split('/').reduce(tree) { |node, part| node[part] ||= {} } }
         tree_rows(tree, '', 0)
       end
 
       def toggle(folder)
-        @folded.delete?(folder) || @folded.add(folder)
+        @expanded.delete?(folder) || @expanded.add(folder)
+      end
+
+      # Opens the folders the file is in, so its row is shown.
+      def reveal(path)
+        folder = File.dirname(path)
+        while folder.start_with?(File.join(root, ''))
+          @expanded.add(folder)
+          folder = File.dirname(folder)
+        end
       end
 
       def relative(path)
-        path.delete_prefix(File.join(root, ''))
+        path.delete_prefix(File.join(base, ''))
+      end
+
+      # A scope's own files, without those of the projects inside it, which are projects of their own.
+      def files
+        return @files unless scope
+
+        @files.select { |path| owner(path) == scope }
       end
 
       private
 
+      def owner(path)
+        [root, *@projects].select { path.start_with?(File.join(it, '')) }.max_by(&:length)
+      end
+
       def tree_rows(tree, prefix, depth)
         folders, files = tree.partition { |_name, children| children.any? }
 
         folders.sort.flat_map { |name, children| folder_rows(name, children, prefix, depth) } +
-          files.sort.map { |name, _| Row.new(text: name, depth:, kind: :file, target: File.join(root, prefix, name)) }
+          files.sort.map { |name, _| file_row(name, File.join(base, prefix, name), depth) }
+      end
+
+      def file_row(name, path, depth)
+        Row.new(text: name, depth:, kind: :file, target: path, open: OpenView.new(view: OutlineView.new(path, workers: @workers)))
       end
 
       # A folder, and the tree inside it unless it's folded.
       def folder_rows(name, children, prefix, depth)
-        folder = File.join(root, prefix, name)
-        folded = @folded.include?(folder)
-        row = Row.new(text: "#{folded ? '▸' : '▾'} #{name}/", depth:, kind: :folder, target: folder)
+        folder = File.join(base, prefix, name)
+        expanded = @expanded.include?(folder)
+        project = @projects.include?(folder)
+        row = Row.new(text: [expanded ? '▾' : '▸', (PROJECT if project), "#{name}/"].compact.join(' '), depth:,
+                      kind: project ? :project : :folder, target: folder, fold: -> { toggle(folder) })
+        return [row] unless expanded
 
-        [row, *(tree_rows(children, File.join(prefix, name), depth + 1) unless folded)]
+        [row, *tree_rows(children, File.join(prefix, name), depth + 1)]
       end
     end
   end

data/lib/raindown/tui/highlighter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # Code coloured with Rouge, which knows over 200 languages, as each line's [text, style] parts. Each part's style is
+    # the kind of token it is, like a keyword or a string, from the few code styles Styles has, so they work in any
+    # terminal. Code in a language Rouge doesn't know is a plain part a line.
+    module Highlighter
+      # Each kind of token's style, by the start of its name, like Literal.String.Double for a string, most specific first.
+      STYLES = [['Name.Function', :code_function], ['Name.Class', :code_constant], ['Name.Constant', :code_constant],
+                ['Name.Builtin', :code_constant], ['Name.Label', :code_constant], ['Keyword', :code_keyword],
+                ['Literal.String', :code_string], ['Literal.Number', :code_number], ['Comment', :code_comment]].freeze
+
+      module_function
+
+      # The lines highlighted for a file's name, like shapes.rb, or a code fence's language, like json. Markdown
+      # highlights the code in its fences in their own languages, like an endpoint's request and response.
+      def lines(lines, filename: nil, language: nil)
+        lexer = lexer(filename:, language:)
+        return lines.map { [[it, :code]] } unless lexer
+
+        lexer.lex(lines.join("\n")).each_with_object([[]]) do |(token, text), highlighted|
+          text.split(/(\n)/).each do |piece|
+            next highlighted << [] if piece == "\n"
+
+            highlighted.last << [piece, style(token)] unless piece.empty?
+          end
+        end
+      end
+
+      # Rouge takes about a third of a second to load, so the TUI loads it when it starts, rather than with its code.
+      def lexer(filename:, language:)
+        require 'rouge'
+        lexer = Rouge::Lexer.find_fancy(language) unless language.to_s.empty?
+        lexer ||= Rouge::Lexer.guess_by_filename(filename).new if filename
+        lexer unless lexer.is_a?(Rouge::Lexers::PlainText)
+      end
+
+      def style(token)
+        name = token.qualname
+        STYLES.find { |prefix, _| name.start_with?(prefix) }&.last || :code
+      end
+    end
+  end
+end