path: root/ext/repo_haiku.cpp

/*
 * Copyright (c) 2011-2013, Ingo Weinhold <ingo_weinhold@gmx.de>
 *
 * This program is licensed under the BSD license, read LICENSE.BSD
 * for further information
 */

#include <package/PackageInfo.h>
#include <package/PackageInfoSet.h>
#include <package/PackageRoster.h>
#include <package/PackageVersion.h>
#include <package/RepositoryCache.h>
#include <package/RepositoryConfig.h>

#include "repo_haiku.h"

using namespace BPackageKit;
using namespace BPackageKit::BHPKG;

static BString haiku_version_to_string(const BPackageVersion &version)
{
  if (version.InitCheck() != B_OK)
    return BString();

  // compose ":<major>.<minor>.<micro>" (empty epoch)
  BString string(":");
  string << version.Major();
  if (!version.Minor().IsEmpty())
    {
      string << '.' << version.Minor();
      if (!version.Micro().IsEmpty())
        string << '.' << version.Micro();
    }

  // append pre-release -- separate it with '/' to keep pool_evrcmp_str() happy
  // (it expects only the release to be separated by '-')
  if (!version.PreRelease().IsEmpty())
    string << '/' << version.PreRelease();

  // append revision
  if (version.Revision() != 0)
    string << '-' << version.Revision();

  return string;
}

static void add_dependency(Repo *repo, Offset &dependencies, const char *name,
  const char *version, int flags, const char* compatVersion = NULL)
{
  Pool *pool = repo->pool;

  Id dependency = pool_str2id(pool, name, 1);

  if (version && version[0] != '\0')
  {
    Id versionId = pool_str2id(pool, version, 1);

    if (compatVersion && compatVersion[0] != '\0')
      {
        versionId = pool_rel2id(pool, pool_str2id(pool, compatVersion, 1),
          versionId, REL_COMPAT, 1);
        versionId = MAKERELDEP(versionId);
      }

    dependency = pool_rel2id(pool, dependency, versionId, flags, 1);
  }

  dependencies = repo_addid_dep(repo, dependencies, dependency, 0);
}

static void add_dependency(Repo *repo, Offset &dependencies, const char *name,
  const BPackageVersion &version, int flags)
{
  add_dependency(repo, dependencies, name, haiku_version_to_string(version),
    flags);
}

static void add_resolvables(Repo *repo, Offset &dependencies,
  const BObjectList<BPackageResolvable> &resolvables)
{
  for (int32 i = 0; BPackageResolvable *resolvable = resolvables.ItemAt(i); i++)
    {
      add_dependency(repo, dependencies, resolvable->Name(),
        haiku_version_to_string(resolvable->Version()), REL_EQ,
        haiku_version_to_string(resolvable->CompatibleVersion()));
    }
}

static void add_resolvable_expressions(Repo *repo, Offset &dependencies,
  const BObjectList<BPackageResolvableExpression> &expressions)
{
  for (int32 i = 0;
    BPackageResolvableExpression *expression = expressions.ItemAt(i); i++)
    {
      // It is possible that no version is specified. In that case any version
      // is acceptable.
      if (expression->Version().InitCheck() != B_OK)
        {
          BPackageVersion version;
          add_dependency(repo, dependencies, expression->Name(), NULL, 0);
          continue;
        }

      int flags = 0;
      switch (expression->Operator())
        {
          case B_PACKAGE_RESOLVABLE_OP_LESS:
            flags |= REL_LT;
            break;
          case B_PACKAGE_RESOLVABLE_OP_LESS_EQUAL:
            flags |= REL_LT | REL_EQ;
            break;
          case B_PACKAGE_RESOLVABLE_OP_EQUAL:
            flags |= REL_EQ;
            break;
          case B_PACKAGE_RESOLVABLE_OP_NOT_EQUAL:
            break;
          case B_PACKAGE_RESOLVABLE_OP_GREATER_EQUAL:
            flags |= REL_GT | REL_EQ;
            break;
          case B_PACKAGE_RESOLVABLE_OP_GREATER:
              flags |= REL_GT;
            break;
        }

      add_dependency(repo, dependencies, expression->Name(),
        expression->Version(), flags);
    }
}

static void add_replaces_list(Repo *repo, Offset &dependencies,
  const BStringList &packageNames)
{
  int32 count = packageNames.CountStrings();
  for (int32 i = 0; i < count; i++)
    {
      const BString &packageName = packageNames.StringAt(i);
      add_dependency(repo, dependencies, packageName, BPackageVersion(), 0);
    }
}

