|
@@ -0,0 +1,995 @@
|
|
|
|
|
+package diff
|
|
|
|
|
+
|
|
|
|
|
+import (
|
|
|
|
|
+ "bytes"
|
|
|
|
|
+ "fmt"
|
|
|
|
|
+ "io"
|
|
|
|
|
+ "regexp"
|
|
|
|
|
+ "strconv"
|
|
|
|
|
+ "strings"
|
|
|
|
|
+ "time"
|
|
|
|
|
+
|
|
|
|
|
+ "github.com/alecthomas/chroma/v2"
|
|
|
|
|
+ "github.com/alecthomas/chroma/v2/formatters"
|
|
|
|
|
+ "github.com/alecthomas/chroma/v2/lexers"
|
|
|
|
|
+ "github.com/alecthomas/chroma/v2/styles"
|
|
|
|
|
+ "github.com/charmbracelet/lipgloss"
|
|
|
|
|
+ "github.com/charmbracelet/x/ansi"
|
|
|
|
|
+ "github.com/sergi/go-diff/diffmatchpatch"
|
|
|
|
|
+)
|
|
|
|
|
+
|
|
|
|
|
+// LineType represents the kind of line in a diff.
|
|
|
|
|
+type LineType int
|
|
|
|
|
+
|
|
|
|
|
+const (
|
|
|
|
|
+ // LineContext represents a line that exists in both the old and new file.
|
|
|
|
|
+ LineContext LineType = iota
|
|
|
|
|
+ // LineAdded represents a line added in the new file.
|
|
|
|
|
+ LineAdded
|
|
|
|
|
+ // LineRemoved represents a line removed from the old file.
|
|
|
|
|
+ LineRemoved
|
|
|
|
|
+)
|
|
|
|
|
+
|
|
|
|
|
+// DiffLine represents a single line in a diff, either from the old file,
|
|
|
|
|
+// the new file, or a context line.
|
|
|
|
|
+type DiffLine struct {
|
|
|
|
|
+ OldLineNo int // Line number in the old file (0 for added lines)
|
|
|
|
|
+ NewLineNo int // Line number in the new file (0 for removed lines)
|
|
|
|
|
+ Kind LineType // Type of line (added, removed, context)
|
|
|
|
|
+ Content string // Content of the line
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// Hunk represents a section of changes in a diff.
|
|
|
|
|
+type Hunk struct {
|
|
|
|
|
+ Header string
|
|
|
|
|
+ Lines []DiffLine
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// DiffResult contains the parsed result of a diff.
|
|
|
|
|
+type DiffResult struct {
|
|
|
|
|
+ OldFile string
|
|
|
|
|
+ NewFile string
|
|
|
|
|
+ Hunks []Hunk
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// HunkDelta represents the change statistics for a hunk.
|
|
|
|
|
+type HunkDelta struct {
|
|
|
|
|
+ StartLine1 int
|
|
|
|
|
+ LineCount1 int
|
|
|
|
|
+ StartLine2 int
|
|
|
|
|
+ LineCount2 int
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// linePair represents a pair of lines to be displayed side by side.
|
|
|
|
|
+type linePair struct {
|
|
|
|
|
+ left *DiffLine
|
|
|
|
|
+ right *DiffLine
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// -------------------------------------------------------------------------
|
|
|
|
|
+// Style Configuration with Option Pattern
|
|
|
|
|
+// -------------------------------------------------------------------------
|
|
|
|
|
+
|
|
|
|
|
+// StyleConfig defines styling for diff rendering.
|
|
|
|
|
+type StyleConfig struct {
|
|
|
|
|
+ RemovedLineBg lipgloss.Color
|
|
|
|
|
+ AddedLineBg lipgloss.Color
|
|
|
|
|
+ ContextLineBg lipgloss.Color
|
|
|
|
|
+ HunkLineBg lipgloss.Color
|
|
|
|
|
+ HunkLineFg lipgloss.Color
|
|
|
|
|
+ RemovedFg lipgloss.Color
|
|
|
|
|
+ AddedFg lipgloss.Color
|
|
|
|
|
+ LineNumberFg lipgloss.Color
|
|
|
|
|
+ HighlightStyle string
|
|
|
|
|
+ RemovedHighlightBg lipgloss.Color
|
|
|
|
|
+ AddedHighlightBg lipgloss.Color
|
|
|
|
|
+ RemovedLineNumberBg lipgloss.Color
|
|
|
|
|
+ AddedLineNamerBg lipgloss.Color
|
|
|
|
|
+ RemovedHighlightFg lipgloss.Color
|
|
|
|
|
+ AddedHighlightFg lipgloss.Color
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// StyleOption defines a function that modifies a StyleConfig.
|
|
|
|
|
+type StyleOption func(*StyleConfig)
|
|
|
|
|
+
|
|
|
|
|
+// NewStyleConfig creates a StyleConfig with default values and applies any provided options.
|
|
|
|
|
+func NewStyleConfig(opts ...StyleOption) StyleConfig {
|
|
|
|
|
+ // Set default values
|
|
|
|
|
+ config := StyleConfig{
|
|
|
|
|
+ RemovedLineBg: lipgloss.Color("#3A3030"),
|
|
|
|
|
+ AddedLineBg: lipgloss.Color("#303A30"),
|
|
|
|
|
+ ContextLineBg: lipgloss.Color("#212121"),
|
|
|
|
|
+ HunkLineBg: lipgloss.Color("#2A2822"),
|
|
|
|
|
+ HunkLineFg: lipgloss.Color("#D4AF37"),
|
|
|
|
|
+ RemovedFg: lipgloss.Color("#7C4444"),
|
|
|
|
|
+ AddedFg: lipgloss.Color("#478247"),
|
|
|
|
|
+ LineNumberFg: lipgloss.Color("#888888"),
|
|
|
|
|
+ HighlightStyle: "dracula",
|
|
|
|
|
+ RemovedHighlightBg: lipgloss.Color("#612726"),
|
|
|
|
|
+ AddedHighlightBg: lipgloss.Color("#256125"),
|
|
|
|
|
+ RemovedLineNumberBg: lipgloss.Color("#332929"),
|
|
|
|
|
+ AddedLineNamerBg: lipgloss.Color("#293229"),
|
|
|
|
|
+ RemovedHighlightFg: lipgloss.Color("#FADADD"),
|
|
|
|
|
+ AddedHighlightFg: lipgloss.Color("#DAFADA"),
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Apply all provided options
|
|
|
|
|
+ for _, opt := range opts {
|
|
|
|
|
+ opt(&config)
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ return config
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithRemovedLineBg sets the background color for removed lines.
|
|
|
|
|
+func WithRemovedLineBg(color lipgloss.Color) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.RemovedLineBg = color
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithAddedLineBg sets the background color for added lines.
|
|
|
|
|
+func WithAddedLineBg(color lipgloss.Color) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.AddedLineBg = color
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithContextLineBg sets the background color for context lines.
|
|
|
|
|
+func WithContextLineBg(color lipgloss.Color) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.ContextLineBg = color
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithRemovedFg sets the foreground color for removed line markers.
|
|
|
|
|
+func WithRemovedFg(color lipgloss.Color) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.RemovedFg = color
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithAddedFg sets the foreground color for added line markers.
|
|
|
|
|
+func WithAddedFg(color lipgloss.Color) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.AddedFg = color
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithLineNumberFg sets the foreground color for line numbers.
|
|
|
|
|
+func WithLineNumberFg(color lipgloss.Color) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.LineNumberFg = color
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithHighlightStyle sets the syntax highlighting style.
|
|
|
|
|
+func WithHighlightStyle(style string) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.HighlightStyle = style
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithRemovedHighlightColors sets the colors for highlighted parts in removed text.
|
|
|
|
|
+func WithRemovedHighlightColors(bg, fg lipgloss.Color) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.RemovedHighlightBg = bg
|
|
|
|
|
+ s.RemovedHighlightFg = fg
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithAddedHighlightColors sets the colors for highlighted parts in added text.
|
|
|
|
|
+func WithAddedHighlightColors(bg, fg lipgloss.Color) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.AddedHighlightBg = bg
|
|
|
|
|
+ s.AddedHighlightFg = fg
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithRemovedLineNumberBg sets the background color for removed line numbers.
|
|
|
|
|
+func WithRemovedLineNumberBg(color lipgloss.Color) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.RemovedLineNumberBg = color
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithAddedLineNumberBg sets the background color for added line numbers.
|
|
|
|
|
+func WithAddedLineNumberBg(color lipgloss.Color) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.AddedLineNamerBg = color
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+func WithHunkLineBg(color lipgloss.Color) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.HunkLineBg = color
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+func WithHunkLineFg(color lipgloss.Color) StyleOption {
|
|
|
|
|
+ return func(s *StyleConfig) {
|
|
|
|
|
+ s.HunkLineFg = color
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// -------------------------------------------------------------------------
|
|
|
|
|
+// Parse Options with Option Pattern
|
|
|
|
|
+// -------------------------------------------------------------------------
|
|
|
|
|
+
|
|
|
|
|
+// ParseConfig configures the behavior of diff parsing.
|
|
|
|
|
+type ParseConfig struct {
|
|
|
|
|
+ ContextSize int // Number of context lines to include
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// ParseOption defines a function that modifies a ParseConfig.
|
|
|
|
|
+type ParseOption func(*ParseConfig)
|
|
|
|
|
+
|
|
|
|
|
+// NewParseConfig creates a ParseConfig with default values and applies any provided options.
|
|
|
|
|
+func NewParseConfig(opts ...ParseOption) ParseConfig {
|
|
|
|
|
+ // Set default values
|
|
|
|
|
+ config := ParseConfig{
|
|
|
|
|
+ ContextSize: 3,
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Apply all provided options
|
|
|
|
|
+ for _, opt := range opts {
|
|
|
|
|
+ opt(&config)
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ return config
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithContextSize sets the number of context lines to include.
|
|
|
|
|
+func WithContextSize(size int) ParseOption {
|
|
|
|
|
+ return func(p *ParseConfig) {
|
|
|
|
|
+ if size >= 0 {
|
|
|
|
|
+ p.ContextSize = size
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// -------------------------------------------------------------------------
|
|
|
|
|
+// Side-by-Side Options with Option Pattern
|
|
|
|
|
+// -------------------------------------------------------------------------
|
|
|
|
|
+
|
|
|
|
|
+// SideBySideConfig configures the rendering of side-by-side diffs.
|
|
|
|
|
+type SideBySideConfig struct {
|
|
|
|
|
+ TotalWidth int
|
|
|
|
|
+ Style StyleConfig
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// SideBySideOption defines a function that modifies a SideBySideConfig.
|
|
|
|
|
+type SideBySideOption func(*SideBySideConfig)
|
|
|
|
|
+
|
|
|
|
|
+// NewSideBySideConfig creates a SideBySideConfig with default values and applies any provided options.
|
|
|
|
|
+func NewSideBySideConfig(opts ...SideBySideOption) SideBySideConfig {
|
|
|
|
|
+ // Set default values
|
|
|
|
|
+ config := SideBySideConfig{
|
|
|
|
|
+ TotalWidth: 160, // Default width for side-by-side view
|
|
|
|
|
+ Style: NewStyleConfig(),
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Apply all provided options
|
|
|
|
|
+ for _, opt := range opts {
|
|
|
|
|
+ opt(&config)
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ return config
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithTotalWidth sets the total width for side-by-side view.
|
|
|
|
|
+func WithTotalWidth(width int) SideBySideOption {
|
|
|
|
|
+ return func(s *SideBySideConfig) {
|
|
|
|
|
+ if width > 0 {
|
|
|
|
|
+ s.TotalWidth = width
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithStyle sets the styling configuration.
|
|
|
|
|
+func WithStyle(style StyleConfig) SideBySideOption {
|
|
|
|
|
+ return func(s *SideBySideConfig) {
|
|
|
|
|
+ s.Style = style
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// WithStyleOptions applies the specified style options.
|
|
|
|
|
+func WithStyleOptions(opts ...StyleOption) SideBySideOption {
|
|
|
|
|
+ return func(s *SideBySideConfig) {
|
|
|
|
|
+ s.Style = NewStyleConfig(opts...)
|
|
|
|
|
+ }
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// -------------------------------------------------------------------------
|
|
|
|
|
+// Diff Parsing and Generation
|
|
|
|
|
+// -------------------------------------------------------------------------
|
|
|
|
|
+
|
|
|
|
|
+// ParseUnifiedDiff parses a unified diff format string into structured data.
|
|
|
|
|
+func ParseUnifiedDiff(diff string) (DiffResult, error) {
|
|
|
|
|
+ var result DiffResult
|
|
|
|
|
+ var currentHunk *Hunk
|
|
|
|
|
+
|
|
|
|
|
+ hunkHeaderRe := regexp.MustCompile(`^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@`)
|
|
|
|
|
+ lines := strings.Split(diff, "\n")
|
|
|
|
|
+
|
|
|
|
|
+ var oldLine, newLine int
|
|
|
|
|
+ inFileHeader := true
|
|
|
|
|
+
|
|
|
|
|
+ for _, line := range lines {
|
|
|
|
|
+ // Parse the file headers
|
|
|
|
|
+ if inFileHeader {
|
|
|
|
|
+ if strings.HasPrefix(line, "--- a/") {
|
|
|
|
|
+ result.OldFile = strings.TrimPrefix(line, "--- a/")
|
|
|
|
|
+ continue
|
|
|
|
|
+ }
|
|
|
|
|
+ if strings.HasPrefix(line, "+++ b/") {
|
|
|
|
|
+ result.NewFile = strings.TrimPrefix(line, "+++ b/")
|
|
|
|
|
+ inFileHeader = false
|
|
|
|
|
+ continue
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Parse hunk headers
|
|
|
|
|
+ if matches := hunkHeaderRe.FindStringSubmatch(line); matches != nil {
|
|
|
|
|
+ if currentHunk != nil {
|
|
|
|
|
+ result.Hunks = append(result.Hunks, *currentHunk)
|
|
|
|
|
+ }
|
|
|
|
|
+ currentHunk = &Hunk{
|
|
|
|
|
+ Header: line,
|
|
|
|
|
+ Lines: []DiffLine{},
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ oldStart, _ := strconv.Atoi(matches[1])
|
|
|
|
|
+ newStart, _ := strconv.Atoi(matches[3])
|
|
|
|
|
+ oldLine = oldStart
|
|
|
|
|
+ newLine = newStart
|
|
|
|
|
+
|
|
|
|
|
+ continue
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ if currentHunk == nil {
|
|
|
|
|
+ continue
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ if len(line) > 0 {
|
|
|
|
|
+ // Process the line based on its prefix
|
|
|
|
|
+ switch line[0] {
|
|
|
|
|
+ case '+':
|
|
|
|
|
+ currentHunk.Lines = append(currentHunk.Lines, DiffLine{
|
|
|
|
|
+ OldLineNo: 0,
|
|
|
|
|
+ NewLineNo: newLine,
|
|
|
|
|
+ Kind: LineAdded,
|
|
|
|
|
+ Content: line[1:], // skip '+'
|
|
|
|
|
+ })
|
|
|
|
|
+ newLine++
|
|
|
|
|
+ case '-':
|
|
|
|
|
+ currentHunk.Lines = append(currentHunk.Lines, DiffLine{
|
|
|
|
|
+ OldLineNo: oldLine,
|
|
|
|
|
+ NewLineNo: 0,
|
|
|
|
|
+ Kind: LineRemoved,
|
|
|
|
|
+ Content: line[1:], // skip '-'
|
|
|
|
|
+ })
|
|
|
|
|
+ oldLine++
|
|
|
|
|
+ default:
|
|
|
|
|
+ currentHunk.Lines = append(currentHunk.Lines, DiffLine{
|
|
|
|
|
+ OldLineNo: oldLine,
|
|
|
|
|
+ NewLineNo: newLine,
|
|
|
|
|
+ Kind: LineContext,
|
|
|
|
|
+ Content: line,
|
|
|
|
|
+ })
|
|
|
|
|
+ oldLine++
|
|
|
|
|
+ newLine++
|
|
|
|
|
+ }
|
|
|
|
|
+ } else {
|
|
|
|
|
+ // Handle empty lines
|
|
|
|
|
+ currentHunk.Lines = append(currentHunk.Lines, DiffLine{
|
|
|
|
|
+ OldLineNo: oldLine,
|
|
|
|
|
+ NewLineNo: newLine,
|
|
|
|
|
+ Kind: LineContext,
|
|
|
|
|
+ Content: "",
|
|
|
|
|
+ })
|
|
|
|
|
+ oldLine++
|
|
|
|
|
+ newLine++
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Add the last hunk if there is one
|
|
|
|
|
+ if currentHunk != nil {
|
|
|
|
|
+ result.Hunks = append(result.Hunks, *currentHunk)
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ return result, nil
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// HighlightIntralineChanges updates the content of lines in a hunk to show
|
|
|
|
|
+// character-level differences within lines.
|
|
|
|
|
+func HighlightIntralineChanges(h *Hunk, style StyleConfig) {
|
|
|
|
|
+ var updated []DiffLine
|
|
|
|
|
+ dmp := diffmatchpatch.New()
|
|
|
|
|
+
|
|
|
|
|
+ for i := 0; i < len(h.Lines); i++ {
|
|
|
|
|
+ // Look for removed line followed by added line, which might have similar content
|
|
|
|
|
+ if i+1 < len(h.Lines) &&
|
|
|
|
|
+ h.Lines[i].Kind == LineRemoved &&
|
|
|
|
|
+ h.Lines[i+1].Kind == LineAdded {
|
|
|
|
|
+
|
|
|
|
|
+ oldLine := h.Lines[i]
|
|
|
|
|
+ newLine := h.Lines[i+1]
|
|
|
|
|
+
|
|
|
|
|
+ // Find character-level differences
|
|
|
|
|
+ patches := dmp.DiffMain(oldLine.Content, newLine.Content, false)
|
|
|
|
|
+ patches = dmp.DiffCleanupEfficiency(patches)
|
|
|
|
|
+ patches = dmp.DiffCleanupSemantic(patches)
|
|
|
|
|
+
|
|
|
|
|
+ // Apply highlighting to the differences
|
|
|
|
|
+ oldLine.Content = colorizeSegments(patches, true, style)
|
|
|
|
|
+ newLine.Content = colorizeSegments(patches, false, style)
|
|
|
|
|
+
|
|
|
|
|
+ updated = append(updated, oldLine, newLine)
|
|
|
|
|
+ i++ // Skip the next line as we've already processed it
|
|
|
|
|
+ } else {
|
|
|
|
|
+ updated = append(updated, h.Lines[i])
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ h.Lines = updated
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// colorizeSegments applies styles to the character-level diff segments.
|
|
|
|
|
+func colorizeSegments(diffs []diffmatchpatch.Diff, isOld bool, style StyleConfig) string {
|
|
|
|
|
+ var buf strings.Builder
|
|
|
|
|
+
|
|
|
|
|
+ removeBg := lipgloss.NewStyle().
|
|
|
|
|
+ Background(style.RemovedHighlightBg).
|
|
|
|
|
+ Foreground(style.RemovedHighlightFg)
|
|
|
|
|
+
|
|
|
|
|
+ addBg := lipgloss.NewStyle().
|
|
|
|
|
+ Background(style.AddedHighlightBg).
|
|
|
|
|
+ Foreground(style.AddedHighlightFg)
|
|
|
|
|
+
|
|
|
|
|
+ removedLineStyle := lipgloss.NewStyle().Background(style.RemovedLineBg)
|
|
|
|
|
+ addedLineStyle := lipgloss.NewStyle().Background(style.AddedLineBg)
|
|
|
|
|
+
|
|
|
|
|
+ afterBg := false
|
|
|
|
|
+
|
|
|
|
|
+ for _, d := range diffs {
|
|
|
|
|
+ switch d.Type {
|
|
|
|
|
+ case diffmatchpatch.DiffEqual:
|
|
|
|
|
+ // Handle text that's the same in both versions
|
|
|
|
|
+ if afterBg {
|
|
|
|
|
+ if isOld {
|
|
|
|
|
+ buf.WriteString(removedLineStyle.Render(d.Text))
|
|
|
|
|
+ } else {
|
|
|
|
|
+ buf.WriteString(addedLineStyle.Render(d.Text))
|
|
|
|
|
+ }
|
|
|
|
|
+ } else {
|
|
|
|
|
+ buf.WriteString(d.Text)
|
|
|
|
|
+ }
|
|
|
|
|
+ case diffmatchpatch.DiffDelete:
|
|
|
|
|
+ // Handle deleted text (only show in old version)
|
|
|
|
|
+ if isOld {
|
|
|
|
|
+ buf.WriteString(removeBg.Render(d.Text))
|
|
|
|
|
+ afterBg = true
|
|
|
|
|
+ }
|
|
|
|
|
+ case diffmatchpatch.DiffInsert:
|
|
|
|
|
+ // Handle inserted text (only show in new version)
|
|
|
|
|
+ if !isOld {
|
|
|
|
|
+ buf.WriteString(addBg.Render(d.Text))
|
|
|
|
|
+ afterBg = true
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ return buf.String()
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// pairLines converts a flat list of diff lines to pairs for side-by-side display.
|
|
|
|
|
+func pairLines(lines []DiffLine) []linePair {
|
|
|
|
|
+ var pairs []linePair
|
|
|
|
|
+ i := 0
|
|
|
|
|
+
|
|
|
|
|
+ for i < len(lines) {
|
|
|
|
|
+ switch lines[i].Kind {
|
|
|
|
|
+ case LineRemoved:
|
|
|
|
|
+ // Check if the next line is an addition, if so pair them
|
|
|
|
|
+ if i+1 < len(lines) && lines[i+1].Kind == LineAdded {
|
|
|
|
|
+ pairs = append(pairs, linePair{left: &lines[i], right: &lines[i+1]})
|
|
|
|
|
+ i += 2
|
|
|
|
|
+ } else {
|
|
|
|
|
+ pairs = append(pairs, linePair{left: &lines[i], right: nil})
|
|
|
|
|
+ i++
|
|
|
|
|
+ }
|
|
|
|
|
+ case LineAdded:
|
|
|
|
|
+ pairs = append(pairs, linePair{left: nil, right: &lines[i]})
|
|
|
|
|
+ i++
|
|
|
|
|
+ case LineContext:
|
|
|
|
|
+ pairs = append(pairs, linePair{left: &lines[i], right: &lines[i]})
|
|
|
|
|
+ i++
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ return pairs
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// -------------------------------------------------------------------------
|
|
|
|
|
+// Syntax Highlighting
|
|
|
|
|
+// -------------------------------------------------------------------------
|
|
|
|
|
+
|
|
|
|
|
+// SyntaxHighlight applies syntax highlighting to a string based on the file extension.
|
|
|
|
|
+func SyntaxHighlight(w io.Writer, source, fileName, formatter string, bg lipgloss.TerminalColor) error {
|
|
|
|
|
+ // Determine the language lexer to use
|
|
|
|
|
+ l := lexers.Match(fileName)
|
|
|
|
|
+ if l == nil {
|
|
|
|
|
+ l = lexers.Analyse(source)
|
|
|
|
|
+ }
|
|
|
|
|
+ if l == nil {
|
|
|
|
|
+ l = lexers.Fallback
|
|
|
|
|
+ }
|
|
|
|
|
+ l = chroma.Coalesce(l)
|
|
|
|
|
+
|
|
|
|
|
+ // Get the formatter
|
|
|
|
|
+ f := formatters.Get(formatter)
|
|
|
|
|
+ if f == nil {
|
|
|
|
|
+ f = formatters.Fallback
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Get the style
|
|
|
|
|
+ s := styles.Get("dracula")
|
|
|
|
|
+ if s == nil {
|
|
|
|
|
+ s = styles.Fallback
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Modify the style to use the provided background
|
|
|
|
|
+ s, err := s.Builder().Transform(
|
|
|
|
|
+ func(t chroma.StyleEntry) chroma.StyleEntry {
|
|
|
|
|
+ r, g, b, _ := bg.RGBA()
|
|
|
|
|
+ ru8 := uint8(r >> 8)
|
|
|
|
|
+ gu8 := uint8(g >> 8)
|
|
|
|
|
+ bu8 := uint8(b >> 8)
|
|
|
|
|
+ t.Background = chroma.NewColour(ru8, gu8, bu8)
|
|
|
|
|
+ return t
|
|
|
|
|
+ },
|
|
|
|
|
+ ).Build()
|
|
|
|
|
+ if err != nil {
|
|
|
|
|
+ s = styles.Fallback
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Tokenize and format
|
|
|
|
|
+ it, err := l.Tokenise(nil, source)
|
|
|
|
|
+ if err != nil {
|
|
|
|
|
+ return err
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ return f.Format(w, s, it)
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// highlightLine applies syntax highlighting to a single line.
|
|
|
|
|
+func highlightLine(fileName string, line string, bg lipgloss.TerminalColor) string {
|
|
|
|
|
+ var buf bytes.Buffer
|
|
|
|
|
+ err := SyntaxHighlight(&buf, line, fileName, "terminal16m", bg)
|
|
|
|
|
+ if err != nil {
|
|
|
|
|
+ return line
|
|
|
|
|
+ }
|
|
|
|
|
+ return buf.String()
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// createStyles generates the lipgloss styles needed for rendering diffs.
|
|
|
|
|
+func createStyles(config StyleConfig) (removedLineStyle, addedLineStyle, contextLineStyle, lineNumberStyle lipgloss.Style) {
|
|
|
|
|
+ removedLineStyle = lipgloss.NewStyle().Background(config.RemovedLineBg)
|
|
|
|
|
+ addedLineStyle = lipgloss.NewStyle().Background(config.AddedLineBg)
|
|
|
|
|
+ contextLineStyle = lipgloss.NewStyle().Background(config.ContextLineBg)
|
|
|
|
|
+ lineNumberStyle = lipgloss.NewStyle().Foreground(config.LineNumberFg)
|
|
|
|
|
+
|
|
|
|
|
+ return
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// renderLeftColumn formats the left side of a side-by-side diff.
|
|
|
|
|
+func renderLeftColumn(fileName string, dl *DiffLine, colWidth int, styles StyleConfig) string {
|
|
|
|
|
+ if dl == nil {
|
|
|
|
|
+ contextLineStyle := lipgloss.NewStyle().Background(styles.ContextLineBg)
|
|
|
|
|
+ return contextLineStyle.Width(colWidth).Render("")
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ removedLineStyle, _, contextLineStyle, lineNumberStyle := createStyles(styles)
|
|
|
|
|
+
|
|
|
|
|
+ var marker string
|
|
|
|
|
+ var bgStyle lipgloss.Style
|
|
|
|
|
+
|
|
|
|
|
+ switch dl.Kind {
|
|
|
|
|
+ case LineRemoved:
|
|
|
|
|
+ marker = removedLineStyle.Foreground(styles.RemovedFg).Render("-")
|
|
|
|
|
+ bgStyle = removedLineStyle
|
|
|
|
|
+ lineNumberStyle = lineNumberStyle.Foreground(styles.RemovedFg).Background(styles.RemovedLineNumberBg)
|
|
|
|
|
+ case LineAdded:
|
|
|
|
|
+ marker = "?"
|
|
|
|
|
+ bgStyle = contextLineStyle
|
|
|
|
|
+ case LineContext:
|
|
|
|
|
+ marker = contextLineStyle.Render(" ")
|
|
|
|
|
+ bgStyle = contextLineStyle
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ lineNum := ""
|
|
|
|
|
+ if dl.OldLineNo > 0 {
|
|
|
|
|
+ lineNum = fmt.Sprintf("%6d", dl.OldLineNo)
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ prefix := lineNumberStyle.Render(lineNum + " " + marker)
|
|
|
|
|
+ content := highlightLine(fileName, dl.Content, bgStyle.GetBackground())
|
|
|
|
|
+
|
|
|
|
|
+ if dl.Kind == LineRemoved {
|
|
|
|
|
+ content = bgStyle.Render(" ") + content
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ lineText := prefix + content
|
|
|
|
|
+ return bgStyle.MaxHeight(1).Width(colWidth).Render(ansi.Truncate(lineText, colWidth, "..."))
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// renderRightColumn formats the right side of a side-by-side diff.
|
|
|
|
|
+func renderRightColumn(fileName string, dl *DiffLine, colWidth int, styles StyleConfig) string {
|
|
|
|
|
+ if dl == nil {
|
|
|
|
|
+ contextLineStyle := lipgloss.NewStyle().Background(styles.ContextLineBg)
|
|
|
|
|
+ return contextLineStyle.Width(colWidth).Render("")
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ _, addedLineStyle, contextLineStyle, lineNumberStyle := createStyles(styles)
|
|
|
|
|
+
|
|
|
|
|
+ var marker string
|
|
|
|
|
+ var bgStyle lipgloss.Style
|
|
|
|
|
+
|
|
|
|
|
+ switch dl.Kind {
|
|
|
|
|
+ case LineAdded:
|
|
|
|
|
+ marker = addedLineStyle.Foreground(styles.AddedFg).Render("+")
|
|
|
|
|
+ bgStyle = addedLineStyle
|
|
|
|
|
+ lineNumberStyle = lineNumberStyle.Foreground(styles.AddedFg).Background(styles.AddedLineNamerBg)
|
|
|
|
|
+ case LineRemoved:
|
|
|
|
|
+ marker = "?"
|
|
|
|
|
+ bgStyle = contextLineStyle
|
|
|
|
|
+ case LineContext:
|
|
|
|
|
+ marker = contextLineStyle.Render(" ")
|
|
|
|
|
+ bgStyle = contextLineStyle
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ lineNum := ""
|
|
|
|
|
+ if dl.NewLineNo > 0 {
|
|
|
|
|
+ lineNum = fmt.Sprintf("%6d", dl.NewLineNo)
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ prefix := lineNumberStyle.Render(lineNum + " " + marker)
|
|
|
|
|
+ content := highlightLine(fileName, dl.Content, bgStyle.GetBackground())
|
|
|
|
|
+
|
|
|
|
|
+ if dl.Kind == LineAdded {
|
|
|
|
|
+ content = bgStyle.Render(" ") + content
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ lineText := prefix + content
|
|
|
|
|
+ return bgStyle.MaxHeight(1).Width(colWidth).Render(ansi.Truncate(lineText, colWidth, "..."))
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// -------------------------------------------------------------------------
|
|
|
|
|
+// Public API Methods
|
|
|
|
|
+// -------------------------------------------------------------------------
|
|
|
|
|
+
|
|
|
|
|
+// RenderSideBySideHunk formats a hunk for side-by-side display.
|
|
|
|
|
+func RenderSideBySideHunk(fileName string, h Hunk, opts ...SideBySideOption) string {
|
|
|
|
|
+ // Apply options to create the configuration
|
|
|
|
|
+ config := NewSideBySideConfig(opts...)
|
|
|
|
|
+
|
|
|
|
|
+ // Make a copy of the hunk so we don't modify the original
|
|
|
|
|
+ hunkCopy := Hunk{Lines: make([]DiffLine, len(h.Lines))}
|
|
|
|
|
+ copy(hunkCopy.Lines, h.Lines)
|
|
|
|
|
+
|
|
|
|
|
+ // Highlight changes within lines
|
|
|
|
|
+ HighlightIntralineChanges(&hunkCopy, config.Style)
|
|
|
|
|
+
|
|
|
|
|
+ // Pair lines for side-by-side display
|
|
|
|
|
+ pairs := pairLines(hunkCopy.Lines)
|
|
|
|
|
+
|
|
|
|
|
+ // Calculate column width
|
|
|
|
|
+ colWidth := config.TotalWidth / 2
|
|
|
|
|
+
|
|
|
|
|
+ var sb strings.Builder
|
|
|
|
|
+ for _, p := range pairs {
|
|
|
|
|
+ leftStr := renderLeftColumn(fileName, p.left, colWidth, config.Style)
|
|
|
|
|
+ rightStr := renderRightColumn(fileName, p.right, colWidth, config.Style)
|
|
|
|
|
+ sb.WriteString(leftStr + rightStr + "\n")
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ return sb.String()
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// FormatDiff creates a side-by-side formatted view of a diff.
|
|
|
|
|
+func FormatDiff(diffText string, opts ...SideBySideOption) (string, error) {
|
|
|
|
|
+ diffResult, err := ParseUnifiedDiff(diffText)
|
|
|
|
|
+ if err != nil {
|
|
|
|
|
+ return "", err
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ var sb strings.Builder
|
|
|
|
|
+
|
|
|
|
|
+ config := NewSideBySideConfig(opts...)
|
|
|
|
|
+ for i, h := range diffResult.Hunks {
|
|
|
|
|
+ if i > 0 {
|
|
|
|
|
+ sb.WriteString(lipgloss.NewStyle().Background(config.Style.HunkLineBg).Foreground(config.Style.HunkLineFg).Width(config.TotalWidth).Render(h.Header) + "\n")
|
|
|
|
|
+ }
|
|
|
|
|
+ sb.WriteString(RenderSideBySideHunk(diffResult.OldFile, h, opts...))
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ return sb.String(), nil
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// GenerateDiff creates a unified diff from two file contents.
|
|
|
|
|
+func GenerateDiff(beforeContent, afterContent, beforeFilename, afterFilename string, opts ...ParseOption) (string, int, int) {
|
|
|
|
|
+ config := NewParseConfig(opts...)
|
|
|
|
|
+
|
|
|
|
|
+ var output strings.Builder
|
|
|
|
|
+
|
|
|
|
|
+ // Ensure we handle newlines correctly
|
|
|
|
|
+ beforeHasNewline := len(beforeContent) > 0 && beforeContent[len(beforeContent)-1] == '\n'
|
|
|
|
|
+ afterHasNewline := len(afterContent) > 0 && afterContent[len(afterContent)-1] == '\n'
|
|
|
|
|
+
|
|
|
|
|
+ // Split into lines
|
|
|
|
|
+ beforeLines := strings.Split(beforeContent, "\n")
|
|
|
|
|
+ afterLines := strings.Split(afterContent, "\n")
|
|
|
|
|
+
|
|
|
|
|
+ // Remove empty trailing element from the split if the content ended with a newline
|
|
|
|
|
+ if beforeHasNewline && len(beforeLines) > 0 {
|
|
|
|
|
+ beforeLines = beforeLines[:len(beforeLines)-1]
|
|
|
|
|
+ }
|
|
|
|
|
+ if afterHasNewline && len(afterLines) > 0 {
|
|
|
|
|
+ afterLines = afterLines[:len(afterLines)-1]
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ dmp := diffmatchpatch.New()
|
|
|
|
|
+ dmp.DiffTimeout = 5 * time.Second
|
|
|
|
|
+
|
|
|
|
|
+ // Convert lines to characters for efficient diffing
|
|
|
|
|
+ lineArray1, lineArray2, lineArrays := dmp.DiffLinesToChars(beforeContent, afterContent)
|
|
|
|
|
+ diffs := dmp.DiffMain(lineArray1, lineArray2, false)
|
|
|
|
|
+ diffs = dmp.DiffCharsToLines(diffs, lineArrays)
|
|
|
|
|
+
|
|
|
|
|
+ // Default filenames if not provided
|
|
|
|
|
+ if beforeFilename == "" {
|
|
|
|
|
+ beforeFilename = "a"
|
|
|
|
|
+ }
|
|
|
|
|
+ if afterFilename == "" {
|
|
|
|
|
+ afterFilename = "b"
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Write diff header
|
|
|
|
|
+ output.WriteString(fmt.Sprintf("diff --git a/%s b/%s\n", beforeFilename, afterFilename))
|
|
|
|
|
+ output.WriteString(fmt.Sprintf("--- a/%s\n", beforeFilename))
|
|
|
|
|
+ output.WriteString(fmt.Sprintf("+++ b/%s\n", afterFilename))
|
|
|
|
|
+
|
|
|
|
|
+ line1 := 0 // Line numbers start from 0 internally
|
|
|
|
|
+ line2 := 0
|
|
|
|
|
+ additions := 0
|
|
|
|
|
+ deletions := 0
|
|
|
|
|
+
|
|
|
|
|
+ var hunks []string
|
|
|
|
|
+ var currentHunk strings.Builder
|
|
|
|
|
+ var hunkStartLine1, hunkStartLine2 int
|
|
|
|
|
+ var hunkLines1, hunkLines2 int
|
|
|
|
|
+ inHunk := false
|
|
|
|
|
+
|
|
|
|
|
+ contextSize := config.ContextSize
|
|
|
|
|
+
|
|
|
|
|
+ // startHunk begins recording a new hunk
|
|
|
|
|
+ startHunk := func(startLine1, startLine2 int) {
|
|
|
|
|
+ inHunk = true
|
|
|
|
|
+ hunkStartLine1 = startLine1
|
|
|
|
|
+ hunkStartLine2 = startLine2
|
|
|
|
|
+ hunkLines1 = 0
|
|
|
|
|
+ hunkLines2 = 0
|
|
|
|
|
+ currentHunk.Reset()
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // writeHunk adds the current hunk to the hunks slice
|
|
|
|
|
+ writeHunk := func() {
|
|
|
|
|
+ if inHunk {
|
|
|
|
|
+ hunkHeader := fmt.Sprintf("@@ -%d,%d +%d,%d @@\n",
|
|
|
|
|
+ hunkStartLine1+1, hunkLines1,
|
|
|
|
|
+ hunkStartLine2+1, hunkLines2)
|
|
|
|
|
+ hunks = append(hunks, hunkHeader+currentHunk.String())
|
|
|
|
|
+ inHunk = false
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Process diffs to create hunks
|
|
|
|
|
+ pendingContext := make([]string, 0, contextSize*2)
|
|
|
|
|
+ var contextLines1, contextLines2 int
|
|
|
|
|
+
|
|
|
|
|
+ // Helper function to add context lines to the hunk
|
|
|
|
|
+ addContextToHunk := func(lines []string, count int) {
|
|
|
|
|
+ for i := 0; i < count; i++ {
|
|
|
|
|
+ if i < len(lines) {
|
|
|
|
|
+ currentHunk.WriteString(" " + lines[i] + "\n")
|
|
|
|
|
+ hunkLines1++
|
|
|
|
|
+ hunkLines2++
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Process diffs
|
|
|
|
|
+ for _, diff := range diffs {
|
|
|
|
|
+ lines := strings.Split(diff.Text, "\n")
|
|
|
|
|
+
|
|
|
|
|
+ // Remove empty trailing line that comes from splitting a string that ends with \n
|
|
|
|
|
+ if len(lines) > 0 && lines[len(lines)-1] == "" && diff.Text[len(diff.Text)-1] == '\n' {
|
|
|
|
|
+ lines = lines[:len(lines)-1]
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ switch diff.Type {
|
|
|
|
|
+ case diffmatchpatch.DiffEqual:
|
|
|
|
|
+ // If we have enough equal lines to serve as context, add them to pending
|
|
|
|
|
+ pendingContext = append(pendingContext, lines...)
|
|
|
|
|
+
|
|
|
|
|
+ // If pending context grows too large, trim it
|
|
|
|
|
+ if len(pendingContext) > contextSize*2 {
|
|
|
|
|
+ pendingContext = pendingContext[len(pendingContext)-contextSize*2:]
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // If we're in a hunk, add the necessary context
|
|
|
|
|
+ if inHunk {
|
|
|
|
|
+ // Only add the first contextSize lines as trailing context
|
|
|
|
|
+ numContextLines := min(contextSize, len(lines))
|
|
|
|
|
+ addContextToHunk(lines[:numContextLines], numContextLines)
|
|
|
|
|
+
|
|
|
|
|
+ // If we've added enough trailing context, close the hunk
|
|
|
|
|
+ if numContextLines >= contextSize {
|
|
|
|
|
+ writeHunk()
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ line1 += len(lines)
|
|
|
|
|
+ line2 += len(lines)
|
|
|
|
|
+ contextLines1 += len(lines)
|
|
|
|
|
+ contextLines2 += len(lines)
|
|
|
|
|
+
|
|
|
|
|
+ case diffmatchpatch.DiffDelete, diffmatchpatch.DiffInsert:
|
|
|
|
|
+ // Start a new hunk if needed
|
|
|
|
|
+ if !inHunk {
|
|
|
|
|
+ // Determine how many context lines we can add before
|
|
|
|
|
+ contextBefore := min(contextSize, len(pendingContext))
|
|
|
|
|
+ ctxStartIdx := len(pendingContext) - contextBefore
|
|
|
|
|
+
|
|
|
|
|
+ // Calculate the correct start lines
|
|
|
|
|
+ startLine1 := line1 - contextLines1 + ctxStartIdx
|
|
|
|
|
+ startLine2 := line2 - contextLines2 + ctxStartIdx
|
|
|
|
|
+
|
|
|
|
|
+ startHunk(startLine1, startLine2)
|
|
|
|
|
+
|
|
|
|
|
+ // Add the context lines before
|
|
|
|
|
+ addContextToHunk(pendingContext[ctxStartIdx:], contextBefore)
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Reset context tracking when we see a diff
|
|
|
|
|
+ pendingContext = pendingContext[:0]
|
|
|
|
|
+ contextLines1 = 0
|
|
|
|
|
+ contextLines2 = 0
|
|
|
|
|
+
|
|
|
|
|
+ // Add the changes
|
|
|
|
|
+ if diff.Type == diffmatchpatch.DiffDelete {
|
|
|
|
|
+ for _, line := range lines {
|
|
|
|
|
+ currentHunk.WriteString("-" + line + "\n")
|
|
|
|
|
+ hunkLines1++
|
|
|
|
|
+ deletions++
|
|
|
|
|
+ }
|
|
|
|
|
+ line1 += len(lines)
|
|
|
|
|
+ } else { // DiffInsert
|
|
|
|
|
+ for _, line := range lines {
|
|
|
|
|
+ currentHunk.WriteString("+" + line + "\n")
|
|
|
|
|
+ hunkLines2++
|
|
|
|
|
+ additions++
|
|
|
|
|
+ }
|
|
|
|
|
+ line2 += len(lines)
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Write the final hunk if there's one pending
|
|
|
|
|
+ if inHunk {
|
|
|
|
|
+ writeHunk()
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Merge hunks that are close to each other (within 2*contextSize lines)
|
|
|
|
|
+ var mergedHunks []string
|
|
|
|
|
+ if len(hunks) > 0 {
|
|
|
|
|
+ mergedHunks = append(mergedHunks, hunks[0])
|
|
|
|
|
+
|
|
|
|
|
+ for i := 1; i < len(hunks); i++ {
|
|
|
|
|
+ prevHunk := mergedHunks[len(mergedHunks)-1]
|
|
|
|
|
+ currHunk := hunks[i]
|
|
|
|
|
+
|
|
|
|
|
+ // Extract line numbers to check proximity
|
|
|
|
|
+ var prevStart, prevLen, currStart, currLen int
|
|
|
|
|
+ fmt.Sscanf(prevHunk, "@@ -%d,%d", &prevStart, &prevLen)
|
|
|
|
|
+ fmt.Sscanf(currHunk, "@@ -%d,%d", &currStart, &currLen)
|
|
|
|
|
+
|
|
|
|
|
+ prevEnd := prevStart + prevLen - 1
|
|
|
|
|
+
|
|
|
|
|
+ // If hunks are close, merge them
|
|
|
|
|
+ if currStart-prevEnd <= contextSize*2 {
|
|
|
|
|
+ // Create a merged hunk - this is a simplification, real git has more complex merging logic
|
|
|
|
|
+ merged := mergeHunks(prevHunk, currHunk)
|
|
|
|
|
+ mergedHunks[len(mergedHunks)-1] = merged
|
|
|
|
|
+ } else {
|
|
|
|
|
+ mergedHunks = append(mergedHunks, currHunk)
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Write all hunks to output
|
|
|
|
|
+ for _, hunk := range mergedHunks {
|
|
|
|
|
+ output.WriteString(hunk)
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Handle "No newline at end of file" notifications
|
|
|
|
|
+ if !beforeHasNewline && len(beforeLines) > 0 {
|
|
|
|
|
+ // Find the last deletion in the diff and add the notification after it
|
|
|
|
|
+ lastPos := strings.LastIndex(output.String(), "\n-")
|
|
|
|
|
+ if lastPos != -1 {
|
|
|
|
|
+ // Insert the notification after the line
|
|
|
|
|
+ str := output.String()
|
|
|
|
|
+ output.Reset()
|
|
|
|
|
+ output.WriteString(str[:lastPos+1])
|
|
|
|
|
+ output.WriteString("\\ No newline at end of file\n")
|
|
|
|
|
+ output.WriteString(str[lastPos+1:])
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ if !afterHasNewline && len(afterLines) > 0 {
|
|
|
|
|
+ // Find the last insertion in the diff and add the notification after it
|
|
|
|
|
+ lastPos := strings.LastIndex(output.String(), "\n+")
|
|
|
|
|
+ if lastPos != -1 {
|
|
|
|
|
+ // Insert the notification after the line
|
|
|
|
|
+ str := output.String()
|
|
|
|
|
+ output.Reset()
|
|
|
|
|
+ output.WriteString(str[:lastPos+1])
|
|
|
|
|
+ output.WriteString("\\ No newline at end of file\n")
|
|
|
|
|
+ output.WriteString(str[lastPos+1:])
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Return the diff without the summary line
|
|
|
|
|
+ return output.String(), additions, deletions
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+// Helper function to merge two hunks
|
|
|
|
|
+func mergeHunks(hunk1, hunk2 string) string {
|
|
|
|
|
+ // This is a simplified implementation
|
|
|
|
|
+ // A full implementation would need to properly recalculate the hunk header
|
|
|
|
|
+ // and remove redundant context lines
|
|
|
|
|
+
|
|
|
|
|
+ // Extract header info from both hunks
|
|
|
|
|
+ var start1, len1, start2, len2 int
|
|
|
|
|
+ var startB1, lenB1, startB2, lenB2 int
|
|
|
|
|
+
|
|
|
|
|
+ fmt.Sscanf(hunk1, "@@ -%d,%d +%d,%d @@", &start1, &len1, &startB1, &lenB1)
|
|
|
|
|
+ fmt.Sscanf(hunk2, "@@ -%d,%d +%d,%d @@", &start2, &len2, &startB2, &lenB2)
|
|
|
|
|
+
|
|
|
|
|
+ // Split the hunks to get content
|
|
|
|
|
+ parts1 := strings.SplitN(hunk1, "\n", 2)
|
|
|
|
|
+ parts2 := strings.SplitN(hunk2, "\n", 2)
|
|
|
|
|
+
|
|
|
|
|
+ content1 := ""
|
|
|
|
|
+ content2 := ""
|
|
|
|
|
+
|
|
|
|
|
+ if len(parts1) > 1 {
|
|
|
|
|
+ content1 = parts1[1]
|
|
|
|
|
+ }
|
|
|
|
|
+ if len(parts2) > 1 {
|
|
|
|
|
+ content2 = parts2[1]
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ // Calculate the new header
|
|
|
|
|
+ newEnd := max(start1+len1-1, start2+len2-1)
|
|
|
|
|
+ newEndB := max(startB1+lenB1-1, startB2+lenB2-1)
|
|
|
|
|
+
|
|
|
|
|
+ newLen := newEnd - start1 + 1
|
|
|
|
|
+ newLenB := newEndB - startB1 + 1
|
|
|
|
|
+
|
|
|
|
|
+ newHeader := fmt.Sprintf("@@ -%d,%d +%d,%d @@", start1, newLen, startB1, newLenB)
|
|
|
|
|
+
|
|
|
|
|
+ // Combine the content, potentially with some overlap handling
|
|
|
|
|
+ return newHeader + "\n" + content1 + content2
|
|
|
|
|
+}
|