refactor(parser/diff): split to smaller functions

internal/parser/diff/meta.go

@@ -7,13 +7,7 @@ import "github.com/joint-online-judge/JOJ3/internal/stage"
 
 var name = "diff"
 
-type Conf struct {
+type Output struct {
-	PassComment       string `default:"🥳Passed!"`
-	FailComment       string `default:"🧐Failed..."`
-	FailOnNotAccepted bool   `default:"true"`
-	ForceQuitOnFailed bool   `default:"false"`
-	Cases             []struct {
-		Outputs []struct {
 	Score            int
 	Filename         string
 	AnswerPath       string
@@ -23,8 +17,18 @@ type Conf struct {
 	MaxDiffLength    int `default:"2048"` // just for reference
 	MaxDiffLines     int `default:"50"`   // just for reference
 	HideCommonPrefix bool
-		}
+}
-	}
+
+type Case struct {
+	Outputs []Output
+}
+
+type Conf struct {
+	PassComment       string `default:"🥳Passed!"`
+	FailComment       string `default:"🧐Failed..."`
+	FailOnNotAccepted bool   `default:"true"`
+	ForceQuitOnFailed bool   `default:"false"`
+	Cases             []Case
 }
 
 type Diff struct{}

internal/parser/diff/parser.go

@@ -9,7 +9,7 @@ import (
 	"github.com/joint-online-judge/JOJ3/internal/stage"
 )
 
-func (*Diff) Run(results []stage.ExecutorResult, confAny any) (
+func (d *Diff) Run(results []stage.ExecutorResult, confAny any) (
 	[]stage.ParserResult, bool, error,
 ) {
 	conf, err := stage.DecodeConf[Conf](confAny)
@@ -24,10 +24,26 @@ func (*Diff) Run(results []stage.ExecutorResult, confAny any) (
 	forceQuit := false
 	for i, caseConf := range conf.Cases {
 		result := results[i]
+		parserResult, fq, err := d.processCase(caseConf, result, conf, i)
+		if err != nil {
+			return nil, true, err
+		}
+		res = append(res, parserResult)
+		if fq {
+			forceQuit = true
+		}
+	}
+
+	return res, forceQuit, nil
+}
+
+// processCase handles a single test case.
+func (d *Diff) processCase(caseConf Case, result stage.ExecutorResult, conf *Conf, index int) (stage.ParserResult, bool, error) {
 	score := 0
 	comment := ""
-		if conf.FailOnNotAccepted &&
+	forceQuit := false
-			result.Status != stage.StatusAccepted {
+
+	if conf.FailOnNotAccepted && result.Status != stage.StatusAccepted {
 		if conf.ForceQuitOnFailed {
 			forceQuit = true
 		}
@@ -35,45 +51,80 @@ func (*Diff) Run(results []stage.ExecutorResult, confAny any) (
 		comment += "Executor status not `Accepted`\n"
 	} else {
 		for _, output := range caseConf.Outputs {
+			outputScore, outputComment, outputForceQuit, err := d.processOutput(output, result, conf, index)
+			if err != nil {
+				return stage.ParserResult{}, true, err
+			}
+			score += outputScore
+			comment += outputComment
+			if outputForceQuit {
+				forceQuit = true
+			}
+		}
+	}
+
+	return stage.ParserResult{
+		Score:   score,
+		Comment: comment,
+	}, forceQuit, nil
+}
+
+// processOutput handles a single output comparison.
+func (d *Diff) processOutput(output Output, result stage.ExecutorResult, conf *Conf, index int) (int, string, bool, error) {
 	answer, err := os.ReadFile(output.AnswerPath)
 	if err != nil {
-					return nil, true, err
+		return 0, "", true, err
 	}
 	answerStr := string(answer)
 	resultStr := result.Files[output.Filename]
+
 	isSame := stringsEqual(
 		answerStr,
 		resultStr,
 		output.CompareSpace,
 	)
+
 	slog.Debug(
 		"compare",
 		"filename", output.Filename,
 		"answerPath", output.AnswerPath,
 		"actualLength", len(resultStr),
 		"answerLength", len(answerStr),
-					"index", i,
+		"index", index,
 		"isSame", isSame,
 	)
-				// If no difference, assign score
+
 	if isSame {
-					score += output.Score
+		return output.Score, conf.PassComment + "\n", false, nil
-					comment += conf.PassComment + "\n"
+	}
-				} else {
+
+	// They are different.
+	forceQuit := false
 	if output.ForceQuitOnDiff || conf.ForceQuitOnFailed {
 		forceQuit = true
 	}
-					comment += conf.FailComment + "\n"
+	comment := conf.FailComment + "\n"
-					comment += fmt.Sprintf("Difference found in `%s`\n",
+	comment += fmt.Sprintf("Difference found in `%s`\n", output.Filename)
-						output.Filename)
+
 	if !output.AlwaysHide {
+		diffComment := d.generateDiffComment(answerStr, resultStr, output)
+		comment += diffComment
+	} else {
+		comment += "(content hidden)\n"
+	}
+
+	return 0, comment, forceQuit, nil
+}
+
+// generateDiffComment generates a diff comment for the given strings.
+func (d *Diff) generateDiffComment(answerStr, resultStr string, output Output) string {
 	if output.MaxDiffLength == 0 { // real default value
 		output.MaxDiffLength = 2048
 	}
 	if output.MaxDiffLines == 0 { // real default value
 		output.MaxDiffLines = 50
 	}
-						// Convert answer to string and split by lines
+
 	truncated := false
 	if len(answerStr) > output.MaxDiffLength {
 		answerStr = answerStr[:output.MaxDiffLength]
@@ -83,9 +134,11 @@ func (*Diff) Run(results []stage.ExecutorResult, confAny any) (
 		resultStr = resultStr[:output.MaxDiffLength]
 		truncated = true
 	}
+
 	answerLines := strings.Split(answerStr, "\n")
 	resultLines := strings.Split(resultStr, "\n")
 	commonPrefixLineCount := 0
+
 	if output.HideCommonPrefix {
 		n := 0
 		for ; n < len(answerLines) &&
@@ -102,6 +155,7 @@ func (*Diff) Run(results []stage.ExecutorResult, confAny any) (
 			commonPrefixLineCount = n
 		}
 	}
+
 	if len(answerLines) > output.MaxDiffLines {
 		answerLines = answerLines[:output.MaxDiffLines]
 		truncated = true
@@ -110,6 +164,7 @@ func (*Diff) Run(results []stage.ExecutorResult, confAny any) (
 		resultLines = resultLines[:output.MaxDiffLines]
 		truncated = true
 	}
+
 	diffs := patienceDiff(
 		answerLines,
 		resultLines,
@@ -118,6 +173,7 @@ func (*Diff) Run(results []stage.ExecutorResult, confAny any) (
 		})
 	diffOutput := diffText(diffs)
 	diffOutput = strings.TrimSuffix(diffOutput, "\n  ")
+
 	if truncated {
 		diffOutput += "\n\n(truncated)"
 	}
@@ -127,21 +183,9 @@ func (*Diff) Run(results []stage.ExecutorResult, confAny any) (
 			commonPrefixLineCount,
 		) + diffOutput
 	}
-						comment += fmt.Sprintf(
+
+	return fmt.Sprintf(
 		"```diff\n%s\n```\n",
 		diffOutput,
 	)
-					} else {
-						comment += "(content hidden)\n"
-					}
-				}
-			}
-		}
-		res = append(res, stage.ParserResult{
-			Score:   score,
-			Comment: comment,
-		})
-	}
-
-	return res, forceQuit, nil
 }