prdigest 0.1.1 → 0.3.0

data/lib/prdigest/result.rb

@@ -1,82 +0,0 @@
-# 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

@@ -1,173 +0,0 @@
-# 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

@@ -1,30 +0,0 @@
-# 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

@@ -1,147 +0,0 @@
-# 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