cloneDependencies method

Future<void> cloneDependencies({ required Directory workspaceDir, required String packageName, required Map<String, Directory> projectDirs, required Set<String> processedNodes, required GgLog ggLog, })

Clone all dependencies of the project

Implementation

Future<void> cloneDependencies({
  required Directory workspaceDir,
  required String packageName,
  required Map<String, Directory> projectDirs,
  required Set<String> processedNodes,
  required GgLog ggLog,
}) async {
  final projectDir = correctDir(projectDirs[packageName]!);

  // Iterate all dependencies
  final keys = await getDependencies(projectDir);

  for (MapEntry<String, Dependency> dependency in keys) {
    String dependencyName = dependency.key;

    if (excludeFromArgs.contains(dependencyName)) {
      continue;
    }

    if (processedNodes.contains(dependencyName)) {
      continue;
    }
    processedNodes.add(dependencyName);

    Directory dependencyDir = getProjectDir(
          packageName: dependencyName,
          workspaceDir: workspaceDir,
        ) ??
        Directory('${workspaceDir.path}/$dependencyName');

    // check if dependency already exists
    bool exists = await dependencyExists(
      dependencyDir: dependencyDir,
      dependency: dependencyName,
      ggLog: ggLog,
    );

    if (!exists) {
      // get the repository url
      String? repositoryUrl;
      String? reference;
      if (dependency.value is HostedDependency) {
        repositoryUrl = await getRepositoryUrl(dependencyName);
      } else if (dependency.value is GitDependency) {
        repositoryUrl = (dependency.value as GitDependency).url.toString();
        reference = (dependency.value as GitDependency).ref;
      } else if (dependency.value is PathDependency) {
        // PathDependency is not supported
        ggLog.call(
          yellow(
            'Dependency $dependencyName is a path '
            'dependency and cannot be cloned.',
          ),
        );
        continue;
      } else if (dependency.value is SdkDependency) {
        // SdkDependency is not supported
        ggLog.call(
          yellow(
            'Dependency $dependencyName is a sdk '
            'dependency and cannot be cloned.',
          ),
        );
        continue;
      }

      if (repositoryUrl == null) {
        ggLog.call(
          yellow(
            'Dependency $dependencyName does not have a '
            'repository url and cannot be cloned.',
          ),
        );
        continue;
      }

      if (checkoutMainFromArgs) {
        reference = null;
      }

      // check if dependency is on github
      bool isOnGithub = await checkGithubOrigin(
        workspaceDir: workspaceDir,
        repositoryUrl: repositoryUrl,
      );

      // clone dependency
      if (!isOnGithub) {
        continue;
      }

      await cloneDependency(
        workspaceDir: workspaceDir,
        dependency: dependencyName,
        repositoryUrl: repositoryUrl,
        ggLog: ggLog,
        reference: reference,
      );

      dependencyDir = getProjectDir(
            packageName: dependencyName,
            workspaceDir: workspaceDir,
          ) ??
          Directory('${workspaceDir.path}/$dependencyName');

      // check if dependency exists after cloning
      bool existsAfterCloning = await dependencyExists(
        dependencyDir: dependencyDir,
        dependency: dependencyName,
      );

      if (!existsAfterCloning) {
        continue;
      }
    }

    // execute cloneDependencies for dependency
    projectDirs[dependencyName] = dependencyDir;

    if (directFromArgs) {
      continue;
    }

    if (allFromArgs) {
      await cloneDependencies(
        workspaceDir: workspaceDir,
        packageName: dependencyName,
        projectDirs: projectDirs,
        processedNodes: processedNodes,
        ggLog: ggLog,
      );
    }
  }
}