SupoSE

		<tika.version>0.8-SNAPSHOT</tika.version>

		<solr.version>1.4.0</solr.version>

			<groupId>org.apache.solr</groupId>

			<artifactId>solr-core</artifactId>

			<version>${solr.version}</version>

		</dependency>

		<dependency>

		  <groupId>org.slf4j</groupId>

		  <artifactId>slf4j-log4j12</artifactId>

		  <version>1.6.0</version>

		</dependency>

		<dependency>

//Todo: Labels and goto have been disabled, need to test on 5.3 

grammar Php;

options {

    backtrack = true; 

    memoize = true;

    k=2;

    output = AST;

    ASTLabelType = CommonTree;

}

tokens{

    SemiColon = ';';

    Comma = ',';

    OpenBrace = '(';

    CloseBrace = ')';

    OpenSquareBrace = '[';

    CloseSquareBrace = ']';

    OpenCurlyBrace = '{';

    CloseCurlyBrace = '}';

    ArrayAssign = '=>';

    LogicalOr = '||';

    LogicalAnd = '&&';

    ClassMember = '::';

    InstanceMember = '->';

    SuppressWarnings = '@';

    QuestionMark = '?';

    Dollar = '$';

    Colon = ':';

    Dot = '.';

    Ampersand = '&';

    Pipe = '|';

    Bang = '!';

    Plus = '+';

    Minus = '-';

    Asterisk = '*';

    Percent = '%';

    Forwardslash = '/'; 

    Tilde = '~';

    Equals = '=';

    New = 'new';

    Clone = 'clone';

    Echo = 'echo';

    If = 'if';

    Else = 'else';

    ElseIf = 'elseif';

    For = 'for';

    Foreach = 'foreach';

    While = 'while';

    Do = 'do';

    Switch = 'switch';

    Case = 'case';

    Default = 'default';

    Function = 'function';

    Break = 'break';

    Continue = 'continue';

    //Goto = 'goto';

    Return = 'return';

    Global = 'global';

    Static = 'static';

    And = 'and';

    Or = 'or';

    Xor = 'xor';

    Instanceof = 'instanceof';

    Class = 'class';

    Interface = 'interface';

    Extends = 'extends';

    Implements = 'implements';

    Abstract = 'abstract';

    Var = 'var';

    Const = 'const';

    Modifiers;

    ClassDefinition;

    Block;

    Params;

    Apply;

    Member;

    Reference;

    Empty;

    Prefix;

    Postfix;

    IfExpression;

    Label;

    Cast;

    ForInit;

    ForCondition;

    ForUpdate;

    Field;

    Method;

}

@header{

package com.soebes.supose.parse.php; 

}

@lexer::header{

package com.soebes.supose.parse.php;

import java.util.ArrayList;

}

@members{	

	private ArrayList<String> methods = new ArrayList<String>();

	private ArrayList<String> classes = new ArrayList<String>();

	public ArrayList<String> getMethods () {

		return methods;

	}

	private void addMethod(String name) {

		methods.add(name);

	}

	public ArrayList<String> getClasses () {

		return classes;

	}

	private void addClass(String name) {

		classes.add(name);

	}

}

@lexer::members{

    // Handle the first token, which will always be a BodyString.

    public Token nextToken(){

        //The following code was pulled out from super.nextToken()

        if (input.index() == 0) {

            try {

                state.token = null;

                state.channel = Token.DEFAULT_CHANNEL;

                state.tokenStartCharIndex = input.index();

                state.tokenStartCharPositionInLine = input.getCharPositionInLine();

                state.tokenStartLine = input.getLine();

                state.text = null;

                mFirstBodyString();

                state.type = BodyString;

                emit();

                return state.token;

            } catch (NoViableAltException nva) {

                reportError(nva);

                recover(nva); // throw out current char and try again

            } catch (RecognitionException re) {

                reportError(re);

                // match() routine has already called recover()

            }    

        }

        return super.nextToken();

    }

    private ArrayList<String> comments = new ArrayList<String>();

	public ArrayList<String> getComments() {

		return comments;

	}

	public void addComment(String comment) {

		comments.add(comment);

	}

}