static Id add_package_info_to_repo(Repo *repo, Repodata *repoData,
  const BPackageInfo &packageInfo)
{
  Pool *pool = repo->pool;

  Id solvableId = repo_add_solvable(repo);
  Solvable *solvable = pool_id2solvable(pool, solvableId);
  // Prepend "pkg:" to package name, so "provides" don't match unless explicitly
  // specified this way.
  BString name("pkg:");
  name << packageInfo.Name();
  solvable->name = pool_str2id(pool, name, 1);
  if (packageInfo.Architecture() == B_PACKAGE_ARCHITECTURE_ANY)
    solvable->arch = ARCH_NOARCH;
  else
    solvable->arch = pool_str2id(pool,
      BPackageInfo::kArchitectureNames[packageInfo.Architecture()], 1);
  solvable->evr = pool_str2id(pool,
    haiku_version_to_string(packageInfo.Version()), 1);
  solvable->vendor = pool_str2id(pool, packageInfo.Vendor(), 1);
  repodata_set_str(repoData, solvable - pool->solvables, SOLVABLE_SUMMARY,
    packageInfo.Summary());
  repodata_set_str(repoData, solvable - pool->solvables, SOLVABLE_DESCRIPTION,
    packageInfo.Description());
  repodata_set_str(repoData, solvable - pool->solvables, SOLVABLE_PACKAGER,
    packageInfo.Packager());

  if (!packageInfo.Checksum().IsEmpty())
    repodata_set_checksum(repoData, solvable - pool->solvables,
      SOLVABLE_CHECKSUM, REPOKEY_TYPE_SHA256, packageInfo.Checksum());

  solvable->provides = repo_addid_dep(repo, solvable->provides,
    pool_rel2id(pool, solvable->name, solvable->evr, REL_EQ, 1), 0);

  add_resolvables(repo, solvable->provides, packageInfo.ProvidesList());
  add_resolvable_expressions(repo, solvable->requires,
    packageInfo.RequiresList());
  add_resolvable_expressions(repo, solvable->supplements,
    packageInfo.SupplementsList());
  add_resolvable_expressions(repo, solvable->conflicts,
    packageInfo.ConflictsList());
  add_resolvable_expressions(repo, solvable->enhances,
    packageInfo.FreshensList());
  add_replaces_list(repo, solvable->obsoletes, packageInfo.ReplacesList());
  // TODO: Check whether freshens and replaces does indeed work as intended
  // here.

  // TODO: copyrights, licenses, URLs, source URLs

  return solvableId;
}

static void add_installed_packages(Repo *repo, Repodata *repoData,
  BPackageInstallationLocation location)
{
  BPackageRoster roster;
  BPackageInfoSet packageInfos;
  if (roster.GetActivePackages(location, packageInfos) == B_OK)
    {
      BRepositoryCache::Iterator it = packageInfos.GetIterator();
      while (const BPackageInfo *packageInfo = it.Next())
        add_package_info_to_repo(repo, repoData, *packageInfo);
    }
}

int repo_add_haiku_installed_packages(Repo *repo, const char *rootdir,
  int flags)
{
  Repodata *repoData = repo_add_repodata(repo, flags);

  add_installed_packages(repo, repoData,
    B_PACKAGE_INSTALLATION_LOCATION_SYSTEM);
  add_installed_packages(repo, repoData,
    B_PACKAGE_INSTALLATION_LOCATION_COMMON);
  add_installed_packages(repo, repoData, B_PACKAGE_INSTALLATION_LOCATION_HOME);

  if (!(flags & REPO_NO_INTERNALIZE))
    repodata_internalize(repoData);

  return 0;
}

Id repo_add_haiku_package(Repo *repo, const char *hpkgPath, int flags)
{
  BPackageInfo packageInfo;
  if (packageInfo.ReadFromPackageFile(hpkgPath) != B_OK)
    return 0;

  return repo_add_haiku_package_info(repo, packageInfo, flags);
}

int repo_add_haiku_packages(Repo *repo, const char *repoName, int flags)
{
  BPackageRoster roster;
  BRepositoryCache cache;
  if (roster.GetRepositoryCache(repoName, &cache) != B_OK)
    return 0;

  Repodata *repoData = repo_add_repodata(repo, flags);

  BRepositoryCache::Iterator it = cache.GetIterator();
  while (const BPackageInfo *packageInfo = it.Next())
    add_package_info_to_repo(repo, repoData, *packageInfo);

  if (!(flags & REPO_NO_INTERNALIZE))
    repodata_internalize(repoData);

  return 0;
}

Id repo_add_haiku_package_info(Repo *repo,
  const BPackageKit::BPackageInfo &packageInfo, int flags)
{
  if (packageInfo.InitCheck() != B_OK)
    return 0;
  
  Repodata *repoData = repo_add_repodata(repo, flags);

  Id id = add_package_info_to_repo(repo, repoData, packageInfo);

  if (!(flags & REPO_NO_INTERNALIZE))
    repodata_internalize(repoData);

  return id;
}