public void makeModules()

in src/org/jetbrains/ether/ProjectWrapper.java [1284:1452]
123 lines of code
27 McCabe index (conditional complexity)

    public void makeModules(final Collection<Module> initial, final Flags flags) {
        if (myHistory == null && !flags.tests()) {
            clean();
        }

        new Logger(flags) {
            @Override
            public void log(final PrintStream stream) {
                stream.println("Request to make modules:");
                logMany(stream, initial);
                stream.println("End of request");
            }
        }.log();

        final ClasspathKind kind = ClasspathKind.compile(flags.tests());

        final Set<Module> modules = new HashSet<Module>();
        final Set<String> marked = new HashSet<String>();
        final Map<String, Boolean> visited = new HashMap<String, Boolean>();
        final Set<String> frontier = new HashSet<String>();

        final Map<String, Set<String>> reversedDependencies = new HashMap<String, Set<String>>();
        final DotPrinter printer = new DotPrinter(flags.logStream());

        printer.header();

        for (Module m : myProject.getModules().values()) {
            final String mName = m.getName();

            printer.node(mName);

            for (ClasspathItem cpi : m.getClasspath(kind)) {
                if (cpi instanceof Module) {
                    final String name = ((Module) cpi).getName();

                    printer.edge(name, mName);

                    Set<String> sm = reversedDependencies.get(name);

                    if (sm == null) {
                        sm = new HashSet<String>();
                        reversedDependencies.put(name, sm);
                    }

                    sm.add(mName);
                }
            }
        }

        printer.footer();

        // Building "upper" subgraph

        printer.header();

        new Object() {
            public void run(final Collection<Module> initial) {
                if (initial == null)
                    return;

                for (Module module : initial) {

                    final String mName = module.getName();

                    if (marked.contains(mName))
                        continue;

                    printer.node(mName);

                    final List<Module> dep = new ArrayList<Module>();

                    for (ClasspathItem cpi : module.getClasspath(kind)) {
                        if (cpi instanceof Module && !marked.contains(((Module) cpi).getName())) {
                            printer.edge(((Module) cpi).getName(), mName);
                            dep.add((Module) cpi);
                        }
                    }

                    if (dep.size() == 0) {
                        frontier.add(mName);
                    }

                    marked.add(mName);

                    run(dep);
                }
            }
        }.run(initial);

        printer.footer();

        // Traversing "upper" subgraph and collecting outdated modules and their descendants
        new Object() {
            public void run(final Collection<String> initial, final boolean force) {
                if (initial == null)
                    return;

                for (String moduleName : initial) {
                    if (!marked.contains(moduleName))
                        continue;

                    final Boolean property = visited.get(moduleName);

                    if (property == null || !property && force) {
                        final boolean outdated = getModule(moduleName).isOutdated(flags.tests(), myHistory);


                        if (force || outdated) {
                            visited.put(moduleName, true);
                            modules.add(myProject.getModules().get(moduleName));

                            run(reversedDependencies.get(moduleName), true);
                        } else {
                            if (property == null) {
                                visited.put(moduleName, false);
                            }
                            run(reversedDependencies.get(moduleName), false);
                        }
                    }
                }
            }
        }.run(frontier, flags.force());

        new Logger(flags) {
            @Override
            public void log(PrintStream stream) {
                stream.println("Propagated modules:");
                logMany(stream, modules);
                stream.println("End of propagated");
            }
        }.log();

        if (modules.size() == 0 && !flags.force()) {
            System.out.println("All requested modules are up-to-date.");
            return;
        }

        final BusyBeaver beaver = new BusyBeaver(myProjectBuilder);

        myProjectBuilder.buildStart();

        if (flags.tests()) {
            beaver.build(modules, new Flags() {
                public boolean tests() {
                    return false;
                }

                public boolean incremental() {
                    return flags.incremental();
                }

                public boolean force() {
                    return flags.force();
                }

                public PrintStream logStream() {
                    return flags.logStream();
                }
            });
        }

        beaver.build(modules, flags);

        myProjectBuilder.buildStop();

        for (Module mod : modules) {
            getModule(mod.getName()).updateOutputStatus();
        }
    }