08_14_01 - Selection Criteria¶

Sistema de criterios de selección de assets para packaging en AudioLab.

Componentes¶

QualityTierSelector¶

Selector de tiers de calidad: Draft (<10MB), Pro (10-50MB), Ultra (>50MB).

Ejemplo:

QualityTierSelector selector;

// Configurar tier Draft
QualityTierSelector::TierAssets draftAssets(QualityTier::Draft);
draftAssets.requiredAssets = {"plugin.dll", "presets/factory/*.json"};
draftAssets.estimatedSize = 5 * 1024 * 1024; // 5MB
draftAssets.description = "Minimal development build";

selector.setTierAssets("TS_Compressor", QualityTier::Draft, draftAssets);

// Configurar tier Pro
QualityTierSelector::TierAssets proAssets(QualityTier::Pro);
proAssets.requiredAssets = {"plugin.dll", "presets/**/*.json", "docs/**"};
proAssets.estimatedSize = 25 * 1024 * 1024;

selector.setTierAssets("TS_Compressor", QualityTier::Pro, proAssets);

// Seleccionar tier por tamaño disponible
auto tier = selector.selectTierBySize("TS_Compressor", 15 * 1024 * 1024);
// Result: QualityTier::Draft (Pro no cabe)

// Validar tamaño
auto validation = selector.validateTierSize("TS_Compressor", QualityTier::Pro);
if (!validation.valid) {
    std::cerr << "Tier exceeds size limit!\n";
}

PlatformRequirements¶

Verificación de requisitos del sistema por plataforma.

Ejemplo:

PlatformRequirements requirements;

// Configurar requisitos de Windows
PlatformRequirements::PlatformConfig winConfig(Platform::Windows);
winConfig.minOSVersion = "Windows 10";
winConfig.minDiskSpace = 100 * 1024 * 1024; // 100MB
winConfig.supportedArchitectures = {"x64"};

// Agregar dependencias
PlatformRequirements::Requirement vcRedist;
vcRedist.type = RequirementType::RuntimeEnv;
vcRedist.name = "Visual C++ Redistributable 2019";
vcRedist.optional = false;
winConfig.requirements.push_back(vcRedist);

requirements.addPlatformConfig(Platform::Windows, winConfig);

// Validar requisitos
auto validation = requirements.validateRequirements(Platform::Windows);
if (!validation.allSatisfied) {
    std::cout << validation.getSummary();
    for (const auto& missing : validation.missingRequired) {
        std::cerr << "Missing: " << missing << "\n";
    }
}

// Usar defaults por plataforma
auto macReqs = PlatformRequirements::getDefaultRequirements(Platform::MacOS);
requirements.addPlatformConfig(Platform::MacOS, macReqs);

LicenseChecker¶

Verificación de compatibilidad de licencias y compliance.

Ejemplo:

LicenseChecker checker;

// Configurar licencia del proyecto
LicenseChecker::ProjectLicense projectLicense;
projectLicense.type = LicenseType::Proprietary;
projectLicense.commercialUse = true;
projectLicense.allowsCopyleft = false;
checker.setProjectLicense(projectLicense);

// Agregar licencias de assets
LicenseChecker::LicenseInfo mitAsset("json_lib.dll");
mitAsset.type = LicenseType::MIT;
mitAsset.commercialUse = true;
mitAsset.requiresAttribution = true;
mitAsset.copyright = "Copyright (c) 2024 JSON Library Authors";
checker.addAssetLicense(mitAsset);

// Verificar compliance de un asset
auto result = checker.checkAssetCompliance("json_lib.dll");
if (!result.compliant) {
    for (const auto& issue : result.issues) {
        std::cerr << "License issue: " << issue << "\n";
    }
}

// Verificar todos los assets
auto validation = checker.validateAllAssets();
std::cout << validation.generateReport();

// Generar texto de atribución
std::string attribution = checker.generateAttributionText();
std::ofstream("THIRD_PARTY_LICENSES.txt") << attribution;

AssetInventory¶

Inventario y gestión de assets con tracking de metadata.

Ejemplo:

AssetInventory inventory;

// Escanear directorio automáticamente
AssetInventory::ScanOptions options;
options.recursive = true;
options.computeHashes = true;
options.autoDetectType = true;
options.excludePatterns = {".git", "temp", ".DS_Store"};

inventory.scanDirectory("/build/output", options);

// Agregar assets manualmente
AssetInventory::AssetMetadata plugin("bin/MyPlugin.vst3");
plugin.type = AssetInventory::AssetType::Plugin;
plugin.size = 2 * 1024 * 1024;
plugin.version = "1.0.0";
plugin.required = true;
plugin.tags = {"vst3", "release"};
plugin.hash = AssetInventory::computeFileHash("/build/output/bin/MyPlugin.vst3");

inventory.addAsset(plugin);

// Obtener assets por tipo
auto plugins = inventory.getAssetsByType(AssetInventory::AssetType::Plugin);
auto presets = inventory.getAssetsByType(AssetInventory::AssetType::Preset);

