Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.openfuxml.addon.wiki.processor.markup;
  
  import java.io.File;
  
  import  net.sf.exlp.util.io.ConfigLoader;
  import  net.sf.exlp.util.io.LoggerInit;
  import  net.sf.exlp.util.io.StringIO;
  import  net.sf.exlp.util.xml.JaxbUtil;
  
 import  org.apache.commons.configuration.Configuration;
 import  org.apache.commons.lang.SystemUtils;
 import  org.openfuxml.addon.wiki.data.jaxb.Category;
 import  org.openfuxml.addon.wiki.data.jaxb.Content;
 import  org.openfuxml.addon.wiki.data.jaxb.Injections;
 import  org.openfuxml.addon.wiki.data.jaxb.Markup;
 import  org.openfuxml.addon.wiki.data.jaxb.ObjectFactory;
 import  org.openfuxml.addon.wiki.data.jaxb.Page;
 import  org.openfuxml.addon.wiki.data.jaxb.Replacements;
 import  org.openfuxml.addon.wiki.data.jaxb.Template;
 import  org.openfuxml.addon.wiki.data.jaxb.Templates;
 import  org.openfuxml.addon.wiki.data.jaxb.Wikiinjection;
 import  org.openfuxml.addon.wiki.data.jaxb.Wikireplace;
 import  org.openfuxml.exception.OfxConfigurationException;
 import  org.openfuxml.exception.OfxInternalProcessingException;
 import  org.openfuxml.xml.renderer.cmp.Cmp;
 import  org.slf4j.Logger;
 import  org.slf4j.LoggerFactory;
 
 public class WikiMarkupProcessor extends AbstractWikiProcessor implements WikiProcessor
 {
 	final static Logger logger = LoggerFactory.getLogger(WikiMarkupProcessor.class);
 	private final static String ls = SystemUtils.LINE_SEPARATOR;
 	
 	public static enum InjectionType {xml,wiki};
 	
 	private Replacements replacements;
 	private Injections injections;
 	private Templates templates;
 	
 	private String wikiText;
 	private ObjectFactory of;
 	
 	private int templateCounter;
 	private static String templateStartDelemiter = "{{";
 	private static String templateEndDelemiter = "}}";
 	
 	private File dirInjection;
 	private int injectionId;
 	
 	public WikiMarkupProcessor(Cmp cmpthrows OfxConfigurationException
 	{
 		this(cmp.getPreprocessor().getWiki().getMarkupProcessor().getReplacements(),
 				cmp.getPreprocessor().getWiki().getMarkupProcessor().getInjections(),
 				cmp.getPreprocessor().getWiki().getTemplates());
 	}
 	
 	public WikiMarkupProcessor(Replacements replacements, Injections injections, Templates templatesthrows OfxConfigurationException
 	{
 		this.=templates;
 		this. = WikiConfigXmlXpathHelper.initReplacements(replacements);
 		this. = WikiConfigXmlXpathHelper.initInjections(injections);
 	}
 	
 	protected void processCategory(Content contentthrows OfxInternalProcessingException
 	{
 		Category category = content.getCategory();
 		for(Page page : category.getPage())
 		{
 			processPage(page);
 		}
 	}
 	
 	protected void processPage(Content contentthrows OfxInternalProcessingException
 	{
 		Page page = content.getPage();
 		processPage(page);
 	}
 	
 	protected void processPage(Page pagethrows OfxInternalProcessingException
 	{
 		.debug("Processing Page: "+page.getName());
 		String fName = page.getFile()+"."+..;
 		String txt = StringIO.loadTxt(fName);
 		String result = process(txtpage.getName());
 		StringIO.writeTxt(fNameresult);
 	}
 	
 	
 	public String process(String wikiPlainString articlethrows OfxInternalProcessingException
 	{
 		//TODO Check the meaning of article!!
		this.=wikiPlain;
		for(Wikireplace replace : .getWikireplace()){processReplacements(replace);}
		for(Wikiinjection inject : .getWikiinjection()){wikiInject(inject,article);}
		for(Template template : .getTemplate()){processTemplate(template);}
		return this.;
	}
	private void processReplacements(Wikireplace replace)
	{
		 = .replaceAll(replace.getFrom(), replace.getTo());
	}
	private void processTemplate(Template templatethrows OfxInternalProcessingException
	{
		.debug("Processing Template: "+template.getName());
		int beginIndex=-1;
		while((beginIndex=.indexOf(+template.getName()))>=0)
		{
			//TODO Nesting templates
			.warn("Nesting Templates are not supported!!");
			StringBuffer sb = new StringBuffer();
			sb.append(.substring(0, beginIndex));
			sb.append(createExternalTemplate(template,.substring(beginIndex+.length()+template.getName().length(), endIndex)));
		}
	}
	private String createExternalTemplate(Template templateDefString templateMarkupthrows OfxInternalProcessingException
	{	
		Template template = new Template();
		template.setName(templateDef.getName());
		template.setId(getNextTemplateId());
		template.setMarkup(new Markup());
		template.getMarkup().setValue(templateMarkup);
		JaxbUtil.save(ftemplatetrue);
		StringBuffer sb = new StringBuffer();
		sb.append(SystemUtils.LINE_SEPARATOR);
		sb.append("<wiki:injection id=\"");
		sb.append(template.getId());
		sb.append("\"/>");
		sb.append(SystemUtils.LINE_SEPARATOR);
		return sb.toString();
	}
	private void wikiInject(Wikiinjection injectString article)
	{
		while(.indexOf("<"+inject.getWikitag()+">")>0)
		{
			.warn("Injection should start, but currently NYI");
			inject.setId(""+);++;
			inject.setArticle(article);
			StringBuffer sbDebug = new StringBuffer();
			String startTag = "<"+inject.getWikitag()+">";
			int from = .indexOf(startTag);
			int to = .indexOf("</"+inject.getWikitag()+">");
			StringBuffer injectionSb = WikiContentIO.toString(inject);
			.debug(injectionSb.toString());
			inject.setWikicontent(.createWikiinjectionWikicontent());
			inject.getWikicontent().setValue(.substring(from+startTag.length(), to));
			WikiContentIO.toFile(inject,);
			sbDebug.append("Injection: "+from+" "+to);
			sbDebug.append(" oldSize="+.length());
			StringBuffer sb = new StringBuffer();
				sb.append(.substring(0, from-1));
				if(inject.getOfxtag()!=null && inject.getOfxtag().length()>0)
				{
					sb.append(injectionSb);
				}
				sb.append(.substring(to+inject.getWikitag().length()+3+1,.length()));
			sbDebug.append(" newSize="+.length());
			.debug(sbDebug.toString());
		}
	}
	{
		return ""+;
	}
	public static void main (String[] argsthrows Exception
	{
		LoggerInit loggerInit = new LoggerInit("log4j.xml");	
			loggerInit.addAltPath("resources/config");
			loggerInit.init();
		String propFile = "resources/properties/user.properties";
		if(args.length==1){propFile=args[0];}
		ConfigLoader.add(propFile);
		Configuration config = ConfigLoader.init();
		String fnCmp = config.getString("ofx.xml.cmp");
		String fnWikiTxt = config.getString("wiki.processor.test.markup");
		.debug("Cmp:  "+fnCmp);
		.debug("Wiki: "+fnWikiTxt);
		Cmp cmp = (Cmp)JaxbUtil.loadJAXB(fnCmp, Cmp.class);
		String wikiText = StringIO.loadTxt(fnWikiTxt);
		.debug("Wiki (Before): "+wikiText);
		wikiText=wpMarkup.process(wikiText"test");
		.debug("Wiki (After): "+wikiText);
	}
New to GrepCode? Check out our FAQ X