private Iterator findConfigRefs()

in src/main/java/org/apache/sling/caconfig/resource/impl/def/DefaultConfigurationResourceResolvingStrategy.java [140:236]
80 lines of code
17 McCabe index (conditional complexity)

    private Iterator<String> findConfigRefs(final Resource startResource, final Collection<String> bucketNames) {

        // collect all context path resources (but filter out those without config reference)
        final Iterator<ContextResource> contextResources =
                new FilterIterator(contextPathStrategy.findContextResources(startResource), new Predicate() {
                    @Override
                    public boolean evaluate(Object object) {
                        ContextResource contextResource = (ContextResource) object;
                        return StringUtils.isNotBlank(contextResource.getConfigRef());
                    }
                });

        // get config resource path for each context resource, filter out items where not reference could be resolved
        final Iterator<String> configPaths = new Iterator<String>() {

            private final List<ContextResource> relativePaths = new ArrayList<>();

            private String next = seek();

            private String useFromRelativePathsWith;

            private String seek() {
                String val = null;
                while (val == null && (useFromRelativePathsWith != null || contextResources.hasNext())) {
                    if (useFromRelativePathsWith != null) {
                        final ContextResource contextResource = relativePaths.remove(relativePaths.size() - 1);
                        val = checkPath(
                                contextResource,
                                useFromRelativePathsWith + "/" + contextResource.getConfigRef(),
                                bucketNames);
                        if (val != null) {
                            log.trace(
                                    "+ Found reference for context path {}: {}",
                                    contextResource.getResource().getPath(),
                                    val);
                        }
                        if (relativePaths.isEmpty()) {
                            useFromRelativePathsWith = null;
                        }
                    } else {
                        final ContextResource contextResource = contextResources.next();
                        val = contextResource.getConfigRef();

                        // if absolute path found we are (probably) done
                        if (val != null && val.startsWith("/")) {
                            val = checkPath(contextResource, val, bucketNames);
                        }

                        if (val != null) {
                            final boolean isAbsolute = val.startsWith("/");
                            if (isAbsolute && !relativePaths.isEmpty()) {
                                useFromRelativePathsWith = val;
                                val = null;
                            } else if (!isAbsolute) {
                                relativePaths.add(0, contextResource);
                                val = null;
                            }
                        }

                        if (val != null) {
                            log.trace(
                                    "+ Found reference for context path {}: {}",
                                    contextResource.getResource().getPath(),
                                    val);
                        }
                    }
                }
                if (val == null && !relativePaths.isEmpty()) {
                    log.error("Relative references not used as no absolute reference was found: {}", relativePaths);
                }
                return val;
            }

            @Override
            public boolean hasNext() {
                return next != null;
            }

            @Override
            public String next() {
                if (next == null) {
                    throw new NoSuchElementException();
                }
                final String result = next;
                next = seek();
                return result;
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }
        };

        // expand paths and eliminate duplicates
        return new PathEliminateDuplicatesIterator(new PathParentExpandIterator(config.configPath(), configPaths));
    }