private void execute()

in src/main/java/org/apache/easyant/tasks/SubModule.java [145:247]
81 lines of code
12 McCabe index (conditional complexity)

    private void execute(File file, File directory) throws BuildException {
        if (!file.exists() || file.isDirectory() || !file.canRead()) {
            String msg = "Invalid file: " + file;
            if (failOnError) {
                throw new BuildException(msg);
            }
            log(msg, Project.MSG_WARN);
            return;
        }

        Project subModule = configureSubModule(file, directory);
        subModule.fireSubBuildStarted();

        try {
            // buildFile should be in the same directory of buildModule
            File buildfile = new File(directory, EasyAntConstants.DEFAULT_BUILD_FILE);
            if (buildfile.exists()) {
                subModule.setNewProperty(MagicNames.ANT_FILE, buildfile.getAbsolutePath());
            }
            subModule.setNewProperty(EasyAntMagicNames.EASYANT_FILE, file.getAbsolutePath());

            ProjectHelper helper = ProjectUtils.configureProjectHelper(subModule);

            getEasyAntEngine().loadSystemPlugins(subModule, false);

            LoadModule lm = new LoadModule();
            lm.setBuildModule(file);
            lm.setBuildFile(buildfile);
            lm.setTaskName(EasyAntConstants.EASYANT_TASK_NAME);
            lm.setProject(subModule);
            lm.setOwningTarget(ProjectUtils.createTopLevelTarget());
            lm.setLocation(new Location(ProjectUtils.emulateMainScript(getProject()).getAbsolutePath()));
            lm.setUseBuildRepository(useBuildRepository);
            lm.execute();

            helper.resolveExtensionOfAttributes(subModule);

            String targetsToRun = filterTargets(subModule);
            printExecutingTargetMsg(subModule);

            if (targetsToRun != null && !"".equals(targetsToRun.trim())) {
                subModule.setNewProperty(EasyAntMagicNames.PROJECT_EXECUTED_TARGETS, targetsToRun);
                subModule.executeTargets(new TargetList(targetsToRun));
                if (useBuildRepository) {
                    String targetArtifacts = subModule.getProperty("target.artifacts");
                    if (targetArtifacts == null) {
                        targetArtifacts = "target/artifacts";
                    }
                    File artifactsDir = subModule.resolveFile(targetArtifacts);
                    if (artifactsDir.isDirectory()) {
                        IvyResolve ivyResolve = new IvyResolve();
                        ivyResolve.setFile(file);
                        ivyResolve.setProject(subModule);
                        ivyResolve.setOwningTarget(getOwningTarget());
                        ivyResolve.setLocation(getLocation());
                        ivyResolve.setTaskName("publish-buildscoped-repository");
                        ivyResolve.setSettingsRef(IvyInstanceHelper.buildProjectIvyReference(subModule));
                        ivyResolve.execute();

                        // this property set by LoadModule task when it
                        // configures the build repo
                        String resolver = subModule.getProperty(EasyAntMagicNames.EASYANT_BUILD_REPOSITORY);

                        subModule.log("Publishing in build scoped repository", Project.MSG_INFO);
                        // Publish on build scoped repository
                        IvyPublish ivyPublish = new IvyPublish();
                        ivyPublish.setSettingsRef(IvyInstanceHelper.buildProjectIvyReference(subModule));
                        ivyPublish.setResolver(resolver);
                        // TODO: this should be more flexible!
                        ivyPublish.setArtifactspattern(artifactsDir.getAbsolutePath()
                                + "/[artifact](-[classifier]).[ext]");
                        // not all sub-build targets will generate ivy
                        // artifacts. we don't want to fail
                        // a successful build just because there's nothing to
                        // publish.
                        ivyPublish.setWarnonmissing(false);
                        ivyPublish.setHaltonmissing(false);
                        ivyPublish.setProject(subModule);
                        ivyPublish.setOwningTarget(getOwningTarget());
                        ivyPublish.setLocation(getLocation());
                        ivyPublish.setOverwrite(overwrite);
                        ivyPublish.setForcedeliver(true);
                        ivyPublish.setTaskName("publish-buildscoped-repository");
                        ivyPublish.execute();
                    } else {
                        subModule.log("Skipping publish because " + artifactsDir.getPath() + " is not a directory",
                                Project.MSG_VERBOSE);
                    }
                }
            } else {
                subModule.log("Skipping sub-project build because no matching targets were found", Project.MSG_VERBOSE);
            }
            subModule.fireSubBuildFinished(null);
        } catch (BuildException e) {
            subModule.fireSubBuildFinished(e);
            throw e;
        } finally {
            // add execution times for the current submodule to parent
            // project references for access from MetaBuildExecutor
            storeExecutionTimes(getProject(), subModule);
        }

    }