// Estadísticas
auto stats = inventory.getStatistics();
std::cout << stats.toString();
// Output:
// Total Assets: 127
// Total Size: 45 MB
// Required: 89
// Optional: 38

// Verificar integridad
auto verification = inventory.verify("/build/output");
if (!verification.valid) {
    std::cout << verification.generateReport();
}

// Exportar inventario
inventory.saveToFile("asset_inventory.json");

VersionTracking¶

Sistema de versionado semántico y tracking de cambios en assets.

Ejemplo:

VersionTracking tracker;
tracker.setCurrentVersion(VersionTracking::Version(1, 2, 0));

// Parsear versión desde string
auto v1 = *VersionTracking::Version::parse("1.0.0");
auto v2 = *VersionTracking::Version::parse("1.1.0-beta");
auto v3 = *VersionTracking::Version::parse("2.0.0+build123");

// Comparar versiones
if (v1 < v2) {
    std::cout << "v1 is older\n";
}

// Track asset versions
VersionTracking::AssetVersion asset1("plugin.dll");
asset1.version = VersionTracking::Version(1, 0, 0);
asset1.hash = "abc123def456";
asset1.size = 1024 * 1024;
asset1.changelog = "Initial release";

tracker.trackAsset(asset1);

// Nueva versión del mismo asset
VersionTracking::AssetVersion asset2("plugin.dll");
asset2.version = VersionTracking::Version(1, 1, 0);
asset2.hash = "def456abc789";
asset2.size = 1100 * 1024;
asset2.changelog = "Added new DSP features";

tracker.trackAsset(asset2);

// Obtener última versión
auto latest = tracker.getLatestAssetVersion("plugin.dll");
std::cout << "Latest version: " << latest->version.toString() << "\n";

// Ver historial
auto history = tracker.getAssetHistory("plugin.dll");
for (const auto& ver : history) {
    std::cout << ver.version.toString() << ": " << ver.changelog << "\n";
}

// Detectar cambios entre versiones
auto changes = tracker.getAssetChanges("plugin.dll", v1, v2);
if (changes.changed) {
    std::cout << "Change type: " << changes.changeType << "\n"; // "modified"
}

// Deprecar assets
tracker.deprecateAsset("old_api.dll",
    VersionTracking::Version(2, 0, 0),
    "Use new_api.dll instead");

if (tracker.isAssetDeprecated("old_api.dll")) {
    std::cout << "Asset is deprecated!\n";
}

// Generar changelog
std::string changelog = tracker.generateChangelog(v1, v3);
std::cout << changelog;

Workflow Completo¶

Ejemplo de uso integrado:

#include "QualityTierSelector.hpp"
#include "PlatformRequirements.hpp"
#include "LicenseChecker.hpp"
#include "AssetInventory.hpp"
#include "VersionTracking.hpp"

using namespace audiolab::plugins::packaging;

void packageProduct(const std::string& productId,
                   Platform platform,
                   QualityTier tier) {
    // 1. Verificar requisitos del sistema
    PlatformRequirements requirements;
    auto config = PlatformRequirements::getDefaultRequirements(platform);
    requirements.addPlatformConfig(platform, config);

    auto reqValidation = requirements.validateRequirements(platform);
    if (!reqValidation.allSatisfied) {
        throw std::runtime_error("Platform requirements not met");
    }

    // 2. Seleccionar assets por tier
    QualityTierSelector tierSelector;
    auto tierAssets = tierSelector.getTierAssets(productId, tier);

    auto sizeValidation = tierSelector.validateTierSize(productId, tier);
    if (!sizeValidation.valid) {
        std::cerr << "Warning: Tier size exceeds limit\n";
    }

    // 3. Escanear y verificar assets
    AssetInventory inventory;
    inventory.scanDirectory("/build/output");

    auto verification = inventory.verify("/build/output");
    if (!verification.valid) {
        throw std::runtime_error("Asset verification failed");
    }

    // 4. Verificar licencias
    LicenseChecker licenseChecker;
    // ... configurar licenses ...

    auto licenseValidation = licenseChecker.validateAllAssets();
    if (!licenseValidation.allCompliant) {
        throw std::runtime_error("License compliance failed");
    }

    // 5. Generar atribuciones
    std::string attributions = licenseChecker.generateAttributionText();

    // 6. Track versión
    VersionTracking versionTracker;
    versionTracker.setCurrentVersion(Version(1, 0, 0));

    for (const auto& [path, metadata] : inventory.getAllAssets()) {
        AssetVersion assetVer(path);
        assetVer.version = versionTracker.getCurrentVersion();
        assetVer.hash = metadata.hash;
        assetVer.size = metadata.size;
        versionTracker.trackAsset(assetVer);
    }

    // 7. Generar package
    std::cout << "Packaging " << productId
              << " for " << PlatformRequirements::platformToString(platform)
              << " tier " << QualityTierSelector::tierToString(tier) << "\n";

    auto stats = inventory.getStatistics();
    std::cout << stats.toString();
}

Build¶

cd tests
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build .
./test_selection_criteria.exe

Dependencies¶

C++20
STL (filesystem, regex, chrono)
Catch2 (tests only)