litvinovg/vitro
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

NIHVIVO-1562 Add initial work on new dump package for freemarker, including unit tests.

Browse source
This commit is contained in:
ryounes 2011-04-07 16:15:49 +00:00
parent 4d1ec35fc9
commit b57acbb87f
3 changed files with 438 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

179
webapp/src/freemarker/ext/dump/BaseDumpDirective.java Normal file
View file

@ -0,0 +1,179 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package freemarker.ext.dump;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import freemarker.core.Environment;
import freemarker.template.Template;
import freemarker.template.TemplateBooleanModel;
import freemarker.template.TemplateDateModel;
import freemarker.template.TemplateDirectiveModel;
import freemarker.template.TemplateException;
import freemarker.template.TemplateHashModel;
import freemarker.template.TemplateHashModelEx;
import freemarker.template.TemplateMethodModel;
import freemarker.template.TemplateModel;
import freemarker.template.TemplateModelException;
import freemarker.template.TemplateNumberModel;
import freemarker.template.TemplateScalarModel;
import freemarker.template.TemplateSequenceModel;
import freemarker.template.utility.DeepUnwrap;
/* TODO
* - Check error messages generated for TemplateModelException-s. If too generic, need to catch, create specific
* error message, and rethrow.
*/
public abstract class BaseDumpDirective implements TemplateDirectiveModel {
private static final Log log = LogFactory.getLog(BaseDumpDirective.class);
protected Map<String, Object> getTemplateVariableData(String varName, Environment env)
throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>();
map.put("name", varName);
TemplateHashModel dataModel = env.getDataModel();
TemplateModel model = dataModel.get(varName);
map.putAll(getData(model));
return map;
}
private Map<String, Object> getData(TemplateModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>();
// Don't return null if model == null. We still want to send the map to the template.
if (model != null) {
// Do TemplateHashModel case first, because model of POJOs are
// StringModels, which are both TemplateScalarModels and TemplateHashModels.
if (model instanceof TemplateHashModel) {
map.putAll( getTemplateModelData( ( TemplateHashModel)model ) );
} else if (model instanceof TemplateScalarModel) {
map.putAll( getTemplateModelData( (TemplateScalarModel)model ) );
} else if (model instanceof TemplateBooleanModel) {
map.putAll( getTemplateModelData( (TemplateBooleanModel)model ) );
} else if (model instanceof TemplateNumberModel) {
map.putAll( getTemplateModelData( (TemplateNumberModel)model ) );
} else if (model instanceof TemplateDateModel) {
map.putAll( getTemplateModelData( (TemplateDateModel)model ) );
} else if (model instanceof TemplateSequenceModel){
map.putAll( getTemplateModelData( ( TemplateSequenceModel)model ) );
} else if (model instanceof TemplateHashModelEx) {
map.putAll( getTemplateModelData( ( TemplateHashModelEx)model ) );
} else if (model instanceof TemplateMethodModel) {
map.putAll( getTemplateModelData( ( TemplateMethodModel)model ) );
} else if (model instanceof TemplateDirectiveModel) {
map.putAll( getTemplateModelData( ( TemplateDirectiveModel)model ) );
} else {
map.putAll( getTemplateModelData( (TemplateModel)model ) );
}
}
return map;
}
private Map<String, Object> getTemplateModelData(TemplateScalarModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "String");
map.put("value", model.getAsString());
return map;
}
private Map<String, Object> getTemplateModelData(TemplateBooleanModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Boolean");
map.put("value", model.getAsBoolean());
return map;
}
private Map<String, Object> getTemplateModelData(TemplateNumberModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Number");
map.put("value", model.getAsNumber());
return map;
}
private Map<String, Object> getTemplateModelData(TemplateDateModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Date");
map.put("dateType", model.getDateType());
map.put("value", model.getAsDate());
return map;
}
private Map<String, Object> getTemplateModelData(TemplateHashModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Hash");
//map.put("value", model.getAsBoolean());
return map;
}
private Map<String, Object> getTemplateModelData(TemplateSequenceModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Sequence");
//map.put("value", model.getAsNumber());
return map;
}
private Map<String, Object> getTemplateModelData(TemplateHashModelEx model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "HashModelEx");;
//map.put("value", model.getAsDate());
return map;
}
private Map<String, Object> getTemplateModelData(TemplateMethodModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Method");
//map.put("value", model.getAsNumber());
return map;
}
private Map<String, Object> getTemplateModelData(TemplateDirectiveModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Directive");;
//map.put("value", model.getAsDate());
return map;
}
private Map<String, Object> getTemplateModelData(TemplateModel model) throws TemplateModelException {
// One of the above cases should have applied. Track whether this actually occurs.
log.debug("Found model with no known type"); //
Map<String, Object> map = new HashMap<String, Object>();
Object unwrappedModel = DeepUnwrap.permissiveUnwrap(model);
map.put("type", unwrappedModel.getClass().getName());
map.put("value", unwrappedModel.toString());
return map;
}
protected void dump(String templateName, Map<String, Object> map, String modelName, Environment env)
throws TemplateException, IOException {
Template template = env.getConfiguration().getTemplate(templateName);
StringWriter sw = new StringWriter();
template.process(map, sw);
Writer out = env.getOut();
out.write(sw.toString());
}
}

