alihan/odo
1
0
Fork 0
mirror of https://github.com/redhat-developer/odo.git synced 2025-10-19 03:06:19 +03:00
Code Issues Packages Projects Releases Wiki Activity

Bump Alizer library to latest commit [1] (#5970)

Browse Source 
[1] 59b004fd45

Signed-off-by: Armel Soro <asoro@redhat.com>
This commit is contained in:
Armel Soro
2022-07-23 09:40:46 +02:00
committed by GitHub
parent 8ba58d9e0f
commit 54f9bb075e
35 changed files with 261 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
go.mod
View File

@@ -35,7 +35,7 @@ require (
github.com/operator-framework/operator-lifecycle-manager v0.21.2
github.com/pborman/uuid v1.2.1
github.com/posener/complete v1.2.3
github.com/redhat-developer/alizer/go v0.0.0-20220530162645-f27a60be88a1
github.com/redhat-developer/alizer/go v0.0.0-20220714080930-59b004fd4586
github.com/redhat-developer/service-binding-operator v1.0.1-0.20211222115357-5b7bbba3bfb3
github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06
github.com/securego/gosec/v2 v2.12.0

4
go.sum
View File

@@ -1064,8 +1064,8 @@ github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1
github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
github.com/pseudomuto/protoc-gen-doc v1.3.2/go.mod h1:y5+P6n3iGrbKG+9O04V5ld71in3v/bX88wUwgt+U8EA=
github.com/pseudomuto/protokit v0.2.0/go.mod h1:2PdH30hxVHsup8KpBTOXTBeMVhJZVio3Q8ViKSAXT0Q=
github.com/redhat-developer/alizer/go v0.0.0-20220530162645-f27a60be88a1 h1:uhf+ll3f7uFvNGBndseVpiGEt6vLiw9vjCg2YH13uk4=
github.com/redhat-developer/alizer/go v0.0.0-20220530162645-f27a60be88a1/go.mod h1:EKkrP0Am7Xt/yg3dF8uH1SSoOcaZmBom8Iy6CJPPDok=
github.com/redhat-developer/alizer/go v0.0.0-20220714080930-59b004fd4586 h1:1BHWri7DqHDJTv7paad9a5zhyaWpaddDVYSjRCucrQM=
github.com/redhat-developer/alizer/go v0.0.0-20220714080930-59b004fd4586/go.mod h1:jzZFFoqYo3vQfo6dNNEv1biEZ1g55GPvvNPeP2gu43c=
github.com/redhat-developer/service-binding-operator v1.0.1-0.20211222115357-5b7bbba3bfb3 h1:hj+Y8vIzfQzzGx0az0MbIqDcW0+MZMc2rht8LuKt8uA=
github.com/redhat-developer/service-binding-operator v1.0.1-0.20211222115357-5b7bbba3bfb3/go.mod h1:pODWh91lgIyjf2n9ZqWYb1EBrLTmvKnjusKw0eG4vcE=
github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=

2
scripts/generate-mod.sh
View File

@@ -16,7 +16,7 @@ go mod edit -require github.com/devfile/registry-support/registry-library@v0.0.0
go mod edit -require github.com/openshift/oc@v0.0.0-alpha.0.0.20220402064836-f1f09a392fd1
go mod edit -require github.com/kubernetes-sigs/service-catalog@v0.3.1
go mod edit -require k8s.io/utils@v0.0.0-20220210201930-3a6ce19ff2f9
go mod edit -require github.com/redhat-developer/alizer/go@v0.0.0-20220530162645-f27a60be88a1
go mod edit -require github.com/redhat-developer/alizer/go@v0.0.0-20220714080930-59b004fd4586
go mod edit -require github.com/redhat-developer/service-binding-operator@v1.0.1-0.20211222115357-5b7bbba3bfb3
go mod edit -require github.com/onsi/ginkgo/v2@v2.1.4
go mod edit -require github.com/segmentio/backo-go@v1.0.1-0.20200129164019-23eae7c10bd3 # fixing this revision because of the missing license in the latest released version

11
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/dotnet_enricher.go generated vendored
View File

@@ -12,7 +12,7 @@ package recognizer
import (
framework "github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/dotnet"
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
utils "github.com/redhat-developer/alizer/go/pkg/utils"
)
@@ -28,18 +28,23 @@ func getDotNetFrameworkDetectors() []FrameworkDetectorWithConfigFile {
}
}
func (j DotNetEnricher) DoEnrichLanguage(language *language.Language, files *[]string) {
func (j DotNetEnricher) DoEnrichLanguage(language *model.Language, files *[]string) {
configFiles := utils.GetFilesByRegex(files, ".*\\.\\w+proj")
for _, configFile := range configFiles {
getDotNetFrameworks(language, configFile)
}
}
func (j DotNetEnricher) DoEnrichComponent(component *model.Component) {
projectName := GetDefaultProjectName(component.Path)
component.Name = projectName
}
func (j DotNetEnricher) IsConfigValidForComponentDetection(language string, config string) bool {
return IsConfigurationValidForLanguage(language, config)
}
func getDotNetFrameworks(language *language.Language, configFile string) {
func getDotNetFrameworks(language *model.Language, configFile string) {
for _, detector := range getDotNetFrameworkDetectors() {
detector.DoFrameworkDetection(language, configFile)
}

13
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/enricher.go generated vendored
View File

@@ -16,22 +16,23 @@ import (
"path/filepath"
"strings"
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
"github.com/redhat-developer/alizer/go/pkg/utils/langfiles"
)
type Enricher interface {
GetSupportedLanguages() []string
DoEnrichLanguage(language *language.Language, files *[]string)
DoEnrichLanguage(language *model.Language, files *[]string)
DoEnrichComponent(component *model.Component)
IsConfigValidForComponentDetection(language string, configFile string) bool
}
type FrameworkDetectorWithConfigFile interface {
DoFrameworkDetection(language *language.Language, config string)
DoFrameworkDetection(language *model.Language, config string)
}
type FrameworkDetectorWithoutConfigFile interface {
DoFrameworkDetection(language *language.Language, files *[]string)
DoFrameworkDetection(language *model.Language, files *[]string)
}
/*
@@ -107,3 +108,7 @@ func isLanguageSupportedByEnricher(nameLanguage string, enricher Enricher) bool
}
return false
}
func GetDefaultProjectName(path string) string {
return filepath.Base(path)
}

4
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/dotnet/dotnet_detector.go generated vendored
View File

@@ -16,14 +16,14 @@ import (
"os"
"strings"
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
"github.com/redhat-developer/alizer/go/pkg/schema"
"github.com/redhat-developer/alizer/go/pkg/utils"
)
type DotNetDetector struct{}
func (m DotNetDetector) DoFrameworkDetection(language *language.Language, configFilePath string) {
func (m DotNetDetector) DoFrameworkDetection(language *model.Language, configFilePath string) {
framework := getFrameworks(configFilePath)
if framework == "" {
return

4
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/go/beego_detector.go generated vendored
View File

@@ -11,13 +11,13 @@
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
"golang.org/x/mod/modfile"
)
type BeegoDetector struct{}
func (e BeegoDetector) DoFrameworkDetection(language *language.Language, goMod *modfile.File) {
func (e BeegoDetector) DoFrameworkDetection(language *model.Language, goMod *modfile.File) {
if hasFramework(goMod.Require, "github.com/beego/beego") {
language.Frameworks = append(language.Frameworks, "Beego")
}

4
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/go/echo_detector.go generated vendored
View File

@@ -11,13 +11,13 @@
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
"golang.org/x/mod/modfile"
)
type EchoDetector struct{}
func (e EchoDetector) DoFrameworkDetection(language *language.Language, goMod *modfile.File) {
func (e EchoDetector) DoFrameworkDetection(language *model.Language, goMod *modfile.File) {
if hasFramework(goMod.Require, "github.com/labstack/echo") {
language.Frameworks = append(language.Frameworks, "Echo")
}

4
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/go/fasthttp_detector.go generated vendored
View File

@@ -11,13 +11,13 @@
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
"golang.org/x/mod/modfile"
)
type FastHttpDetector struct{}
func (e FastHttpDetector) DoFrameworkDetection(language *language.Language, goMod *modfile.File) {
func (e FastHttpDetector) DoFrameworkDetection(language *model.Language, goMod *modfile.File) {
if hasFramework(goMod.Require, "github.com/valyala/fasthttp") {
language.Frameworks = append(language.Frameworks, "FastHttp")
}

4
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/go/gin_detector.go generated vendored
View File

@@ -11,13 +11,13 @@
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
"golang.org/x/mod/modfile"
)
type GinDetector struct{}
func (e GinDetector) DoFrameworkDetection(language *language.Language, goMod *modfile.File) {
func (e GinDetector) DoFrameworkDetection(language *model.Language, goMod *modfile.File) {
if hasFramework(goMod.Require, "github.com/gin-gonic/gin") {
language.Frameworks = append(language.Frameworks, "Gin")
}

4
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/go/gofiber_detector.go generated vendored
View File

@@ -11,13 +11,13 @@
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
"golang.org/x/mod/modfile"
)
type GoFiberDetector struct{}
func (e GoFiberDetector) DoFrameworkDetection(language *language.Language, goMod *modfile.File) {
func (e GoFiberDetector) DoFrameworkDetection(language *model.Language, goMod *modfile.File) {
if hasFramework(goMod.Require, "github.com/gofiber/fiber") {
language.Frameworks = append(language.Frameworks, "GoFiber")
}

4
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/go/mux_detector.go generated vendored
View File

@@ -11,13 +11,13 @@
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
"golang.org/x/mod/modfile"
)
type MuxDetector struct{}
func (e MuxDetector) DoFrameworkDetection(language *language.Language, goMod *modfile.File) {
func (e MuxDetector) DoFrameworkDetection(language *model.Language, goMod *modfile.File) {
if hasFramework(goMod.Require, "github.com/gorilla/mux") {
language.Frameworks = append(language.Frameworks, "Mux")
}

6
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/java/micronaut_detector.go generated vendored
View File

@@ -10,13 +10,11 @@
******************************************************************************/
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
)
import "github.com/redhat-developer/alizer/go/pkg/apis/model"
type MicronautDetector struct{}
func (m MicronautDetector) DoFrameworkDetection(language *language.Language, config string) {
func (m MicronautDetector) DoFrameworkDetection(language *model.Language, config string) {
if hasFwk, _ := hasFramework(config, "io.micronaut"); hasFwk {
language.Frameworks = append(language.Frameworks, "Micronaut")
}

6
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/java/openliberty_detector.go generated vendored
View File

@@ -10,13 +10,11 @@
******************************************************************************/
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
)
import "github.com/redhat-developer/alizer/go/pkg/apis/model"
type OpenLibertyDetector struct{}
func (o OpenLibertyDetector) DoFrameworkDetection(language *language.Language, config string) {
func (o OpenLibertyDetector) DoFrameworkDetection(language *model.Language, config string) {
if hasFwk, _ := hasFramework(config, "io.openliberty"); hasFwk {
language.Frameworks = append(language.Frameworks, "OpenLiberty")
}

6
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/java/quarkus_detector.go generated vendored
View File

@@ -10,13 +10,11 @@
******************************************************************************/
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
)
import "github.com/redhat-developer/alizer/go/pkg/apis/model"
type QuarkusDetector struct{}
func (q QuarkusDetector) DoFrameworkDetection(language *language.Language, config string) {
func (q QuarkusDetector) DoFrameworkDetection(language *model.Language, config string) {
if hasFwk, _ := hasFramework(config, "io.quarkus"); hasFwk {
language.Frameworks = append(language.Frameworks, "Quarkus")
}

6
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/java/spring_detector.go generated vendored
View File

@@ -10,13 +10,11 @@
******************************************************************************/
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
)
import "github.com/redhat-developer/alizer/go/pkg/apis/model"
type SpringDetector struct{}
func (s SpringDetector) DoFrameworkDetection(language *language.Language, config string) {
func (s SpringDetector) DoFrameworkDetection(language *model.Language, config string) {
if hasFwk, _ := hasFramework(config, "org.springframework"); hasFwk {
language.Frameworks = append(language.Frameworks, "Spring")
}

6
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/java/vertx_detector.go generated vendored
View File

@@ -10,13 +10,11 @@
******************************************************************************/
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
)
import "github.com/redhat-developer/alizer/go/pkg/apis/model"
type VertxDetector struct{}
func (v VertxDetector) DoFrameworkDetection(language *language.Language, config string) {
func (v VertxDetector) DoFrameworkDetection(language *model.Language, config string) {
if hasFwk, _ := hasFramework(config, "io.vertx"); hasFwk {
language.Frameworks = append(language.Frameworks, "Vertx")
}

6
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/javascript/nodejs/express_detector.go generated vendored
View File

@@ -10,13 +10,11 @@
******************************************************************************/
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
)
import "github.com/redhat-developer/alizer/go/pkg/apis/model"
type ExpressDetector struct{}
func (e ExpressDetector) DoFrameworkDetection(language *language.Language, config string) {
func (e ExpressDetector) DoFrameworkDetection(language *model.Language, config string) {
if hasFramework(config, "express") {
language.Frameworks = append(language.Frameworks, "Express")
}

6
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/javascript/nodejs/reactjs_detector.go generated vendored
View File

@@ -10,13 +10,11 @@
******************************************************************************/
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
)
import "github.com/redhat-developer/alizer/go/pkg/apis/model"
type ReactJsDetector struct{}
func (r ReactJsDetector) DoFrameworkDetection(language *language.Language, config string) {
func (r ReactJsDetector) DoFrameworkDetection(language *model.Language, config string) {
if hasFramework(config, "react") {
language.Frameworks = append(language.Frameworks, "React")
}

4
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/python/django_detector.go generated vendored
View File

@@ -11,13 +11,13 @@
package recognizer
import (
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
"github.com/redhat-developer/alizer/go/pkg/utils"
)
type DjangoDetector struct{}
func (d DjangoDetector) DoFrameworkDetection(language *language.Language, files *[]string) {
func (d DjangoDetector) DoFrameworkDetection(language *model.Language, files *[]string) {
managePy := utils.GetFile(files, "manage.py")
urlsPy := utils.GetFile(files, "urls.py")
wsgiPy := utils.GetFile(files, "wsgi.py")

13
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/go_enricher.go generated vendored
View File

@@ -15,7 +15,7 @@ import (
"io/ioutil"
framework "github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/go"
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
utils "github.com/redhat-developer/alizer/go/pkg/utils"
"golang.org/x/mod/modfile"
)
@@ -23,7 +23,7 @@ import (
type GoEnricher struct{}
type GoFrameworkDetector interface {
DoFrameworkDetection(language *language.Language, goMod *modfile.File)
DoFrameworkDetection(language *model.Language, goMod *modfile.File)
}
func getGoFrameworkDetectors() []GoFrameworkDetector {
@@ -41,7 +41,7 @@ func (j GoEnricher) GetSupportedLanguages() []string {
return []string{"go"}
}
func (j GoEnricher) DoEnrichLanguage(language *language.Language, files *[]string) {
func (j GoEnricher) DoEnrichLanguage(language *model.Language, files *[]string) {
goModPath := utils.GetFile(files, "go.mod")
if goModPath != "" {
@@ -56,6 +56,11 @@ func (j GoEnricher) DoEnrichLanguage(language *language.Language, files *[]strin
}
}
func (j GoEnricher) DoEnrichComponent(component *model.Component) {
projectName := GetDefaultProjectName(component.Path)
component.Name = projectName
}
func (j GoEnricher) IsConfigValidForComponentDetection(language string, config string) bool {
return IsConfigurationValidForLanguage(language, config)
}
@@ -68,7 +73,7 @@ func getGoModFile(filePath string) (*modfile.File, error) {
return modfile.Parse(filePath, b, nil)
}
func detectGoFrameworks(language *language.Language, configFile *modfile.File) {
func detectGoFrameworks(language *model.Language, configFile *modfile.File) {
for _, detector := range getGoFrameworkDetectors() {
detector.DoFrameworkDetection(language, configFile)
}

49
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/java_enricher.go generated vendored
View File

@@ -11,11 +11,13 @@
package recognizer
import (
"os"
"path/filepath"
"regexp"
"strings"
framework "github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/java"
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
utils "github.com/redhat-developer/alizer/go/pkg/utils"
)
@@ -35,7 +37,7 @@ func (j JavaEnricher) GetSupportedLanguages() []string {
return []string{"java"}
}
func (j JavaEnricher) DoEnrichLanguage(language *language.Language, files *[]string) {
func (j JavaEnricher) DoEnrichLanguage(language *model.Language, files *[]string) {
gradle := utils.GetFile(files, "build.gradle")
maven := utils.GetFile(files, "pom.xml")
ant := utils.GetFile(files, "build.xml")
@@ -51,6 +53,47 @@ func (j JavaEnricher) DoEnrichLanguage(language *language.Language, files *[]str
}
}
func (j JavaEnricher) DoEnrichComponent(component *model.Component) {
projectName := getProjectNameMaven(component.Path)
if projectName == "" {
projectName = getProjectNameGradle(component.Path)
}
if projectName == "" {
projectName = GetDefaultProjectName(component.Path)
}
component.Name = projectName
}
func getProjectNameGradle(root string) string {
settingsGradlePath := filepath.Join(root, "settings.gradle")
if _, err := os.Stat(settingsGradlePath); err == nil {
re := regexp.MustCompile(`rootProject.name\s*=\s*(.*)`)
bytes, err := os.ReadFile(settingsGradlePath)
if err != nil {
return ""
}
content := string(bytes)
matchProjectName := re.FindStringSubmatch(content)
if len(matchProjectName) > 0 && matchProjectName[1] != "" {
projectName := strings.TrimLeft(matchProjectName[1], "\"'")
projectName = strings.TrimRight(projectName, "\"' ")
return projectName
}
}
return ""
}
func getProjectNameMaven(root string) string {
pomXMLPath := filepath.Join(root, "pom.xml")
if _, err := os.Stat(pomXMLPath); err == nil {
pomXML, err := utils.GetPomFileContent(pomXMLPath)
if err == nil {
return pomXML.ArtifactId
}
}
return ""
}
func (j JavaEnricher) IsConfigValidForComponentDetection(language string, config string) bool {
return IsConfigurationValidForLanguage(language, config) && !isParentModuleMaven(config)
}
@@ -72,7 +115,7 @@ func isParentModuleMaven(configPath string) bool {
return hasTag
}
func detectJavaFrameworks(language *language.Language, configFile string) {
func detectJavaFrameworks(language *model.Language, configFile string) {
for _, detector := range getJavaFrameworkDetectors() {
detector.DoFrameworkDetection(language, configFile)
}

24
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/javascript_enricher.go generated vendored
View File

@@ -11,8 +11,11 @@
package recognizer
import (
"os"
"path/filepath"
framework "github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/javascript/nodejs"
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
utils "github.com/redhat-developer/alizer/go/pkg/utils"
)
@@ -29,7 +32,7 @@ func (j JavaScriptEnricher) GetSupportedLanguages() []string {
return []string{"javascript", "typescript"}
}
func (j JavaScriptEnricher) DoEnrichLanguage(language *language.Language, files *[]string) {
func (j JavaScriptEnricher) DoEnrichLanguage(language *model.Language, files *[]string) {
packageJson := utils.GetFile(files, "package.json")
if packageJson != "" {
@@ -38,11 +41,26 @@ func (j JavaScriptEnricher) DoEnrichLanguage(language *language.Language, files
}
}
func (j JavaScriptEnricher) DoEnrichComponent(component *model.Component) {
projectName := ""
packageJsonPath := filepath.Join(component.Path, "package.json")
if _, err := os.Stat(packageJsonPath); err == nil {
packageJson, err := utils.GetPackageJsonFile(packageJsonPath)
if err == nil {
projectName = packageJson.Name
}
}
if projectName == "" {
projectName = GetDefaultProjectName(component.Path)
}
component.Name = projectName
}
func (j JavaScriptEnricher) IsConfigValidForComponentDetection(language string, config string) bool {
return IsConfigurationValidForLanguage(language, config)
}
func detectJavaScriptFrameworks(language *language.Language, configFile string) {
func detectJavaScriptFrameworks(language *model.Language, configFile string) {
for _, detector := range getJavaScriptFrameworkDetectors() {
detector.DoFrameworkDetection(language, configFile)
}

11
vendor/github.com/redhat-developer/alizer/go/pkg/apis/enricher/python_enricher.go generated vendored
View File

@@ -12,7 +12,7 @@ package recognizer
import (
framework "github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/python"
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
)
type PythonEnricher struct{}
@@ -27,16 +27,21 @@ func (p PythonEnricher) GetSupportedLanguages() []string {
return []string{"python"}
}
func (p PythonEnricher) DoEnrichLanguage(language *language.Language, files *[]string) {
func (p PythonEnricher) DoEnrichLanguage(language *model.Language, files *[]string) {
language.Tools = []string{}
detectPythonFrameworks(language, files)
}
func (j PythonEnricher) DoEnrichComponent(component *model.Component) {
projectName := GetDefaultProjectName(component.Path)
component.Name = projectName
}
func (p PythonEnricher) IsConfigValidForComponentDetection(language string, config string) bool {
return IsConfigurationValidForLanguage(language, config)
}
func detectPythonFrameworks(language *language.Language, files *[]string) {
func detectPythonFrameworks(language *model.Language, files *[]string) {
for _, detector := range getPythonFrameworkDetectors() {
detector.DoFrameworkDetection(language, files)
}

20
vendor/github.com/redhat-developer/alizer/go/pkg/apis/language/language.go → vendor/github.com/redhat-developer/alizer/go/pkg/apis/model/model.go generated vendored
View File

@@ -8,13 +8,19 @@
* Contributors:
* Red Hat, Inc.
******************************************************************************/
package language
package model
type Language struct {
Name string
Aliases []string
UsageInPercentage float64
Frameworks []string
Tools []string
CanBeComponent bool
Name string
Aliases []string
Weight float64
Frameworks []string
Tools []string
CanBeComponent bool
}
type Component struct {
Name string
Path string
Languages []Language
}

67
vendor/github.com/redhat-developer/alizer/go/pkg/apis/recognizer/component_recognizer.go generated vendored
View File

@@ -18,36 +18,31 @@ import (
"strings"
enricher "github.com/redhat-developer/alizer/go/pkg/apis/enricher"
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
"github.com/redhat-developer/alizer/go/pkg/utils/langfiles"
)
type Component struct {
Path string
Languages []language.Language
}
func DetectComponentsInRoot(path string) ([]Component, error) {
func DetectComponentsInRoot(path string) ([]model.Component, error) {
files, err := getFilePathsInRoot(path)
if err != nil {
return []Component{}, err
return []model.Component{}, err
}
components, err := detectComponents(files)
components, err := DetectComponentsFromFilesList(files)
if err != nil {
return []Component{}, err
return []model.Component{}, err
}
return components, nil
}
func DetectComponents(path string) ([]Component, error) {
files, err := getFilePathsFromRoot(path)
func DetectComponents(path string) ([]model.Component, error) {
files, err := GetFilePathsFromRoot(path)
if err != nil {
return []Component{}, err
return []model.Component{}, err
}
components, err := detectComponents(files)
components, err := DetectComponentsFromFilesList(files)
if err != nil {
return []Component{}, err
return []model.Component{}, err
}
// it may happen that a language has no a specific configuration file (e.g opposite to JAVA -> pom.xml and Nodejs -> package.json)
@@ -65,8 +60,8 @@ func DetectComponents(path string) ([]Component, error) {
Returns:
components found
*/
func getComponentsWithoutConfigFile(directories []string) []Component {
var components []Component
func getComponentsWithoutConfigFile(directories []string) []model.Component {
var components []model.Component
for _, dir := range directories {
component, _ := detectComponent(dir, []string{})
if component.Path != "" && isLangForNoConfigComponent(component.Languages) {
@@ -83,7 +78,7 @@ func getComponentsWithoutConfigFile(directories []string) []Component {
Returns:
bool: true if language does not require any config file
*/
func isLangForNoConfigComponent(languages []language.Language) bool {
func isLangForNoConfigComponent(languages []model.Language) bool {
if len(languages) == 0 {
return false
}
@@ -104,7 +99,7 @@ func isLangForNoConfigComponent(languages []language.Language) bool {
Returns:
list of directories path that does not contain any component
*/
func getDirectoriesWithoutConfigFile(root string, components []Component) []string {
func getDirectoriesWithoutConfigFile(root string, components []model.Component) []string {
if len(components) == 0 {
return []string{root}
}
@@ -156,7 +151,7 @@ func getParentFolders(target string, directories []string) []string {
Returns:
true if a component is found starting from path
*/
func isAnyComponentInPath(path string, components []Component) bool {
func isAnyComponentInPath(path string, components []model.Component) bool {
for _, component := range components {
if strings.EqualFold(path, component.Path) || isFirstPathParentOfSecond(component.Path, path) || isFirstPathParentOfSecond(path, component.Path) {
return true
@@ -178,15 +173,15 @@ func isFirstPathParentOfSecond(firstPath string, secondPath string) bool {
}
/*
detectComponents detect components by analyzing all files
DetectComponentsFromFilesList detect components by analyzing all files
Parameters:
files: list of files to analyze
Returns:
list of components detected or err if any error occurs
*/
func detectComponents(files []string) ([]Component, error) {
func DetectComponentsFromFilesList(files []string) ([]model.Component, error) {
configurationPerLanguage := langfiles.Get().GetConfigurationPerLanguageMapping()
var components []Component
var components []model.Component
for _, file := range files {
dir, fileName := filepath.Split(file)
if dir == "" {
@@ -209,7 +204,7 @@ func detectComponents(files []string) ([]Component, error) {
return components, nil
}
func appendIfMissing(components []Component, component Component) []Component {
func appendIfMissing(components []model.Component, component model.Component) []model.Component {
for _, comp := range components {
if strings.EqualFold(comp.Path, component.Path) {
return components
@@ -233,26 +228,29 @@ func getLanguagesByConfigurationFile(configurationPerLanguage map[string][]strin
, error otherwise
Parameters:
root: path to be used as root where to start the detection
configFile: name of configuration file
configLanguages: languages associated to the config file found and to be used as target for detection
Returns:
component detected or error if any error occurs
*/
func detectComponent(root string, configLanguages []string) (Component, error) {
func detectComponent(root string, configLanguages []string) (model.Component, error) {
languages, err := Analyze(root)
if err != nil {
return Component{}, err
return model.Component{}, err
}
languages = getLanguagesWeightedByConfigFile(languages, configLanguages)
if len(languages) > 0 {
if mainLang := languages[0]; mainLang.CanBeComponent {
return Component{
component := model.Component{
Path: root,
Languages: languages,
}, nil
}
enrichComponent(&component)
return component, nil
}
}
return Component{}, nil
return model.Component{}, nil
}
@@ -265,7 +263,7 @@ func detectComponent(root string, configLanguages []string) (Component, error) {
Returns:
list of languages reordered
*/
func getLanguagesWeightedByConfigFile(languages []language.Language, configLanguages []string) []language.Language {
func getLanguagesWeightedByConfigFile(languages []model.Language, configLanguages []string) []model.Language {
if len(configLanguages) == 0 {
return languages
}
@@ -274,7 +272,7 @@ func getLanguagesWeightedByConfigFile(languages []language.Language, configLangu
for _, configLanguage := range configLanguages {
if strings.EqualFold(lang.Name, configLanguage) {
sliceWithoutLang := append(languages[:index], languages[index+1:]...)
return append([]language.Language{lang}, sliceWithoutLang...)
return append([]model.Language{lang}, sliceWithoutLang...)
}
}
}
@@ -288,3 +286,10 @@ func isConfigurationValid(language string, file string) bool {
}
return false
}
func enrichComponent(component *model.Component) {
componentEnricher := enricher.GetEnricherByLanguage(component.Languages[0].Name)
if componentEnricher != nil {
componentEnricher.DoEnrichComponent(component)
}
}

6
vendor/github.com/redhat-developer/alizer/go/pkg/apis/recognizer/devfile_recognizer.go generated vendored
View File

@@ -14,7 +14,7 @@ import (
"errors"
"strings"
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
)
type DevFileType struct {
@@ -52,7 +52,7 @@ func SelectDevFileFromTypes(path string, devFileTypes []DevFileType) (int, error
return devfile, nil
}
func SelectDevFileUsingLanguagesFromTypes(languages []language.Language, devFileTypes []DevFileType) (int, error) {
func SelectDevFileUsingLanguagesFromTypes(languages []model.Language, devFileTypes []DevFileType) (int, error) {
for _, language := range languages {
devfile, err := selectDevFileByLanguage(language, devFileTypes)
if err == nil {
@@ -62,7 +62,7 @@ func SelectDevFileUsingLanguagesFromTypes(languages []language.Language, devFile
return -1, errors.New("no valid devfile found by using those languages")
}
func selectDevFileByLanguage(language language.Language, devFileTypes []DevFileType) (int, error) {
func selectDevFileByLanguage(language model.Language, devFileTypes []DevFileType) (int, error) {
scoreTarget := 0
devfileTarget := -1
FRAMEWORK_WEIGHT := 10

64
vendor/github.com/redhat-developer/alizer/go/pkg/apis/recognizer/language_recognizer.go generated vendored
View File

@@ -11,6 +11,7 @@
package recognizer
import (
"errors"
"io/ioutil"
"os"
"path/filepath"
@@ -18,22 +19,23 @@ import (
"strings"
enricher "github.com/redhat-developer/alizer/go/pkg/apis/enricher"
"github.com/redhat-developer/alizer/go/pkg/apis/language"
"github.com/redhat-developer/alizer/go/pkg/apis/model"
langfile "github.com/redhat-developer/alizer/go/pkg/utils/langfiles"
ignore "github.com/sabhiram/go-gitignore"
)
type languageItem struct {
item langfile.LanguageItem
percentage int
item langfile.LanguageItem
weight int
}
func Analyze(path string) ([]language.Language, error) {
func Analyze(path string) ([]model.Language, error) {
languagesFile := langfile.Get()
languagesDetected := make(map[string]languageItem)
paths, err := getFilePathsFromRoot(path)
paths, err := GetFilePathsFromRoot(path)
if err != nil {
return []language.Language{}, err
return []model.Language{}, err
}
extensionsGrouped := extractExtensions(paths)
extensionHasProgrammingLanguage := false
@@ -56,8 +58,8 @@ func Analyze(path string) ([]language.Language, error) {
}
}
tmpLanguageItem := languageItem{languageFileItem, 0}
percentage := languagesDetected[tmpLanguageItem.item.Name].percentage + extensionsGrouped[extension]
tmpLanguageItem.percentage = percentage
weight := languagesDetected[tmpLanguageItem.item.Name].weight + extensionsGrouped[extension]
tmpLanguageItem.weight = weight
languagesDetected[tmpLanguageItem.item.Name] = tmpLanguageItem
extensionHasProgrammingLanguage = true
}
@@ -68,18 +70,18 @@ func Analyze(path string) ([]language.Language, error) {
}
}
var languagesFound []language.Language
var languagesFound []model.Language
for name, item := range languagesDetected {
tmpPercentage := float64(item.percentage) / float64(totalProgrammingOccurrences)
tmpPercentage = float64(int(tmpPercentage*10000)) / 10000
if tmpPercentage > 0.02 {
tmpLanguage := language.Language{
Name: name,
Aliases: item.item.Aliases,
UsageInPercentage: tmpPercentage * 100,
Frameworks: []string{},
Tools: []string{},
CanBeComponent: item.item.Component}
tmpWeight := float64(item.weight) / float64(totalProgrammingOccurrences)
tmpWeight = float64(int(tmpWeight*10000)) / 10000
if tmpWeight > 0.02 {
tmpLanguage := model.Language{
Name: name,
Aliases: item.item.Aliases,
Weight: tmpWeight * 100,
Frameworks: []string{},
Tools: []string{},
CanBeComponent: item.item.Component}
langEnricher := enricher.GetEnricherByLanguage(name)
if langEnricher != nil {
langEnricher.DoEnrichLanguage(&tmpLanguage, &paths)
@@ -89,7 +91,7 @@ func Analyze(path string) ([]language.Language, error) {
}
sort.SliceStable(languagesFound, func(i, j int) bool {
return languagesFound[i].UsageInPercentage > languagesFound[j].UsageInPercentage
return languagesFound[i].Weight > languagesFound[j].Weight
})
return languagesFound, nil
@@ -108,10 +110,18 @@ func extractExtensions(paths []string) map[string]int {
return extensions
}
func getFilePathsFromRoot(root string) ([]string, error) {
func GetFilePathsFromRoot(root string) ([]string, error) {
var files []string
err := filepath.Walk(root,
ignoreFile, errorIgnoreFile := getIgnoreFile(root)
errWalk := filepath.Walk(root,
func(path string, info os.FileInfo, err error) error {
if errorIgnoreFile == nil && ignoreFile.MatchesPath(path) {
if info.IsDir() {
return filepath.SkipDir
} else {
return nil
}
}
if !info.IsDir() && isFileInRoot(root, path) {
files = append([]string{path}, files...)
} else {
@@ -119,7 +129,15 @@ func getFilePathsFromRoot(root string) ([]string, error) {
}
return nil
})
return files, err
return files, errWalk
}
func getIgnoreFile(root string) (*ignore.GitIgnore, error) {
gitIgnorePath := filepath.Join(root, ".gitignore")
if _, err := os.Stat(gitIgnorePath); err == nil {
return ignore.CompileIgnoreFile(gitIgnorePath)
}
return nil, errors.New("no git ignore file found")
}
func isFileInRoot(root string, file string) bool {

1
vendor/github.com/redhat-developer/alizer/go/pkg/schema/languages.go generated vendored
View File

@@ -31,6 +31,7 @@ type LanguageCustomization struct {
Component bool `yaml:"component"`
ExcludeFolders []string `yaml:"exclude_folders,omitempty"`
Aliases []string `yaml:"aliases"`
Disabled bool `default:"false" yaml:"disable_detection"`
}
type LanguagesCustomizations map[string]LanguageCustomization

1
vendor/github.com/redhat-developer/alizer/go/pkg/schema/package_json.go generated vendored
View File

@@ -11,5 +11,6 @@
package schema
type PackageJson struct {
Name string `json:"name"`
Dependencies map[string]string `json:"dependencies"`
}

1
vendor/github.com/redhat-developer/alizer/go/pkg/schema/pom_xml.go generated vendored
View File

@@ -24,4 +24,5 @@ type Pom struct {
Modules struct {
Module string `xml:"module"`
} `xml:"modules,omitempty"`
ArtifactId string `xml:"artifactId"`
}

27
vendor/github.com/redhat-developer/alizer/go/pkg/utils/detector.go generated vendored
View File

@@ -13,6 +13,7 @@ package utils
import (
"encoding/json"
"encoding/xml"
"errors"
"io/ioutil"
"os"
"path/filepath"
@@ -98,17 +99,8 @@ func GetPomFileContent(pomFilePath string) (schema.Pom, error) {
}
func IsTagInPackageJsonFile(file string, tag string) bool {
jsonFile, err := os.Open(file)
if err != nil {
return false
}
byteValue, _ := ioutil.ReadAll(jsonFile)
var packageJson schema.PackageJson
json.Unmarshal(byteValue, &packageJson)
defer jsonFile.Close()
if packageJson.Dependencies != nil {
packageJson, err := GetPackageJsonFile(file)
if err == nil && packageJson.Dependencies != nil {
for dependency := range packageJson.Dependencies {
if strings.Contains(dependency, tag) {
return true
@@ -118,6 +110,19 @@ func IsTagInPackageJsonFile(file string, tag string) bool {
return false
}
func GetPackageJsonFile(file string) (schema.PackageJson, error) {
jsonFile, err := os.Open(file)
if err != nil {
return schema.PackageJson{}, errors.New("error opening file")
}
byteValue, _ := ioutil.ReadAll(jsonFile)
var packageJson schema.PackageJson
err = json.Unmarshal(byteValue, &packageJson)
defer jsonFile.Close()
return packageJson, err
}
func AddToArrayIfValueExist(arr *[]string, val string) {
if val != "" {
*arr = append(*arr, val)

16
vendor/github.com/redhat-developer/alizer/go/pkg/utils/langfiles/languages_file_handler.go generated vendored
View File

@@ -27,6 +27,7 @@ type LanguageItem struct {
ConfigurationFiles []string
ExcludeFolders []string
Component bool
disabled bool
}
type LanguageFile struct {
@@ -62,12 +63,14 @@ func create() *LanguageFile {
Group: properties.Group,
}
customizeLanguage(&languageItem)
languages[name] = languageItem
extensions := properties.Extensions
for _, ext := range extensions {
languagesByExtension := extensionsXLanguage[ext]
languagesByExtension = append(languagesByExtension, languageItem)
extensionsXLanguage[ext] = languagesByExtension
if !languageItem.disabled {
languages[name] = languageItem
extensions := properties.Extensions
for _, ext := range extensions {
languagesByExtension := extensionsXLanguage[ext]
languagesByExtension = append(languagesByExtension, languageItem)
extensionsXLanguage[ext] = languagesByExtension
}
}
}
@@ -84,6 +87,7 @@ func customizeLanguage(languageItem *LanguageItem) {
(*languageItem).ExcludeFolders = customization.ExcludeFolders
(*languageItem).Component = customization.Component
(*languageItem).Aliases = appendSlice((*languageItem).Aliases, customization.Aliases)
(*languageItem).disabled = customization.Disabled
}
}

2
vendor/github.com/redhat-developer/alizer/go/pkg/utils/langfiles/resources/languages-customization.yml generated vendored
View File

@@ -12,6 +12,8 @@ F#:
- ".*\\.\\w+proj"
- "appsettings.json"
component: true
GCC Machine Description:
disable_detection: true
Go:
configuration_files:
- "go.mod"

4
vendor/modules.txt vendored
View File

@@ -631,7 +631,7 @@ github.com/prometheus/common/model
github.com/prometheus/procfs
github.com/prometheus/procfs/internal/fs
github.com/prometheus/procfs/internal/util
# github.com/redhat-developer/alizer/go v0.0.0-20220530162645-f27a60be88a1
# github.com/redhat-developer/alizer/go v0.0.0-20220714080930-59b004fd4586
## explicit; go 1.17
github.com/redhat-developer/alizer/go/pkg/apis/enricher
github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/dotnet
@@ -639,7 +639,7 @@ github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/go
github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/java
github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/javascript/nodejs
github.com/redhat-developer/alizer/go/pkg/apis/enricher/framework/python
github.com/redhat-developer/alizer/go/pkg/apis/language
github.com/redhat-developer/alizer/go/pkg/apis/model
github.com/redhat-developer/alizer/go/pkg/apis/recognizer
github.com/redhat-developer/alizer/go/pkg/schema
github.com/redhat-developer/alizer/go/pkg/utils