CMake/Source/CPack/IFW/cmCPackIFWPackage.cxx

/*============================================================================
  CMake - Cross Platform Makefile Generator
  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium

  Distributed under the OSI-approved BSD License (the "License");
  see accompanying file Copyright.txt for details.

  This software is distributed WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the License for more information.
============================================================================*/

#include "cmCPackIFWPackage.h"

#include "cmCPackIFWGenerator.h"

#include <CPack/cmCPackLog.h>

#include <cmGeneratedFileStream.h>
#include <cmTimestamp.h>

//----------------------------------------------------------------- Logger ---
#ifdef cmCPackLogger
# undef cmCPackLogger
#endif
#define cmCPackLogger(logType, msg)                                     \
  do {                                                                  \
  std::ostringstream cmCPackLog_msg;                                    \
  cmCPackLog_msg << msg;                                                \
  if(Generator) {                                                       \
  Generator->Logger->Log(logType, __FILE__, __LINE__,                   \
                         cmCPackLog_msg.str().c_str());                 \
  }                                                                     \
  } while ( 0 )

//---------------------------------------------------------- CompareStruct ---
cmCPackIFWPackage::CompareStruct::CompareStruct() :
  Type(CompareNone)
{
}

//------------------------------------------------------- DependenceStruct ---
cmCPackIFWPackage::DependenceStruct::DependenceStruct()
{
}

//----------------------------------------------------------------------------
cmCPackIFWPackage::DependenceStruct::DependenceStruct(
  const std::string &dependence)
{
  // Search compare section
  size_t pos = std::string::npos;
  if((pos = dependence.find("<=")) != std::string::npos)
    {
    Compare.Type = CompareLessOrEqual;
    Compare.Value = dependence.substr(pos + 2);
    }
  else if((pos = dependence.find(">=")) != std::string::npos)
    {
    Compare.Type = CompareGreaterOrEqual;
    Compare.Value = dependence.substr(pos + 2);
    }
  else if((pos = dependence.find("<")) != std::string::npos)
    {
    Compare.Type = CompareLess;
    Compare.Value = dependence.substr(pos + 1);
    }
  else if((pos = dependence.find("=")) != std::string::npos)
    {
    Compare.Type = CompareEqual;
    Compare.Value = dependence.substr(pos + 1);
    }
  else if((pos = dependence.find(">")) != std::string::npos)
    {
    Compare.Type = CompareGreater;
    Compare.Value = dependence.substr(pos + 1);
    }
  Name = pos == std::string::npos ? dependence : dependence.substr(0, pos);
}

//----------------------------------------------------------------------------
std::string cmCPackIFWPackage::DependenceStruct::NameWithCompare() const
{
  if (Compare.Type == CompareNone) return Name;

  std::string result = Name;

  if (Compare.Type == CompareLessOrEqual)
    {
    result += "<=";
    }
  else if (Compare.Type == CompareGreaterOrEqual)
    {
    result += ">=";
    }
  else if (Compare.Type == CompareLess)
    {
    result += "<";
    }
  else if (Compare.Type == CompareEqual)
    {
    result += "=";
    }
  else if (Compare.Type == CompareGreater)
    {
    result += ">";
    }

  result += Compare.Value;

  return result;
}

//------------------------------------------------------ cmCPackIFWPackage ---
cmCPackIFWPackage::cmCPackIFWPackage() :
  Generator(0),
  Installer(0)
{
}

//----------------------------------------------------------------------------
const char *cmCPackIFWPackage::GetOption(const std::string &op) const
{
  const char *option = Generator ? Generator->GetOption(op) : 0;
  return option && *option ? option : 0;
}

//----------------------------------------------------------------------------
bool cmCPackIFWPackage::IsOn(const std::string &op) const
{
  return Generator ? Generator->IsOn(op) : false;
}

//----------------------------------------------------------------------------
bool cmCPackIFWPackage::IsVersionLess(const char *version)
{
  return Generator ? Generator->IsVersionLess(version) : false;
}

//----------------------------------------------------------------------------
bool cmCPackIFWPackage::IsVersionGreater(const char *version)
{
  return Generator ? Generator->IsVersionGreater(version) : false;
}

//----------------------------------------------------------------------------
bool cmCPackIFWPackage::IsVersionEqual(const char *version)
{
  return Generator ? Generator->IsVersionEqual(version) : false;
}

//----------------------------------------------------------------------------
std::string cmCPackIFWPackage::GetComponentName(cmCPackComponent *component)
{
  if (!component) return "";
  const char* option = GetOption(
    "CPACK_IFW_COMPONENT_"
    + cmsys::SystemTools::UpperCase(component->Name)
    + "_NAME");
  return option ? option : component->Name;
}

//----------------------------------------------------------------------------
void cmCPackIFWPackage::DefaultConfiguration()
{
  DisplayName = "";
  Description = "";
  Version = "";
  ReleaseDate = "";
  Script = "";
  Licenses.clear();
  SortingPriority = "";
  Default = "";
  Virtual = "";
  ForcedInstallation = "";
}