50
webapp/src/freemarker/ext/dump/DumpDirective.java Normal file
View file

@ -0,0 +1,50 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package freemarker.ext.dump;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import freemarker.core.Environment;
import freemarker.template.SimpleScalar;
import freemarker.template.TemplateDirectiveBody;
import freemarker.template.TemplateException;
import freemarker.template.TemplateModel;
import freemarker.template.TemplateModelException;
public class DumpDirective extends BaseDumpDirective {
@SuppressWarnings("unused")
private static final Log log = LogFactory.getLog(DumpDirective.class);
@SuppressWarnings("rawtypes")
@Override
public void execute(Environment env, Map params, TemplateModel[] loopVars,
TemplateDirectiveBody body) throws TemplateException, IOException {
if (loopVars.length != 0) {
throw new TemplateModelException(
"The dump directive doesn't allow loop variables.");
}
if (body != null) {
throw new TemplateModelException(
"The dump directive doesn't allow nested content.");
}
Object o = params.get("var");
if ( !(o instanceof SimpleScalar)) {
throw new TemplateModelException(
"Value of parameter 'var' must be a string.");
}
String varName = ((SimpleScalar)o).getAsString();
Map<String, Object> map = new HashMap<String, Object>();
map.put("var", getTemplateVariableData(varName, env));
dump("dumpvar.ftl", map, varName, env);
}
}

209
webapp/test/freemarker/ext/dump/DumpDirectiveTest.java Normal file
View file

