LicenseChecker Class Reference

#include <license_checker.h>

Classes
struct	Flags

Static Public Member Functions
static std::vector< absl::Status >	Run (std::string_view working_dir, std::ostream &licenses, const Data &data)
static std::vector< absl::Status >	Run (std::string_view working_dir, std::ostream &licenses, const Data &data, const Flags &flags)
static int	Run (std::string_view working_dir, std::ostream &licenses, std::string_view data_dir, const Flags &flags)
static int	FileRun (std::string_view working_dir, std::string_view full_path, std::ostream &licenses, std::string_view data_dir, const Flags &flags)
	Run on a single file.

Static Public Attributes
static const char *	kHeaderLicenseRegex = "(?i)(license|copyright)"

Detailed Description

Definition at line 14 of file license_checker.h.

Member Function Documentation

FileRun()

int LicenseChecker::FileRun ( std::string_view  working_dir, std::string_view  full_path, std::ostream &  licenses, std::string_view  data_dir, const Flags &  flags  )

static

Run on a single file.

Definition at line 627 of file license_checker.cc.

                                                {
  absl::StatusOr<Data> data = Data::Open(data_dir);
  if (!data.ok()) {
    std::cerr << "Can't load data at " << data_dir << ": " << data.status()
              << std::endl;
    return 1;
  }
 
  ProcessState state;
  fs::path working_dir_path =
      fs::absolute(fs::path(working_dir)).lexically_normal();
  fs::path absolute_full_path = fs::absolute(fs::path(full_path));
  absl::Status process_result =
      ProcessFile(working_dir_path, licenses, data.value(), absolute_full_path,
                  flags, &state);
 
  if (!process_result.ok()) {
    std::cerr << process_result << std::endl;
    return 1;
  }
 
  state.license_map.Write(licenses);
  for (const absl::Status& status : state.errors) {
    std::cerr << status << "\n";
  }
 
  if (!state.errors.empty()) {
    std::cout << "Error count: " << state.errors.size();
  }
 
  return state.errors.empty() ? 0 : 1;
}

References data, and Data::Open().

Referenced by main().

Run() [1/3]

std::vector< absl::Status > LicenseChecker::Run ( std::string_view  working_dir, std::ostream &  licenses, const Data &  data  )

static

Definition at line 497 of file license_checker.cc.

                                                                {
  Flags flags;
  return Run(working_dir, licenses, data, flags);
}

References data.

Referenced by main(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Run() [2/3]

std::vector< absl::Status > LicenseChecker::Run ( std::string_view  working_dir, std::ostream &  licenses, const Data &  data, const Flags &  flags  )

static

Definition at line 504 of file license_checker.cc.

                                      {
  fs::path working_dir_path =
      fs::absolute(fs::path(working_dir)).lexically_normal();
  std::vector<fs::path> git_repos = GetGitRepos(working_dir_path.string());
 
  size_t count = 0;
  ProcessState state;
 
  // Not every dependency is a git repository, so it won't be considered with
  // the crawl that happens below of git repositories. For those dependencies
  // we just crawl the whole directory.
  fs::path deps_path = FindFileInParentDirectories(working_dir_path, "DEPS");
  if (!deps_path.empty()) {
    absl::StatusOr<MMapFile> deps_file = MMapFile::Make(deps_path.string());
    if (deps_file.ok()) {
      DepsParser deps_parser;
      std::vector<std::string> deps = deps_parser.Parse(
          std::string_view(deps_file->GetData(), deps_file->GetSize()));
      for (const std::string& dep : deps) {
        fs::path dep_path = deps_path.parent_path() / dep;
        if (fs::is_directory(dep_path)) {
          // We don't want to process deps that are outside the working
          // directory.
          if (dep_path.string().find(working_dir_path.string()) != 0) {
            continue;
          }
 
          for (const auto& entry : fs::recursive_directory_iterator(dep_path)) {
            if (entry.is_regular_file()) {
              absl::Status process_result =
                  ProcessFile(working_dir_path, licenses, data, entry.path(),
                              flags, &state);
              if (!process_result.ok()) {
                return state.errors;
              }
            }
          }
        }
      }
    }
  }
 
  for (const fs::path& git_repo : git_repos) {
    if (!VLOG_IS_ON(1) && IsStdoutTerminal()) {
      PrintProgress(count++, git_repos.size());
    }
 
    absl::StatusOr<std::vector<std::string>> git_files = GitLsFiles(git_repo);
    if (!git_files.ok()) {
      state.errors.push_back(git_files.status());
      return state.errors;
    }
    for (const std::string& git_file : git_files.value()) {
      fs::path full_path = git_repo / git_file;
      absl::Status process_result = ProcessFile(working_dir_path, licenses,
                                                data, full_path, flags, &state);
      if (!process_result.ok()) {
        return state.errors;
      }
    }
  }
 
  if (!data.secondary_dir.empty()) {
    for (const auto& entry :
         fs::recursive_directory_iterator(data.secondary_dir)) {
      if (!fs::is_directory(entry)) {
        fs::path relative_path = fs::relative(entry, data.secondary_dir);
        if (!fs::exists(working_dir / relative_path.parent_path())) {
          state.errors.push_back(absl::InvalidArgumentError(absl::StrCat(
              "secondary license path mixmatch at ", relative_path.string())));
        } else {
          fs::path full_path = data.secondary_dir / entry;
          Package package =
              GetPackage(data, working_dir_path, relative_path, flags);
          absl::StatusOr<MMapFile> file = MMapFile::Make(full_path.string());
          if (file.ok()) {
            state.license_map.Add(
                package.name,
                std::string_view(file->GetData(), file->GetSize()));
          } else {
            state.errors.push_back(file.status());
          }
        }
      }
    }
  }
 
  state.license_map.Write(licenses);
  if (!VLOG_IS_ON(1) && IsStdoutTerminal()) {
    PrintProgress(count++, git_repos.size());
    std::cout << std::endl;
  }
 
  return state.errors;
}

References data, MMapFile::Make(), and DepsParser::Parse().

Run() [3/3]

int LicenseChecker::Run ( std::string_view  working_dir, std::ostream &  licenses, std::string_view  data_dir, const Flags &  flags  )

static

Definition at line 604 of file license_checker.cc.

                                                          {
  absl::StatusOr<Data> data = Data::Open(data_dir);
  if (!data.ok()) {
    std::cerr << "Can't load data at " << data_dir << ": " << data.status()
              << std::endl;
    return 1;
  }
  std::vector<absl::Status> errors =
      Run(working_dir, licenses, data.value(), flags);
  for (const absl::Status& status : errors) {
    std::cerr << status << "\n";
  }
 
  if (!errors.empty()) {
    std::cout << "Error count: " << errors.size();
  }
 
  return errors.empty() ? 0 : 1;
}

References data, and Data::Open().

Member Data Documentation

kHeaderLicenseRegex

const char * LicenseChecker::kHeaderLicenseRegex = "(?i)(license|copyright)"

static

Definition at line 21 of file license_checker.h.

---

The documentation for this class was generated from the following files:

• tools/licenses_cpp/src/license_checker.h
• tools/licenses_cpp/src/license_checker.cc