main.cc File Reference

#include <filesystem>
#include <fstream>
#include "flutter/tools/licenses_cpp/src/license_checker.h"
#include "third_party/abseil-cpp/absl/flags/flag.h"
#include "third_party/abseil-cpp/absl/flags/parse.h"
#include "third_party/abseil-cpp/absl/flags/usage.h"
#include "third_party/abseil-cpp/absl/log/globals.h"
#include "third_party/abseil-cpp/absl/log/initialize.h"
#include "third_party/abseil-cpp/absl/strings/str_cat.h"

Go to the source code of this file.

Functions
	ABSL_FLAG (std::optional< std::string >, working_dir, std::nullopt, "[REQUIRED] The directory to scan.")
	ABSL_FLAG (std::optional< std::string >, input, std::nullopt, "The file to scan.")
	ABSL_FLAG (std::optional< std::string >, data_dir, std::nullopt, "[REQUIRED] The directory with the licenses.")
	ABSL_FLAG (std::optional< std::string >, licenses_path, std::nullopt, "[REQUIRED] The path to write the licenses collection to.")
	ABSL_FLAG (std::optional< std::string >, include_filter, std::nullopt, "Regex that overrides the include filter.")
	ABSL_FLAG (int, v, 0, "Set the verbosity of logs.")
	ABSL_FLAG (bool, treat_unmatched_comments_as_errors, false, "Whether unmatched comments are considered errors.")
	ABSL_FLAG (std::optional< std::string >, root_package, std::nullopt, "Name of the root package.")
int	main (int argc, char **argv)

Function Documentation

ABSL_FLAG() [1/8]

ABSL_FLAG	(	bool	,
		treat_unmatched_comments_as_errors	,
		false	,
		"Whether unmatched comments are considered errors."
	)

ABSL_FLAG() [2/8]

ABSL_FLAG	(	int	,
		v	,
		0	,
		"Set the verbosity of logs."
	)

ABSL_FLAG() [3/8]

ABSL_FLAG	(	std::optional< std::string >	,
		data_dir	,
		std::nullopt	,
		" The directory with the licenses."	[REQUIRED]
	)

ABSL_FLAG() [4/8]

ABSL_FLAG	(	std::optional< std::string >	,
		include_filter	,
		std::nullopt	,
		"Regex that overrides the include filter."
	)

ABSL_FLAG() [5/8]

ABSL_FLAG	(	std::optional< std::string >	,
		input	,
		std::nullopt	,
		"The file to scan."
	)

ABSL_FLAG() [6/8]

ABSL_FLAG	(	std::optional< std::string >	,
		licenses_path	,
		std::nullopt	,
		" The path to write the licenses collection to."	[REQUIRED]
	)

ABSL_FLAG() [7/8]

ABSL_FLAG	(	std::optional< std::string >	,
		root_package	,
		std::nullopt	,
		"Name of the root package."
	)

ABSL_FLAG() [8/8]

ABSL_FLAG	(	std::optional< std::string >	,
		working_dir	,
		std::nullopt	,
		" The directory to scan."	[REQUIRED]
	)

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 78 of file main.cc.

                                {
  absl::SetProgramUsageMessage(
      absl::StrCat("Sample usage:\n", argv[0],
                   " --working_dir=<directory> --data_dir=<directory>"));
 
  std::vector<char*> args = absl::ParseCommandLine(argc, argv);
  absl::SetGlobalVLogLevel(absl::GetFlag(FLAGS_v));
  absl::InitializeLog();
  absl::SetStderrThreshold(absl::LogSeverity::kInfo);
 
  std::optional<std::string> working_dir = absl::GetFlag(FLAGS_working_dir);
  std::optional<std::string> input = absl::GetFlag(FLAGS_input);
  std::optional<std::string> data_dir = absl::GetFlag(FLAGS_data_dir);
  std::optional<std::string> licenses_path = absl::GetFlag(FLAGS_licenses_path);
  std::optional<std::string> include_filter =
      absl::GetFlag(FLAGS_include_filter);
  if (working_dir.has_value() && data_dir.has_value() &&
      licenses_path.has_value()) {
    std::ofstream licenses;
    licenses.open(licenses_path.value());
    if (licenses.bad()) {
      std::cerr << "Unable to write to '" << licenses_path.value() << "'.";
      return 1;
    }
    LicenseChecker::Flags flags;
    flags.treat_unmatched_comments_as_errors =
        absl::GetFlag(FLAGS_treat_unmatched_comments_as_errors);
    flags.root_package_name = absl::GetFlag(FLAGS_root_package);
    if (input.has_value()) {
      if (include_filter.has_value()) {
        std::cerr << "`--input_filter` not supported with `--input`"
                  << std::endl;
      }
      fs::path full_path = fs::canonical(input.value());
      return LicenseChecker::FileRun(working_dir.value(), full_path.string(),
                                     licenses, data_dir.value(), flags);
    } else {
      if (include_filter.has_value()) {
        return Run(working_dir.value(), licenses, data_dir.value(),
                   include_filter.value(), flags);
      } else {
        return LicenseChecker::Run(working_dir.value(), licenses,
                                   data_dir.value(), flags);
      }
    }
  }
 
  if (!working_dir.has_value()) {
    std::cerr << "Expected --working_dir flag." << std::endl;
  }
 
  if (!licenses_path.has_value()) {
    std::cerr << "Expected --licenses_path flag." << std::endl;
  }
 
  if (!data_dir.has_value()) {
    std::cerr << "Expected --data_dir flag." << std::endl;
  }
 
  return 1;
}

References args, argv, LicenseChecker::FileRun(), input(), LicenseChecker::Flags::root_package_name, LicenseChecker::Run(), and LicenseChecker::Flags::treat_unmatched_comments_as_errors.