samagotchi 0.149.0 → 0.151.0

data/lib/samagotchi/block_renderers.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  autoload :Log, File.expand_path("log", __dir__)
+  autoload :VERSION, File.expand_path("version", __dir__)
+  module MemoryBundle
+    autoload :Manifest, File.expand_path("memory_bundle/manifest", __dir__)
+    autoload :Provenance, File.expand_path("memory_bundle/provenance", __dir__)
+  end
+
+  # Declarative block renderers (docs/plugins.md, docs/internals/block-renderers.md):
+  # a bundle's manifest maps a fenced block's language to the scripts/ files the
+  # owner's page loads to draw it:
+  #
+  #   block_renderers:
+  #     - lang: mermaid
+  #       load: [mermaid.tiny.js, mermaid_renderer.js]
+  #
+  # JS draws, in a sandboxed frame; Ruby only routes and serves, so chi web
+  # (which runs no plugins) can answer, and a reloaded page draws after the
+  # worker has gone. The installer records them in the bundle's provenance;
+  # .for_installed reads them from there.
+  module BlockRenderers
+    # A renderer as the manifest declares it.
+    Renderer = Data.define(:lang, :load) do
+      def to_h = { "lang" => lang, "load" => load }
+    end
+
+    # One the page may use: the bundle that won the language, and its files.
+    Installed = Data.define(:lang, :bundle, :files)
+
+    class Invalid < ArgumentError; end
+
+    # A language a block can carry: a fence's first word, downcased
+    # (MarkdownRenderer sets it as data-lang under this same pattern).
+    LANG = /\A[a-z0-9_+-]{1,32}\z/
+
+    module_function
+
+    # The manifest's block_renderers: list.
+    # @return [Array<Renderer>] [] when absent
+    # @raise [Invalid]
+    def parse_list(raw)
+      return [] if raw.nil?
+      raise Invalid, "block_renderers: must be a list of mappings" unless raw.is_a?(Array)
+
+      renderers = raw.map { |item| parse(item) }
+      twice = renderers.map(&:lang).tally.select { |_lang, count| count > 1 }.keys
+      raise Invalid, "block_renderers: #{twice.join(", ")} listed more than once" unless twice.empty?
+
+      renderers
+    end
+
+    # @raise [Invalid]
+    def parse(item)
+      raise Invalid, "block_renderers: each item must be a mapping, not #{item.inspect}" unless item.is_a?(Hash)
+
+      data = item.transform_keys(&:to_s)
+      lang = data["lang"]
+      unless lang.is_a?(String) && lang.match?(LANG)
+        raise Invalid, "block_renderers: lang #{lang.inspect} isn't a fence's language (lowercase letters, digits, _ + -; at most 32)"
+      end
+
+      load = data["load"]
+      unless load.is_a?(Array) && !load.empty? && load.all? { |file| file.is_a?(String) && file.match?(MemoryBundle::Manifest::SCRIPT_FILE) }
+        raise Invalid, "block_renderers: #{lang}'s load must be a non-empty list of file names in scripts/, not #{load.inspect}"
+      end
+
+      Renderer.new(lang: lang, load: load)
+    end
+
+    # What the installed bundles draw: the first bundle by name wins a
+    # language. A bundle whose requires_chi this chi doesn't meet, or whose list
+    # doesn't parse (logged), is skipped; a record that doesn't read lists none.
+    # @return [Array<Installed>]
+    def for_installed
+      taken = {}
+      MemoryBundle::Provenance.each_installed do |bundle, record|
+        next unless record.block_renderers?
+        next if MemoryBundle::Manifest.requires_chi_failure(record.requires_chi, VERSION)
+
+        renderers(bundle, record).each do |renderer|
+          taken[renderer.lang] ||= Installed.new(lang: renderer.lang, bundle: bundle, files: renderer.load)
+        end
+      end
+      taken.values
+    end
+
+    # The installed path of +file+, once a renderer .for_installed lists loads
+    # it from +bundle+ (neither name is ever joined into a path before that:
+    # they come from the URL) and it is as installed. This code runs in the
+    # owner's browser, so it is checked as a plugin's load and a provider's
+    # script are; a --dev install's links are not.
+    # @return [String, nil] nil when no such renderer loads such a file
+    # @raise [Invalid] the file is gone or changed
+    def script_path(bundle, file)
+      return nil unless for_installed.any? { |renderer| renderer.bundle == bundle && renderer.files.include?(file) }
+
+      provenance = MemoryBundle::Provenance.new(name: bundle)
+      path = File.join(provenance.scripts_dir, file)
+      recorded = provenance.record&.scripts&.fetch(file, nil)
+      return path if File.file?(path) && MemoryBundle::Provenance.sha_matches?(path, recorded)
+
+      raise Invalid, "bundle #{bundle}'s scripts/#{file} differs from the installed one (reinstall the bundle)"
+    end
+
+    def renderers(bundle, record)
+      parse_list(record.block_renderers)
+    rescue ArgumentError => e # Invalid is one; so are a record's bytes that aren't UTF-8
+      Log.warn(:web, "block_renderers_unreadable", bundle: bundle, msg: e.message)
+      []
+    end
+    private_class_method :renderers
+  end
+end

