ExpandingFilterWriter.java

Violations

Source code

/*
 * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
 */
package biz.hammurapi.eval;

import java.io.FilterWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import biz.hammurapi.config.Context;

/**
 * @author Pavel Vlasov
 * @version $Revision$
 */
public class ExpandingFilterWriter extends FilterWriter {
    private Context context;
    private boolean stop;
    
    /**
     * When pragma:stop token is encountered subsequent characters are not
     * expanded until pragma:start token is encountered. pragma:start and pragma:stop are not output to
     * filtered writer.
     */
    public static final String PRAGMA_STOP = "pragma:stop";
    public static final String PRAGMA_START = "pragma:start";

//    private static final Logger logger = Logger.getLogger(ExpandingFilterWriter.class);


	private Set keySet;

    public ExpandingFilterWriter(Writer out, Context context) {
        this(out, context, new HashSet());
    }

    protected ExpandingFilterWriter(Writer out, Context context, Set keySet) {
        super(out);
        this.context = context;
        this.keySet=keySet;
    }

    private int lastChar;

    private StringBuffer keyBuffer;

    private static final int STATE_NORMAL = 0;

    private static final int STATE_DOLLAR = 1;

    private static final int STATE_EXPRESSION = 2;

    private static final int STATE_QUOTE = 3;

    private int state = STATE_NORMAL;

    public void write(int c) throws IOException {
        switch (c) {
	        case '$':
	            switch (state) {
		            case STATE_NORMAL:
		                state = STATE_DOLLAR;
		                break;
		            case STATE_DOLLAR:
		                state = STATE_NORMAL;
		                out.write(c);
		                if (stop) {
		                	out.write(c);
		                }
//		                out.write(b);

		                break;
		            case STATE_EXPRESSION:
		            case STATE_QUOTE:
		                toBuffer(c);
		                break;
		            default:
		                throw new IOException("Invalid lexer state: " + state);
	            }
	            break;
	        case '{':
	            switch (state) {
		            case STATE_EXPRESSION:
		            case STATE_QUOTE:
		                toBuffer(c);
		                break;
		            case STATE_NORMAL:
		                out.write(c);
		                break;
		            case STATE_DOLLAR:
		                state = STATE_EXPRESSION;
		                break;
		            default:
		                throw new IOException("Invalid lexer state: " + state);
	            }
	            break;
	        case '}':
	            switch (state) {
		            case STATE_NORMAL:
		                out.write(c);
		                break;
		            case STATE_DOLLAR:
		                state = STATE_NORMAL;
		                out.write(c);
		            case STATE_EXPRESSION:
		                state = STATE_NORMAL;
		                if (keyBuffer == null || keyBuffer.length()==0) {
		                    out.write('$');
		                    out.write('{');
		                    out.write('}');
		                } else if (PRAGMA_START.equals(keyBuffer.toString())){
		                	stop=false;
		                	keyBuffer=null;
		                } else if (PRAGMA_STOP.equals(keyBuffer.toString())){
		                	stop=true;
		                	keyBuffer=null;
		                } else if (stop) {
                    		out.write("${");
                    		out.write(keyBuffer.toString());
                    		out.write("}");
                    		keyBuffer=null;
		                } else {
		                    String key = keyBuffer.toString();
		                    keyBuffer = null;
		                    
                    		if (keySet.contains(key)) {
                    			throw new CircularReferenceException("Circular reference: "+key);
                    		}
                    		
	                    	Object o=context.get(key);
	                    	if (o==null) {
	                    		out.write("${");
	                    		out.write(key);
	                    		out.write("}");
	                    	} else {	                    	
		                    	if (o instanceof Collection) {
			                        Iterator it = ((Collection) o).iterator();
			                        while (it.hasNext()) {
			                            Object object = it.next();
			                            if (object == null) {
			                                out.write("(null)");
			                            } else {
			                            	try {
			                            		keySet.add(key);
			                            		out.write(toString(object, context, keySet));
			                            	} finally {
			                            		keySet.remove(key);
			                            	}
			                            	
			                                if (it.hasNext()) {
			                                    out.write(' ');
			                                }
			                            }
			                        }
		                    	} else {
		                    		try {
		                    			keySet.add(key);
		                    			out.write(toString(o, context, keySet));
		                    		} finally {
		                    			keySet.remove(key);
		                    		}
		                    	}
			                }
		                }
		                break;
		            case STATE_QUOTE:
		                toBuffer(c);
		                break;
		            default:
		                throw new IOException("Invalid lexer state: " + state);
		        }
	            break;
	        case '"':
	            switch (state) {
		            case STATE_NORMAL:
		                out.write(c);
		                break;
		            case STATE_DOLLAR:
		                state=STATE_NORMAL;
		                out.write('$');
		                out.write(c);
		                break;
		            case STATE_EXPRESSION:
		                state=STATE_QUOTE;
		                toBuffer(c);
		                break;
		            case STATE_QUOTE:
		                if (lastChar!='\\') {
		                    state=STATE_EXPRESSION;
		                }
	                    toBuffer(c);
	                    break;
		            default:
		                throw new IOException("Invalid lexer state: " + state);
	            }
	            break;
	        default:
	            switch (state) {
		            case STATE_NORMAL:
		                out.write(c);
		                break;
		            case STATE_DOLLAR:
		                state=STATE_NORMAL;
		                out.write('$');
		                out.write(c);
		                break;
		            case STATE_EXPRESSION:
		            case STATE_QUOTE:
		                toBuffer(c);
		                break;
		            default:
		                throw new IOException("Invalid lexer state: " + state);
	            }
        }
        lastChar = c;
    }