prog : statement*;

statement

    : simpleStatement? BodyString

    | '{' statement '}' -> statement

    | bracketedBlock

    //| UnquotedString Colon statement -> ^(Label UnquotedString statement)

    | classDefinition

    | interfaceDefinition

    | complexStatement

    | simpleStatement ';'!

    ;

bracketedBlock

    : '{' stmts=statement* '}' -> ^(Block $stmts)

    ;

interfaceDefinition

    : Interface interfaceName=UnquotedString interfaceExtends?

        OpenCurlyBrace

        interfaceMember*

        CloseCurlyBrace

        -> ^(Interface $interfaceName interfaceExtends? interfaceMember*)

    ;

interfaceExtends

    : Extends^ UnquotedString (Comma! UnquotedString)*

    ;

interfaceMember

    : Const UnquotedString (Equals atom)? ';' 

        -> ^(Const UnquotedString atom?)

    | fieldModifier* Function UnquotedString parametersDefinition ';'

        -> ^(Method ^(Modifiers fieldModifier*) UnquotedString parametersDefinition)

    ;

classDefinition

    :   classModifier? 

        Class className=UnquotedString { addClass($className.getText()); }

        (Extends extendsclass=UnquotedString)? 

        classImplements?

        OpenCurlyBrace

        classMember*

        CloseCurlyBrace 

        -> ^(Class ^(Modifiers classModifier?) $className ^(Extends $extendsclass)? classImplements?

            classMember*

        )

     ;

classImplements

    :  Implements^ (UnquotedString (Comma! UnquotedString)*)

    ;

classMember

    : fieldModifier* Function UnquotedString parametersDefinition { addMethod($UnquotedString.getText());}

        (bracketedBlock | ';')

        -> ^(Method ^(Modifiers fieldModifier*) UnquotedString parametersDefinition bracketedBlock?)

    | Var Dollar UnquotedString (Equals atom)? ';' 

        -> ^(Var ^(Dollar UnquotedString) atom?) 

    | Const UnquotedString (Equals atom)? ';' 

        -> ^(Const UnquotedString atom?)

    | fieldModifier* (Dollar UnquotedString) (Equals atom)? ';' 

        -> ^(Field ^(Modifiers fieldModifier*) ^(Dollar UnquotedString) atom?)

    ;

fieldDefinition

    : Dollar UnquotedString (Equals atom)? ';'-> ^(Field ^(Dollar UnquotedString) atom?)

    ;

classModifier

    : 'abstract';

fieldModifier

    : AccessModifier | 'abstract' | 'static' 

    ;

complexStatement

    : If '(' ifCondition=expression ')' ifTrue=statement conditional?

        -> ^('if' expression $ifTrue conditional?)

    | For '(' forInit forCondition forUpdate ')' statement -> ^(For forInit forCondition forUpdate statement)

    | Foreach '(' variable 'as' arrayEntry ')' statement -> ^(Foreach variable arrayEntry statement)

    | While '(' whileCondition=expression? ')' statement -> ^(While $whileCondition statement)

    | Do statement While '(' doCondition=expression ')' ';' -> ^(Do statement $doCondition)

    | Switch '(' expression ')' '{'cases'}' -> ^(Switch expression cases)

    | functionDefinition

    ;

simpleStatement

    : Echo^ commaList

    | Global^ name (','! name)*

    | Static^ variable Equals! atom

    | Break^ Integer?

    | Continue^ Integer?

    //| Goto^ UnquotedString

    | Return^ expression?

    | RequireOperator^ expression

    | expression

    ;

conditional

    : ElseIf '(' ifCondition=expression ')' ifTrue=statement conditional? -> ^(If $ifCondition $ifTrue conditional?)

    | Else statement -> statement

    ;

forInit

    : commaList? ';' -> ^(ForInit commaList?)

    ;

forCondition

    : commaList? ';' -> ^(ForCondition commaList?)

    ;