//----------------------------------------------------------------------------
// Defaul configuration (all in one package)
int cmCPackIFWPackage::ConfigureFromOptions()
{
  // Restore defaul configuration
  DefaultConfiguration();

  // Name
  Name = Generator->GetRootPackageName();

  // Display name
  if (const char *option = this->GetOption("CPACK_PACKAGE_NAME"))
    {
    DisplayName = option;
    }
  else
    {
    DisplayName = "Your package";
    }

  // Description
  if (const char* option =
      this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY"))
    {
    Description = option;
    }
  else
    {
    Description = "Your package description";
    }

  // Version
  if(const char* option = GetOption("CPACK_PACKAGE_VERSION"))
    {
    Version = option;
    }
  else
    {
    Version = "1.0.0";
    }

  ForcedInstallation = "true";

  return 1;
}

//----------------------------------------------------------------------------
int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
{
  if(!component) return 0;

  // Restore defaul configuration
  DefaultConfiguration();

  std::string prefix = "CPACK_IFW_COMPONENT_"
    + cmsys::SystemTools::UpperCase(component->Name)
    + "_";

  // Display name
  DisplayName = component->DisplayName;

  // Description
  Description = component->Description;

  // Version
  if(const char* optVERSION = GetOption(prefix + "VERSION"))
    {
    Version = optVERSION;
    }
  else if(const char* optPACKAGE_VERSION =
          GetOption("CPACK_PACKAGE_VERSION"))
    {
    Version = optPACKAGE_VERSION;
    }
  else
    {
    Version = "1.0.0";
    }

  // Script
  if (const char* option = GetOption(prefix + "SCRIPT"))
    {
    Script = option;
    }

  // CMake dependencies
  if (!component->Dependencies.empty())
    {
    std::vector<cmCPackComponent*>::iterator dit;
    for(dit = component->Dependencies.begin();
        dit != component->Dependencies.end();
        ++dit)
      {
      Dependencies.insert(Generator->ComponentPackages[*dit]);
      }
    }

  // QtIFW dependencies
  if(const char* option = this->GetOption(prefix + "DEPENDS"))
    {
    std::vector<std::string> deps;
    cmSystemTools::ExpandListArgument(option,
                                      deps);
    for(std::vector<std::string>::iterator
          dit = deps.begin(); dit != deps.end(); ++dit)
      {
      DependenceStruct dep(*dit);
      if (!Generator->Packages.count(dep.Name))
        {
        bool hasDep = Generator->DependentPackages.count(dep.Name) > 0;
        DependenceStruct &depRef =
          Generator->DependentPackages[dep.Name];
        if(!hasDep)
          {
          depRef = dep;
          }
        AlienDependencies.insert(&depRef);
        }
      }
    }

  // Licenses
  if (const char* option = this->GetOption(prefix + "LICENSES"))
    {
    Licenses.clear();
    cmSystemTools::ExpandListArgument( option, Licenses );
    if ( Licenses.size() % 2 != 0 )
      {
      cmCPackLogger(cmCPackLog::LOG_WARNING, prefix << "LICENSES"
        << " should contain pairs of <display_name> and <file_path>."
        << std::endl);
      Licenses.clear();
      }
    }

  // Priority
  if(const char* option = this->GetOption(prefix + "PRIORITY"))
    {
    SortingPriority = option;
    }

  // Default
  Default = component->IsDisabledByDefault ? "false" : "true";

  // Virtual
  Virtual = component->IsHidden ? "true" : "";

  // ForcedInstallation
  ForcedInstallation = component->IsRequired ? "true" : "false";

  return 1;
}

//----------------------------------------------------------------------------
int
cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup *group)
{
  if(!group) return 0;

  // Restore defaul configuration
  DefaultConfiguration();

  std::string prefix = "CPACK_IFW_COMPONENT_GROUP_"
    + cmsys::SystemTools::UpperCase(group->Name)
    + "_";

  DisplayName = group->DisplayName;
  Description = group->Description;

  // Version
  if(const char* optVERSION = GetOption(prefix + "VERSION"))
    {
    Version = optVERSION;
    }
  else if(const char* optPACKAGE_VERSION =
          GetOption("CPACK_PACKAGE_VERSION"))
    {
    Version = optPACKAGE_VERSION;
    }
  else
    {
    Version = "1.0.0";
    }

  // Script
  if (const char* option = GetOption(prefix + "SCRIPT"))
    {
    Script = option;
    }

  // Licenses
  if (const char* option = this->GetOption(prefix + "LICENSES"))
    {
    Licenses.clear();
    cmSystemTools::ExpandListArgument( option, Licenses );
    if ( Licenses.size() % 2 != 0 )
      {
      cmCPackLogger(cmCPackLog::LOG_WARNING, prefix << "LICENSES"
        << " should contain pairs of <display_name> and <file_path>."
        << std::endl);
      Licenses.clear();
      }
    }

  // Priority
  if(const char* option = this->GetOption(prefix + "PRIORITY"))
    {
    SortingPriority = option;
    }

  return 1;
}