    /**
	 * @param object
	 * @return
	 */
	private static String toString(Object object, Context context, Set keySet) {
		try {
			StringWriter sw=new StringWriter();
	    	ExpandingFilterWriter efw=new ExpandingFilterWriter(sw, context, keySet);
	    	char[] buf=new char[1024];
	    	StringReader reader=new StringReader(object.toString());
	    	int l;
	    	while ((l=reader.read(buf))!=-1) {
	    		efw.write(buf, 0, l);
	    	}
	    	efw.close();
	    	sw.close();
	    	reader.close();
			return sw.toString();
		} catch (IOException e) {
			throw new EvaluationException("Shall never happen", e);
		}
	}

	/**
     * @param b
     */
    private void toBuffer(int b) {
        if (keyBuffer == null) {
            keyBuffer = new StringBuffer();
        }
        keyBuffer.append((char) b);
    }

    public void close() throws IOException {
        if (state == STATE_DOLLAR) {
            out.write('$');
        } else if (state == STATE_EXPRESSION /*|| state == STATE_QUOTE */) {
            out.write('$');
            out.write('{');
        }

        if (keyBuffer != null) {
            out.write(keyBuffer.toString());
            keyBuffer = null;
        }
        out.close();
        super.close();
    }
    
    public void write(char[] cbuf, int off, int len) throws IOException {
        for (int i=0; i<len; i++) {
            write(cbuf[i+off]);
        }
    }
    
    public void write(String str, int off, int len) throws IOException {
        for (int i=0; i<len; i++) {
            write(str.charAt(i+off));
        }
    }
    
    public static Reader expand(Reader reader, Context context) throws IOException {
		return new StringReader(expandToString(reader, context));
    }

	/**
	 * @param reader
	 * @param context
	 * @return
	 * @throws IOException
	 */
	public static String expandToString(Reader reader, Context context) throws IOException {
		StringWriter sw=new StringWriter();
    	ExpandingFilterWriter efw=new ExpandingFilterWriter(sw, context);
    	char[] buf=new char[1024];
    	int l;
    	while ((l=reader.read(buf))!=-1) {
    		efw.write(buf, 0, l);
    	}
    	efw.close();
    	sw.close();
    	reader.close();
		return sw.toString();
	}
}