public AnalyserResult analyse()

in src/main/java/org/apache/sling/feature/analyser/Analyser.java [206:434]
196 lines of code
32 McCabe index (conditional complexity)

    public AnalyserResult analyse(final Feature feature, final ArtifactId fwk, final FeatureProvider featureProvider)
            throws Exception {
        logger.info("Starting analyzing feature '{}'...", feature.getId());

        final long start = System.currentTimeMillis();
        final FeatureDescriptor featureDesc = scanner.scan(feature);
        BundleDescriptor bd = null;
        ArtifactId framework = fwk;
        if (framework == null) {
            final ExecutionEnvironmentExtension ext =
                    ExecutionEnvironmentExtension.getExecutionEnvironmentExtension(feature);
            if (ext != null && ext.getFramework() != null) {
                framework = ext.getFramework().getId();
            }
        }
        if (framework != null) {
            bd = scanner.scan(framework, feature.getFrameworkProperties());
        }
        if (this.outputTaskDetails) {
            logger.info("- Scanned feature in {}ms", System.currentTimeMillis() - start);
        }
        final BundleDescriptor fwkDesc = bd;

        final List<AnalyserResult.GlobalReport> globalWarnings = new ArrayList<>();
        final List<AnalyserResult.ArtifactReport> artifactWarnings = new ArrayList<>();
        final List<AnalyserResult.ExtensionReport> extensionWarnings = new ArrayList<>();
        final List<AnalyserResult.ConfigurationReport> configurationWarnings = new ArrayList<>();

        final List<AnalyserResult.GlobalReport> globalErrors = new ArrayList<>();
        final List<AnalyserResult.ArtifactReport> artifactErrors = new ArrayList<>();
        final List<AnalyserResult.ExtensionReport> extensionErrors = new ArrayList<>();
        final List<AnalyserResult.ConfigurationReport> configurationErrors = new ArrayList<>();

        AnalyserMetaDataExtension analyserMetaDataExtension =
                AnalyserMetaDataExtension.getAnalyserMetaDataExtension(feature);

        // execute analyser tasks
        for (final AnalyserTask task : tasks) {
            if (this.outputTaskDetails) {
                logger.info("- Executing {} [{}]...", task.getName(), task.getId());
            }
            final long startTask = System.currentTimeMillis();
            final Map<String, String> taskConfiguration = getConfiguration(task.getId());

            final boolean strict = Boolean.valueOf(taskConfiguration.getOrDefault("strict", "false"));

            task.execute(new AnalyserTaskContext() {
                private final FeatureProvider cachingFeatureProvider = featureProvider != null
                        ? new FeatureProvider() {
                            private final ConcurrentHashMap<ArtifactId, Feature> cache = new ConcurrentHashMap<>();

                            @Override
                            public Feature provide(ArtifactId artifactId) {
                                return cache.computeIfAbsent(artifactId, key -> featureProvider.provide(artifactId));
                            }
                        }
                        : null;

                @Override
                public Feature getFeature() {
                    return feature;
                }

                @Override
                public FeatureDescriptor getFeatureDescriptor() {
                    return featureDesc;
                }

                @Override
                public FeatureProvider getFeatureProvider() {
                    return cachingFeatureProvider;
                }

                @Override
                public BundleDescriptor getFrameworkDescriptor() {
                    return fwkDesc;
                }

                @Override
                public Map<String, String> getConfiguration() {
                    return taskConfiguration;
                }

                @Override
                public void reportWarning(final String message) {
                    if (strict) {
                        reportError(message);
                    }
                    if (analyserMetaDataExtension == null || analyserMetaDataExtension.reportWarning(feature.getId())) {
                        globalWarnings.add(new AnalyserResult.GlobalReport(message, task.getId()));
                    }
                }

                @Override
                public void reportArtifactWarning(ArtifactId artifactId, String message) {
                    if (strict) {
                        reportArtifactError(artifactId, message);
                    }
                    if (analyserMetaDataExtension == null
                            || (analyserMetaDataExtension.reportWarning(artifactId)
                                    && analyserMetaDataExtension.reportWarning(feature.getId()))) {
                        artifactWarnings.add(new AnalyserResult.ArtifactReport(artifactId, message, task.getId()));
                    }
                }

                @Override
                public void reportArtifactError(ArtifactId artifactId, String message) {
                    if (analyserMetaDataExtension == null
                            || (analyserMetaDataExtension.reportError(artifactId)
                                    && analyserMetaDataExtension.reportError(feature.getId()))) {
                        artifactErrors.add(new AnalyserResult.ArtifactReport(artifactId, message, task.getId()));
                    }
                }

                @Override
                public void reportExtensionWarning(String extension, String message) {
                    if (strict) {
                        reportExtensionError(extension, message);
                    }
                    if (analyserMetaDataExtension == null || analyserMetaDataExtension.reportWarning(feature.getId())) {
                        extensionWarnings.add(new AnalyserResult.ExtensionReport(extension, message, task.getId()));
                    }
                }

                @Override
                public void reportExtensionError(String extension, String message) {
                    if (analyserMetaDataExtension == null || analyserMetaDataExtension.reportError(feature.getId())) {
                        extensionErrors.add(new AnalyserResult.ExtensionReport(extension, message, task.getId()));
                    }
                }

                @Override
                public void reportError(final String message) {
                    if (analyserMetaDataExtension == null || analyserMetaDataExtension.reportError(feature.getId())) {
                        globalErrors.add(new AnalyserResult.GlobalReport(message, task.getId()));
                    }
                }

                @Override
                public void reportConfigurationError(Configuration cfg, String message) {
                    if (analyserMetaDataExtension == null || analyserMetaDataExtension.reportWarning(feature.getId())) {
                        configurationErrors.add(new AnalyserResult.ConfigurationReport(cfg, message, task.getId()));
                    }
                }

                @Override
                public void reportConfigurationWarning(Configuration cfg, String message) {
                    if (strict) {
                        reportConfigurationError(cfg, message);
                    }
                    if (analyserMetaDataExtension == null || analyserMetaDataExtension.reportWarning(feature.getId())) {
                        configurationWarnings.add(new AnalyserResult.ConfigurationReport(cfg, message, task.getId()));
                    }
                }
            });
            if (this.outputTaskDetails) {
                logger.info(
                        "- Executed {} [{}] in {}ms",
                        task.getName(),
                        task.getId(),
                        System.currentTimeMillis() - startTask);
            }
        }

        final int allWarnings = globalWarnings.size()
                + artifactWarnings.size()
                + extensionWarnings.size()
                + configurationWarnings.size();
        final int allErrors =
                globalErrors.size() + artifactErrors.size() + extensionErrors.size() + configurationErrors.size();
        logger.info(
                "Finished analyzing feature '{}' in {}ms : {} warnings, {} errors.",
                feature.getId(),
                System.currentTimeMillis() - start,
                allWarnings,
                allErrors);

        return new AnalyserResult() {
            @Override
            public List<GlobalReport> getGlobalWarnings() {
                return globalWarnings;
            }

            @Override
            public List<ArtifactReport> getArtifactWarnings() {
                return artifactWarnings;
            }

            @Override
            public List<ExtensionReport> getExtensionWarnings() {
                return extensionWarnings;
            }

            @Override
            public List<GlobalReport> getGlobalErrors() {
                return globalErrors;
            }

            @Override
            public List<ArtifactReport> getArtifactErrors() {
                return artifactErrors;
            }

            @Override
            public List<ExtensionReport> getExtensionErrors() {
                return extensionErrors;
            }

            @Override
            public FeatureDescriptor getFeatureDescriptor() {
                return featureDesc;
            }

            @Override
            public BundleDescriptor getFrameworkDescriptor() {
                return fwkDesc;
            }

            @Override
            public List<ConfigurationReport> getConfigurationErrors() {
                return configurationErrors;
            }

            @Override
            public List<ConfigurationReport> getConfigurationWarnings() {
                return configurationWarnings;
            }
        };
    }