import org.eclipse.aether.util.graph.selector.ExclusionDependencySelector;
import org.eclipse.aether.util.graph.transformer.ChainedDependencyGraphTransformer;
import org.eclipse.aether.util.graph.transformer.ConfigurableVersionSelector;
import org.eclipse.aether.util.graph.transformer.ConflictResolver;
import org.eclipse.aether.util.graph.transformer.SimpleOptionalitySelector;
import org.eclipse.aether.util.repository.SimpleArtifactDescriptorPolicy;

        childUrlSet.remove(url);
    }

    /**
     * Get the transformer name.
     * @return transformer
     */
    public String getTransformerName() {
        return transformerName;
    }

    /**
     * Set the transformer name.
     * @param transformerName the name of the transformer to set
     */
    public void setTransformerName(final String transformerName) {

<!DOCTYPE components PUBLIC "-//DBFLUTE//DTD LastaDi 1.0//EN"
	"http://dbflute.org/meta/lastadi10.dtd">
<components namespace="fessCrawler">
	<include path="crawler/container.xml" />
	<include path="crawler/transformer.xml" />

	<component name="ruleManager"
		class="org.codelibs.fess.crawler.rule.impl.RuleManagerImpl" instance="prototype">
		<postConstruct name="addRule">
			<arg>sitemapsRule</arg>
		</postConstruct>

    String ROLE = ArtifactTransformationManager.class.getName();

    /**
     * Take in an artifact and return the transformed artifact for locating in the remote repository. If no
     * transformation has occurred the original artifact is returned.
     *
     * @param artifact           Artifact to be transformed.
     * @param request the repositories to check
     */

import gradlebuild.docs.model.ClassMetaDataRepository
import gradlebuild.docs.model.SimpleClassMetaDataRepository
import groovy.time.TimeCategory
import groovy.time.TimeDuration
import org.gradle.api.Action
import org.gradle.api.Transformer
import org.gradle.api.file.FileTree
import org.gradle.api.file.RegularFileProperty
import org.gradle.api.logging.Logging
import org.gradle.api.tasks.CacheableTask
import org.gradle.api.tasks.OutputFile

import org.eclipse.aether.deployment.DeployRequest;
import org.eclipse.aether.installation.InstallRequest;
import org.eclipse.aether.spi.artifact.transformer.ArtifactTransformer;

import static java.util.Objects.requireNonNull;

/**
 * Maven specific transformer.
 */
@Singleton
@Named
final class MavenTransformer implements ArtifactTransformer {
    private final TransformerManager transformerManager;

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.transformer.impl;

import java.io.InputStream;

import org.apache.commons.io.IOUtils;
import org.codelibs.fess.crawler.entity.AccessResultDataImpl;
import org.codelibs.fess.crawler.entity.ResponseData;

        }
    }

    static class ExtensionInterpolator extends MavenTransformer {
        ExtensionInterpolator(UnaryOperator<String> transformer) {
            super(transformer);
        }

        public XmlNode transform(XmlNode node) {
            return super.transform(node);
        }
    }

                        + responseProcessor + ", url: " + url);
            }
            final Transformer transformer = ((DefaultResponseProcessor) responseProcessor).getTransformer();
            final ResultData resultData = transformer.transform(responseData);
            final Object rawData = resultData.getRawData();
            if (rawData != null) {

import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.deployment.DeployRequest;
import org.eclipse.aether.installation.InstallRequest;

/**
 * Maven POM transformer.
 * TODO: rename this interface to "Transformer" as it can do much more than just transform POM.
 * @since TBD
 */
public interface PomArtifactTransformer {