forUpdate

    : commaList? -> ^(ForUpdate commaList?)

    ;

cases 

    : casestatement*  defaultcase

    ;

casestatement

    : Case^ expression ':'! statement*

    ;

defaultcase 

    : (Default^ ':'! statement*)

    ;

functionDefinition

    : Function UnquotedString parametersDefinition bracketedBlock -> 

        ^(Function UnquotedString parametersDefinition bracketedBlock)

    ;

parametersDefinition

    : OpenBrace (paramDef (Comma paramDef)*)? CloseBrace -> ^(Params paramDef*) 

    ;

paramDef

    : paramName (Equals^ atom)?

    ;

paramName

    : Dollar^ UnquotedString

    | Ampersand Dollar UnquotedString -> ^(Ampersand ^(Dollar UnquotedString))

    ;

commaList

    : expression (','! expression)* 

    ;

expression

    : weakLogicalOr

    ;

weakLogicalOr

    : weakLogicalXor (Or^ weakLogicalXor)*

    ;

weakLogicalXor

    : weakLogicalAnd (Xor^ weakLogicalAnd)*

    ;

weakLogicalAnd

    : assignment (And^ assignment)*

    ;

assignment

    : name ((Equals | AsignmentOperator)^ assignment)

    | ternary

    ;

ternary

    : logicalOr QuestionMark expression Colon expression -> ^(IfExpression logicalOr expression*)

    | logicalOr

    ;

logicalOr

    : logicalAnd (LogicalOr^ logicalAnd)*

    ;

logicalAnd

    : bitwiseOr (LogicalAnd^ bitwiseOr)*

    ;

bitwiseOr

    : bitWiseAnd (Pipe^ bitWiseAnd)*

    ;

bitWiseAnd

    : equalityCheck (Ampersand^ equalityCheck)*

    ;

equalityCheck

    : comparisionCheck (EqualityOperator^ comparisionCheck)?

    ;

comparisionCheck

    : bitWiseShift (ComparisionOperator^ bitWiseShift)?

    ;

bitWiseShift

    : addition (ShiftOperator^ addition)*

    ;

addition

    : multiplication ((Plus | Minus | Dot)^ multiplication)*

    ;

multiplication

    : logicalNot ((Asterisk | Forwardslash | Percent)^ logicalNot)*

    ;

logicalNot

    : Bang^ logicalNot

    | instanceOf

    ;

instanceOf

    : negateOrCast (Instanceof^ negateOrCast)?

    ;

negateOrCast

    : (Tilde | Minus | SuppressWarnings)^ increment

    | OpenBrace PrimitiveType CloseBrace increment -> ^(Cast PrimitiveType increment)

    | OpenBrace! weakLogicalAnd CloseBrace!

    | increment

    ;

increment

    : IncrementOperator name -> ^(Prefix IncrementOperator name)

    | name IncrementOperator -> ^(Postfix IncrementOperator name)

    | newOrClone

    ;

newOrClone

    : New^ nameOrFunctionCall

    | Clone^ name

    | atomOrReference

    ;

atomOrReference

    : atom

    | reference

    ;

arrayDeclaration

    : Array OpenBrace (arrayEntry (Comma arrayEntry)*)? CloseBrace -> ^(Array arrayEntry*)

    ;

arrayEntry

    : (keyValuePair | expression)

    ;

keyValuePair

    : (expression ArrayAssign expression) -> ^(ArrayAssign expression+)

    ;

atom: SingleQuotedString | DoubleQuotedString | HereDoc | Integer | Real | Boolean | arrayDeclaration

    ;

//Need to be smarter with references, they have their own tower of application.

reference

    : Ampersand^ nameOrFunctionCall

    | nameOrFunctionCall

    ;

nameOrFunctionCall

    : name OpenBrace (expression (Comma expression)*)? CloseBrace -> ^(Apply name expression*)

    | name

    ;

name: staticMemberAccess

    | memberAccess

    | variable

    ;

staticMemberAccess

    : UnquotedString '::'^ variable

    ;

