build method

Implementation

@override
Future<void> build(BuildStep buildStep) async {
  if (!buildStep.inputId.path.endsWith('pubspec.yaml')) {
    return;
  }

  final cacheFiles =
      await buildStep.findAssets(Glob('**/*.rdf_mapper.cache.json')).toList();
  if (cacheFiles.isEmpty) {
    return;
  }

  final jsonFiles = await Future.wait(cacheFiles.map((file) async => (
        file.path,
        await buildStep.readAsString(file),
      )));

  final currentLockState = _collectLockState(jsonFiles);
  final existingLockState = _readLockState();
  final lockComparison = _compareLockStates(
    previous: existingLockState,
    current: currentLockState,
  );
  for (final info in lockComparison.infos) {
    log.info(info);
  }
  for (final warning in lockComparison.warnings) {
    log.warning(warning);
  }
  if (lockComparison.errors.isNotEmpty) {
    throw StateError(lockComparison.errors.join('\n\n'));
  }

  final vocabData =
      _collectVocabData(jsonFiles, iriTermFactory: _iriTermFactory);
  if (vocabData.isEmpty) {
    return;
  }

  if (_options.isConfigured) {
    final missing = vocabData.keys
        .where((vocabIri) => !_options.vocabularies.containsKey(vocabIri))
        .toList();
    if (missing.isNotEmpty) {
      throw StateError(
          'Vocabulary IRIs not configured in vocabularies: ${missing.join(', ')}');
    }
  }

  final graphByOutputPath = <String, RdfGraph>{};
  for (final entry in vocabData.entries) {
    final vocabIri = entry.key;
    final vocabConfig = _options.vocabularies[vocabIri];
    final outputPath = _resolveOutputPath(
      vocabIri: vocabIri,
      vocabConfig: vocabConfig,
      vocabCount: vocabData.length,
      isConfigured: _options.isConfigured,
    );

    final extensionPath = vocabConfig?.extensions;
    final graphWithExtensions = extensionPath == null
        ? entry.value
        : entry.value
            .merge(await _readExtensionGraph(buildStep, extensionPath));

    final existingGraph = graphByOutputPath[outputPath];
    if (existingGraph == null) {
      graphByOutputPath[outputPath] = graphWithExtensions;
    } else {
      graphByOutputPath[outputPath] =
          existingGraph.merge(graphWithExtensions);
    }
  }

  for (final entry in graphByOutputPath.entries) {
    await buildStep.writeAsString(
      AssetId(buildStep.inputId.package, entry.key),
      turtle.encode(entry.value),
    );
  }

  _writeLockState(currentLockState);
}