TODO language boilerplate

Author: bauersimon

language/golang/language.go

@@ -54,6 +54,11 @@ func (l *Language) TestFramework() (testFramework string) {
 	return ""
 }
 
+// HasTestsInSource returns if the tests for this language are commonly located within the corresponding implementation file.
+func (l *Language) HasTestsInSource() bool {
+	return false
+}
+
 // DefaultFileExtension returns the default file extension.
 func (l *Language) DefaultFileExtension() string {
 	return ".go"

language/java/language.go

@@ -70,6 +70,11 @@ func (l *Language) TestFramework() (testFramework string) {
 	return "JUnit 5"
 }
 
+// HasTestsInSource returns if the tests for this language are commonly located within the corresponding implementation file.
+func (l *Language) HasTestsInSource() bool {
+	return false
+}
+
 // DefaultFileExtension returns the default file extension.
 func (l *Language) DefaultFileExtension() string {
 	return ".java"

language/language.go

@@ -38,6 +38,8 @@ type Language interface {
 	TestFilePath(projectRootPath string, filePath string) (testFilePath string)
 	// TestFramework returns the human-readable name of the test framework that should be used.
 	TestFramework() (testFramework string)
+	// HasTestsInSource returns if the tests for this language are commonly located within the corresponding implementation file.
+	HasTestsInSource() bool
 
 	// DefaultFileExtension returns the default file extension of the implemented language.
 	DefaultFileExtension() string

language/ruby/language.go

@@ -59,6 +59,11 @@ func (l *Language) TestFramework() (testFramework string) {
 	return "Minitest"
 }
 
+// HasTestsInSource returns if the tests for this language are commonly located within the corresponding implementation file.
+func (l *Language) HasTestsInSource() bool {
+	return false
+}
+
 // DefaultFileExtension returns the default file extension.
 func (l *Language) DefaultFileExtension() string {
 	return ".rb"

language/rust/language.go

@@ -0,0 +1,159 @@
+package rust
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+
+	pkgerrors "github.com/pkg/errors"
+
+	"github.com/symflower/eval-dev-quality/language"
+	"github.com/symflower/eval-dev-quality/log"
+	"github.com/symflower/eval-dev-quality/util"
+)
+
+// Language holds a Rust language to evaluate a repository.
+type Language struct{}
+
+func init() {
+	language.Register(&Language{})
+}
+
+var _ language.Language = (*Language)(nil)
+
+// ID returns the unique ID of this language.
+func (l *Language) ID() (id string) {
+	return "rust"
+}
+
+// Name is the prose name of this language.
+func (l *Language) Name() (id string) {
+	return "Rust"
+}
+
+// Files returns a list of relative file paths of the repository that should be evaluated.
+func (l *Language) Files(logger *log.Logger, repositoryPath string) (filePaths []string, err error) {
+	return language.Files(logger, l, repositoryPath)
+}
+
+// ImportPath returns the import path of the given source file.
+func (l *Language) ImportPath(projectRootPath string, filePath string) (importPath string) {
+	importPath = strings.ReplaceAll(filepath.Dir(filePath), string(os.PathSeparator), "::")
+
+	return strings.TrimPrefix(strings.TrimPrefix(importPath, "src"), "::")
+}
+
+// TestFilePath returns the file path of a test file given the corresponding file path of the test's source file.
+func (l *Language) TestFilePath(projectRootPath string, filePath string) (testFilePath string) {
+	return filePath
+}
+
+// TestFramework returns the human-readable name of the test framework that should be used.
+func (l *Language) TestFramework() (testFramework string) {
+	return ""
+}
+
+// HasTestsInSource returns if the tests for this language are commonly located within the corresponding implementation file.
+func (l *Language) HasTestsInSource() bool {
+	return true
+}
+
+// DefaultFileExtension returns the default file extension.
+func (l *Language) DefaultFileExtension() string {
+	return ".rs"
+}
+
+// DefaultTestFileSuffix returns the default test file suffix.
+func (l *Language) DefaultTestFileSuffix() string {
+	return ".rs"
+}
+
+// ExecuteTests invokes the language specific testing on the given repository.
+func (l *Language) ExecuteTests(logger *log.Logger, repositoryPath string) (testResult *language.TestResult, problems []error, err error) {
+	commandOutput, err := util.CommandWithResult(context.Background(), logger, &util.Command{
+		Command: []string{ // TODO Move this to `symflower test` to get coverage information.
+			"cargo",
+			"test",
+		},
+
+		Directory: repositoryPath,
+	})
+	if err != nil {
+		return nil, nil, pkgerrors.WithMessage(pkgerrors.WithStack(err), commandOutput)
+	}
+
+	testsTotal, testsPass, e := parseSymflowerTestOutput(commandOutput)
+	if e != nil {
+		problems = append(problems, pkgerrors.WithMessage(pkgerrors.WithStack(e), commandOutput))
+	}
+	// If there are test failures, then this is just a soft error since we still are able to receive coverage data.
+	if err != nil {
+		if testsTotal-testsPass <= 0 {
+			return nil, nil, pkgerrors.WithMessage(pkgerrors.WithStack(err), commandOutput)
+		}
+
+		problems = append(problems, pkgerrors.WithMessage(pkgerrors.WithStack(err), commandOutput))
+	}
+
+	testResult = &language.TestResult{
+		TestsTotal: uint(testsTotal),
+		TestsPass:  uint(testsPass),
+
+		StdOut: commandOutput,
+	}
+
+	// coverageFilePath := "" // TODO
+	// testResult.Coverage, err = language.CoverageObjectCountOfFile(logger, coverageFilePath)
+	// if err != nil {
+	// 	return testResult, problems, pkgerrors.WithMessage(pkgerrors.WithStack(err), commandOutput)
+	// }
+
+	return testResult, problems, nil
+}
+
+var languageRustTestSummaryRE = regexp.MustCompile(`test result: (?:ok|FAILED). (\d+) passed; (\d+) failed;`)
+
+func parseSymflowerTestOutput(data string) (testsTotal int, testsPass int, err error) {
+	testSummary := languageRustTestSummaryRE.FindStringSubmatch(data)
+	if len(testSummary) == 0 {
+		return 0, 0, pkgerrors.WithMessage(pkgerrors.WithStack(language.ErrCannotParseTestSummary), data)
+	}
+
+	testsTotal, err = strconv.Atoi(testSummary[1])
+	if err != nil {
+		return 0, 0, pkgerrors.WithStack(err)
+	}
+
+	testsPass, err = strconv.Atoi(testSummary[2])
+	if err != nil {
+		return 0, 0, pkgerrors.WithStack(err)
+	}
+
+	return testsTotal, testsPass, nil
+}
+
+// Mistakes builds a Rust repository and returns the list of mistakes found.
+func (l *Language) Mistakes(logger *log.Logger, repositoryPath string) (mistakes []string, err error) {
+	// TODO
+	return []string{}, nil
+}
+
+// mistakesRe defines the structure of a Rust compiler error.
+var mistakesRe = regexp.MustCompile(`(?m)^.*\.rs:\d+:\d+:.*$`)
+
+func extractMistakes(rawMistakes string) (mistakes []string) {
+	return mistakesRe.FindAllString(rawMistakes, -1)
+}
+
+// SupportsFix reports if the language is supported by "symflower fix".
+func (l *Language) SupportsFix() bool {
+	return false
+}
+
+// SupportsTemplate reports if the language is supported by "symflower unit-test-skeleton".
+func (l *Language) SupportsTemplate() bool {
+	return false
+}