Fix argument handling regression.

Author: daveshanley

cmd/common.go

@@ -214,16 +214,16 @@ func loadCommitsFromArgs(args []string, opts summaryOpts, breakingConfig *whatCh
 	if _, _, ok := parseGitRef(args[0]); ok {
 		return loadLeftRightCommits(args[0], args[1], opts)
 	}
+	f, statErr := os.Stat(args[0])
+	if statErr == nil && f.IsDir() {
+		return loadGitHistoryCommits(args[0], args[1], opts, breakingConfig)
+	}
 	if _, _, ok := parseGitRef(args[1]); ok {
 		return loadLeftRightCommits(args[0], args[1], opts)
 	}
-	f, statErr := os.Stat(args[0])
 	if statErr != nil {
 		return nil, fmt.Errorf("cannot open file/repository: '%s'", args[0])
 	}
-	if f.IsDir() {
-		return loadGitHistoryCommits(args[0], args[1], opts, breakingConfig)
-	}
 	return loadLeftRightCommits(args[0], args[1], opts)
 }
 

cmd/left_right_sources.go

@@ -25,12 +25,15 @@ import (
 )
 
 type comparisonSource struct {
-	Display   string
-	RootBytes []byte
-	DocConfig *datamodel.DocumentConfiguration
-	Cleanup   func()
+	Display             string
+	RootBytes           []byte
+	DocConfig           *datamodel.DocumentConfiguration
+	RewriteDocumentPath documentPathRewriter
+	Cleanup             func()
 }
 
+type documentPathRewriter func(string) string
+
 func newComparisonDocConfig(opts summaryOpts) *datamodel.DocumentConfiguration {
 	docConfig := datamodel.NewDocumentConfiguration()
 	docConfig.IgnoreArrayCircularReferences = true
@@ -108,10 +111,11 @@ func resolveLocalFileSource(raw string, opts summaryOpts) (comparisonSource, err
 	}
 
 	return comparisonSource{
-		Display:   raw,
-		RootBytes: bits,
-		DocConfig: docConfig,
-		Cleanup:   func() {},
+		Display:             raw,
+		RootBytes:           bits,
+		DocConfig:           docConfig,
+		RewriteDocumentPath: nil,
+		Cleanup:             func() {},
 	}, nil
 }
 
@@ -175,13 +179,46 @@ func resolveGitRefSource(raw, revision, filePath string, opts summaryOpts) (comp
 	docConfig.LocalFS = revisionFS
 
 	return comparisonSource{
-		Display:   raw,
-		RootBytes: rootBytes,
-		DocConfig: docConfig,
-		Cleanup:   func() {},
+		Display:             raw,
+		RootBytes:           rootBytes,
+		DocConfig:           docConfig,
+		RewriteDocumentPath: newGitRefDocumentPathRewriter(repoRoot, basePath, virtualBasePath),
+		Cleanup:             func() {},
 	}, nil
 }
 
+func newGitRefDocumentPathRewriter(repoRoot, basePath, virtualBasePath string) documentPathRewriter {
+	baseRelPath, err := filepath.Rel(repoRoot, basePath)
+	if err != nil {
+		return nil
+	}
+	if baseRelPath == ".." || strings.HasPrefix(baseRelPath, ".."+string(filepath.Separator)) {
+		return nil
+	}
+	cleanVirtualBasePath := filepath.Clean(virtualBasePath)
+	if baseRelPath == "." {
+		baseRelPath = ""
+	}
+
+	return func(raw string) string {
+		cleaned := filepath.Clean(filepath.FromSlash(raw))
+		relPath, err := filepath.Rel(cleanVirtualBasePath, cleaned)
+		if err != nil {
+			return raw
+		}
+		if relPath == "." || relPath == "" {
+			return raw
+		}
+		if relPath == ".." || strings.HasPrefix(relPath, ".."+string(filepath.Separator)) {
+			return raw
+		}
+		if baseRelPath != "" {
+			relPath = filepath.Join(baseRelPath, relPath)
+		}
+		return filepath.ToSlash(filepath.Clean(relPath))
+	}
+}
+
 func resolveURLSource(raw string, opts summaryOpts) (comparisonSource, error) {
 	display := sanitizeURLLabel(raw)
 
@@ -232,10 +269,11 @@ func resolveURLSource(raw string, opts summaryOpts) (comparisonSource, error) {
 	}
 
 	return comparisonSource{
-		Display:   display,
-		RootBytes: bits,
-		DocConfig: docConfig,
-		Cleanup:   func() {},
+		Display:             display,
+		RootBytes:           bits,
+		DocConfig:           docConfig,
+		RewriteDocumentPath: nil,
+		Cleanup:             func() {},
 	}, nil
 }
 