memberAccess

    : variable 

        ( OpenSquareBrace^ expression CloseSquareBrace!

        | '->'^ UnquotedString)*

    ;

variable

    : Dollar^ variable

    | UnquotedString

    ;

BodyString 

    : '?>' (('<' ~ '?')=> '<' | ~'<' )* ('<?' ('php'?))?

    ;

fragment

FirstBodyString

    : (('<' ~ '?')=> '<' | ~'<' )* '<?' ('php'?)

    ;

MultilineComment    

    : '/*' (('*' ~ '/')=>'*' | ~ '*')* '*/' {$channel=HIDDEN;addComment(getText());}

    ;

SinglelineComment

    : '//'  (('?' ~'>')=>'?' | ~('\n'|'?'))* {$channel=HIDDEN;addComment(getText());}

    ;

UnixComment

    : '#' (('?' ~'>')=>'?' | ~('\n'|'?'))* {$channel=HIDDEN;addComment(getText());}

    ;

Array

    : ('a'|'A')('r'|'R')('r'|'R')('a'|'A')('y'|'Y')

    ;

RequireOperator

    : 'require' | 'require_once' | 'include' | 'include_once'

    ;

PrimitiveType

    : 'int'|'float'|'string'|'array'|'object'|'bool'

    ;

AccessModifier

    : 'public' | 'private' | 'protected' 

    ;

fragment

Decimal	

	:('1'..'9' ('0'..'9')*)|'0'

	;

fragment

Hexadecimal

	: '0'('x'|'X')('0'..'9'|'a'..'f'|'A'..'F')+

	;

fragment

Octal

	: '0'('0'..'7')+

	;

Integer

	:Octal|Decimal|Hexadecimal

	;

fragment

Digits

	: '0'..'9'+

	;

fragment

DNum

	:(('.' Digits)=>('.' Digits)|(Digits '.' Digits?))

	;

fragment

Exponent_DNum

	:((Digits|DNum)('e'|'E')('+''-')?Digits)

	;

Real

    : DNum|Exponent_DNum

    ;

Boolean

    : 'true' | 'false'

    ;

SingleQuotedString

    : '\'' (('\\' '\'')=>'\\' '\''

    |         ('\\' '\\')=>'\\' '\\' 

    |         '\\' | ~ ('\'' | '\\'))* 

      '\''

    ;

fragment

EscapeCharector

    : 'n' | 'r' | 't' | '\\' | '$' | '"' | Digits | 'x'

    ;

DoubleQuotedString

    : '"'  ( ('\\' EscapeCharector)=> '\\' EscapeCharector 

    | '\\' 

    | ~('\\'|'"') )* 

      '"'

    ;

HereDoc 

    : '<<<' HereDocContents

    ;

//Todo handle '\x7f' - '\xff'

UnquotedString

   : ('a'..'z' | 'A'..'Z' | '_')  ('a'..'z' | 'A'..'Z' | '0'..'9' | '_')*

   ;

//TODO: add error handling

fragment 

HereDocContents

    : {

        StringBuilder sb = new StringBuilder();

        while(input.LA(1)!='\n'){

            sb.append((char)input.LA(1));

            input.consume();

        }

        input.consume();

        String hereDocName = sb.toString();

        int hdnl = hereDocName.length();

        while(true){

            boolean matchEnd = true;

            for(int i = 0; i<hdnl; i++){

                if(input.LA(1)!=hereDocName.charAt(i)){

                    matchEnd=false;

                    break;

                }

                input.consume();

            }

            if(matchEnd==false){

                while(input.LA(1)!='\n'){

                    input.consume();

                }

                input.consume();

            }else{

                break;

            }

        }

    }

    ;

AsignmentOperator

    : '+='|'-='|'*='|'/='|'.='|'%='|'&='|'|='|'^='|'<<='|'>>='

    ;

EqualityOperator

    : '==' | '!=' | '===' | '!=='

    ;

ComparisionOperator

    : '<' | '<=' | '>' | '>=' | '<>'

    ;

