public BuildStatus build()

in src/org/jetbrains/ether/ProjectWrapper.java [1201:1281]
63 lines of code
15 McCabe index (conditional complexity)

        public BuildStatus build(final Collection<Module> modules, final Flags flags) {
            boolean incremental = flags.incremental();
            final List<ModuleChunk> chunks = myProjectBuilder.getChunks(flags.tests()).getChunkList();

            for (final ModuleChunk c : chunks) {
                final Set<Module> chunkModules = c.getElements();

                if (!DefaultGroovyMethods.intersect(modules, chunkModules).isEmpty()) {
                    final Set<StringCache.S> removedSources = new HashSet<StringCache.S>();

                    if (incremental) {
                        final Set<StringCache.S> chunkSources = new HashSet<StringCache.S>();
                        final Set<StringCache.S> outdatedSources = new HashSet<StringCache.S>();

                        for (Module m : chunkModules) {
                            final ModuleWrapper mw = getModule(m.getName());

                            outdatedSources.addAll(mw.getOutdatedFiles(flags.tests()));
                            chunkSources.addAll(mw.getSources(flags.tests()));
                            removedSources.addAll(mw.getRemovedFiles(flags.tests()));
                        }

                        final BuildStatus result = iterativeCompile(c, chunkSources, outdatedSources, removedSources, flags);

                        incremental = result == BuildStatus.INCREMENTAL;

                        if (result == BuildStatus.FAILURE) {
                            return result;
                        }
                    } else {
                        new Logger(flags) {
                            @Override
                            public void log(PrintStream stream) {
                                stream.println("Compiling chunk " + c.getName() + " non-incrementally.");
                            }
                        }.log();

                        for (Module m : chunkModules) {
                            final ModuleWrapper mw = getModule(m.getName());
                            removedSources.addAll(flags.tests() ? mw.getRemovedTests() : mw.getRemovedSources());
                        }

                        final Set<Module> toClean = new HashSet<Module>();

                        for (Module m : chunkModules) {
                            if (!cleared.contains(m)) {
                                toClean.add(m);
                            }
                        }

                        if (!toClean.isEmpty() && !flags.tests()) {
                            builder.clearChunk(new ModuleChunk(toClean), null, ProjectWrapper.this);
                            cleared.addAll(toClean);
                        }

                        final Mappings delta = new Mappings(ProjectWrapper.this);
                        final Callbacks.Backend deltaCallback = delta.getCallback();

                        try {
                            builder.buildChunk(c, flags.tests(), null, deltaCallback, ProjectWrapper.this);
                        } catch (Exception e) {
                            e.printStackTrace();
                            return BuildStatus.FAILURE;
                        }

                        for (Module m : c.getElements()) {
                            final ModuleWrapper module = getModule(m.getName());
                            affectedFiles.removeAll(module.getSources(flags.tests()));
                        }

                        dependencyMapping.integrate(delta, removedSources);

                        for (Module m : chunkModules) {
                            Reporter.reportBuildSuccess(m, flags.tests());
                        }
                    }
                }
            }

            return BuildStatus.INCREMENTAL;
        }