OjoAgent.cc

/*
 SPDX-FileCopyrightText: © 2019 Siemens AG
 
 SPDX-License-Identifier: GPL-2.0-only
*/
 
#include "OjoAgent.hpp"
 
using namespace std;
 
OjoAgent::OjoAgent() :
    regLicenseList(
        boost::regex(SPDX_LICENSE_LIST, boost::regex_constants::icase)),
    regLicenseName(
        boost::regex(SPDX_LICENSE_NAMES, boost::regex_constants::icase)),
    regDualLicense(
        boost::regex(SPDX_DUAL_LICENSE, boost::regex_constants::icase))
{
}
 
vector<ojomatch> OjoAgent::processFile(const string &filePath,
  OjosDatabaseHandler &databaseHandler, const int groupId, const int userId)
{
  ifstream stream(filePath);
  std::stringstream sstr;
  sstr << stream.rdbuf();
  if (stream.fail())
  {
    throw std::runtime_error(filePath);
  }
  stream.close();
  const string fileContent = sstr.str();
  vector<ojomatch> licenseList;
  vector<ojomatch> licenseNames;
 
  scanString(fileContent, regLicenseList, licenseList, 0, false);
  for (auto m : licenseList)
  {
    scanString(m.content, regLicenseName, licenseNames, m.start, false);
    scanString(m.content, regDualLicense, licenseNames, m.start, true);
  }
 
  findLicenseId(licenseNames, databaseHandler, groupId, userId);
  filterMatches(licenseNames);
 
  return licenseNames;
}
 
vector<ojomatch> OjoAgent::processFile(const string &filePath)
{
  ifstream stream(filePath);
  std::stringstream sstr;
  sstr << stream.rdbuf();
  if (stream.fail())
  {
    throw std::runtime_error(filePath);
  }
  stream.close();
  const string fileContent = sstr.str();
  vector<ojomatch> licenseList;
  vector<ojomatch> licenseNames;
 
  scanString(fileContent, regLicenseList, licenseList, 0, false);
  for (auto m : licenseList)
  {
    scanString(m.content, regLicenseName, licenseNames, m.start, false);
    scanString(m.content, regDualLicense, licenseNames, m.start, true);
  }
 
  // Remove duplicate matches for CLI run
  vector<ojomatch>::iterator uniqueListIt = std::unique(licenseNames.begin(),
    licenseNames.end());
  licenseNames.resize(std::distance(licenseNames.begin(), uniqueListIt));
 
  return licenseNames;
}
 
void OjoAgent::scanString(const string &text, boost::regex reg,
    vector<ojomatch> &result, unsigned int offset, bool isDualTest)
{
  string::const_iterator end = text.end();
  string::const_iterator pos = text.begin();
 
  while (pos != end)
  {
    // Find next match
    boost::smatch res;
    if (boost::regex_search(pos, end, res, reg))
    {
      string content = "Dual-license";
      if (! isDualTest)
      {
        content = res[1].str();
      }
      // Found match
      result.push_back(
          ojomatch(offset + res.position(1),
              offset + res.position(1) + res.length(1),
              res.length(1),
              content));
      pos = res[0].second;
      offset += res.position() + res.length();
    }
    else
    {
      // No match found
      break;
    }
  }
}
 
void OjoAgent::filterMatches(vector<ojomatch> &matches)
{
  // Remvoe entries with license_fk < 1
  matches.erase(
    std::remove_if(matches.begin(), matches.end(), [](ojomatch match)
    { return match.license_fk <= 0;}), matches.end());
}
 
void OjoAgent::findLicenseId(vector<ojomatch> &matches,
  OjosDatabaseHandler &databaseHandler, const int groupId, const int userId)
{
  // Update license_fk
  for (size_t i = 0; i < matches.size(); ++i)
  {
    matches[i].license_fk = databaseHandler.getLicenseIdForName(
      matches[i].content, groupId, userId);
  }
}