process method

void process()

Main process that analyzes dependencies and generates outputs.

Implementation

void process() {
  var directory = Directory(options.libPath);

  if (!directory.existsSync()) {
    print("${options.libPath} don't exist");
    exit(-1);
  }
  String timeStamp = DateTime.now().toIso8601String();
  String finalString = '';
  finalString += 'Project            : ${directory.parent.absolute.path}\n';
  finalString +=
      'Mode               : ${options.reverse ? 'reverse' : 'normal'}\n';
  finalString += 'Sort               : ${options.sortMode}\n';

  final results = analyzeFiles(options.path, used: (!options.reverse));

  // Sort results if needed
  if (options.sortMode == 'dependencies') {
    results.sort((a, b) => a.dependenciesSize.compareTo(b.dependenciesSize));
  } else if (options.sortMode == 'path') {
    results.sort((a, b) => a.file.path.compareTo(b.file.path));
  }

  String rightArrow = "\u2192"; // →
  String leftArrow = "\u2190"; // ←
  String baseArrow = (!options.reverse) ? leftArrow : rightArrow;

  finalString += 'Files Analyzed     : ${results.length}\n';
  var refCount = 0;
  var depCount = 0;
  var cyclicCount = 0;
  for (final r in results) {
    depCount += r.dependencyList.length;
    refCount += r.referenceList.length;
    for (var dep in r.dependencyList) {
      cyclicCount += (dep.isCyclic) ? 1 : 0;
    }
  }
  finalString += 'Reference Count    : ${refCount}\n';
  finalString += 'Dependencies Count : ${depCount}\n';
  finalString += 'Cyclic Count       : ${cyclicCount}\n';
  finalString += 'TimeStamp          : $timeStamp\n';
  finalString +=
      '\n=============================================================\n\n';

  for (final r in results) {
    finalString +=
        '${r.getRelativePath(options.path)}: dependencies =${r.dependenciesSize}\n';
    for (var dep in r.dependencyList) {
      finalString +=
          '                  $baseArrow ${dep.code.getRelativePath(options.path)}  ${(dep.isCyclic) ? '  [Cyclic]' : ''}\n';
      for (var ref in dep.itemList) {
        finalString += '                             $ref \n';
      }
    }
    finalString += '\n';
  }

  // Prepare JSON/YAML data structure
  List<dynamic> files = [];

  for (final r in results) {
    List<dynamic> dependencies = [];
    for (var dep in r.dependencyList) {
      var mp = {
        'dependency': {
          'path': dep.code.getRelativePath(options.path),
          'cyclic': dep.isCyclic,
          'references': dep.itemList,
        },
      };
      dependencies.add(mp);
    }
    var mp = {
      'File': {
        'path': r.getRelativePath(options.path),
        'dependenciesCount': r.dependenciesSize,
        'dependencies': dependencies,
      },
    };
    files.add(mp);
  }

  Map<String, dynamic> appliMap = {
    'parameters': {
      'project': directory.parent.absolute.path,
      'mode': options.reverse ? 'reverse' : 'normal',
      'sort': options.sortMode,
      'referenceCount': refCount,
      'dependenciesCount': depCount,
      'cyclicCount': cyclicCount,
      'timeStamp': timeStamp,
    },
    'project': files,
  };

  String jsonString = JsonEncoder.withIndent('  ').convert(appliMap);
  String yamlString = json2yaml(appliMap);

  finalString += '\n';

  // Output to console if required
  if (options.outputConsole) {
    print(finalString);
  }

  // Write outputs to files if paths are provided
  if ((options.outputTextFile ?? '').isNotEmpty) {
    var oFile = File(options.outputTextFile!);
    oFile.writeAsStringSync(finalString, mode: FileMode.write, flush: true);
  }

  if ((options.outputJsonFile ?? '').isNotEmpty) {
    var oFile = File(options.outputJsonFile!);
    oFile.writeAsStringSync(jsonString, mode: FileMode.write, flush: true);
  }

  if ((options.outputYamlFile ?? '').isNotEmpty) {
    var oFile = File(options.outputYamlFile!);
    oFile.writeAsStringSync(yamlString, mode: FileMode.write, flush: true);
  }
}