def manifests_in_dependency_order()

in build/fbcode_builder/getdeps/load.py [0:0]

• 41 lines of code
• 15 McCabe index (conditional complexity)

    def manifests_in_dependency_order(self, manifest=None):
        """Compute all dependencies of the specified project.  Returns a list of the
        dependencies plus the project itself, in topologically sorted order.

        Each entry in the returned list only depends on projects that appear before it
        in the list.

        If the input manifest is None, the dependencies for all currently loaded
        projects will be computed.  i.e., if you call load_all_manifests() followed by
        manifests_in_dependency_order() this will return a global dependency ordering of
        all projects."""
        # The list of deps that have been fully processed
        seen = set()
        # The list of deps which have yet to be evaluated.  This
        # can potentially contain duplicates.
        if manifest is None:
            deps = list(self.manifests_by_name.values())
        else:
            assert manifest.name in self.manifests_by_name
            deps = [manifest]
        # The list of manifests in dependency order
        dep_order = []
        system_packages = {}

        while len(deps) > 0:
            m = deps.pop(0)
            if m.name in seen:
                continue

            # Consider its deps, if any.
            # We sort them for increased determinism; we'll produce
            # a correct order even if they aren't sorted, but we prefer
            # to produce the same order regardless of how they are listed
            # in the project manifest files.
            ctx = self.ctx_gen.get_context(m.name)
            dep_list = m.get_dependencies(ctx)

            dep_count = 0
            for dep_name in dep_list:
                # If we're not sure whether it is done, queue it up
                if dep_name not in seen:
                    dep = self.manifests_by_name.get(dep_name)
                    if dep is None:
                        dep = self._loader.load_project(self.build_opts, dep_name)
                        self.manifests_by_name[dep.name] = dep

                    deps.append(dep)
                    dep_count += 1

            if dep_count > 0:
                # If we queued anything, re-queue this item, as it depends
                # those new item(s) and their transitive deps.
                deps.append(m)
                continue

            # Its deps are done, so we can emit it
            seen.add(m.name)
            # Capture system packages as we may need to set PATHs to then later
            if (
                self.build_opts.allow_system_packages
                and self.build_opts.host_type.get_package_manager()
            ):
                packages = m.get_required_system_packages(ctx)
                for pkg_type, v in packages.items():
                    merged = system_packages.get(pkg_type, [])
                    if v not in merged:
                        merged += v
                    system_packages[pkg_type] = merged
                # A manifest depends on all system packages in it dependencies as well
                m.resolved_system_packages = copy.copy(system_packages)
            dep_order.append(m)

        return dep_order