diff --git a/src/plugin/parse-xsl/build.xml b/src/plugin/parse-xsl/build.xml
new file mode 100644
index 0000000..8bbd3cf
--- /dev/null
+++ b/src/plugin/parse-xsl/build.xml
@@ -0,0 +1,47 @@
+<?xml version="1.0"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ 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.
+-->
+<project name="parse-xsl" default="jar-core">
+
+	<import file="../build-plugin.xml"/>
+	
+	
+	<taskdef name="xjc" classname="com.sun.tools.xjc.XJCTask">
+	  <classpath>
+	    <fileset dir="lib/jaxb" includes="*.jar" />
+	  </classpath>
+	</taskdef>
+
+	<xjc schema="conf/documents.xsd" destdir="src/java" package="org.apache.nutch.parse.xsl.xml.document"/>
+	<xjc  schema="conf/rules.xsd" destdir="src/java" package="org.apache.nutch.parse.xsl.xml.rule"/>
+	
+	  <!-- Build compilation dependencies -->
+	  <target name="deps-jar">
+	    <ant target="jar" inheritall="false" dir="../lib-nekohtml"/>
+	  	<ant target="jar" inheritall="false" dir="../parse-html"/>
+	  </target>
+
+	  <!-- Add compilation dependencies to classpath -->
+	  <path id="plugin.deps">
+	    <fileset dir="${nutch.root}/build">
+	      <include name="**/lib-nekohtml/*.jar" />
+	    	<include name="**/parse-html/*.jar" />
+	    </fileset>
+	  </path>
+	
+	
+</project>
diff --git a/src/plugin/parse-xsl/conf/documents.xsd b/src/plugin/parse-xsl/conf/documents.xsd
new file mode 100644
index 0000000..1fda53a
--- /dev/null
+++ b/src/plugin/parse-xsl/conf/documents.xsd
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:documents="http://www.example.org/documents/"
+	targetNamespace="http://www.example.org/documents/">
+
+	<!-- Root element -->
+	<element name="documents">
+		<complexType>
+			<sequence maxOccurs="unbounded" minOccurs="0">
+				<element name="document" type="documents:TDocument"></element>
+			</sequence>
+		</complexType>
+	</element>
+
+	<complexType name="TDocument">
+		<sequence maxOccurs="unbounded" minOccurs="0">
+			<element name="field" type="documents:TField"></element>
+		</sequence>
+	</complexType>
+
+	<complexType name="TField">
+		<simpleContent>
+			<extension base="string">
+				<attribute name="name" type="string"></attribute>
+			</extension>
+		</simpleContent>
+	</complexType>
+</schema>
\ No newline at end of file
diff --git a/src/plugin/parse-xsl/conf/rules.xsd b/src/plugin/parse-xsl/conf/rules.xsd
new file mode 100644
index 0000000..a175e09
--- /dev/null
+++ b/src/plugin/parse-xsl/conf/rules.xsd
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:rules="http://www.example.org/rules/"
+	targetNamespace="http://www.example.org/rules/">
+
+	<!-- Root element -->
+	<element name="rules">
+		<complexType>
+			<sequence maxOccurs="unbounded" minOccurs="1">
+				<element name="rule" type="rules:TRule"></element>
+			</sequence>
+			<attribute name="filterUrlsWithNoRule" type="boolean" use="optional" default="true"></attribute>
+		</complexType>
+	</element>
+
+	<complexType name="TRule">
+		<sequence maxOccurs="1" minOccurs="1">
+			<element name="transformer" type="rules:TTransformer"></element>
+		</sequence>
+		<attribute name="matches" type="string" use="required"></attribute>
+	</complexType>
+
+	<complexType name="TTransformer">
+		<simpleContent>
+			<extension base="string">
+				<attribute name="file" type="string" use="required"></attribute>
+			</extension>
+		</simpleContent>
+	</complexType>
+</schema>
\ No newline at end of file
diff --git a/src/plugin/parse-xsl/ivy.xml b/src/plugin/parse-xsl/ivy.xml
new file mode 100644
index 0000000..3dcc548
--- /dev/null
+++ b/src/plugin/parse-xsl/ivy.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" ?>
+
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   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.
+-->
+
+<ivy-module version="1.0">
+  <info organisation="org.apache.nutch" module="${ant.project.name}">
+    <license name="Apache 2.0"/>
+    <ivyauthor name="Apache Nutch Team" url="http://nutch.apache.org"/>
+    <description>
+        Apache Nutch
+    </description>
+  </info>
+
+  <configurations>
+    <include file="../../..//ivy/ivy-configurations.xml"/>
+  </configurations>
+
+  <publications>
+    <!--get the artifact from our module name-->
+    <artifact conf="master"/>
+  </publications>
+
+
+  <dependencies>
+   <dependency org="org.ccil.cowan.tagsoup" name="tagsoup" rev="1.2.1"/>
+  </dependencies>
+  
+</ivy-module>
diff --git a/src/plugin/parse-xsl/plugin.xml b/src/plugin/parse-xsl/plugin.xml
new file mode 100644
index 0000000..ff14c0a
--- /dev/null
+++ b/src/plugin/parse-xsl/plugin.xml
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ 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.
+-->
+<plugin
+   id="parse-xsl"
+   name="XSL parser"
+   version="1.0.0"
+   provider-name="nutch.org">
+
+   <runtime>
+      <library name="parse-xsl.jar">
+         <export name="*"/>
+      </library>
+   </runtime>
+
+   <requires>
+      <import plugin="nutch-extensionpoints"/>
+      <import plugin="parse-html"/>
+   </requires>
+
+   <extension id="org.apache.nutch.parse"
+              name="Parse XSL Filter"
+              point="org.apache.nutch.parse.HtmlParseFilter">
+      <implementation id="XslParseFilter" class="org.apache.nutch.parse.xsl.XslParseFilter">
+      </implementation>
+   </extension>
+   
+   <extension id="org.apache.nutch.indexer"
+              name="Index XSL Filter"
+              point="org.apache.nutch.indexer.IndexingFilter">
+      <implementation id="XslIndexFilter" class="org.apache.nutch.parse.xsl.XslIndexFilter">
+      </implementation>
+   </extension>
+
+</plugin>
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/RulesManager.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/RulesManager.java
new file mode 100644
index 0000000..6d15c64
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/RulesManager.java
@@ -0,0 +1,161 @@
+package org.apache.nutch.parse.xsl;
+
+import java.io.File;
+import java.util.HashMap;
+
+import javax.xml.bind.JAXB;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.stream.StreamSource;
+
+import org.apache.nutch.parse.xsl.xml.rule.Rules;
+import org.apache.nutch.parse.xsl.xml.rule.TRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This class allows to manage a set of Transformer singletons. It allows to
+ * avoid having several instances of Transformers with XSL to load each time for
+ * performance matter. The decision to use a given Transformer is determined by
+ * a set
+ * DO NOT make this class a singleton otherwise it will produce thread safety problems related to Xsl transformers not thread safe.
+ * @see Transformer
+ * 
+ */
+public class RulesManager {
+
+	/** All the rules used to determine which xsl parser to use */
+	protected Rules rules = null;
+
+	/** A map containing all transformers given their file name as key */
+	protected HashMap<String, Transformer> transformers;
+
+	/** The XSLT file to use for transformation */
+	public static final String CONF_XML_RULES = "parser.xsl.rulesFile";
+
+	private static final Logger LOG = LoggerFactory.getLogger(RulesManager.class);
+
+	/**
+	 * Default constructor forbidden.
+	 */
+	private RulesManager() {
+		super();
+	}
+
+	/**
+	 * Instanciates an object using the apache nutch configuration (that
+	 * contains the property defining the rules).
+	 * 
+	 * @param rulesFile the rules file to use
+	 * @throws Exception
+	 */
+	public RulesManager(String rulesFile) throws Exception {
+		super();
+
+		if (rulesFile == null)
+			throw new Exception("The rules file shall be set in your configuration file");
+
+		// Loading rules object
+		try {
+			this.rules = JAXB.unmarshal(new File(rulesFile), Rules.class);
+		} catch (Exception e) {
+			throw new Exception("Cannot load the rules file, please check it.", e);
+		}
+
+	}
+
+	/**
+	 * 
+	 * @param url
+	 *            the url to filter
+	 * @return the transformer file path that suits the rules
+	 * @throws Exception
+	 */
+	public String getTransformerFilePath(String url) throws Exception {
+		String xslFile = null;
+
+		if (url == null)
+			throw new Exception("Cannot get transformer for a null url");
+
+		// Search for a matching rule by applying defined regex
+		// The first matching rule will be applied
+		for (TRule rule : this.rules.getRule()) {
+			if (url.matches(rule.getMatches())) {
+				if (LOG.isDebugEnabled()) {
+					LOG.debug(String.format("Url %s is matching regex rule %s", url, rule.getMatches()));
+				}
+				xslFile = rule.getTransformer().getFile();
+
+				break;
+			}
+		}
+		if (xslFile == null) {
+			throw new Exception("No filter found for url: " + url);
+		}
+
+		return xslFile;
+	}
+
+	/**
+	 * 
+	 * @param url
+	 *            the url to filter
+	 * @return the transformer that suits the rules
+	 * @throws Exception
+	 */
+	public Transformer getTransformer(String url) throws Exception {
+		Transformer transformer = null;
+		String xslFile = this.getTransformerFilePath(url);
+		if (xslFile != null) {
+			// Creating map if needed
+			if (this.transformers == null) {
+				this.transformers = new HashMap<String, Transformer>();
+			}
+			transformer = this.transformers.get(xslFile);
+			// Getting xsl file
+			if (transformer == null) {
+				transformer = createTransformer(xslFile);
+				this.transformers.put(xslFile, transformer);
+			}
+
+		}
+		return transformer;
+	}
+
+	/**
+	 * 
+	 * @param url
+	 *            the url to test match in rules file
+	 * @return true if the url is matching a rule.
+	 * @throws Exception
+	 */
+	public boolean matches(String url) throws Exception {
+		return this.getTransformerFilePath(url) != null;
+	}
+
+	/**
+	 * 
+	 * @param xslFile
+	 *            the path of the xsl file to load
+	 * @return the transformer corresponding to the xsl file
+	 * @throws Exception
+	 */
+	private Transformer createTransformer(String xslFile) throws Exception {
+		Transformer transformer = null;
+		try {
+			transformer = TransformerFactory.newInstance().newTransformer(new StreamSource(xslFile));
+		} catch (Exception e) {
+			throw new Exception("Cannot create transformer for xsl file " + xslFile, e);
+		}
+		return transformer;
+	}
+	
+	
+	/**
+	 * @return the current set of rules defined in the xml file
+	 */
+	public Rules getRules() {
+		return rules;
+	}
+
+}
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/XslIndexFilter.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/XslIndexFilter.java
new file mode 100644
index 0000000..c62eaa3
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/XslIndexFilter.java
@@ -0,0 +1,157 @@
+package org.apache.nutch.parse.xsl;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.Text;
+import org.apache.nutch.crawl.CrawlDatum;
+import org.apache.nutch.crawl.Inlinks;
+import org.apache.nutch.indexer.IndexingException;
+import org.apache.nutch.indexer.IndexingFilter;
+import org.apache.nutch.indexer.NutchDocument;
+import org.apache.nutch.parse.Parse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.NodeList;
+
+import com.sun.org.apache.xpath.internal.XPathAPI;
+
+/**
+ * This class allows to:
+ * <ul>
+ * <li>index automatically fields defined in rules file.
+ * <li>exlude urls that are not declared in the rules file.
+ */
+public class XslIndexFilter implements IndexingFilter {
+
+	private static final String NAME_ATTRIBUTE = "name";
+
+	private static final String FIELD_TAG = "//field";
+
+	private Configuration conf;
+
+	private static final Logger LOG = LoggerFactory.getLogger(XslParseFilter.class);
+
+	private static HashMap<String, List<String>> transformers = new HashMap<String, List<String>>();
+
+	// Rules file to use
+	private String rulesFile;
+
+	/**
+	 * @return the current configuration.
+	 */
+	@Override
+	public Configuration getConf() {
+		return this.conf;
+	}
+
+	/**
+	 * Sets the current configuration.
+	 */
+	@Override
+	public void setConf(Configuration conf) {
+		this.conf = conf;
+
+		// Getting rules file
+		this.rulesFile = this.conf.get(RulesManager.CONF_XML_RULES);
+	}
+
+	@Override
+	public NutchDocument filter(NutchDocument doc, Parse parse, Text url, CrawlDatum datum, Inlinks inlinks) throws IndexingException {
+
+		NutchDocument result = null;
+		if (doc == null)
+			return result;
+
+		try {
+
+			// Rules manager that contains url corresponding transformer.
+			RulesManager manager = new RulesManager(this.rulesFile);
+
+			// Getting transformer file path associated to rule if exists
+			String xsltFilePath = null;
+			try {
+				xsltFilePath = manager.getTransformerFilePath(url.toString());
+			} catch (Exception e) {
+				LOG.info("Xslt not found");
+			}
+
+			// The url matches a rule, we keep it
+			if (xsltFilePath != null) {
+				// We keep the document
+				result = doc;
+				List<String> fields = XslIndexFilter.transformers.get(xsltFilePath);
+				// List was never loaded
+				if (fields == null) {
+					fields = this.extractFields(xsltFilePath);
+				}
+
+				// All the fields defined in the xsl file will be put directly
+				// into the nutch document
+				// Fields defined by the xsl plugin are only stored in parse
+				// meta.
+				if (parse != null && parse.getData() != null && parse.getData().getParseMeta() != null) {
+					for (String field : fields) {
+						String value = parse.getData().getParseMeta().get(field);
+						doc.add(field, value);
+					}
+				}
+
+			}
+			// The document is indexed anyway because explicitly decided
+			else if (!manager.getRules().isFilterUrlsWithNoRule()) {
+				result = doc;
+				LOG.info("The url " + url.toString() + " has been kept because it has been explicitly specified in the rules");
+			}
+			// The document is not indexed
+			else {
+				LOG.info("The url " + url.toString() + " has been filtered because no xsl file fits the defined rules");
+			}
+
+		} catch (Exception e) {
+			String message = "Cannot index data";
+			if (url != null && url.toString() != null) {
+				message += " from " + url.toString();
+			}
+			LOG.error(message, e);
+		}
+
+		return result;
+	}
+
+	/**
+	 * 
+	 * @param xsltFilePath
+	 *            the path of the xsl file
+	 * @return the list of fields defined in xsl file
+	 * @throws Exception
+	 */
+	protected List<String> extractFields(String xsltFilePath) throws Exception {
+		List<String> fields = new ArrayList<String>();
+		// Creating xsl DOM document
+		Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new File(xsltFilePath));
+		NodeList list = XPathAPI.selectNodeList(document, FIELD_TAG);
+		HashSet<String> hashedFields = new HashSet<String>();
+		// Populating list
+		for (int i = 0; i < list.getLength(); i++) {
+			NamedNodeMap attributes = list.item(i).getAttributes();
+			if (attributes != null && attributes.getNamedItem(NAME_ATTRIBUTE) != null) {
+				hashedFields.add(attributes.getNamedItem(NAME_ATTRIBUTE).getNodeValue());
+			}
+		}
+		// Keeps list
+		fields.addAll(hashedFields);
+		XslIndexFilter.transformers.put(xsltFilePath, fields);
+
+		return fields;
+	}
+
+}
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/XslParseFilter.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/XslParseFilter.java
new file mode 100644
index 0000000..4f6a47b
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/XslParseFilter.java
@@ -0,0 +1,260 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * 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.apache.nutch.parse.xsl;
+
+import java.io.File;
+import java.io.FileOutputStream;
+
+import javax.xml.bind.JAXB;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMResult;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.nutch.parse.HTMLMetaTags;
+import org.apache.nutch.parse.HtmlParseFilter;
+import org.apache.nutch.parse.Parse;
+import org.apache.nutch.parse.ParseResult;
+import org.apache.nutch.parse.xsl.xml.document.Documents;
+import org.apache.nutch.parse.xsl.xml.document.TDocument;
+import org.apache.nutch.parse.xsl.xml.document.TField;
+import org.apache.nutch.protocol.Content;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.DocumentFragment;
+import org.w3c.dom.Node;
+
+import com.sun.org.apache.xpath.internal.XPathAPI;
+
+/**
+ * This is a parse filter plugin (@see HtmlParseFilter) A class to apply an xsl
+ * transformation on an html page. Instead of coding java, a simple xpath can be
+ * used.
+ * 
+ */
+public class XslParseFilter implements HtmlParseFilter {
+
+	/** Specifies wether to use html parse TagSoup or NekoHtml */
+	public enum PARSER {
+		/** TagSoup parser */
+		TAGSOUP {
+			@Override
+			public String toString() {
+				return "tagsoup";
+			}
+		},
+		/** Neko parser */
+		NEKO {
+			@Override
+			public String toString() {
+				return "neko";
+			}
+		}
+	}
+
+	/**
+	 * The output of the tranformation for debug purpose (log level "DEBUG"
+	 * shall be activated)
+	 */
+	public static final String CONF_XSLT_OUTPUT_DEBUG_FILE = "parser.xsl.output.debug.file";
+
+	/** Wether to use Saxon or Standard JVM XSLT parser */
+	public static final String CONF_XSLT_USE_SAXON = "parser.xsl.useSaxon";
+
+	/**
+	 * Wether to use Neko or Tagsoup.
+	 * 
+	 * @Warning this configuration property is set by nutch and not by the
+	 *          current plugin. see HtmlParser
+	 */
+	public static final String CONF_HTML_PARSER = "parser.html.impl";
+
+	private static final Logger LOG = LoggerFactory.getLogger(XslParseFilter.class);
+
+	private Configuration conf;
+
+	// The html parser to use (default is neko. Otherwise Tag Soup)
+	private String parser;
+	// The xsl parser to use (default from jvm or Saxon)
+	private boolean ifSaxonParser;
+	// Rules file to use
+	private String rulesFile;
+	// Debug file to use
+	private String debugFile;
+
+	/**
+	 * Default constructor forbidden.
+	 */
+	public XslParseFilter() {
+		super();
+	}
+
+	/**
+	 * @param content
+	 *            full content to parse
+	 * @param parseResult
+	 *            result of the parse process
+	 * @param metaTags
+	 *            metatags set in the document
+	 * @param document
+	 *            the DOM document to parse
+	 * @return the resulting {@link ParseResult}
+	 */
+	@Override
+	public ParseResult filter(Content content, ParseResult parseResult, HTMLMetaTags metaTags, DocumentFragment document) {
+
+		try {
+			// We are selecting the HTML tag with a XPath to convert the
+			// DocumentFragment to a more natural
+			// HTML document that can be further processed with XSL.
+			// TODO applying an "html" xpath is a dirty trick to change.
+			String xpath = "html";
+
+			// For neko, all tags are UPPER CASE.
+			// For tagsoup, it is in lower case.
+			// This is decided by the html parser plugin
+			if (this.parser.equals(PARSER.NEKO.toString())) {
+				xpath = xpath.toUpperCase();
+			} else {
+				// TODO Tag soup is not working. To be investigated.
+				throw new Exception("tag soup parser not implemented.");
+			}
+
+			Node doc = XPathAPI.selectSingleNode(document, xpath);
+
+			Parse parse = parseResult.get(content.getUrl());
+
+			// TODO: use saxon for xslt 2.0 compliancy
+			if (this.ifSaxonParser) {
+				System.setProperty("javax.xml.transform.TransformerFactory", "net.sf.saxon.TransformerFactoryImpl");
+			}
+
+			// Rules manager that contains url corresponding transformer.
+			RulesManager manager = new RulesManager(this.rulesFile);
+
+			DOMResult result = new DOMResult();
+			// At this state, thanks to the HtmlParser that is using
+			// HtmlParseFilter interface, we got
+			// a DOM object properly built (with Neko or TagSoup).
+			manager.getTransformer(content.getUrl()).transform(new DOMSource(doc), result);
+
+			// Storing the xml output for debug purpose
+			if (LOG.isDebugEnabled() && this.debugFile != null) {
+				XslParseFilter.saveDOMOutput(result.getNode(), new File(debugFile));
+			}
+
+			XslParseFilter.updateMetadata(result.getNode(), parse);
+
+		} catch (Exception e) {
+			LOG.warn("Cannot extract HTML tags. The XSL processing will not be run.", e);
+		}
+
+		return parseResult;
+	}
+
+	/**
+	 * @param node
+	 *            the node that is used to provide metadata information.
+	 * @param data
+	 *            the data to update This is a simple format like the following:
+	 *            Check the documents.xsd to figure out the structure.
+	 */
+	protected static void updateMetadata(Node node, Parse data) {
+
+		Documents documents = JAXB.unmarshal(new DOMSource(node), Documents.class);
+
+		// No document unmarshalled
+		if (documents == null) {
+			LOG.debug("No metadata to update");
+			return;
+		}
+
+		// Browsing documents
+		for (TDocument document : documents.getDocument()) {
+
+			// There are metadata to process
+			for (TField field : document.getField()) {
+				String value = field.getValue();
+				// Trim values by default
+				if (value != null) {
+					value = value.trim();
+					// Do not keep string with 0 size
+					if (value.length() != 0) {
+						// Adds the meta to the parse meta list
+						data.getData().getParseMeta().add(field.getName(), value);
+					}
+					if (LOG.isDebugEnabled())
+						LOG.debug("Content " + field.getName() + " has value: '" + value + "'");
+				}
+			}
+		}
+
+	}
+
+	/**
+	 * 
+	 * @param node
+	 *            the DOM node to save.
+	 * @param file
+	 *            the file where to write the DOM.
+	 */
+	private static void saveDOMOutput(Node node, File file) {
+		FileOutputStream fos = null;
+
+		try {
+			fos = new FileOutputStream(file);
+
+			TransformerFactory.newInstance().newTransformer().transform(new DOMSource(node), new StreamResult(fos));
+		} catch (Exception e) {
+			LOG.warn("Cannot store DOM node to file: " + file.getAbsolutePath(), e);
+		} finally {
+			if (fos != null)
+				try {
+					fos.close();
+				} catch (Exception e) {
+					LOG.warn("Cannot close xml file stream.", e);
+				}
+		}
+	}
+
+	/**
+	 * @param conf
+	 *            the configuration file to load.
+	 */
+	@Override
+	public void setConf(Configuration conf) {
+		this.conf = conf;
+
+		// Setting the parser from conf
+		this.parser = this.conf.get(CONF_HTML_PARSER, PARSER.NEKO.toString());
+		// Setting the parser to use from conf
+		this.ifSaxonParser = this.conf.getBoolean(CONF_XSLT_USE_SAXON, false);
+		// Getting rules file
+		this.rulesFile = this.conf.get(RulesManager.CONF_XML_RULES);
+		// Debug file to use
+		this.debugFile = this.conf.get(CONF_XSLT_OUTPUT_DEBUG_FILE);
+	}
+
+	/**
+	 * @return the current configuration.
+	 */
+	@Override
+	public Configuration getConf() {
+		return this.conf;
+	}
+}
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/Documents.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/Documents.java
new file mode 100644
index 0000000..df92b83
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/Documents.java
@@ -0,0 +1,76 @@
+//
+// Ce fichier a été généré par l'implémentation de référence JavaTM Architecture for XML Binding (JAXB), v2.2.7 
+// Voir <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+// Toute modification apportée à ce fichier sera perdue lors de la recompilation du schéma source. 
+// Généré le : 2014.10.17 à 09:35:13 PM CEST 
+//
+
+
+package org.apache.nutch.parse.xsl.xml.document;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlType;
+
+
+/**
+ * <p>Classe Java pour anonymous complex type.
+ * 
+ * <p>Le fragment de schéma suivant indique le contenu attendu figurant dans cette classe.
+ * 
+ * <pre>
+ * &lt;complexType>
+ *   &lt;complexContent>
+ *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
+ *       &lt;sequence maxOccurs="unbounded" minOccurs="0">
+ *         &lt;element name="document" type="{http://www.example.org/documents/}TDocument"/>
+ *       &lt;/sequence>
+ *     &lt;/restriction>
+ *   &lt;/complexContent>
+ * &lt;/complexType>
+ * </pre>
+ * 
+ * 
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "", propOrder = {
+    "document"
+})
+@XmlRootElement(name = "documents")
+public class Documents {
+
+    protected List<TDocument> document;
+
+    /**
+     * Gets the value of the document property.
+     * 
+     * <p>
+     * This accessor method returns a reference to the live list,
+     * not a snapshot. Therefore any modification you make to the
+     * returned list will be present inside the JAXB object.
+     * This is why there is not a <CODE>set</CODE> method for the document property.
+     * 
+     * <p>
+     * For example, to add a new item, do as follows:
+     * <pre>
+     *    getDocument().add(newItem);
+     * </pre>
+     * 
+     * 
+     * <p>
+     * Objects of the following type(s) are allowed in the list
+     * {@link TDocument }
+     * 
+     * 
+     */
+    public List<TDocument> getDocument() {
+        if (document == null) {
+            document = new ArrayList<TDocument>();
+        }
+        return this.document;
+    }
+
+}
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/ObjectFactory.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/ObjectFactory.java
new file mode 100644
index 0000000..fc047c0
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/ObjectFactory.java
@@ -0,0 +1,63 @@
+//
+// Ce fichier a été généré par l'implémentation de référence JavaTM Architecture for XML Binding (JAXB), v2.2.7 
+// Voir <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+// Toute modification apportée à ce fichier sera perdue lors de la recompilation du schéma source. 
+// Généré le : 2014.10.17 à 09:35:13 PM CEST 
+//
+
+
+package org.apache.nutch.parse.xsl.xml.document;
+
+import javax.xml.bind.annotation.XmlRegistry;
+
+
+/**
+ * This object contains factory methods for each 
+ * Java content interface and Java element interface 
+ * generated in the org.apache.nutch.parse.xsl.xml.document package. 
+ * <p>An ObjectFactory allows you to programatically 
+ * construct new instances of the Java representation 
+ * for XML content. The Java representation of XML 
+ * content can consist of schema derived interfaces 
+ * and classes representing the binding of schema 
+ * type definitions, element declarations and model 
+ * groups.  Factory methods for each of these are 
+ * provided in this class.
+ * 
+ */
+@XmlRegistry
+public class ObjectFactory {
+
+
+    /**
+     * Create a new ObjectFactory that can be used to create new instances of schema derived classes for package: org.apache.nutch.parse.xsl.xml.document
+     * 
+     */
+    public ObjectFactory() {
+    }
+
+    /**
+     * Create an instance of {@link Documents }
+     * 
+     */
+    public Documents createDocuments() {
+        return new Documents();
+    }
+
+    /**
+     * Create an instance of {@link TDocument }
+     * 
+     */
+    public TDocument createTDocument() {
+        return new TDocument();
+    }
+
+    /**
+     * Create an instance of {@link TField }
+     * 
+     */
+    public TField createTField() {
+        return new TField();
+    }
+
+}
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/TDocument.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/TDocument.java
new file mode 100644
index 0000000..760acaa
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/TDocument.java
@@ -0,0 +1,74 @@
+//
+// Ce fichier a été généré par l'implémentation de référence JavaTM Architecture for XML Binding (JAXB), v2.2.7 
+// Voir <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+// Toute modification apportée à ce fichier sera perdue lors de la recompilation du schéma source. 
+// Généré le : 2014.10.17 à 09:35:13 PM CEST 
+//
+
+
+package org.apache.nutch.parse.xsl.xml.document;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+
+/**
+ * <p>Classe Java pour TDocument complex type.
+ * 
+ * <p>Le fragment de schéma suivant indique le contenu attendu figurant dans cette classe.
+ * 
+ * <pre>
+ * &lt;complexType name="TDocument">
+ *   &lt;complexContent>
+ *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
+ *       &lt;sequence maxOccurs="unbounded" minOccurs="0">
+ *         &lt;element name="field" type="{http://www.example.org/documents/}TField"/>
+ *       &lt;/sequence>
+ *     &lt;/restriction>
+ *   &lt;/complexContent>
+ * &lt;/complexType>
+ * </pre>
+ * 
+ * 
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "TDocument", propOrder = {
+    "field"
+})
+public class TDocument {
+
+    protected List<TField> field;
+
+    /**
+     * Gets the value of the field property.
+     * 
+     * <p>
+     * This accessor method returns a reference to the live list,
+     * not a snapshot. Therefore any modification you make to the
+     * returned list will be present inside the JAXB object.
+     * This is why there is not a <CODE>set</CODE> method for the field property.
+     * 
+     * <p>
+     * For example, to add a new item, do as follows:
+     * <pre>
+     *    getField().add(newItem);
+     * </pre>
+     * 
+     * 
+     * <p>
+     * Objects of the following type(s) are allowed in the list
+     * {@link TField }
+     * 
+     * 
+     */
+    public List<TField> getField() {
+        if (field == null) {
+            field = new ArrayList<TField>();
+        }
+        return this.field;
+    }
+
+}
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/TField.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/TField.java
new file mode 100644
index 0000000..6b62a23
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/TField.java
@@ -0,0 +1,94 @@
+//
+// Ce fichier a été généré par l'implémentation de référence JavaTM Architecture for XML Binding (JAXB), v2.2.7 
+// Voir <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+// Toute modification apportée à ce fichier sera perdue lors de la recompilation du schéma source. 
+// Généré le : 2014.10.17 à 09:35:13 PM CEST 
+//
+
+
+package org.apache.nutch.parse.xsl.xml.document;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.XmlValue;
+
+
+/**
+ * <p>Classe Java pour TField complex type.
+ * 
+ * <p>Le fragment de schéma suivant indique le contenu attendu figurant dans cette classe.
+ * 
+ * <pre>
+ * &lt;complexType name="TField">
+ *   &lt;simpleContent>
+ *     &lt;extension base="&lt;http://www.w3.org/2001/XMLSchema>string">
+ *       &lt;attribute name="name" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *     &lt;/extension>
+ *   &lt;/simpleContent>
+ * &lt;/complexType>
+ * </pre>
+ * 
+ * 
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "TField", propOrder = {
+    "value"
+})
+public class TField {
+
+    @XmlValue
+    protected String value;
+    @XmlAttribute(name = "name")
+    protected String name;
+
+    /**
+     * Obtient la valeur de la propriété value.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getValue() {
+        return value;
+    }
+
+    /**
+     * Définit la valeur de la propriété value.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    /**
+     * Obtient la valeur de la propriété name.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Définit la valeur de la propriété name.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setName(String value) {
+        this.name = value;
+    }
+
+}
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/package-info.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/package-info.java
new file mode 100644
index 0000000..5210dd4
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/document/package-info.java
@@ -0,0 +1,9 @@
+//
+// Ce fichier a été généré par l'implémentation de référence JavaTM Architecture for XML Binding (JAXB), v2.2.7 
+// Voir <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+// Toute modification apportée à ce fichier sera perdue lors de la recompilation du schéma source. 
+// Généré le : 2014.10.17 à 09:35:13 PM CEST 
+//
+
+@javax.xml.bind.annotation.XmlSchema(namespace = "http://www.example.org/documents/")
+package org.apache.nutch.parse.xsl.xml.document;
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/ObjectFactory.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/ObjectFactory.java
new file mode 100644
index 0000000..adcfac2
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/ObjectFactory.java
@@ -0,0 +1,63 @@
+//
+// Ce fichier a été généré par l'implémentation de référence JavaTM Architecture for XML Binding (JAXB), v2.2.7 
+// Voir <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+// Toute modification apportée à ce fichier sera perdue lors de la recompilation du schéma source. 
+// Généré le : 2014.10.17 à 09:35:14 PM CEST 
+//
+
+
+package org.apache.nutch.parse.xsl.xml.rule;
+
+import javax.xml.bind.annotation.XmlRegistry;
+
+
+/**
+ * This object contains factory methods for each 
+ * Java content interface and Java element interface 
+ * generated in the org.apache.nutch.parse.xsl.xml.rule package. 
+ * <p>An ObjectFactory allows you to programatically 
+ * construct new instances of the Java representation 
+ * for XML content. The Java representation of XML 
+ * content can consist of schema derived interfaces 
+ * and classes representing the binding of schema 
+ * type definitions, element declarations and model 
+ * groups.  Factory methods for each of these are 
+ * provided in this class.
+ * 
+ */
+@XmlRegistry
+public class ObjectFactory {
+
+
+    /**
+     * Create a new ObjectFactory that can be used to create new instances of schema derived classes for package: org.apache.nutch.parse.xsl.xml.rule
+     * 
+     */
+    public ObjectFactory() {
+    }
+
+    /**
+     * Create an instance of {@link Rules }
+     * 
+     */
+    public Rules createRules() {
+        return new Rules();
+    }
+
+    /**
+     * Create an instance of {@link TRule }
+     * 
+     */
+    public TRule createTRule() {
+        return new TRule();
+    }
+
+    /**
+     * Create an instance of {@link TTransformer }
+     * 
+     */
+    public TTransformer createTTransformer() {
+        return new TTransformer();
+    }
+
+}
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/Rules.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/Rules.java
new file mode 100644
index 0000000..71a7774
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/Rules.java
@@ -0,0 +1,110 @@
+//
+// Ce fichier a été généré par l'implémentation de référence JavaTM Architecture for XML Binding (JAXB), v2.2.7 
+// Voir <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+// Toute modification apportée à ce fichier sera perdue lors de la recompilation du schéma source. 
+// Généré le : 2014.10.17 à 09:35:14 PM CEST 
+//
+
+
+package org.apache.nutch.parse.xsl.xml.rule;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlType;
+
+
+/**
+ * <p>Classe Java pour anonymous complex type.
+ * 
+ * <p>Le fragment de schéma suivant indique le contenu attendu figurant dans cette classe.
+ * 
+ * <pre>
+ * &lt;complexType>
+ *   &lt;complexContent>
+ *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
+ *       &lt;sequence maxOccurs="unbounded">
+ *         &lt;element name="rule" type="{http://www.example.org/rules/}TRule"/>
+ *       &lt;/sequence>
+ *       &lt;attribute name="filterUrlsWithNoRule" type="{http://www.w3.org/2001/XMLSchema}boolean" default="true" />
+ *     &lt;/restriction>
+ *   &lt;/complexContent>
+ * &lt;/complexType>
+ * </pre>
+ * 
+ * 
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "", propOrder = {
+    "rule"
+})
+@XmlRootElement(name = "rules")
+public class Rules {
+
+    @XmlElement(required = true)
+    protected List<TRule> rule;
+    @XmlAttribute(name = "filterUrlsWithNoRule")
+    protected Boolean filterUrlsWithNoRule;
+
+    /**
+     * Gets the value of the rule property.
+     * 
+     * <p>
+     * This accessor method returns a reference to the live list,
+     * not a snapshot. Therefore any modification you make to the
+     * returned list will be present inside the JAXB object.
+     * This is why there is not a <CODE>set</CODE> method for the rule property.
+     * 
+     * <p>
+     * For example, to add a new item, do as follows:
+     * <pre>
+     *    getRule().add(newItem);
+     * </pre>
+     * 
+     * 
+     * <p>
+     * Objects of the following type(s) are allowed in the list
+     * {@link TRule }
+     * 
+     * 
+     */
+    public List<TRule> getRule() {
+        if (rule == null) {
+            rule = new ArrayList<TRule>();
+        }
+        return this.rule;
+    }
+
+    /**
+     * Obtient la valeur de la propriété filterUrlsWithNoRule.
+     * 
+     * @return
+     *     possible object is
+     *     {@link Boolean }
+     *     
+     */
+    public boolean isFilterUrlsWithNoRule() {
+        if (filterUrlsWithNoRule == null) {
+            return true;
+        } else {
+            return filterUrlsWithNoRule;
+        }
+    }
+
+    /**
+     * Définit la valeur de la propriété filterUrlsWithNoRule.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link Boolean }
+     *     
+     */
+    public void setFilterUrlsWithNoRule(Boolean value) {
+        this.filterUrlsWithNoRule = value;
+    }
+
+}
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/TRule.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/TRule.java
new file mode 100644
index 0000000..4f73d76
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/TRule.java
@@ -0,0 +1,97 @@
+//
+// Ce fichier a été généré par l'implémentation de référence JavaTM Architecture for XML Binding (JAXB), v2.2.7 
+// Voir <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+// Toute modification apportée à ce fichier sera perdue lors de la recompilation du schéma source. 
+// Généré le : 2014.10.17 à 09:35:14 PM CEST 
+//
+
+
+package org.apache.nutch.parse.xsl.xml.rule;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+
+/**
+ * <p>Classe Java pour TRule complex type.
+ * 
+ * <p>Le fragment de schéma suivant indique le contenu attendu figurant dans cette classe.
+ * 
+ * <pre>
+ * &lt;complexType name="TRule">
+ *   &lt;complexContent>
+ *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
+ *       &lt;sequence>
+ *         &lt;element name="transformer" type="{http://www.example.org/rules/}TTransformer"/>
+ *       &lt;/sequence>
+ *       &lt;attribute name="matches" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *     &lt;/restriction>
+ *   &lt;/complexContent>
+ * &lt;/complexType>
+ * </pre>
+ * 
+ * 
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "TRule", propOrder = {
+    "transformer"
+})
+public class TRule {
+
+    @XmlElement(required = true)
+    protected TTransformer transformer;
+    @XmlAttribute(name = "matches", required = true)
+    protected String matches;
+
+    /**
+     * Obtient la valeur de la propriété transformer.
+     * 
+     * @return
+     *     possible object is
+     *     {@link TTransformer }
+     *     
+     */
+    public TTransformer getTransformer() {
+        return transformer;
+    }
+
+    /**
+     * Définit la valeur de la propriété transformer.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link TTransformer }
+     *     
+     */
+    public void setTransformer(TTransformer value) {
+        this.transformer = value;
+    }
+
+    /**
+     * Obtient la valeur de la propriété matches.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getMatches() {
+        return matches;
+    }
+
+    /**
+     * Définit la valeur de la propriété matches.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setMatches(String value) {
+        this.matches = value;
+    }
+
+}
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/TTransform.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/TTransform.java
new file mode 100644
index 0000000..e6fd7ef
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/TTransform.java
@@ -0,0 +1,94 @@
+//
+// Ce fichier a été généré par l'implémentation de référence JavaTM Architecture for XML Binding (JAXB), v2.2.7 
+// Voir <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+// Toute modification apportée à ce fichier sera perdue lors de la recompilation du schéma source. 
+// Généré le : 2014.09.12 à 01:12:06 PM CEST 
+//
+
+
+package org.apache.nutch.parse.xsl.xml.rule;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.XmlValue;
+
+
+/**
+ * <p>Classe Java pour TTransform complex type.
+ * 
+ * <p>Le fragment de schéma suivant indique le contenu attendu figurant dans cette classe.
+ * 
+ * <pre>
+ * &lt;complexType name="TTransform">
+ *   &lt;simpleContent>
+ *     &lt;extension base="&lt;http://www.w3.org/2001/XMLSchema>string">
+ *       &lt;attribute name="file" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *     &lt;/extension>
+ *   &lt;/simpleContent>
+ * &lt;/complexType>
+ * </pre>
+ * 
+ * 
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "TTransform", propOrder = {
+    "value"
+})
+public class TTransform {
+
+    @XmlValue
+    protected String value;
+    @XmlAttribute(name = "file", required = true)
+    protected String file;
+
+    /**
+     * Obtient la valeur de la propriété value.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getValue() {
+        return value;
+    }
+
+    /**
+     * Définit la valeur de la propriété value.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    /**
+     * Obtient la valeur de la propriété file.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getFile() {
+        return file;
+    }
+
+    /**
+     * Définit la valeur de la propriété file.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setFile(String value) {
+        this.file = value;
+    }
+
+}
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/TTransformer.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/TTransformer.java
new file mode 100644
index 0000000..4233f44
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/TTransformer.java
@@ -0,0 +1,94 @@
+//
+// Ce fichier a été généré par l'implémentation de référence JavaTM Architecture for XML Binding (JAXB), v2.2.7 
+// Voir <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+// Toute modification apportée à ce fichier sera perdue lors de la recompilation du schéma source. 
+// Généré le : 2014.10.17 à 09:35:14 PM CEST 
+//
+
+
+package org.apache.nutch.parse.xsl.xml.rule;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.XmlValue;
+
+
+/**
+ * <p>Classe Java pour TTransformer complex type.
+ * 
+ * <p>Le fragment de schéma suivant indique le contenu attendu figurant dans cette classe.
+ * 
+ * <pre>
+ * &lt;complexType name="TTransformer">
+ *   &lt;simpleContent>
+ *     &lt;extension base="&lt;http://www.w3.org/2001/XMLSchema>string">
+ *       &lt;attribute name="file" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *     &lt;/extension>
+ *   &lt;/simpleContent>
+ * &lt;/complexType>
+ * </pre>
+ * 
+ * 
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "TTransformer", propOrder = {
+    "value"
+})
+public class TTransformer {
+
+    @XmlValue
+    protected String value;
+    @XmlAttribute(name = "file", required = true)
+    protected String file;
+
+    /**
+     * Obtient la valeur de la propriété value.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getValue() {
+        return value;
+    }
+
+    /**
+     * Définit la valeur de la propriété value.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    /**
+     * Obtient la valeur de la propriété file.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getFile() {
+        return file;
+    }
+
+    /**
+     * Définit la valeur de la propriété file.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setFile(String value) {
+        this.file = value;
+    }
+
+}
diff --git a/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/package-info.java b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/package-info.java
new file mode 100644
index 0000000..b6dca9b
--- /dev/null
+++ b/src/plugin/parse-xsl/src/java/org/apache/nutch/parse/xsl/xml/rule/package-info.java
@@ -0,0 +1,9 @@
+//
+// Ce fichier a été généré par l'implémentation de référence JavaTM Architecture for XML Binding (JAXB), v2.2.7 
+// Voir <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+// Toute modification apportée à ce fichier sera perdue lors de la recompilation du schéma source. 
+// Généré le : 2014.10.17 à 09:35:14 PM CEST 
+//
+
+@javax.xml.bind.annotation.XmlSchema(namespace = "http://www.example.org/rules/")
+package org.apache.nutch.parse.xsl.xml.rule;
diff --git a/src/plugin/parse-xsl/src/tests/files/sample1/book1.html b/src/plugin/parse-xsl/src/tests/files/sample1/book1.html
new file mode 100644
index 0000000..fb8a491
--- /dev/null
+++ b/src/plugin/parse-xsl/src/tests/files/sample1/book1.html
@@ -0,0 +1,38 @@
+<html>
+<!-- This is a fake page built to show you how to extract metadata given the parse-xsl plugin 
+To see how the job is done please refer to transformer_book.xsl
+-->
+
+<title>Buy Nutch for dummies!</title>
+
+<body>
+
+<!-- Easy data to extract (full data located between tags) -->
+<h1>Nutch for dummies</h1>
+
+<!-- Easy data to extract given a unique attribute value-->
+<div id="description">The ultimate book to master all nutch powerful mechanisms !</div>
+
+<!-- Data to extract after a label string -->
+<div>Isbn: 123654987789</div>
+
+<!-- Etc.. -->
+<ul>Authors
+<li>Mr Allan A.
+<li>Mrs Mulan B.
+</ul>
+<span>Price: free</span>
+
+<div class=".collection">Collection from nowhere</div>
+
+<!-- This to avoid getting authors data without thinking ;) -->
+<ul>Other related books
+<li>Lucene explained to your grandmother
+<li>How I met Solr?
+<li>Feels better with Elastic Search
+</ul>
+
+</body>
+
+
+</html>
\ No newline at end of file
diff --git a/src/plugin/parse-xsl/src/tests/files/sample1/rules.xml b/src/plugin/parse-xsl/src/tests/files/sample1/rules.xml
new file mode 100644
index 0000000..0ed6027
--- /dev/null
+++ b/src/plugin/parse-xsl/src/tests/files/sample1/rules.xml
@@ -0,0 +1,8 @@
+<rules>
+	<!-- When this url matches, the associated transformer is used.
+	If not matching any other page will be ignored (see conf/rules.xsd) -->
+	<rule matches="http://www.sample1.com/book\?\d+" filterUrlsWithNoRule="true">
+		<transformer file="src/plugin/parse-xsl/src/tests/files/sample1/transformer_book.xsl" />
+
+	</rule>
+</rules>
\ No newline at end of file
diff --git a/src/plugin/parse-xsl/src/tests/files/sample1/transformer_book.xsl b/src/plugin/parse-xsl/src/tests/files/sample1/transformer_book.xsl
new file mode 100644
index 0000000..c607880
--- /dev/null
+++ b/src/plugin/parse-xsl/src/tests/files/sample1/transformer_book.xsl
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- This file will transform a book.html to an xml document compounded of 
+	specific fields. Each field will then be indexed (by default) -->
+<xsl:stylesheet version="1.0"
+	xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+
+
+	<xsl:template match="/">
+		<documents>
+			<document>
+
+				<field name="title">
+					<xsl:value-of select="/HTML/BODY/H1" />
+				</field>
+
+				<field name="description">
+					<xsl:value-of select="//DIV[@id='description']" />
+				</field>
+
+				<field name="isbn">
+					<xsl:variable name="fullDivText"
+						select="//DIV[starts-with(text(), 'Isbn:')]/text()" />
+					<xsl:value-of select="substring-after($fullDivText, 'Isbn: ')" />
+				</field>
+
+				<!-- Adding several Author fields -->
+				<xsl:for-each select="/HTML/BODY/UL[starts-with(text(),'Authors')]/LI">
+					<field name="author">
+						<xsl:value-of select="." />
+					</field>
+				</xsl:for-each>
+
+				<field name="price">
+					<xsl:variable name="fullSpanText"
+						select="//SPAN[starts-with(text(), 'Price:')]/text()" />
+					<xsl:value-of select="substring-after($fullSpanText, 'Price: ')" />
+				</field>
+
+				<field name="collection">
+					<xsl:value-of select="//DIV[@class='.collection']" />
+				</field>
+
+
+			</document>
+		</documents>
+	</xsl:template>
+
+</xsl:stylesheet>
\ No newline at end of file
diff --git a/src/plugin/parse-xsl/src/tests/org/apache/nutch/parse/xsl/AbstractCrawlTest.java b/src/plugin/parse-xsl/src/tests/org/apache/nutch/parse/xsl/AbstractCrawlTest.java
new file mode 100644
index 0000000..8592594
--- /dev/null
+++ b/src/plugin/parse-xsl/src/tests/org/apache/nutch/parse/xsl/AbstractCrawlTest.java
@@ -0,0 +1,238 @@
+package org.apache.nutch.parse.xsl;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.text.NumberFormat;
+import java.util.Date;
+
+import junit.framework.TestCase;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.html.dom.HTMLDocumentImpl;
+import org.apache.log4j.PropertyConfigurator;
+import org.apache.nutch.metadata.Metadata;
+import org.apache.nutch.parse.HtmlParseFilter;
+import org.apache.nutch.parse.ParseData;
+import org.apache.nutch.parse.ParseImpl;
+import org.apache.nutch.parse.ParseResult;
+import org.apache.nutch.parse.html.DOMBuilder;
+import org.apache.nutch.parse.xsl.XslParseFilter.PARSER;
+import org.apache.nutch.protocol.Content;
+import org.apache.nutch.util.NutchConfiguration;
+import org.cyberneko.html.parsers.DOMFragmentParser;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.DocumentFragment;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+/**
+ * A class to group all classic methods to simulate a crawl without running
+ * Nutch like setting a configuration, providing a DocumentFragment, etc... All
+ * your tests related to parse-xsl shall extend this test.
+ * 
+ * 
+ */
+public abstract class AbstractCrawlTest extends TestCase {
+
+	/** The logger used for current and derived classes */
+	protected static final Logger LOG = LoggerFactory.getLogger(AbstractCrawlTest.class);
+	
+	static {
+		PropertyConfigurator.configure("conf/log4j.properties");
+	}
+
+	/**
+	 * the configuration to use with current crawler Never access this property. @see
+	 * AbstractCrawlTest#getConfiguration()
+	 */
+	private Configuration configuration = null;
+
+	private long startDate;
+
+	/**
+	 * @param parseFilter
+	 *            the filter to use
+	 * @param filePath
+	 *            the file to crawl
+	 * @param url
+	 *            the url that identifies the file to crawl (only used to set
+	 *            the unique key)
+	 * @return the resulting content after the crawl
+	 * @throws Exception
+	 */
+	protected ParseResult simulateCrawl(PARSER parseFilter, String filePath, String url) throws Exception {
+		ParseResult result = null;
+		FileInputStream is = null;
+		try {
+			// Opening test file
+			File file = new File(filePath);
+			is = new FileInputStream(file);
+			byte[] bytes = new byte[0];
+
+			// config.addResource(new
+			// Path("src/plugin/parse-filter-amisfinder/src/tests/files/configuration.xml"));
+
+			// Setting the void content
+			Content content = new Content(url, "", bytes, "text/html", new Metadata(), this.getConfiguration());
+
+			// Parse document with related parser
+			DocumentFragment document = null;
+			if (parseFilter == PARSER.NEKO) {
+				document = parseNeko(new InputSource(is));
+
+			} else {
+				document = parseTagSoup(new InputSource(is));
+			}
+
+			// Creates a parser with dedicated method
+			HtmlParseFilter filter = new XslParseFilter();
+			// Setting configuration
+			filter.setConf(this.getConfiguration());
+
+			ParseData data = new ParseData();
+
+			// Initializing the parse result
+			ParseResult parseResult = ParseResult.createParseResult(url, new ParseImpl("no text", data));
+
+			// Extracting metadata
+			result = filter.filter(content, parseResult, null, document);
+		} catch (Exception e) {
+			throw new Exception("Cannot simulate crawl", e);
+		} finally {
+			if (is != null) {
+				try {
+					is.close();
+				} catch (IOException e) {
+					LOG.error("Cannot close input stream", e);
+				}
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Constructs a an html DOM structure.
+	 * 
+	 * @param input
+	 *            the html/xml input stream
+	 * @return DocumentFragment the document that has been created.
+	 * @throws Exception
+	 */
+	protected static DocumentFragment parseTagSoup(InputSource input) throws Exception {
+		HTMLDocumentImpl doc = new HTMLDocumentImpl();
+		DocumentFragment frag = doc.createDocumentFragment();
+		DOMBuilder builder = new DOMBuilder(doc, frag);
+		org.ccil.cowan.tagsoup.Parser reader = new org.ccil.cowan.tagsoup.Parser();
+		reader.setContentHandler(builder);
+		reader.setFeature(org.ccil.cowan.tagsoup.Parser.ignoreBogonsFeature, true);
+		reader.setFeature(org.ccil.cowan.tagsoup.Parser.bogonsEmptyFeature, false);
+		reader.setProperty("http://xml.org/sax/properties/lexical-handler", builder);
+		reader.parse(input);
+		return frag;
+	}
+
+	/**
+	 * Constructs a an html DOM structure.
+	 * 
+	 * @param input
+	 *            the html/xml input stream
+	 * @return DocumentFragment the document that has been created.
+	 * @throws Exception
+	 */
+	protected static DocumentFragment parseNeko(InputSource input) throws Exception {
+		DOMFragmentParser parser = new DOMFragmentParser();
+		try {
+			parser.setFeature("http://cyberneko.org/html/features/scanner/allow-selfclosing-iframe", true);
+			parser.setFeature("http://cyberneko.org/html/features/augmentations", true);
+			parser.setProperty("http://cyberneko.org/html/properties/default-encoding", "UTF-8");
+			parser.setFeature("http://cyberneko.org/html/features/scanner/ignore-specified-charset", true);
+			parser.setFeature("http://cyberneko.org/html/features/balance-tags/ignore-outside-content", false);
+			parser.setFeature("http://cyberneko.org/html/features/balance-tags/document-fragment", true);
+			parser.setFeature("http://cyberneko.org/html/features/balance-tags", true);
+			parser.setFeature("http://cyberneko.org/html/features/report-errors", true);
+			parser.setProperty("http://cyberneko.org/html/properties/names/elems", "lower");
+
+			System.out.println(LOG.isTraceEnabled());
+
+		} catch (SAXException e) {
+			LOG.error("Cannot set parser features", e);
+		}
+		// convert Document to DocumentFragment
+		HTMLDocumentImpl doc = new HTMLDocumentImpl();
+		doc.setErrorChecking(false);
+		DocumentFragment res = doc.createDocumentFragment();
+		DocumentFragment frag = doc.createDocumentFragment();
+		parser.parse(input, frag);
+		res.appendChild(frag);
+
+		try {
+			while (true) {
+				frag = doc.createDocumentFragment();
+				parser.parse(input, frag);
+				if (!frag.hasChildNodes())
+					break;
+				// if (LOG.isInfoEnabled()) {
+				LOG.info(" - new frag, " + frag.getChildNodes().getLength() + " nodes.");
+				System.out.println(" - new frag, " + frag.getChildNodes().getLength() + " nodes.");
+				// }
+				res.appendChild(frag);
+			}
+		} catch (Exception e) {
+			LOG.error("Error: ", e);
+			System.out.println(e);
+		}
+
+		return res;
+	}
+
+	/**
+	 * 
+	 * @return the current configuration.
+	 */
+	public Configuration getConfiguration() {
+		if (this.configuration == null) {
+			this.configuration = NutchConfiguration.create();
+		}
+		return this.configuration;
+	}
+
+	/**
+	 * To display some memory related information. Can be used for benchmark
+	 * test
+	 */
+	private void displayMemoryUsage() {
+		Runtime runtime = Runtime.getRuntime();
+
+		NumberFormat format = NumberFormat.getInstance();
+
+		long maxMemory = runtime.maxMemory();
+		long allocatedMemory = runtime.totalMemory();
+		long freeMemory = runtime.freeMemory();
+
+		System.out.println("free memory: " + format.format(freeMemory / 1024));
+		System.out.println("allocated memory: " + format.format(allocatedMemory / 1024));
+		System.out.println("max memory: " + format.format(maxMemory / 1024));
+		System.out.println("total free memory: " + format.format((freeMemory + (maxMemory - allocatedMemory)) / 1024));
+	}
+
+	/**
+	 * Can be called before each test to get the run test date.
+	 */
+	protected void startTest() {
+		System.out.println("Starting test...");
+		this.displayMemoryUsage();
+		this.startDate = new Date().getTime();
+	}
+
+	/**
+	 * Can be called at the end of a test to evaluate the elapsed time.
+	 */
+	private void endTest() {
+		this.displayMemoryUsage();
+		System.out.println("Test took " + (new Date().getTime() - this.startDate) + " ms");
+		System.out.println("Test ended.");
+	}
+
+}
diff --git a/src/plugin/parse-xsl/src/tests/org/apache/nutch/parse/xsl/ParseTechnicalTests.java b/src/plugin/parse-xsl/src/tests/org/apache/nutch/parse/xsl/ParseTechnicalTests.java
new file mode 100644
index 0000000..b555915
--- /dev/null
+++ b/src/plugin/parse-xsl/src/tests/org/apache/nutch/parse/xsl/ParseTechnicalTests.java
@@ -0,0 +1,59 @@
+package org.apache.nutch.parse.xsl;
+
+import java.io.FileReader;
+
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathFactory;
+
+import org.w3c.dom.DocumentFragment;
+import org.w3c.dom.NodeList;
+import org.xml.sax.InputSource;
+
+/**
+ *  
+ */
+public class ParseTechnicalTests extends AbstractCrawlTest {
+
+	/**
+	 * Executes some xpath on neko parsed document
+	 */
+	public void testXpathNeko() {
+		try {
+			DocumentFragment doc = parseNeko(new InputSource(new FileReader("src/plugin/parse-xsl/src/tests/files/sample1/book1.html")));
+			XPath xpath = XPathFactory.newInstance().newXPath();
+			NodeList result = (NodeList) xpath.compile("//DIV").evaluate(doc, XPathConstants.NODESET);
+			assertNotNull(result);
+			assertEquals(3, result.getLength());
+			System.out.println(result.getLength());
+			result = (NodeList) xpath.compile("//HTML").evaluate(doc, XPathConstants.NODESET);
+			assertNotNull(result);
+			System.out.println(result.getLength());
+			assertEquals(1, result.getLength());
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * Executes some xpath on TagSoup parsed document TODO not working with
+	 * TagSoup. Investigate why.
+	 */
+	public void testXpathTagSoup() {
+		try {
+			DocumentFragment doc = parseTagSoup(new InputSource(new FileReader("src/plugin/parse-xsl/src/tests/files/sample1/book1.html")));
+			XPath xpath = XPathFactory.newInstance().newXPath();
+			NodeList result = (NodeList) xpath.compile("//div").evaluate(doc, XPathConstants.NODESET);
+			assertNotNull(result);
+			assertEquals(3, result.getLength());
+			System.out.println(result.getLength());
+			result = (NodeList) xpath.compile("//html").evaluate(doc, XPathConstants.NODESET);
+			assertNotNull(result);
+			System.out.println(result.getLength());
+			assertEquals(1, result.getLength());
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+}
diff --git a/src/plugin/parse-xsl/src/tests/org/apache/nutch/parse/xsl/Sample1Test.java b/src/plugin/parse-xsl/src/tests/org/apache/nutch/parse/xsl/Sample1Test.java
new file mode 100644
index 0000000..26e1084
--- /dev/null
+++ b/src/plugin/parse-xsl/src/tests/org/apache/nutch/parse/xsl/Sample1Test.java
@@ -0,0 +1,53 @@
+package org.apache.nutch.parse.xsl;
+
+import org.apache.nutch.metadata.Metadata;
+import org.apache.nutch.parse.ParseResult;
+import org.apache.nutch.parse.xsl.XslParseFilter.PARSER;
+
+/**
+ * 
+ * This sample test will show you how to test the crawling of a page by
+ * simulating a crawl. All the thing that you have to do is to inherit from
+ * AbstractCrawlTest.
+ * 
+ */
+public class Sample1Test extends AbstractCrawlTest {
+
+	/**
+	 * Loads the rules xml file that will route your transformers from urls.
+	 */
+	public Sample1Test() {
+		this.getConfiguration().set(RulesManager.CONF_XML_RULES, "src/plugin/parse-xsl/src/tests/files/sample1/rules.xml");
+	}
+
+	public void testBook1() {
+		String url = "http://www.sample1.com/book?1245";
+
+		try {
+			ParseResult parseResult = simulateCrawl(PARSER.NEKO, "src/plugin/parse-xsl/src/tests/files/sample1/book1.html", url);
+			assertNotNull(parseResult);
+
+			Metadata parsedMetadata = parseResult.get(url).getData().getParseMeta();
+			// Asserts we have metadata
+			assertNotNull(parsedMetadata);
+			// Title check
+			assertEquals("Nutch for dummies", parsedMetadata.get("title"));
+			// Description check
+			assertEquals("The ultimate book to master all nutch powerful mechanisms !", parsedMetadata.get("description"));
+			// Isbn check
+			assertEquals("123654987789", parsedMetadata.get("isbn"));
+			// Authors check
+			assertEquals("Mr Allan A.", parsedMetadata.getValues("author")[0]);
+			assertEquals("Mrs Mulan B.", parsedMetadata.getValues("author")[1]);
+			// Price check
+			assertEquals("free", parsedMetadata.get("price"));
+			// Collection check
+			assertEquals("Collection from nowhere", parsedMetadata.get("collection"));
+
+		} catch (Exception e) {
+			e.printStackTrace();
+			fail("testBook1 exception");
+		}
+	}
+
+}
diff --git a/src/plugin/parse-xsl/src/tests/org/apache/nutch/parse/xsl/XslIndexFilterTest.java b/src/plugin/parse-xsl/src/tests/org/apache/nutch/parse/xsl/XslIndexFilterTest.java
new file mode 100644
index 0000000..f5b0815
--- /dev/null
+++ b/src/plugin/parse-xsl/src/tests/org/apache/nutch/parse/xsl/XslIndexFilterTest.java
@@ -0,0 +1,27 @@
+package org.apache.nutch.parse.xsl;
+
+import java.util.List;
+
+import junit.framework.TestCase;
+
+/**
+ * 
+ * Testing the filter that will auto import fields defined in the xsl file.
+ * 
+ */
+public class XslIndexFilterTest extends TestCase {
+
+	/**
+	 * Test the fields fetch from xsl file.
+	 */
+	public void testFields() {
+		XslIndexFilter filter = new XslIndexFilter();
+		try {
+			List<String> list = filter.extractFields("src/plugin/parse-xsl/src/tests/files/sample1/transformer_book.xsl");
+			assertNotNull(list);
+			assertEquals(6, list.size());
+		} catch (Exception e) {
+			fail();
+		}
+	}
+}