@ -0,0 +1,209 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package freemarker.ext.dump;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import freemarker.core.Environment;
import freemarker.template.Configuration;
import freemarker.template.Template;
import freemarker.template.TemplateDirectiveBody;
import freemarker.template.TemplateDirectiveModel;
import freemarker.template.TemplateException;
import freemarker.template.TemplateMethodModel;
import freemarker.template.TemplateModel;
import freemarker.template.TemplateModelException;
public class DumpDirectiveTest {
private Template template;
@Before
public void setUp() {
Configuration config = new Configuration();
String templateStr = "";
try {
template = new Template("template", new StringReader(templateStr), config);
} catch (Exception e) {
Assert.fail(e.getMessage());
}
}
@Test
public void dumpString() {
String varName = "dog";
String value = "Rover";
Map<String, Object> dataModel = new HashMap<String, Object>();
dataModel.put(varName, value);
Map<String, Object> expected = new HashMap<String, Object>();
expected.put("name", varName);
expected.put("type", "String");
expected.put("value", value);
try {
Environment env = template.createProcessingEnvironment(dataModel, new StringWriter());
Map<String, Object> dumpData = new DumpDirective().getTemplateVariableData(varName, env);
Assert.assertEquals(expected, dumpData);
} catch (Exception e) {
Assert.fail(e.getMessage());
}
}
@Test
public void dumpBoolean() {
String varName = "hasSiteAdminAccess";
boolean value = true;
Map<String, Object> dataModel = new HashMap<String, Object>();
dataModel.put(varName, value);
Map<String, Object> expected = new HashMap<String, Object>();
expected.put("name", varName);
expected.put("type", "Boolean");
expected.put("value", value);
try {
Environment env = template.createProcessingEnvironment(dataModel, new StringWriter());
Map<String, Object> dumpData = new DumpDirective().getTemplateVariableData(varName, env);
Assert.assertEquals(expected, dumpData);
} catch (Exception e) {
Assert.fail(e.getMessage());
}
}
@Test
public void dumpNumber() {
String varName = "tabCount";
int value = 7;
Map<String, Object> dataModel = new HashMap<String, Object>();
dataModel.put(varName, value);
Map<String, Object> expected = new HashMap<String, Object>();
expected.put("name", varName);
expected.put("type", "Number");
expected.put("value", value);
try {
Environment env = template.createProcessingEnvironment(dataModel, new StringWriter());
Map<String, Object> dumpData = new DumpDirective().getTemplateVariableData(varName, env);
Assert.assertEquals(expected, dumpData);
} catch (Exception e) {
Assert.fail(e.getMessage());
}
}
@Test
public void dumpDate() {
String varName = "tabCount";
int value = 7;
Map<String, Object> dataModel = new HashMap<String, Object>();
dataModel.put(varName, value);
Map<String, Object> expected = new HashMap<String, Object>();
expected.put("name", varName);
expected.put("type", "Number");
expected.put("value", value);
try {
Environment env = template.createProcessingEnvironment(dataModel, new StringWriter());
Map<String, Object> dumpData = new DumpDirective().getTemplateVariableData(varName, env);
Assert.assertEquals(expected, dumpData);
} catch (Exception e) {
Assert.fail(e.getMessage());
}
}
// RY test method and directive types with and without help methods
@Test
public void dumpMethod() {
String varName = "profileUri";
TemplateMethodModel value = new StubMethodModel();
Map<String, Object> dataModel = new HashMap<String, Object>();
dataModel.put(varName, value);
Map<String, Object> expected = new HashMap<String, Object>();
expected.put("name", varName);
expected.put("type", "Method");
//expected.put("value", value);
try {
Environment env = template.createProcessingEnvironment(dataModel, new StringWriter());
Map<String, Object> dumpData = new DumpDirective().getTemplateVariableData(varName, env);
Assert.assertEquals(expected, dumpData);
} catch (Exception e) {
Assert.fail(e.getMessage());
}
}
@Test
public void dumpDirective() {
String varName = "widget";
TemplateDirectiveModel value = new StubDirectiveModel();
Map<String, Object> dataModel = new HashMap<String, Object>();
dataModel.put(varName, value);
Map<String, Object> expected = new HashMap<String, Object>();
expected.put("name", varName);
expected.put("type", "Directive");
//expected.put("value", value);
try {
Environment env = template.createProcessingEnvironment(dataModel, new StringWriter());
Map<String, Object> dumpData = new DumpDirective().getTemplateVariableData(varName, env);
Assert.assertEquals(expected, dumpData);
} catch (Exception e) {
Assert.fail(e.getMessage());
}
}
// RY Do these with different BeansWrappers
@Test
public void dumpSequence() {
}
@Test
public void dumpHash() {
}
@Test
public void dumpHashEx() {
}
private class StubMethodModel implements TemplateMethodModel {
@Override
public Object exec(List arg0) throws TemplateModelException {
return null;
}
}
private class StubDirectiveModel implements TemplateDirectiveModel {
@Override
public void execute(Environment arg0, Map arg1, TemplateModel[] arg2,
TemplateDirectiveBody arg3) throws TemplateException,
IOException {
}
}
}