data/lib/samagotchi/bootstrap_command.rb

@@ -477,11 +477,14 @@ module Samagotchi
 
     def system_bundle_line(result, dry_run)
       version = "v#{result.to || result.from}"
+      standing = MemoryBundle::FileStanding.clauses(MemoryBundle::SystemBundle::BUNDLE_NAME, nil, merged: Array(result.merged),
+                                                                                                         behind: Array(result.behind), dry_run: dry_run).join("; ")
       text = case result.status
              when :installed then dry_run ? "would install #{version}" : "#{version} installed"
-             when :updated then "#{result.from} → #{result.to} #{dry_run ? "would update" : "updated"}"
+             when :updated then "#{result.from} → #{result.to} #{dry_run ? "would update" : "updated"}#{" (#{standing})" unless standing.empty?}"
              when :restored then "#{version} #{dry_run ? "would restore" : "restored"} missing files"
-             when :up_to_date then "#{version} up to date"
+             when :merged then "#{version} #{standing}"
+             when :up_to_date then "#{version} #{standing.empty? ? "up to date" : standing}"
              when :newer_installed then "v#{result.from} left as is (newer than this chi's v#{result.to})"
              when :skipped then "skipped (#{result.error})"
              else "failed (#{result.error})"

data/lib/samagotchi/bridge/card_places.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../steer"
+
+module Samagotchi
+  class Bridge
+    # Where a CardStore's entries sit in a session's messages: the turns the
+    # page draws after each. The messages count, with the rule the page and
+    # the recap share (Steer.turn_opening?); the store's turn log only orders
+    # the ids. So a turn with no opening (a reminder, a Continue, a failed or
+    # rolled-back one, a prompt stopped before the model) counts nothing, and
+    # an opening with no id (/continue no's reason, Qwen's recovery line) counts
+    # as it does on the page. Nothing orders such an opening against an entry, so
+    # an entry says how many it came after (+past_idless+, #idless_after). Pure:
+    # no Engine, no file.
+    class CardPlaces
+      # @param turn_log [Array<String>] the turn ids, oldest first
+      # @param messages [Array<Hash>] the messages the page draws
+      def initialize(turn_log, messages)
+        positions = turn_log.each_with_index.to_h
+        @ids = Array(messages).select { |message| Steer.turn_opening?(message) }.map { |message| message[:turn_id] || message["turn_id"] }
+        @openings = @ids.size
+        @opened = @ids.compact.to_set
+        @places = @ids.map { |id| positions[id] }
+        index_by_position(@places, turn_log.size)
+        @positions = positions
+      end
+
+      # The openings after the last one whose turn is at or before the entry's
+      # in the log (none: from the first one whose turn is later; none: 0),
+      # less the ones with no id it came after. An entry from an older file
+      # (+base_since+) has no id: all the log's turns are later, on top of what
+      # it had counted.
+      # @param entry [Hash] a store's entry: :turn_id, :base_since
+      # @return [Integer]
+      def turns_since(entry)
+        position = @positions.fetch(entry[:turn_id], -1)
+        at_or_before = position >= 0 ? @last_at_or_before[position] : nil
+        since = if at_or_before
+                  @openings - at_or_before - 1 - [entry[:past_idless].to_i, idless_run(at_or_before)].min
+                else
+                  later = @first_after[position + 1]
+                  later ? @openings - later : 0
+                end
+        entry[:base_since].to_i + since
+      end
+
+      # The openings with no id right after the one +turn_id+ counts from: what
+      # an entry shown now has come after. A rollback can only shorten the run, so
+      # a count read back against it never eats a later turn.
+      # @return [Integer]
+      def idless_after(turn_id)
+        position = @positions.fetch(turn_id, -1)
+        at_or_before = position >= 0 ? @last_at_or_before[position] : nil
+        at_or_before ? idless_run(at_or_before) : 0
+      end
+
+      # Where a log may start and still read an entry at +position+ the same: at
+      # the opening that entry counts from, or at the entry's turn with none.
+      # @return [Integer] a log position
+      def log_start_for(position)
+        at_or_before = @last_at_or_before[position]
+        at_or_before ? @places[at_or_before] : position
+      end
+
+      # @return [Boolean] whether that turn has an opening in the messages
+      def opened?(turn_id)
+        @opened.include?(turn_id)
+      end
+
+      private
+
+      def idless_run(opening)
+        @ids.drop(opening + 1).take_while(&:nil?).size
+      end
+
+      # For each log position: the last opening at or before it, and the first
+      # one at or after it. One pass each, for the store's many entries.
+      def index_by_position(places, size)
+        @last_at_or_before = Array.new(size)
+        @first_after = Array.new(size + 1)
+        places.each_with_index do |place, opening|
+          next unless place
+
+          @last_at_or_before[place] = opening
+          @first_after[place] ||= opening
+        end
+        (1...size).each { |i| @last_at_or_before[i] = [@last_at_or_before[i - 1], @last_at_or_before[i]].compact.max }
+        (size - 1).downto(0) { |i| @first_after[i] = [@first_after[i], @first_after[i + 1]].compact.min }
+      end
+    end
+  end
+end