feat: add cargo detection for rust

analyzer.go

@@ -4,7 +4,10 @@ import (
 	"strings"
 	"time"
 
+	"github.com/cidverse/repoanalyzer/analyzer/cargo"
+	"github.com/cidverse/repoanalyzer/analyzer/composer"
 	"github.com/cidverse/repoanalyzer/analyzer/container"
+	"github.com/cidverse/repoanalyzer/analyzer/dotnet"
 	"github.com/cidverse/repoanalyzer/analyzer/gomod"
 	"github.com/cidverse/repoanalyzer/analyzer/gradle"
 	"github.com/cidverse/repoanalyzer/analyzer/helm"
@@ -67,5 +70,8 @@ func initAnalyzers() {
 		node.Analyzer{},
 		python.Analyzer{},
 		mkdocs.Analyzer{},
+		dotnet.Analyzer{},
+		composer.Analyzer{},
+		cargo.Analyzer{},
 	)
 }

analyzer/cargo/cargo.go

@@ -0,0 +1,56 @@
+package cargo
+
+import (
+	"path/filepath"
+
+	"github.com/cidverse/repoanalyzer/analyzerapi"
+	"github.com/gosimple/slug"
+	"github.com/rs/zerolog/log"
+)
+
+type Analyzer struct{}
+
+func (a Analyzer) GetName() string {
+	return "cargo"
+}
+
+func (a Analyzer) Analyze(ctx analyzerapi.AnalyzerContext) []*analyzerapi.ProjectModule {
+	var result []*analyzerapi.ProjectModule
+
+	for _, file := range ctx.FilesByExtension["toml"] {
+		filename := filepath.Base(file)
+		if filename == "Cargo.toml" {
+			// parse Cargo.toml
+			cargoFile, err := parseCargoFile(file)
+			if err != nil {
+				log.Debug().Err(err).Msg("failed to parse Cargo.toml")
+			}
+
+			// module
+			module := analyzerapi.ProjectModule{
+				RootDirectory:     ctx.ProjectDir,
+				Directory:         filepath.Dir(file),
+				Name:              filepath.Base(filepath.Dir(file)),
+				Slug:              slug.Make(filepath.Base(filepath.Dir(file))),
+				Discovery:         []analyzerapi.ProjectModuleDiscovery{{File: file}},
+				BuildSystem:       analyzerapi.BuildSystemCargo,
+				BuildSystemSyntax: analyzerapi.BuildSystemSyntaxDefault,
+				Language:          analyzerapi.GetSingleLanguageMap(analyzerapi.LanguageRust, getRustVersionFromCargoFile(cargoFile)),
+				Dependencies:      nil,
+				Submodules:        nil,
+				Files:             ctx.Files,
+				FilesByExtension:  ctx.FilesByExtension,
+			}
+			analyzerapi.AddModuleToResult(&result, &module)
+		}
+	}
+
+	return result
+}
+
+func getRustVersionFromCargoFile(cargoFile Config) string {
+	if cargoFile.Package.RustVersion != "" {
+		return cargoFile.Package.RustVersion + ".0"
+	}
+	return "0.0.0"
+}

analyzer/cargo/cargo_test.go

