Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
65 changes: 47 additions & 18 deletions internal/diff/diff.go
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,7 @@ import (
"fmt"
"sort"

"github.com/envaar/vaar/internal/analysis"
"github.com/envaar/vaar/internal/envfile"
)

Expand All @@ -31,6 +32,8 @@ func (r Result) HasDifferences() bool {
}

// Compare parses two dotenv inputs and compares assignment key presence only.
// It remains a compatibility wrapper until the diff command migrates to the
// shared source and analysis pipeline.
func Compare(leftPath string, leftData []byte, rightPath string, rightData []byte) (Result, error) {
left, err := envfile.Parse(leftPath, leftData)
if err != nil {
Expand All @@ -45,33 +48,59 @@ func Compare(leftPath string, leftData []byte, rightPath string, rightData []byt
return CompareFiles(left, right), nil
}

// CompareFiles compares key presence between two already parsed dotenv files.
func CompareFiles(left envfile.File, right envfile.File) Result {
leftKeys := keySet(left)
rightKeys := keySet(right)
// CompareInventories compares two value-free analysis key inventories. Labels
// are supplied separately because an empty inventory has no declaration from
// which a display path could be recovered.
func CompareInventories(leftLabel string, left analysis.KeyInventory, rightLabel string, right analysis.KeyInventory) Result {
leftKeys := left.Keys()
rightKeys := right.Keys()

return Result{
Left: left.Path,
Right: right.Path,
MissingFromLeft: missingKeys(leftKeys, rightKeys),
MissingFromRight: missingKeys(rightKeys, leftKeys),
Left: leftLabel,
Right: rightLabel,
MissingFromLeft: missingInventoryKeys(leftKeys, rightKeys),
MissingFromRight: missingInventoryKeys(rightKeys, leftKeys),
}
}

func keySet(file envfile.File) map[string]struct{} {
keys := make(map[string]struct{})
// CompareFiles compares key presence between two already parsed dotenv files.
// It is a temporary compatibility adapter for callers that have not yet
// migrated to analysis key inventories.
func CompareFiles(left envfile.File, right envfile.File) Result {
return CompareInventories(
left.Path,
inventoryFromFile(left),
right.Path,
inventoryFromFile(right),
)
}

func inventoryFromFile(file envfile.File) analysis.KeyInventory {
lines := make([]analysis.Line, 0, len(file.Lines))
for _, line := range file.Lines {
if line.HasAssignment && line.HasKey {
keys[line.Key] = struct{}{}
}
lines = append(lines, analysis.Line{
Number: line.Number,
Key: line.Key,
HasKey: line.HasKey,
HasAssignment: line.HasAssignment,
})
}
return keys

return analysis.NewKeyInventory(analysis.Document{
DisplayPath: file.Path,
Lines: lines,
})
}

func missingKeys(have map[string]struct{}, want map[string]struct{}) []string {
missing := make([]string, 0)
for key := range want {
if _, ok := have[key]; !ok {
func missingInventoryKeys(have, want []string) []string {
haveSet := make(map[string]struct{}, len(have))
for _, key := range have {
haveSet[key] = struct{}{}
}

missing := make([]string, 0, len(want))
for _, key := range want {
if _, ok := haveSet[key]; !ok {
missing = append(missing, key)
}
}
Expand Down
153 changes: 153 additions & 0 deletions internal/diff/inventory_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,153 @@
// Copyright © 2026 envaar
// SPDX-License-Identifier: Apache-2.0

package diff_test

import (
"fmt"
"reflect"
"testing"

"github.com/envaar/vaar/internal/analysis"
"github.com/envaar/vaar/internal/diff"
)

func TestCompareInventoriesPreservesKeyPresenceSemantics(t *testing.T) {
tests := []struct {
name string
left analysis.KeyInventory
right analysis.KeyInventory
wantLeft string
wantRight string
wantMissingFromLeft []string
wantMissingFromRight []string
}{
{
name: "matching inventories including empty assignments",
left: inventory("left.env",
assignment("COMMON"),
assignment("EMPTY"),
),
right: inventory("right.env",
assignment("COMMON"),
assignment("EMPTY"),
),
wantLeft: "left.env",
wantRight: "right.env",
wantMissingFromLeft: []string{},
wantMissingFromRight: []string{},
},
{
name: "missing keys are sorted independently",
left: inventory("left.env",
assignment("ZED"),
assignment("COMMON"),
),
right: inventory("right.env",
assignment("BETA"),
assignment("ALPHA"),
),
wantLeft: "left.env",
wantRight: "right.env",
wantMissingFromLeft: []string{"ALPHA", "BETA"},
wantMissingFromRight: []string{"COMMON", "ZED"},
},
{
name: "duplicates collapse and comparison is case sensitive",
left: inventory("left.env",
assignment("TOKEN"),
assignment("TOKEN"),
),
right: inventory("right.env",
assignment("token"),
),
wantLeft: "left.env",
wantRight: "right.env",
wantMissingFromLeft: []string{"token"},
wantMissingFromRight: []string{"TOKEN"},
},
{
name: "bare and malformed declarations are excluded",
left: inventory("left.env",
bareKey("BARE"),
malformedKey("COLON"),
assignment("VALID"),
),
right: inventory("right.env",
assignment("VALID"),
),
wantLeft: "left.env",
wantRight: "right.env",
wantMissingFromLeft: []string{},
wantMissingFromRight: []string{},
},
}

for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
result := diff.CompareInventories(tc.wantLeft, tc.left, tc.wantRight, tc.right)

if result.Left != tc.wantLeft || result.Right != tc.wantRight {
t.Fatalf("labels = (%q, %q), want (%q, %q)", result.Left, result.Right, tc.wantLeft, tc.wantRight)
}
if !reflect.DeepEqual(result.MissingFromLeft, tc.wantMissingFromLeft) {
t.Fatalf("MissingFromLeft = %#v, want %#v", result.MissingFromLeft, tc.wantMissingFromLeft)
}
if !reflect.DeepEqual(result.MissingFromRight, tc.wantMissingFromRight) {
t.Fatalf("MissingFromRight = %#v, want %#v", result.MissingFromRight, tc.wantMissingFromRight)
}
})
}
}

func TestCompareInventoriesDoesNotExposeValues(t *testing.T) {
left := inventory("left.env", assignment("DATABASE_PASSWORD"))
right := inventory("right.env", assignment("DATABASE_URL"))

result := diff.CompareInventories("left.env", left, "right.env", right)
rendered := fmt.Sprintf("%#v", result)
if rendered != "diff.Result{Left:\"left.env\", Right:\"right.env\", MissingFromLeft:[]string{\"DATABASE_URL\"}, MissingFromRight:[]string{\"DATABASE_PASSWORD\"}}" {
t.Fatalf("unexpected value-bearing or unstable result rendering: %s", rendered)
}
}

func TestCompareInventoriesHasDifferencesMatchesResult(t *testing.T) {
matching := diff.CompareInventories(
"left.env",
inventory("left.env", assignment("COMMON")),
"right.env",
inventory("right.env", assignment("COMMON")),
)
if matching.HasDifferences() {
t.Fatal("matching inventories reported differences")
}

different := diff.CompareInventories(
"left.env",
inventory("left.env", assignment("LEFT_ONLY")),
"right.env",
inventory("right.env", assignment("RIGHT_ONLY")),
)
if !different.HasDifferences() {
t.Fatal("different inventories reported no differences")
}
}

func inventory(displayPath string, lines ...analysis.Line) analysis.KeyInventory {
return analysis.NewKeyInventory(analysis.Document{
DisplayPath: displayPath,
Lines: lines,
})
}

func assignment(key string) analysis.Line {
return analysis.Line{Key: key, HasKey: true, HasAssignment: true}
}

func bareKey(key string) analysis.Line {
return analysis.Line{Key: key, HasKey: true, DelimiterState: analysis.DelimiterMissing}
}

func malformedKey(key string) analysis.Line {
return analysis.Line{Key: key, HasKey: true, DelimiterState: analysis.DelimiterColon}
}
Loading