ShiftOperator

    : '<<' | '>>'

    ;

IncrementOperator

    : '--'|'++'

    ;

fragment

Eol : '\n'

    ;

WhiteSpace

@init{

    $channel=HIDDEN;

}

	:	(' '| '\t'| '\n'|'\r')*

	;

    private Option optionSolrUrl = null;

    	optionSolrUrl = obuilder

			.withShortName("S")

			.withLongName("solr")

			.withArgument(

				abuilder

				.withName("solr")

				.withMinimum(1)

				.withMaximum(1)

				.create()

			)

			.withDescription("Use Solr to store data. Specify URL at which Solr is running.")

			.create();

    		.withOption(optionSolrUrl)

	public Option getOptionSolrUrl() {

		return optionSolrUrl;

	}

		if(getSolrUrl(cline) != null) {

			return null;

		}

	public String getSolrUrl (CommandLine cline) {

		String solrUrl = (String) cline.getValue((getOptionSolrUrl()));

		return solrUrl;

	}

    private Option optionSolrUrl = null;

    	optionSolrUrl = obuilder

		.withShortName("S")

		.withLongName("solr")

		.withArgument(abuilder.withName("solr").create())

		.withDescription("Define the Solr url which is used to query.")

		.create();

    		.withOption(optionSolrUrl)

	public Option getOptionSolrUrl() {

		return optionSolrUrl;

	}

	public String getSolrUrl (CommandLine cline) {

		String solrUrl = (String) cline.getValue(getOptionSolrUrl());

		return solrUrl;

	}

import java.net.MalformedURLException;

import java.net.URL;

import com.soebes.supose.index.IndexerFactory;

import com.soebes.supose.index.Reader;

