func Main()

in cmd/yesiscan/main.go [77:209]
102 lines of code
17 McCabe index (conditional complexity)

func Main(c *cli.Context, program string, debug bool, logf func(format string, v ...interface{})) error {

	userCacheDir, err := os.UserCacheDir()
	if err != nil {
		return err
	}
	if err := os.MkdirAll(userCacheDir, interfaces.Umask); err != nil {
		return err
	}
	prefix := filepath.Join(userCacheDir, program)
	if err := os.MkdirAll(prefix, interfaces.Umask); err != nil {
		return err
	}
	safePrefixAbsDir, err := safepath.ParseIntoAbsDir(prefix)
	if err != nil {
		return err
	}
	logf("prefix: %s", safePrefixAbsDir)

	// TODO: add more --flags to specify which parser/backends to use...

	inputStrings := []string{}

	for i := 0; i < c.NArg(); i++ {
		s := c.Args().Get(i)
		if s == "-" { // stdin
			var err error
			s, err = stdinAsString(logf)
			if err != nil {
				return err
			}
		}
		inputStrings = append(inputStrings, s)
	}
	if c.NArg() == 0 { // if we didn't get any args, assume stdin
		s, err := stdinAsString(logf)
		if err != nil {
			return err
		}
		inputStrings = append(inputStrings, s)
	}

	iterators := []interfaces.Iterator{}
	for _, s := range inputStrings {
		trivialURIParser := &parser.TrivialURIParser{
			Debug: debug,
			Logf: func(format string, v ...interface{}) {
				logf(format, v...)
			},
			Prefix: safePrefixAbsDir,
			Input:  s,
		}
		logf("input: %s", s)

		ixs, err := trivialURIParser.Parse() // parser returns iterators
		if err != nil {
			return errwrap.Wrapf(err, "parser failed")
		}
		iterators = append(iterators, ixs...)
	}

	backends := []interfaces.Backend{}
	backendWeights := make(map[interfaces.Backend]float64)

	if !c.Bool("no-backend-licenseclassifier") {
		licenseClassifierBackend := &backend.LicenseClassifier{
			Debug: debug,
			Logf: func(format string, v ...interface{}) {
				logf("backend: "+format, v...)
			},
			IncludeHeaders:       false,
			UseDefaultConfidence: false,

			// useful for testing before we add file name filtering
			//SkipZeroResults: true,
		}
		backends = append(backends, licenseClassifierBackend)
		backendWeights[licenseClassifierBackend] = 1.0 // TODO: adjust as needed
	}

	if !c.Bool("no-backend-spdx") {
		spdxBackend := &backend.SPDXClassifier{
			Debug: debug,
			Logf: func(format string, v ...interface{}) {
				logf("backend: "+format, v...)
			},
		}
		backends = append(backends, spdxBackend)
		backendWeights[spdxBackend] = 2.0 // TODO: adjust as needed
	}

	//if !c.Bool("no-backend-example") {
	//	exampleBackend := &backend.ExampleClassifier{
	//		Debug: debug,
	//		Logf: func(format string, v ...interface{}) {
	//			logf("backend: "+format, v...)
	//		},
	//	}
	//	backends = append(backends, exampleBackend)
	//	backendWeights[exampleBackend] = 99.0 // TODO: adjust as needed
	//}

	core := &lib.Core{
		Debug: debug,
		Logf: func(format string, v ...interface{}) {
			logf("core: "+format, v...)
		},
		Backends:        backends,
		Iterators:       iterators, // TODO: should this be passed into Run instead?
		ShutdownOnError: false,     // set to true for "perfect" scanning.
	}

	if err := core.Init(); err != nil {
		return errwrap.Wrapf(err, "could not initialize core")
	}

	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
	defer stop()

	results, err := core.Run(ctx)
	if err != nil {
		return errwrap.Wrapf(err, "core run failed")
	}

	str, err := lib.SimpleResults(results, backendWeights)
	if err != nil {
		return err
	}

	logf("Results...\n%s", str)

	return nil
}