@@ -303,3 +341,31 @@ func buildLeftRightCommit(left, right comparisonSource) (*model.Commit, error) {
 		Synthetic:   true,
 	}, nil
 }
+
+func buildLeftRightCommitAndSources(left, right string, opts summaryOpts) (*model.Commit, []documentPathRewriter, error) {
+	leftSource, err := resolveComparisonSource(left, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer leftSource.Cleanup()
+
+	rightSource, err := resolveComparisonSource(right, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rightSource.Cleanup()
+
+	commit, err := buildLeftRightCommit(leftSource, rightSource)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var rewriters []documentPathRewriter
+	if leftSource.RewriteDocumentPath != nil {
+		rewriters = append(rewriters, leftSource.RewriteDocumentPath)
+	}
+	if rightSource.RewriteDocumentPath != nil {
+		rewriters = append(rewriters, rightSource.RewriteDocumentPath)
+	}
+	return commit, rewriters, nil
+}

cmd/loaders.go

@@ -200,19 +200,7 @@ func loadGitHistoryCommits(gitPath, filePath string, opts summaryOpts, breakingC
 }
 
 func loadLeftRightCommits(left, right string, opts summaryOpts) ([]*model.Commit, error) {
-	leftSource, err := resolveComparisonSource(left, opts)
-	if err != nil {
-		return nil, err
-	}
-	defer leftSource.Cleanup()
-
-	rightSource, err := resolveComparisonSource(right, opts)
-	if err != nil {
-		return nil, err
-	}
-	defer rightSource.Cleanup()
-
-	commit, err := buildLeftRightCommit(leftSource, rightSource)
+	commit, _, err := buildLeftRightCommitAndSources(left, right, opts)
 	if err != nil {
 		return nil, err
 	}

cmd/loaders_test.go

@@ -320,3 +320,14 @@ func TestLoadCommitsFromArgs_LocalColonPathOutsideGitRepoStaysFileComparison(t *
 	require.Len(t, commits, 1)
 	assert.Equal(t, "Original: "+leftPath+", Modified: "+rightPath, commits[0].Message)
 }
+
+func TestLoadCommitsFromArgs_RepoHistoryColonPathUsesHistoryDispatch(t *testing.T) {
+	repoDir := createGitSpecRepoForFile(t, "v1:beta.yaml")
+	chdirForTest(t, t.TempDir())
+
+	commits, err := loadCommitsFromArgs([]string{repoDir, "v1:beta.yaml"}, summaryOpts{limitTime: -1}, nil)
+	require.NoError(t, err)
+	require.NotEmpty(t, commits)
+	assert.Equal(t, repoDir, commits[0].RepoDirectory)
+	assert.Equal(t, "v1:beta.yaml", commits[0].FilePath)
+}

cmd/report.go

@@ -53,22 +53,20 @@ func changerateAndFlatten(commits []*model.Commit, breakingConfig *whatChangedMo
 }
 
 func runLeftRightReport(left, right string, opts summaryOpts, breakingConfig *whatChangedModel.BreakingRulesConfig) (*model.FlatReport, error) {
-	commits, err := loadLeftRightCommits(left, right, opts)
+	commit, documentPathRewriters, err := buildLeftRightCommitAndSources(left, right, opts)
 	if err != nil {
 		return nil, err
 	}
-	if len(commits) == 0 {
-		return nil, nil
-	}
-	result, err := changerateCommit(commits[0], breakingConfig)
+	result, err := changerateCommit(commit, breakingConfig)
 	if err != nil {
 		return nil, err
 	}
 	if result == nil {
 		return nil, nil
 	}
 	defer result.Release()
-	flat := FlattenReportWithParameterNames(createReport(commits[0]), result.Changerator.ParameterNames)
+	flat := FlattenReportWithParameterNames(createReport(commit), result.Changerator.ParameterNames)
+	rewriteFlatReportDocumentPaths(flat, documentPathRewriters)
 	flat.Commit = nil
 	flat.OriginalPath = sourceLabelForReport(left)
 	flat.ModifiedPath = sourceLabelForReport(right)
@@ -188,9 +186,6 @@ func GetReportCommand() *cobra.Command {
 				if _, _, ok := parseGitRef(args[0]); ok {
 					return printReportJSONOrNoChanges(args, opts, breakingConfig, reproducible)
 				}
-				if _, _, ok := parseGitRef(args[1]); ok {
-					return printReportJSONOrNoChanges(args, opts, breakingConfig, reproducible)
-				}
 				f, statErr := os.Stat(args[0])
 				if statErr == nil && f.IsDir() {
 					flat, reportErr := runGitHistoryReport(args[0], args[1], opts, breakingConfig)
@@ -206,13 +201,16 @@ func GetReportCommand() *cobra.Command {
 					}
 					return printReportJSON(flat)
 				}
+				if _, _, ok := parseGitRef(args[1]); ok {
+					return printReportJSONOrNoChanges(args, opts, breakingConfig, reproducible)
+				}
 			}
 
 			return printReportJSONOrNoChanges(args, opts, breakingConfig, reproducible)
 		},
 	}
 	addTerminalThemeFlags(cmd)
-	cmd.Flags().Bool("reproducible", false, "Omit generated timestamps so report JSON is stable across runs")
+	cmd.Flags().Bool("reproducible", false, "Omit generated timestamps from report JSON")
 	return cmd
 }
 
@@ -253,9 +251,25 @@ func makeFlatReportReproducible(report *model.FlatReport) {
 		return
 	}
 	report.DateGenerated = ""
+}
+
+func rewriteFlatReportDocumentPaths(report *model.FlatReport, rewriters []documentPathRewriter) {
+	if report == nil || len(rewriters) == 0 {
+		return
+	}
 	for _, change := range report.Changes {
-		if change != nil {
-			change.RawPath = ""
+		if change == nil || change.Context == nil || change.Context.DocumentLocation == "" {
+			continue
+		}
+		for _, rewrite := range rewriters {
+			if rewrite == nil {
+				continue
+			}
+			rewritten := rewrite(change.Context.DocumentLocation)
+			if rewritten != change.Context.DocumentLocation {
+				change.Context.DocumentLocation = rewritten
+				break
+			}
 		}
 	}
 }

cmd/report_test.go

@@ -184,10 +184,10 @@ func TestReportCommand_ReproducibleOutputIsStableAcrossRuns(t *testing.T) {
 	first := runOnce()
 	second := runOnce()
 
-	assert.Equal(t, first, second)
+	assert.Equal(t, stripRawPaths(t, first), stripRawPaths(t, second))
 	assert.NotContains(t, first, `"dateGenerated"`)
 	assert.NotContains(t, first, `"commitDetails"`)
-	assert.NotContains(t, first, `"rawPath"`)
+	assert.Contains(t, first, `"rawPath"`)
 }
 
 func TestRunLeftRightReport_GitRefExplodedSpecIncludesSiblingChanges(t *testing.T) {
@@ -207,8 +207,11 @@ func TestRunLeftRightReport_GitRefExplodedSpecIncludesSiblingChanges(t *testing.
 
 	encoded, err := json.Marshal(report)
 	require.NoError(t, err)
-	assert.Contains(t, string(encoded), `"property":"required"`)
-	assert.Contains(t, string(encoded), `"path":"$.paths['/pets'].get.responses['200'].content['application/json'].schema"`)
+	content := string(encoded)
+	assert.Contains(t, content, `"property":"required"`)
+	assert.Contains(t, content, `"path":"$.paths['/pets'].get.responses['200'].content['application/json'].schema"`)
+	assert.Contains(t, content, `"document":"apis/components/pet.yaml"`)
+	assert.NotContains(t, content, ".openapi-changes-gitref")
 }
 
 func TestRunLeftRightReport_LocalExplodedSpecIncludesSiblingChanges(t *testing.T) {
@@ -282,3 +285,44 @@ func TestReportCommand_GitRefUsesLeftRightMode(t *testing.T) {
 	assert.Contains(t, output, `"summary"`)
 	assert.NotContains(t, output, `"reports"`)
 }
+
+func TestReportCommand_RepoHistoryColonPathUsesHistoryMode(t *testing.T) {
+	repoDir := createGitSpecRepoForFile(t, "v1:beta.yaml")
+	chdirForTest(t, t.TempDir())
+
+	cmd := testRootCmd(GetReportCommand(), repoDir, "v1:beta.yaml")
+	output := captureStdout(t, func() {
+		require.NoError(t, cmd.Execute())
+	})
+
+	assert.Contains(t, output, `"gitRepoPath": "`+repoDir+`"`)
+	assert.Contains(t, output, `"gitFilePath": "v1:beta.yaml"`)
+	assert.Contains(t, output, `"reports"`)
+	assert.NotContains(t, output, `"originalPath"`)
+}
+
+func stripRawPaths(t *testing.T, raw string) string {
+	t.Helper()
+
+	var payload any
+	require.NoError(t, json.Unmarshal([]byte(raw), &payload))
+	removeJSONKey(payload, "rawPath")
+
+	bits, err := json.MarshalIndent(payload, "", "  ")
+	require.NoError(t, err)
+	return string(bits)
+}
+
+func removeJSONKey(value any, key string) {
+	switch typed := value.(type) {
+	case map[string]any:
+		delete(typed, key)
+		for _, child := range typed {
+			removeJSONKey(child, key)
+		}
+	case []any:
+		for _, child := range typed {
+			removeJSONKey(child, key)
+		}
+	}
+}