prdigest 0.1.0

data/lib/prdigest/renderer.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Prdigest
+  class Renderer
+    Output = Data.define(:chunks, :outcome)
+    SUPPORTED_TAG = %r{</?(?:b|a)(?:\s+href="[^"]*")?>}.freeze
+
+    def self.parsed_length(html)
+      CGI.unescapeHTML(html.gsub(SUPPORTED_TAG, "")).length
+    end
+
+    def initialize(send_empty:, empty_message:, limit: 4_096)
+      @send_empty = send_empty
+      @empty_message = empty_message.to_s
+      @limit = Integer(limit)
+    end
+
+    def render(digest)
+      return render_empty(digest) if digest.total_prs.zero?
+
+      pack(digest)
+    rescue RenderError
+      raise
+    rescue StandardError => e
+      raise RenderError, "digest rendering failed: #{e.class}"
+    end
+
+    private
+
+    def render_empty(digest)
+      return Output.new([].freeze, "suppressed_empty") unless @send_empty
+
+      text = escape(@empty_message.gsub("{date}", digest.date.iso8601))
+      raise RenderError, "configured empty message exceeds Telegram limit" unless fits_text?(text)
+      Output.new([text.freeze].freeze, "rendered")
+    end
+
+    def pack(digest)
+      chunks = []
+      heading = "<b>Merged PR digest — #{digest.date.iso8601}</b>"
+      continuation = "<b>Merged PR digest — #{digest.date.iso8601} (cont.)</b>"
+      current = [heading]
+
+      digest.repositories.each do |section|
+        next if section.pull_requests.empty?
+        current = add_section(chunks, current, continuation, section)
+      end
+
+      footer = render_footer(digest)
+      unless fits_parts?(current + [footer])
+        flush!(chunks, current)
+        current = [continuation, footer]
+        raise RenderError, "digest footer exceeds Telegram limit" unless fits_parts?(current)
+      else
+        current << footer
+      end
+      flush!(chunks, current)
+      Output.new(chunks.map(&:freeze).freeze, "rendered")
+    end
+
+    def add_section(chunks, current, continuation, section)
+      header = "<b>#{escape(section.name)}</b>"
+      entries = section.pull_requests.map { |pull| render_pull(pull) }
+      whole = ([header] + entries).join("\n")
+      if fits_parts?(current + [whole])
+        current << whole
+        return current
+      end
+
+      if current.length > 1
+        flush!(chunks, current)
+        current = [continuation]
+        if fits_parts?(current + [whole])
+          current << whole
+          return current
+        end
+      end
+
+      section_part = header
+      entries.each do |entry|
+        proposed = "#{section_part}\n#{entry}"
+        if fits_parts?(current + [proposed])
+          section_part = proposed
+          next
+        end
+
+        if section_part == header
+          raise RenderError, "pull request entry exceeds Telegram limit"
+        end
+        current << section_part
+        flush!(chunks, current)
+        current = [continuation]
+        section_part = "<b>#{escape(section.name)} (cont.)</b>\n#{entry}"
+        raise RenderError, "pull request entry exceeds Telegram limit" unless fits_parts?(current + [section_part])
+      end
+      current << section_part
+      current
+    end
+
+    def render_pull(pull)
+      number_and_title = "##{pull.number} #{pull.title}"
+      "• <a href=\"#{escape(pull.url)}\">#{escape(number_and_title)}</a> — @#{escape(pull.author)}"
+    end
+
+    def render_footer(digest)
+      label = digest.total_prs == 1 ? "PR" : "PRs"
+      footer = "<b>Total:</b> #{digest.total_prs} #{label}"
+      if digest.line_stats
+        footer += " · +#{digest.total_additions}/−#{digest.total_deletions} · #{digest.total_commits} commits"
+      end
+      footer
+    end
+
+    def flush!(chunks, parts)
+      text = parts.join("\n\n")
+      raise RenderError, "rendered chunk exceeds Telegram limit" unless fits_text?(text)
+      chunks << text
+    end
+
+    def fits_parts?(parts)
+      fits_text?(parts.join("\n\n"))
+    end
+
+    def fits_text?(text)
+      self.class.parsed_length(text) <= @limit
+    end
+
+    def escape(value)
+      CGI.escapeHTML(value.to_s)
+    end
+  end
+end

data/lib/prdigest/result.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Prdigest
+  class Result
+    SCHEMA = "prdigest-result"
+    SCHEMA_VERSION = 1
+    REQUIRED_FIELDS = %i[
+      status mode requested_days settled_days skipped_days failed_date remaining_days error
+    ].freeze
+    EXIT_CODES = {
+      "config" => 2, "cli" => 2, "refusal" => 2,
+      "github" => 3,
+      "telegram" => 4, "telegram_refused" => 4, "telegram_permanent" => 4,
+      "telegram_ambiguous" => 4, "delivery_checkpoint" => 4,
+      "delivery_checkpoint_permanent" => 4,
+      "state" => 5
+    }.freeze
+
+    attr_reader(*REQUIRED_FIELDS, :chunks, :delivery)
+
+    def initialize(status:, mode:, requested_days: [], settled_days: [], skipped_days: [],
+                   failed_date: nil, remaining_days: [], error: nil, chunks: [], delivery: nil)
+      @status = status.to_s.freeze
+      @mode = mode.to_s.freeze
+      @requested_days = Array(requested_days).freeze
+      @settled_days = Array(settled_days).freeze
+      @skipped_days = Array(skipped_days).freeze
+      @failed_date = failed_date
+      @remaining_days = Array(remaining_days).freeze
+      @error = error&.transform_keys(&:to_sym)&.freeze
+      @chunks = Array(chunks).map(&:to_s).freeze
+      @delivery = delivery&.transform_keys(&:to_sym)&.freeze
+      freeze
+    end
+
+    def self.failure(mode:, error_kind:, message:, requested_days: [], settled_days: [], skipped_days: [],
+                     failed_date: nil, remaining_days: [], chunks: [], delivery: nil)
+      progress = !settled_days.empty? || !skipped_days.empty?
+      new(
+        status: progress ? "partial_failure" : "failure",
+        mode: mode,
+        requested_days: requested_days,
+        settled_days: settled_days,
+        skipped_days: skipped_days,
+        failed_date: failed_date,
+        remaining_days: remaining_days,
+        error: { kind: error_kind.to_s, message: message.to_s },
+        chunks: chunks,
+        delivery: delivery
+      )
+    end
+
+    def exit_code
+      return 0 if %w[success dry_run].include?(status)
+      return 6 if status == "partial_failure"
+      EXIT_CODES.fetch(error && error[:kind], 1)
+    end
+
+    def to_h
+      {
+        schema: SCHEMA,
+        schema_version: SCHEMA_VERSION,
+        status: status,
+        mode: mode,
+        requested_days: serialize_dates(requested_days),
+        settled_days: serialize_dates(settled_days),
+        skipped_days: serialize_dates(skipped_days),
+        failed_date: failed_date&.to_s,
+        remaining_days: serialize_dates(remaining_days),
+        error: error,
+        chunks: chunks,
+        delivery: delivery
+      }
+    end
+
+    private
+
+    def serialize_dates(values)
+      values.map(&:to_s)
+    end
+  end
+end

data/lib/prdigest/runner.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Prdigest
+  class Runner
+    def initialize(config:, date: nil, dry_run: false, clock: nil, state_factory: nil,
+                   github: nil, renderer: nil, telegram_factory: nil, repositories: nil, env: ENV)
+      @config = config
+      @date = date && Date.iso8601(date.to_s)
+      @dry_run = dry_run
+      @clock = clock || Clock.new(timezone: config.timezone)
+      @state_factory = state_factory || -> { State.new(path: config.state_path, timezone: config.timezone) }
+      @env = env
+      @repositories = repositories || config.repos
+      @github = github || GitHub.new(token: config.github_token(env))
+      @renderer = renderer || Renderer.new(send_empty: config.send_empty?, empty_message: config.empty_message)
+      @delivery_checkpoint_store_factory = lambda {
+        DeliveryCheckpointStore.new(root: config.delivery_state_path)
+      }
+      @telegram_factory = telegram_factory || lambda {
+        Telegram.new(
+          token: config.telegram_token(env),
+          chat_id: config.chat_id,
+          allowlist: config.chat_id_allowlist
+        )
+      }
+    end
+
+    def call
+      mode = @date ? "explicit_date_replay" : "scheduled"
+      requested = []
+      settled = []
+      skipped = []
+      chunks = []
+      failed_date = nil
+      delivery = nil
+      state = nil
+      skip_audit = nil
+
+      if @dry_run || @date
+        requested = [@date || @clock.yesterday]
+      else
+        state = @state_factory.call
+        yesterday = @clock.yesterday
+        record = state.read(yesterday: yesterday)
+        skip_audit = record.last_skip
+        skipped.concat(expand_skip(skip_audit)) if skip_audit && skip_audit[:notice_pending]
+        schedule = Schedule.new(
+          yesterday: yesterday,
+          last_digested_date: record.last_digested_date,
+          max_catchup_days: @config.max_catchup_days
+        ).call
+        requested = schedule.requested_days
+        unless schedule.skipped_days.empty?
+          skip_audit = merge_skip_audit(skip_audit, schedule.skipped_days)
+          state.write(last_digested_date: schedule.skipped_days.last, last_skip: skip_audit)
+          skipped |= schedule.skipped_days
+        end
+      end
+
+      telegram = nil
+      requested.each do |date|
+        failed_date = date
+        window = @clock.window(date)
+        digest = if window.zero_length?
+                     DayDigest.build(date: date, repository_order: @repositories, pulls: [], line_stats: @config.line_stats?)
+                 else
+                   @github.fetch(
+                     date: date,
+                     window: window,
+                     repositories: @repositories,
+                     line_stats: @config.line_stats?
+                   )
+                 end
+        rendered = @renderer.render(digest)
+        if @dry_run
+          chunks.concat(rendered.chunks)
+          next
+        end
+
+        unless rendered.chunks.empty?
+          telegram ||= @telegram_factory.call
+          delivery = telegram.deliver(
+            rendered.chunks,
+            digest_date: date,
+            checkpoint_store: @delivery_checkpoint_store_factory.call,
+            scope: @repositories
+          )
+        end
+        if state
+          if skip_audit
+            skip_audit = skip_audit.merge(notice_pending: false)
+          end
+          state.write(last_digested_date: date, last_skip: skip_audit)
+        end
+        settled << date
+        failed_date = nil
+      end
+
+      Result.new(
+        status: @dry_run ? "dry_run" : "success",
+        mode: mode,
+        requested_days: requested,
+        settled_days: settled,
+        skipped_days: skipped,
+        chunks: chunks,
+        delivery: delivery
+      )
+    rescue StandardError => e
+      Result.failure(
+        mode: mode || (@date ? "explicit_date_replay" : "scheduled"),
+        error_kind: error_kind(e),
+        message: safe_message(e),
+        requested_days: requested || [],
+        settled_days: settled || [],
+        skipped_days: skipped || [],
+        failed_date: failed_date,
+        remaining_days: remaining_days(requested || [], failed_date),
+        chunks: chunks || [],
+        delivery: e.is_a?(SendError) ? e.delivery : delivery
+      )
+    end
+
+    def inspect
+      "#<#{self.class} mode=#{@date ? "explicit_date_replay" : "scheduled"} " \
+        "dry_run=#{@dry_run} credentials=[REDACTED]>"
+    end
+
+    alias to_s inspect
+
+    private
+
+    def expand_skip(audit)
+      return [] unless audit
+      (audit.fetch(:start_date)..audit.fetch(:end_date)).to_a
+    end
+
+    def merge_skip_audit(existing, dates)
+      start_date = if existing && existing[:notice_pending]
+                     [existing[:start_date], dates.first].min
+                   else
+                     dates.first
+                   end
+      { start_date: start_date, end_date: dates.last, notice_pending: true }
+    end
+
+    def remaining_days(requested, failed_date)
+      return requested unless failed_date
+      index = requested.index(failed_date)
+      index ? requested.drop(index) : [failed_date]
+    end
+
+    def error_kind(error)
+      case error
+      when ConfigError then "config"
+      when FetchError then error.kind
+      when SendError then error.kind
+      when StateError then "state"
+      when RenderError then error.kind
+      else "internal"
+      end
+    end
+
+    def safe_message(error)
+      message = error.is_a?(Error) ? error.message : "unexpected failure (#{error.class})"
+      secrets = []
+      secrets << @config.github_token(@env) if @config.respond_to?(:github_token)
+      secrets << @config.telegram_token(@env) if @config.respond_to?(:telegram_token)
+      secrets.compact.reject(&:empty?).reduce(message.dup) { |safe, secret| safe.gsub(secret, "[REDACTED]") }
+    end
+  end
+end

data/lib/prdigest/schedule.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Prdigest
+  class Schedule
+    Result = Data.define(:skipped_days, :requested_days)
+
+    def initialize(yesterday:, last_digested_date:, max_catchup_days:)
+      @yesterday = Date.iso8601(yesterday.to_s)
+      @last_digested_date = last_digested_date && Date.iso8601(last_digested_date.to_s)
+      @max_catchup_days = Integer(max_catchup_days)
+    end
+
+    def call
+      raise ArgumentError, "max_catchup_days must be from 1 to 30" unless (1..30).cover?(@max_catchup_days)
+      raise ArgumentError, "last digested date is in the future" if @last_digested_date && @last_digested_date > @yesterday
+
+      owed = if @last_digested_date.nil?
+               [@yesterday]
+             elsif @last_digested_date == @yesterday
+               []
+             else
+               ((@last_digested_date + 1)..@yesterday).to_a
+             end
+      split = [owed.length - @max_catchup_days, 0].max
+      Result.new(owed.first(split).freeze, owed.drop(split).freeze)
+    end
+  end
+end

data/lib/prdigest/state.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "date"
+require "fileutils"
+require "json"
+require "securerandom"
+
+module Prdigest
+  class State
+    VERSION = 1
+    Record = Data.define(:last_digested_date, :last_skip)
+
+    def initialize(path:, timezone:, rename: File.method(:rename), directory_sync: nil)
+      @path = File.expand_path(path)
+      @timezone = timezone
+      @rename = rename
+      @directory_sync = directory_sync || method(:sync_directory)
+    end
+
+    def read(yesterday: nil)
+      return Record.new(nil, nil) unless File.exist?(@path)
+
+      payload = JSON.parse(File.binread(@path))
+      validate_payload!(payload, yesterday: yesterday)
+    rescue StateError
+      raise
+    rescue StandardError => e
+      raise StateError, "cannot read state: #{e.class}"
+    end
+
+    def write(last_digested_date:, last_skip: nil)
+      directory = File.dirname(@path)
+      FileUtils.mkdir_p(directory, mode: 0o700)
+      temp_path = File.join(directory, ".#{File.basename(@path)}.tmp-#{SecureRandom.hex(8)}")
+      payload = JSON.generate(serialize(last_digested_date, last_skip)) << "\n"
+
+      File.open(temp_path, File::WRONLY | File::CREAT | File::EXCL, 0o600) do |file|
+        file.write(payload)
+        file.chmod(0o600)
+        file.flush
+        file.fsync
+      end
+      rollback_path = preserve_previous_checkpoint(directory)
+      @rename.call(temp_path, @path)
+      begin
+        @directory_sync.call(directory)
+      rescue StandardError
+        restore_previous_checkpoint(rollback_path)
+        raise
+      end
+      Record.new(Date.iso8601(last_digested_date.to_s), normalize_skip(last_skip))
+    rescue StandardError => e
+      raise StateError, "cannot write state: #{e.class}"
+    ensure
+      File.unlink(temp_path) if defined?(temp_path) && temp_path && File.exist?(temp_path)
+      discard_rollback(rollback_path) if defined?(rollback_path) && rollback_path
+    end
+
+    private
+
+    def sync_directory(directory)
+      File.open(directory, File::RDONLY) { |dir| dir.fsync }
+    end
+
+    def preserve_previous_checkpoint(directory)
+      rollback_path = File.join(directory, ".#{File.basename(@path)}.rollback-#{SecureRandom.hex(8)}")
+      File.link(@path, rollback_path)
+      rollback_path
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def restore_previous_checkpoint(rollback_path)
+      if rollback_path
+        File.rename(rollback_path, @path)
+      else
+        File.unlink(@path)
+      end
+    rescue Errno::ENOENT
+      raise if rollback_path
+      nil
+    end
+
+    def discard_rollback(rollback_path)
+      FileUtils.rm_f(rollback_path) if rollback_path
+    end
+
+    def validate_payload!(payload, yesterday:)
+      raise StateError, "state root must be an object" unless payload.is_a?(Hash)
+      raise StateError, "unsupported state version" unless payload["version"] == VERSION
+      raise StateError, "state timezone does not match config" unless payload["timezone"] == @timezone
+      raise StateError, "state last_digested_date is required" unless payload.key?("last_digested_date")
+
+      value = payload["last_digested_date"]
+      last_date = Date.iso8601(value)
+      raise StateError, "state date is in the future" if yesterday && last_date && last_date > Date.iso8601(yesterday.to_s)
+
+      skip = parse_skip(payload["last_skip"])
+      if skip && (skip[:start_date] > skip[:end_date] || skip[:end_date] > last_date)
+        raise StateError, "state last_skip range is invalid"
+      end
+      Record.new(last_date, skip)
+    rescue Date::Error, TypeError
+      raise StateError, "state contains an invalid date"
+    end
+
+    def parse_skip(value)
+      return nil if value.nil?
+      raise StateError, "state last_skip is invalid" unless value.is_a?(Hash)
+
+      pending = value.fetch("notice_pending")
+      raise StateError, "state last_skip is invalid" unless pending == true || pending == false
+      {
+        start_date: Date.iso8601(value.fetch("start_date")),
+        end_date: Date.iso8601(value.fetch("end_date")),
+        notice_pending: pending
+      }
+    rescue KeyError
+      raise StateError, "state last_skip is invalid"
+    end
+
+    def normalize_skip(skip)
+      return nil unless skip
+      {
+        start_date: Date.iso8601(skip.fetch(:start_date).to_s),
+        end_date: Date.iso8601(skip.fetch(:end_date).to_s),
+        notice_pending: skip.fetch(:notice_pending) == true
+      }
+    end
+
+    def serialize(last_date, last_skip)
+      payload = {
+        version: VERSION,
+        timezone: @timezone,
+        last_digested_date: Date.iso8601(last_date.to_s).iso8601
+      }
+      if (skip = normalize_skip(last_skip))
+        payload[:last_skip] = {
+          start_date: skip[:start_date].iso8601,
+          end_date: skip[:end_date].iso8601,
+          notice_pending: skip[:notice_pending]
+        }
+      end
+      payload
+    end
+  end
+end