func()

in cmd/create.go [167:279]

• 100 lines of code
• 28 McCabe index (conditional complexity)

func (cc *createCmd) detectLanguage() (*handlers.Template, string, error) {
	hasGo := false
	hasGoMod := false
	var langs []*linguist.Language
	var err error
	supportedLanguages, err := listSupportedLanguages()
	if err != nil {
		log.Errorf("loading supported languages: %s", err.Error())
	}
	log.Debugf("loaded supported languages: %v", supportedLanguages)
	if cc.createConfig.LanguageType == "" {
		if cc.lang != "" {
			cc.createConfig.LanguageType = cc.lang
		} else {
			log.Info("--- Detecting Language ---")
			langs, err = linguist.ProcessDir(cc.dest)
			log.Debugf("linguist.ProcessDir(%v) result:\n\nError: %v", cc.dest, err)
			if err != nil {
				return nil, "", fmt.Errorf("there was an error detecting the language: %s", err)
			}
			if len(langs) == 0 {
				if !interactive {
					return nil, "", ErrNoLanguageDetected
				}
				langs, err = promptLanguageSelection(supportedLanguages)
				if err != nil {
					return nil, "", fmt.Errorf("prompting for language: %w", err)
				}
			}
			for _, lang := range langs {
				log.Debugf("%s:\t%f (%s)", lang.Language, lang.Percent, lang.Color)
				// For now let's check here for weird stuff like go module support
				hasGoMod = true
				if interactive && lang.Language == "Go" {
					hasGo = true

					selection := &promptui.Select{
						Label: "Linguist detected Go, do you use Go Modules?",
						Items: []string{"yes", "no"},
					}

					_, selectResponse, err := selection.Run()
					if err != nil {
						return nil, "", err
					}
					hasGoMod = strings.EqualFold(selectResponse, "yes")

				}

				if interactive && lang.Language == "Java" {

					selection := &promptui.Select{
						Label: "Linguist detected Java, are you using maven or gradle?",
						Items: []string{"maven", "gradle", "gradlew"},
					}

					_, selectResponse, err := selection.Run()
					if err != nil {
						return nil, "", err
					}

					if selectResponse == "gradle" {
						lang.Language = "Gradle"
					} else if selectResponse == "gradlew" {
						lang.Language = "Gradlew"
					}
				}
			}

			log.Debugf("detected %d langs", len(langs))

			if len(langs) == 0 {
				return nil, "", ErrNoLanguageDetected
			}
		}
	}

	if cc.createConfig.LanguageType != "" {
		log.Debug("using configuration language")
		lowerLang := strings.ToLower(cc.createConfig.LanguageType)
		langDockerfileTemplate, err := handlers.GetTemplate(fmt.Sprintf("dockerfile-%s", lowerLang), "", cc.dest, cc.templateWriter)
		if err != nil {
			return nil, "", err
		}
		if langDockerfileTemplate == nil {
			return nil, "", fmt.Errorf("could not find a template for %s", cc.createConfig.LanguageType)
		}

		return langDockerfileTemplate, lowerLang, nil
	}

	for _, lang := range langs {
		detectedLang := linguist.Alias(lang)
		log.Infof("--> Draft detected %s (%f%%)\n", detectedLang.Language, detectedLang.Percent)
		lowerLang := strings.ToLower(detectedLang.Language)
		if handlers.IsValidTemplate(fmt.Sprintf("dockerfile-%s", lowerLang)) {
			if lowerLang == "go" && hasGo && hasGoMod {
				log.Debug("detected go and go module")
				lowerLang = "gomodule"
			}
			langDockerfileTemplate, err := handlers.GetTemplate(fmt.Sprintf("dockerfile-%s", lowerLang), "", cc.dest, cc.templateWriter)
			if err != nil {
				return nil, "", err
			}
			if langDockerfileTemplate == nil {
				return nil, "", fmt.Errorf("could not find a template for detected language %s", detectedLang.Language)
			}
			return langDockerfileTemplate, lowerLang, nil
		}
		log.Infof("--> Could not find a pack for %s. Trying to find the next likely language match...", detectedLang.Language)
	}
	return nil, "", ErrNoLanguageDetected
}