import com.soebes.supose.index.Writer;

		List<?> helpLines = suposeOptions.helpLines(0, HelpFormatter.DEFAULT_DISPLAY_USAGE_SETTINGS, null);

		for (Iterator<?> i = helpLines.iterator(); i.hasNext();) {

		String solrUrl = scanCommand.getSolrUrl(commandLine);

		Writer indexWriter = null;

		if(indexDirectory != null && solrUrl != null) {

			printHelp();

	        System.exit(0);

		} else if(indexDirectory != null) {

			indexWriter = IndexerFactory.getIndexWriter(indexDirectory, create);

		} else if(solrUrl != null) {

			try {

				indexWriter = IndexerFactory.getIndexWriter(new URL(solrUrl));

			} catch (MalformedURLException e) {

				LOGGER.warn("Could not parse Solr url " + solrUrl + ": " + e);

			}

		}

		long blockNumber = ScanSingleRepository.scanFullRepository(url, fromRev, indexWriter, create, authManager);

		ScanSingleRepository.mergeIndexesAndCleanUp(indexWriter, blockNumber);

            	jobDetail.getJobDataMap().put(JobDataNames.INDEX, configurationBaseDir);

		// We assume that the indexes exist.

		// Because only LuceneWriter could merge indexes we dont need a separation

		IndexerFactory.getIndexWriter(destination, false).merge(destination, indexList);

		String solrUrl = searchCommand.getSolrUrl(commandLine);

		Reader indexReader = null;

		if(indexDirectory != null && solrUrl != null) {

			printHelp();

			System.exit(0);

		} else if(indexDirectory != null) {

			indexReader = IndexerFactory.getIndexReader(indexDirectory);

		} else if (solrUrl != null) {

			try {

				URL solrServerUrl = new URL(solrUrl);

				indexReader = IndexerFactory.getIndexReader(solrServerUrl);

			} catch (MalformedURLException e) {

				LOGGER.error("Could not parse Solr url " + solrUrl + ": " + e);

			}

		}

		List<ResultEntry> result = indexReader.getResult(queryLine);

		/**

		 * @todo: solr xml output

		 */

						Object attribute = IndexHelper.callGetterByName(item, fn.getValue());

			indexReader.close();

	CONTENT("content"),

	RTTITLE("rttitle"),

	RTSUBJECT("rtsubject"),

	RTAUTHOR("rtauthor"),

	RTDATE("rtdate"),

	RTKEYWORDS("rtkeywords"),

package com.soebes.supose.index;

import java.net.URL;

import com.soebes.supose.index.lucene.LuceneIndexReader;

import com.soebes.supose.index.lucene.LuceneIndexWriter;

import com.soebes.supose.index.solr.SolrIndexReader;

import com.soebes.supose.index.solr.SolrIndexWriter;

public class IndexerFactory {

	public static Writer getIndexWriter(String indexDirectory, boolean overwrite) {

		return new LuceneIndexWriter(indexDirectory, overwrite);

	}

	public static Reader getIndexReader(String indexDirectory) {

		return new LuceneIndexReader(indexDirectory);

	}

	public static Writer getIndexWriter(URL solrUrl) {

		return new SolrIndexWriter(solrUrl);

	}

	public static Reader getIndexReader(URL solrUrl) {

		return new SolrIndexReader(solrUrl);

	}

}

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import com.soebes.supose.search.ResultEntry;

	public static Method getGetterByName(Class<?> z, String name) {

		Method[] methods = z.getMethods();

		Method result = null;

		for (Method method : methods) {

			if (method.getName().toLowerCase().startsWith("get")) {

				String m = method.getName().toLowerCase();

				if (m.equals("get" + name.toLowerCase())) {

//					System.out.println("MS:" + name);

					result = method;

				}

			}

		}

		return result;

	}

	public static Method getSetterByName(Class<?> z, String name) {

		Method[] methods = z.getMethods();

		Method result = null;

		for (Method method : methods) {

			if (method.getName().toLowerCase().startsWith("set")) {

				String m = method.getName().toLowerCase();

				if (m.equals("set" + name.toLowerCase())) {

//					System.out.println("MS:" + name);

					result = method;

				}

			}

		}

		return result;

	public static Object callGetterByName(ResultEntry z, String name) {

		Method m = getGetterByName(z.getClass(), name);

		Object attribute = null;

		if (m == null) {

			LOGGER.fatal("Method get" + name + " not found!");

			return attribute; 

		}

			attribute = m.invoke(z);

		} catch (IllegalArgumentException e) {

			LOGGER.fatal("IllegalArgumentException", e);

		} catch (IllegalAccessException e) {

			LOGGER.fatal("IllegalAccessException", e);

		} catch (InvocationTargetException e) {

			LOGGER.fatal("InvocationTargetException", e);

		return attribute;

package com.soebes.supose.index.lucene;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.List;

import org.apache.log4j.Logger;

import org.apache.lucene.analysis.Analyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.CorruptIndexException;

import org.apache.lucene.queryParser.QueryParser;

import org.apache.lucene.search.BooleanQuery;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.Query;

import org.apache.lucene.search.Searcher;

import org.apache.lucene.search.Sort;

import org.apache.lucene.search.SortField;

import org.apache.lucene.search.TopDocs;

import com.soebes.supose.FieldNames;

import com.soebes.supose.index.IndexHelper;

import com.soebes.supose.index.Reader;

import com.soebes.supose.search.CustomQueryParser;

import com.soebes.supose.search.ResultEntry;

import com.soebes.supose.utility.AnalyzerFactory;

public class LuceneIndexReader implements Reader {

	private static Logger LOGGER = Logger.getLogger(LuceneIndexReader.class);

	private String indexDirectory = null;

	private Analyzer analyzer = null;

	public LuceneIndexReader(String indexDirectory) {

		this.indexDirectory = indexDirectory;

		this.analyzer = AnalyzerFactory.createInstance();

	}

	public List<ResultEntry> getResult(String queryLine) {

		TopDocs result = getQueryResult(queryLine);

		ArrayList<ResultEntry> resultList = new ArrayList<ResultEntry>();

		try {

			Searcher searcher = new IndexSearcher(indexDirectory);

			for (int i = 0; i < result.scoreDocs.length; i++) {

		    	Document hit = searcher.doc(result.scoreDocs[i].doc);

				List<Field> fieldList = hit.getFields();

				ResultEntry re = new ResultEntry();

				for(Field f : fieldList) {

					Method method = IndexHelper.getSetterByName(re.getClass(), f.name());

					if (method != null) {

//						System.out.println(

//							"-> Name:" + field.name() 

//							+ " " + field.stringValue()

//							+ " [" + field.getBinaryLength() + "] "

//							+ " Method:" + method.getName());

						try {

							method.invoke(re, f.stringValue());

						} catch (IllegalArgumentException e) {

							LOGGER.fatal("IllegalArgumentException", e);

						} catch (IllegalAccessException e) {

							LOGGER.fatal("IllegalAccessException", e);

						} catch (InvocationTargetException e) {

							LOGGER.fatal("InvocationTargetException", e);

						}

					}

				}

				resultList.add(re);

			}

		} catch (Exception e) {

			LOGGER.fatal("Exception", e);

		}

		return resultList;

	}

	private TopDocs getQueryResult(String queryLine) {

	    TopDocs result = null;	    

	    try {

	    	BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);

	    	Searcher searcher = new IndexSearcher(indexDirectory);

	    	SortField[] sf = {

	    		new SortField(FieldNames.REVISION.getValue()),

	    		new SortField(FieldNames.FILENAME.getValue()), //We use for sorting the filename

	    	};

	    	Sort sort = new Sort(sf);

	    	//Here we define the default field for searching.

	    	QueryParser parser = new CustomQueryParser(FieldNames.CONTENT.toString(), this.analyzer);

	    	//We will allow using a wildcard at the beginning of the expression.

	    	parser.setAllowLeadingWildcard(true);

	    	//The search term will not be expanded to lowercase.

	        parser.setLowercaseExpandedTerms(true);

	        Query query = parser.parse(queryLine);

	        LOGGER.info("Query: " + query.toString());

	        //That's not the best idea...but currently i have not better solution for this...

	        //This is intended to get all results not only a limited number results.

	        TopDocs tmp = searcher.search(query, null, 20, sort);

		    result = searcher.search(query, null, tmp.totalHits, sort);

		    searcher.close();

	    } catch (CorruptIndexException e) {

			LOGGER.error("Error: The index is corrupted: ", e);

	    } catch (IOException e) {

			LOGGER.error("Error: IOException: ", e);

		} catch (Exception e) {

			LOGGER.error("Error: Something has gone wrong: ", e);

		}

		return result;

	}

	@Override

	public void close() throws IOException {

		// TODO Auto-generated method stub

	}

	@Override

	public void open() throws IOException {

		// TODO Auto-generated method stub

	}

}

/**

 * The (Su)bversion Re(po)sitory (S)earch (E)ngine (SupoSE for short).

 *

 * Copyright (c) 2007, 2008, 2009, 2010 by SoftwareEntwicklung Beratung Schulung (SoEBeS)

 * Copyright (c) 2007, 2008, 2009, 2010 by Karl Heinz Marbaise

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA

 *

 * The License can viewed online under http://www.gnu.org/licenses/gpl.html

 * If you have any questions about the Software or about the license

 * just write an email to license@soebes.de

 */

package com.soebes.supose.index.lucene;

import java.io.File;

import java.io.IOException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map.Entry;

import org.apache.log4j.Logger;

import org.apache.lucene.analysis.Analyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.CorruptIndexException;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.IndexWriter.MaxFieldLength;

import org.apache.lucene.store.FSDirectory;

import org.apache.lucene.store.LockObtainFailedException;

import com.soebes.supose.index.Writer;

import com.soebes.supose.search.Analyze;

import com.soebes.supose.search.ResultEntry;

import com.soebes.supose.utility.AnalyzerFactory;

/**

 * @author Karl Heinz Marbaise

 * 

 */

public class LuceneIndexWriter implements Writer {

	private static Logger LOGGER = Logger.getLogger(LuceneIndexWriter.class);

	private int commitSize = 100;

	private Collection<Document> docs = new ArrayList<Document>(commitSize);