BuildStatus iterativeCompile()

in src/org/jetbrains/ether/ProjectWrapper.java [1077:1199]
97 lines of code
24 McCabe index (conditional complexity)

        BuildStatus iterativeCompile(final ModuleChunk chunk, final Set<StringCache.S> sources, final Set<StringCache.S> outdated, final Set<StringCache.S> removed, final Flags flags) {
            final Collection<StringCache.S> filesToCompile = DefaultGroovyMethods.intersect(affectedFiles, sources);
            final Set<StringCache.S> safeFiles = new HashSet<StringCache.S>();

            if (outdated != null) {
                for (StringCache.S s : outdated) {
                    assert (s != null);
                }

                filesToCompile.addAll(outdated);

                for (StringCache.S f : outdated) {
                    if (f.value.endsWith(".form")) {
                        final StringCache.S sourceFileName = dependencyMapping.getJavaByForm(f);

                        if (sourceFileName != null && !filesToCompile.contains(sourceFileName)) {
                            safeFiles.add(sourceFileName);
                            filesToCompile.add(sourceFileName);
                        }
                    } else if (f.value.endsWith(".java")) {
                        final StringCache.S formFileName = dependencyMapping.getFormByJava(f);

                        if (formFileName != null) {
                            filesToCompile.add(formFileName);
                        }
                    }
                }
            }

            filesToCompile.removeAll(compiledFiles);

            if (!filesToCompile.isEmpty() || removed != null) {
                final Set<StringCache.S> outputFiles = new HashSet<StringCache.S>();

                for (StringCache.S f : filesToCompile) {
                    final Set<ClassRepr> classes = dependencyMapping.getClasses(f);

                    if (classes != null)
                        for (ClassRepr cr : classes) {
                            outputFiles.add(cr.fileName);
                        }
                }

                if (removed != null) {
                    for (StringCache.S f : removed) {
                        final Set<ClassRepr> classes = dependencyMapping.getClasses(f);
                        if (classes != null) {
                            for (ClassRepr cr : classes) {
                                outputFiles.add(cr.fileName);
                            }
                        }
                    }
                }

                if (!outputFiles.isEmpty()) {
                    new Logger(flags) {
                        @Override
                        public void log(PrintStream stream) {
                            stream.println("Cleaning output files:");
                            logFilePaths(stream, outputFiles);
                            stream.println("End of files");
                        }
                    }.log();

                    builder.clearChunk(chunk, outputFiles, ProjectWrapper.this);
                }

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

                new Logger(flags) {
                    @Override
                    public void log(PrintStream stream) {
                        stream.println("Compiling files:");
                        logFilePaths(stream, filesToCompile);
                        stream.println("End of files");
                    }
                }.log();

                boolean buildException = false;

                try {
                    builder.buildChunk(chunk, flags.tests(), filesToCompile, deltaBackend, ProjectWrapper.this);
                } catch (Exception e) {
                    e.printStackTrace();
                    buildException = true;
                }

                if (!buildException) {
                    compiledFiles.addAll(filesToCompile);
                    affectedFiles.removeAll(filesToCompile);

                    delta.compensateRemovedContent(filesToCompile);

                    final boolean incremental = dependencyMapping.differentiate(delta, removed, compiledFiles, affectedFiles, safeFiles);

                    dependencyMapping.integrate(delta, removed);

                    if (!incremental) {
                        affectedFiles.addAll(sources);
                        affectedFiles.removeAll(compiledFiles);

                        final BuildStatus result = iterativeCompile(chunk, sources, null, null, flags);

                        if (result == BuildStatus.FAILURE) {
                            return result;
                        }

                        return BuildStatus.CONSERVATIVE;
                    }

                    return iterativeCompile(chunk, sources, null, null, flags);
                } else {
                    return BuildStatus.FAILURE;
                }
            } else {
                for (Module m : chunk.getElements()) {
                    Reporter.reportBuildSuccess(m, flags.tests());
                }
            }

            return BuildStatus.INCREMENTAL;
        }