//----------------------------------------------------------------------------
int cmCPackIFWPackage::ConfigureFromGroup(const std::string &groupName)
{
  // Group configuration

  cmCPackComponentGroup group;
  std::string prefix = "CPACK_COMPONENT_GROUP_"
      + cmsys::SystemTools::UpperCase(groupName)
      + "_";

  if (const char *option = GetOption(prefix + "DISPLAY_NAME"))
    {
    group.DisplayName = option;
    }
  else
    {
    group.DisplayName = group.Name;
    }

  if (const char* option = GetOption(prefix + "DESCRIPTION"))
    {
    group.Description = option;
    }
  group.IsBold = IsOn(prefix + "BOLD_TITLE");
  group.IsExpandedByDefault = IsOn(prefix + "EXPANDED");

  // Package configuration

  group.Name = groupName;

  if(Generator)
    {
    Name = Generator->GetGroupPackageName(&group);
    }
  else
    {
    Name = group.Name;
    }

  return ConfigureFromGroup(&group);
}

//----------------------------------------------------------------------------
void cmCPackIFWPackage::GeneratePackageFile()
{
  // Lazy directory initialization
  if (Directory.empty())
    {
    if(Installer)
      {
      Directory = Installer->Directory + "/packages/" + Name;
      }
    else if (Generator)
      {
      Directory = Generator->toplevel + "/packages/" + Name;
      }
    }

  // Output stream
  cmGeneratedFileStream xout((Directory + "/meta/package.xml").data());

  xout << "<?xml version=\"1.0\"?>" << std::endl;

  WriteGeneratedByToStrim(xout);

  xout << "<Package>" << std::endl;

  xout << "    <DisplayName>" << DisplayName
       << "</DisplayName>" << std::endl;

  xout << "    <Description>" << Description
       << "</Description>" << std::endl;

  xout << "    <Name>" << Name << "</Name>" << std::endl;

  xout << "    <Version>" <<  Version
       << "</Version>" << std::endl;

  xout << "    <ReleaseDate>";
  if(ReleaseDate.empty())
    {
    xout << cmTimestamp().CurrentTime("%Y-%m-%d", true);
    }
  else
    {
    xout << ReleaseDate;
    }
  xout << "</ReleaseDate>" << std::endl;

  // Script (copy to meta dir)
  if(!Script.empty())
    {
    std::string name = cmSystemTools::GetFilenameName(Script);
    std::string path = Directory + "/meta/" + name;
    cmsys::SystemTools::CopyFileIfDifferent(Script.data(), path.data());
    xout << "    <Script>" << name << "</Script>" << std::endl;
    }

  // Dependencies
  std::set<DependenceStruct> compDepSet;
  for(std::set<DependenceStruct*>::iterator ait = AlienDependencies.begin();
      ait != AlienDependencies.end(); ++ait)
    {
    compDepSet.insert(*(*ait));
    }
  for(std::set<cmCPackIFWPackage*>::iterator it = Dependencies.begin();
      it != Dependencies.end(); ++it)
    {
    compDepSet.insert(DependenceStruct((*it)->Name));
    }
  // Write dependencies
  if  (!compDepSet.empty())
    {
    xout << "    <Dependencies>";
    std::set<DependenceStruct>::iterator it = compDepSet.begin();
    xout << it->NameWithCompare();
    ++it;
    while(it != compDepSet.end())
      {
      xout << "," << it->NameWithCompare();
      ++it;
      }
    xout << "</Dependencies>" << std::endl;
    }

  // Licenses (copy to meta dir)
  std::vector<std::string> licenses = Licenses;
  for(size_t i = 1; i < licenses.size(); i += 2)
    {
    std::string name = cmSystemTools::GetFilenameName(licenses[i]);
    std::string path = Directory + "/meta/" + name;
    cmsys::SystemTools::CopyFileIfDifferent(licenses[i].data(), path.data());
    licenses[i] = name;
    }
  if(!licenses.empty())
    {
    xout << "    <Licenses>" << std::endl;
    for(size_t i = 0; i < licenses.size(); i += 2)
      {
      xout << "        <License "
           << "name=\"" << licenses[i] << "\" "
           << "file=\"" << licenses[i + 1] << "\" "
           << "/>" <<std::endl;
      }
    xout << "    </Licenses>" << std::endl;
    }

  if (!ForcedInstallation.empty())
    {
    xout << "    <ForcedInstallation>" << ForcedInstallation
         << "</ForcedInstallation>" << std::endl;
    }

  if (!Virtual.empty())
    {
    xout << "    <Virtual>" << Virtual << "</Virtual>" << std::endl;
    }
  else if (!Default.empty())
    {
    xout << "    <Default>" << Default << "</Default>" << std::endl;
    }

  // Priority
  if(!SortingPriority.empty())
    {
    xout << "    <SortingPriority>" << SortingPriority
         << "</SortingPriority>" << std::endl;
    }

  xout << "</Package>" << std::endl;
}

void cmCPackIFWPackage::WriteGeneratedByToStrim(cmGeneratedFileStream &xout)
{
  if(Generator) Generator->WriteGeneratedByToStrim(xout);
}