@@ -0,0 +1,27 @@
+package cargo
+
+import (
+	"testing"
+
+	"github.com/cidverse/repoanalyzer/analyzerapi"
+	"github.com/cidverse/repoanalyzer/util"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAnalyzer_AnalyzeCargo(t *testing.T) {
+	ctx := analyzerapi.GetAnalyzerContext(util.GetTestDataDir(t, "cargo"))
+
+	analyzer := Analyzer{}
+	result := analyzer.Analyze(ctx)
+
+	// module
+	assert.Len(t, result, 1)
+	assert.Equal(t, "cargo", result[0].Name)
+	assert.Equal(t, "cargo", string(result[0].BuildSystem))
+	assert.Equal(t, "default", string(result[0].BuildSystemSyntax))
+
+	// print result
+	for i, item := range result {
+		t.Logf("result[%d]: %+v", i, *item)
+	}
+}

analyzer/cargo/parser.go

@@ -0,0 +1,36 @@
+package cargo
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+type Config struct {
+	Package Package `toml:"package"`
+}
+
+type Package struct {
+	Name        string `toml:"name"`
+	RustVersion string `toml:"rust-version"`
+}
+
+func parseCargoFile(file string) (Config, error) {
+	content, err := os.ReadFile(file)
+	if err != nil {
+		return Config{}, fmt.Errorf("failed to open Cargo.toml: %w", err)
+	}
+
+	return parseCargoFileFromByteArray(content)
+}
+
+func parseCargoFileFromByteArray(content []byte) (Config, error) {
+	var cfg Config
+	err := toml.Unmarshal(content, &cfg)
+	if err != nil {
+		return Config{}, fmt.Errorf("failed to parse Cargo.toml: %w", err)
+	}
+
+	return cfg, nil
+}

analyzer/cargo/parser_test.go

@@ -0,0 +1,47 @@
+package cargo
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseCargoFile(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected Config
+	}{
+		{
+			name: "Valid Cargo file",
+			input: `
+				[package]
+				name = "my-project"
+				version = "0.1.0"
+				authors = ["Firstname Lastname <[email protected]>"]
+				edition = "2021"
+				license = "MIT"
+				description = """
+				Multiline
+				Description
+				"""
+				rust-version = "1.56"
+			`,
+			expected: Config{
+				Package: Package{
+					Name:        "my-project",
+					RustVersion: "1.56",
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			cfg, err := parseCargoFileFromByteArray([]byte(tc.input))
+
+			assert.Nil(t, err)
+			assert.Equal(t, tc.expected, cfg)
+		})
+	}
+}

analyzer/composer/composer_test.go

@@ -3,10 +3,8 @@ package composer
 import (
 	"testing"
 
-	"github.com/cidverse/repoanalyzer/util"
-	"github.com/rs/zerolog/log"
-
 	"github.com/cidverse/repoanalyzer/analyzerapi"
+	"github.com/cidverse/repoanalyzer/util"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -24,5 +22,7 @@ func TestAnalyzer_AnalyzeComposer(t *testing.T) {
 	assert.Equal(t, "8.0.0", result[0].Language[analyzerapi.LanguagePHP])
 
 	// print result
-	log.Info().Interface("result", result).Msg("output")
+	for i, item := range result {
+		t.Logf("result[%d]: %+v", i, *item)
+	}
 }

analyzer/dotnet/dotnet_test.go

@@ -3,10 +3,8 @@ package dotnet
 import (
 	"testing"
 
-	"github.com/cidverse/repoanalyzer/util"
-	"github.com/rs/zerolog/log"
-
 	"github.com/cidverse/repoanalyzer/analyzerapi"
+	"github.com/cidverse/repoanalyzer/util"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -23,5 +21,7 @@ func TestAnalyzer_AnalyzeVisualStudioSolution(t *testing.T) {
 	assert.Equal(t, "default", string(result[0].BuildSystemSyntax))
 
 	// print result
-	log.Info().Interface("result", result).Msg("output")
+	for i, item := range result {
+		t.Logf("result[%d]: %+v", i, *item)
+	}
 }

analyzer/gomod/gomod_test.go

@@ -5,8 +5,6 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/rs/zerolog/log"
-
 	"github.com/cidverse/repoanalyzer/analyzerapi"
 	"github.com/stretchr/testify/assert"
 )
@@ -34,5 +32,7 @@ func TestGoModAnalyzer_Analyze(t *testing.T) {
 	assert.Len(t, result[0].Submodules, 0)
 
 	// print result
-	log.Info().Interface("result", result).Msg("output")
+	for i, item := range result {
+		t.Logf("result[%d]: %+v", i, *item)
+	}
 }

analyzer/gradle/gradle_test.go

@@ -4,10 +4,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/cidverse/repoanalyzer/util"
-	"github.com/rs/zerolog/log"
-
 	"github.com/cidverse/repoanalyzer/analyzerapi"
+	"github.com/cidverse/repoanalyzer/util"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -35,7 +33,9 @@ func TestGradleAnalyzer_AnalyzeGroovy(t *testing.T) {
 	assert.Equal(t, string(analyzerapi.GradleGroovyDSL), string(result[0].Submodules[0].BuildSystemSyntax))
 
 	// print result
-	log.Info().Interface("result", result).Msg("output")
+	for i, item := range result {
+		t.Logf("result[%d]: %+v", i, *item)
+	}
 }
 
 func TestGradleAnalyzer_AnalyzeKotlin(t *testing.T) {
@@ -59,5 +59,7 @@ func TestGradleAnalyzer_AnalyzeKotlin(t *testing.T) {
 	assert.Equal(t, string(analyzerapi.GradleKotlinDSL), string(result[0].Submodules[0].BuildSystemSyntax))
 
 	// print result
-	log.Info().Interface("result", result).Msg("output")
+	for i, item := range result {
+		t.Logf("result[%d]: %+v", i, *item)
+	}
 }

analyzer/helm/helm_test.go

@@ -1,10 +1,10 @@
 package helm
 
 import (
-	"github.com/cidverse/repoanalyzer/util"
-	"github.com/rs/zerolog/log"
 	"testing"
 
+	"github.com/cidverse/repoanalyzer/util"
+
 	"github.com/cidverse/repoanalyzer/analyzerapi"
 	"github.com/stretchr/testify/assert"
 )
@@ -22,5 +22,7 @@ func TestAnalyzer_AnalyzeHugo(t *testing.T) {
 	assert.Nil(t, result[0].Language)
 
 	// print result
-	log.Info().Interface("result", result).Msg("output")
+	for i, item := range result {
+		t.Logf("result[%d]: %+v", i, *item)
+	}
 }

analyzer/hugo/hugo_test.go

@@ -1,10 +1,10 @@
 package hugo
 
 import (
-	"github.com/cidverse/repoanalyzer/util"
-	"github.com/rs/zerolog/log"
 	"testing"
 
+	"github.com/cidverse/repoanalyzer/util"
+
 	"github.com/cidverse/repoanalyzer/analyzerapi"
 	"github.com/stretchr/testify/assert"
 )
@@ -20,5 +20,7 @@ func TestAnalyzer_AnalyzeHugo(t *testing.T) {
 	assert.Equal(t, "hugo", result[0].Name)
 
 	// print result
-	log.Info().Interface("result", result).Msg("output")
+	for i, item := range result {
+		t.Logf("result[%d]: %+v", i, *item)
+	}
 }

analyzer/maven/maven_test.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/cidverse/repoanalyzer/analyzerapi"
 	"github.com/cidverse/repoanalyzer/util"
-	"github.com/rs/zerolog/log"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -27,5 +26,7 @@ func TestAnalyzer_AnalyzeMaven(t *testing.T) {
 	assert.Equal(t, "4.12", result[0].Dependencies[0].Version)
 
 	// print result
-	log.Info().Interface("result", result).Msg("output")
+	for i, item := range result {
+		t.Logf("result[%d]: %+v", i, *item)
+	}
 }

analyzer/mkdocs/mkdocs_test.go

@@ -1,11 +1,10 @@
 package mkdocs
 
 import (
-	"github.com/cidverse/repoanalyzer/util"
-	"github.com/rs/zerolog/log"
 	"testing"
 
 	"github.com/cidverse/repoanalyzer/analyzerapi"
+	"github.com/cidverse/repoanalyzer/util"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -22,7 +21,9 @@ func TestAnalyzer_AnalyzeMkdocs(t *testing.T) {
 	assert.Equal(t, "default", string(result[0].BuildSystemSyntax))
 
 	// print result
-	log.Info().Interface("result", result).Msg("output")
+	for i, item := range result {
+		t.Logf("result[%d]: %+v", i, *item)
+	}
 }
 
 func TestAnalyzer_AnalyzeTechdocs(t *testing.T) {
@@ -38,5 +39,7 @@ func TestAnalyzer_AnalyzeTechdocs(t *testing.T) {
 	assert.Equal(t, "mkdocs-techdocs", string(result[0].BuildSystemSyntax))
 
 	// print result
-	log.Info().Interface("result", result).Msg("output")
+	for i, item := range result {
+		t.Logf("result[%d]: %+v", i, *item)
+	}
 }

analyzer/node/node_test.go

@@ -1,10 +1,10 @@
 package node
 
 import (
-	"github.com/cidverse/repoanalyzer/util"
-	"github.com/rs/zerolog/log"
 	"testing"
 
+	"github.com/cidverse/repoanalyzer/util"
+
 	"github.com/cidverse/repoanalyzer/analyzerapi"
 )
 
@@ -14,5 +14,7 @@ func TestAnalyzer_AnalyzeReact(t *testing.T) {
 	result := analyzer.Analyze(ctx)
 
 	// print result
-	log.Info().Interface("result", result).Msg("output")
+	for i, item := range result {
+		t.Logf("result[%d]: %+v", i, *item)
+	}
 }