output.go

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"strings"

	"github.com/charmbracelet/glamour"
	"github.com/charmbracelet/lipgloss"
	"github.com/charmbracelet/lipgloss/table"
	"github.com/mattn/go-isatty"
)

func outputJSON(entry *ChangelogEntry) {
	encoder := json.NewEncoder(os.Stdout)
	encoder.SetIndent("", "  ")
	if err := encoder.Encode(entry); err != nil {
		fmt.Fprintf(os.Stderr, "Error encoding JSON: %v\n", err)
		os.Exit(1)
	}
}

func outputMarkdown(entry *ChangelogEntry) {
	if !entry.ReleasedAt.IsZero() {
		fmt.Printf("## %s (%s)\n\n", entry.Version, entry.ReleasedAt.Format("2006-01-02"))
	} else {
		fmt.Printf("## %s\n\n", entry.Version)
	}

	// Output sectioned changes
	for _, section := range entry.Sections {
		fmt.Printf("### %s\n\n", section.Name)
		for _, change := range section.Changes {
			fmt.Printf("- %s\n", change)
		}
		fmt.Println()
	}

	// Output ungrouped changes
	for _, change := range entry.Changes {
		fmt.Printf("- %s\n", change)
	}
}

func outputVersionList(displayName string, entries []ChangelogEntry) {
	if !isatty.IsTerminal(os.Stdout.Fd()) && !isatty.IsCygwinTerminal(os.Stdout.Fd()) {
		for _, entry := range entries {
			fmt.Println(entry.Version)
		}
		return
	}

	fmt.Printf("%s — %d releases\n\n", displayName, len(entries))

	rows := make([][]string, len(entries))
	for i, entry := range entries {
		date := "-"
		ago := "-"
		if !entry.ReleasedAt.IsZero() {
			date = entry.ReleasedAt.Format("2006-01-02")
			ago = formatRelativeTime(entry.ReleasedAt)
		}
		rows[i] = []string{entry.Version, date, ago}
	}

	headerStyle := lipgloss.NewStyle().Bold(true)

	t := table.New().
		Border(lipgloss.NormalBorder()).
		Headers("Version", "Released", "Ago").
		Rows(rows...).
		StyleFunc(func(row, col int) lipgloss.Style {
			if row == table.HeaderRow {
				return headerStyle
			}
			return lipgloss.NewStyle()
		})

	fmt.Println(t)
}

func outputRendered(displayName string, entry *ChangelogEntry) {
	var dateStr string
	if !entry.ReleasedAt.IsZero() {
		dateStr = fmt.Sprintf(" (%s)", entry.ReleasedAt.Format("2006-01-02"))
	}
	md := fmt.Sprintf("# %s %s%s\n\n%s", displayName, entry.Version, dateStr, entry.RawBody)

	rendered, err := glamour.RenderWithEnvironmentConfig(md)
	if err != nil {
		outputPlainText(displayName, entry)
		return
	}
	fmt.Print(rendered)
}

func outputPlainText(displayName string, entry *ChangelogEntry) {
	if !entry.ReleasedAt.IsZero() {
		fmt.Printf("%s %s (%s)\n", displayName, entry.Version, entry.ReleasedAt.Format("2006-01-02"))
	} else {
		fmt.Printf("%s %s\n", displayName, entry.Version)
	}
	fmt.Println(strings.Repeat("-", 40))

	// Output sectioned changes
	for _, section := range entry.Sections {
		fmt.Printf("\n[%s]\n", section.Name)
		for _, change := range section.Changes {
			fmt.Printf("  * %s\n", change)
		}
	}

	// Output ungrouped changes
	if len(entry.Sections) > 0 && len(entry.Changes) > 0 {
		fmt.Println()
	}
	for _, change := range entry.Changes {
		fmt.Printf("  * %s\n", change)
	}
}