private void handleGeneratedFeatures()

in src/main/java/org/apache/sling/feature/maven/mojos/AbstractFeatureMojo.java [250:334]
65 lines of code
15 McCabe index (conditional complexity)

    private void handleGeneratedFeatures() throws MojoExecutionException {
        final File dir;
        if (this.generatedFeatures == null) {
            Path targetPath = null;
            File basedir = this.project.getBasedir();
            if (basedir == null) {
                // no basedir? use the build directory instead.
                targetPath = Paths.get(this.project.getBuild().getDirectory());
            } else {
                // resolve build directory relative to the basedir path
                targetPath = basedir.toPath().resolve(this.project.getBuild().getDirectory());
            }
            final File targetDir = targetPath == null ? null : targetPath.toFile();
            final File genDir = new File(targetDir, "generated-features");
            if (genDir.exists()) {
                dir = genDir;
            } else {
                if (genDir.mkdirs()) {
                    dir = genDir;
                } else {
                    dir = null;
                }
            }
        } else {
            dir = this.generatedFeatures;
        }
        if (dir != null) {
            if (!dir.exists()) {
                if (!dir.mkdirs()) {
                    throw new MojoExecutionException("Directory does not exists: " + dir);
                }
            }
            if (!dir.isDirectory()) {
                throw new MojoExecutionException("Generated features configuration is not a directory: " + dir);
            }

            final List<File> files = new ArrayList<>();
            ProjectHelper.scan(files, dir, this.generatedFeaturesIncludes, this.generatedFeaturesExcludes);

            for (final File file : files) {
                getLog().debug("Reading feature file " + file);
                try {
                    final String json = ProjectHelper.readFeatureFile(
                            project,
                            file,
                            null,
                            this.enableLegacyVariableReplacement,
                            this.enableProjectVariableReplacement,
                            this.replacePropertyVariables != null ? this.replacePropertyVariables.split(",") : null);

                    try (final Reader reader = new StringReader(json)) {
                        final Feature feature = FeatureJSONReader.read(reader, file.getAbsolutePath());

                        ProjectHelper.checkFeatureId(project, feature);

                        // Extension handling
                        JSONFeatures.handleExtensions(feature, file);

                        // Default metadata
                        JSONFeatures.handleDefaultMetadata(feature, ProjectHelper.getDefaultMetadata(project));

                        ProjectHelper.setFeatureInfo(project, feature);

                        // Add feature to map of features
                        final String key = file.toPath().normalize().toFile().getAbsolutePath();
                        ProjectHelper.getFeatures(this.project).put(key, feature);

                        // assemble feature and add
                        final Feature assembledFeature = FeatureBuilder.assemble(feature, getBuilderContext());
                        ProjectHelper.getAssembledFeatures(project).put(key, assembledFeature);

                        // finally validate classifier
                        ProjectHelper.validateFeatureClassifiers(project);
                    } catch (final IOException io) {
                        throw new MojoExecutionException("Unable to read feature " + file.getAbsolutePath(), io);
                    }
                } catch (final RuntimeException re) {
                    // this is a bit unusual, but as ProjectHelper can only throw RuntimeException
                    // it's
                    // more user friendly to catch it and rethrow a mojo friendly exception
                    throw new MojoExecutionException(re.getMessage(), re.getCause() != null ? re.getCause() : re);
                }
            }
        }
    }