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

NIHVIVO-1562 Replace hard-coded strings with enums in dump methods. Rudimentary template for variable dump.

Browse source
This commit is contained in:
ryounes 2011-04-11 22:05:36 +00:00
parent 306a6c8712
commit 79effb9a6e
3 changed files with 498 additions and 224 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

138
webapp/src/freemarker/ext/dump/BaseDumpDirective.java
View file

@ -7,7 +7,6 @@ import java.io.StringWriter;
import java.io.Writer; import java.io.Writer;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -42,25 +41,86 @@ public abstract class BaseDumpDirective implements TemplateDirectiveModel {
private static final Log log = LogFactory.getLog(BaseDumpDirective.class); private static final Log log = LogFactory.getLog(BaseDumpDirective.class);
enum Key {
NAME("name"),
TYPE("type"),
VALUE("value"),
DATE_TYPE("dateType");
private final String key;
Key(String key) {
this.key = key;
}
public String toString() {
return key;
}
}
enum Type {
STRING("String"),
NUMBER("Number"),
BOOLEAN("Boolean"),
DATE("Date"),
SEQUENCE("Sequence"),
HASH("Hash"),
HASH_EX("HashEx"),
COLLECTION("Collection"),
METHOD("Method"),
DIRECTIVE("Directive");
private final String type;
Type(String type) {
this.type = type;
}
public String toString() {
return type;
}
}
enum DateType {
DATE("Date"),
DATETIME("DateTime"),
TIME("Time"),
UNKNOWN("Unknown");
private final String type;
DateType(String type) {
this.type = type;
}
public String toString() {
return type;
}
}
protected Map<String, Object> getTemplateVariableData(String varName, Environment env) protected Map<String, Object> getTemplateVariableData(String varName, Environment env)
throws TemplateModelException { throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.put("name", varName); map.put(Key.NAME.toString(), varName);
TemplateHashModel dataModel = env.getDataModel(); TemplateHashModel dataModel = env.getDataModel();
TemplateModel model = dataModel.get(varName); TemplateModel model = dataModel.get(varName);
// TemplateMethodModel and TemplateDirectiveModel objects can only be // Don't return null if model == null. We still want to send the map to the template.
// included in the data model at the top level. if (model != null) {
if (model instanceof TemplateMethodModel) { // TemplateMethodModel and TemplateDirectiveModel objects can only be
map.putAll( getTemplateModelData( ( TemplateMethodModel)model, varName ) ); // included in the data model at the top level.
if (model instanceof TemplateMethodModel) {
} else if (model instanceof TemplateDirectiveModel) { map.putAll( getTemplateModelData( ( TemplateMethodModel)model, varName ) );
map.putAll( getTemplateModelData( ( TemplateDirectiveModel)model, varName ) );
} else if (model instanceof TemplateDirectiveModel) {
} else { map.putAll( getTemplateModelData( ( TemplateDirectiveModel)model, varName ) );
map.putAll(getData(model));
} else {
map.putAll(getData(model));
}
} }
return map; return map;
@ -109,47 +169,47 @@ public abstract class BaseDumpDirective implements TemplateDirectiveModel {
private Map<String, Object> getTemplateModelData(TemplateScalarModel model) throws TemplateModelException { private Map<String, Object> getTemplateModelData(TemplateScalarModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "String"); map.put(Key.TYPE.toString(), Type.STRING);
map.put("value", model.getAsString()); map.put(Key.VALUE.toString(), model.getAsString());
return map; return map;
} }
private Map<String, Object> getTemplateModelData(TemplateBooleanModel model) throws TemplateModelException { private Map<String, Object> getTemplateModelData(TemplateBooleanModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Boolean"); map.put(Key.TYPE.toString(), Type.BOOLEAN);
map.put("value", model.getAsBoolean()); map.put(Key.VALUE.toString(), model.getAsBoolean());
return map; return map;
} }
private Map<String, Object> getTemplateModelData(TemplateNumberModel model) throws TemplateModelException { private Map<String, Object> getTemplateModelData(TemplateNumberModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Number"); map.put(Key.TYPE.toString(), Type.NUMBER);
map.put("value", model.getAsNumber()); map.put(Key.VALUE.toString(), model.getAsNumber());
return map; return map;
} }
private Map<String, Object> getTemplateModelData(TemplateDateModel model) throws TemplateModelException { private Map<String, Object> getTemplateModelData(TemplateDateModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Date"); map.put(Key.TYPE.toString(), Type.DATE);
int dateType = model.getDateType(); int dateType = model.getDateType();
String type; DateType type;
switch (dateType) { switch (dateType) {
case TemplateDateModel.DATE: case TemplateDateModel.DATE:
type = "Date"; type = DateType.DATE;
break; break;
case TemplateDateModel.DATETIME: case TemplateDateModel.DATETIME:
type = "DateTime"; type = DateType.DATETIME;
break; break;
case TemplateDateModel.TIME: case TemplateDateModel.TIME:
type = "Time"; type = DateType.TIME;
break; break;
default: default:
type = "Unknown"; type = DateType.UNKNOWN;
} }
map.put("dateType", type); map.put(Key.DATE_TYPE.toString(), type);
map.put("value", model.getAsDate()); map.put(Key.VALUE.toString(), model.getAsDate());
return map; return map;
} }
@ -157,27 +217,27 @@ public abstract class BaseDumpDirective implements TemplateDirectiveModel {
// The data model is a hash; when else do we get here? // The data model is a hash; when else do we get here?
log.debug("Dumping model " + model); log.debug("Dumping model " + model);
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Hash"); map.put(Key.TYPE.toString(), Type.HASH);
//map.put("value", model.getAsBoolean()); //map.put(Key.VALUE.toString(), ????);
return map; return map;
} }
private Map<String, Object> getTemplateModelData(TemplateSequenceModel model) throws TemplateModelException { private Map<String, Object> getTemplateModelData(TemplateSequenceModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Sequence"); map.put(Key.TYPE.toString(), Type.SEQUENCE);
int itemCount = model.size(); int itemCount = model.size();
List<Map<String, Object>> items = new ArrayList<Map<String, Object>>(itemCount); List<Map<String, Object>> items = new ArrayList<Map<String, Object>>(itemCount);
for ( int i = 0; i < itemCount; i++ ) { for ( int i = 0; i < itemCount; i++ ) {
TemplateModel item = model.get(i); TemplateModel item = model.get(i);
items.add(getData(item)); items.add(getData(item));
} }
map.put("value", items); map.put(Key.VALUE.toString(), items);
return map; return map;
} }
private Map<String, Object> getTemplateModelData(TemplateHashModelEx model) throws TemplateModelException { private Map<String, Object> getTemplateModelData(TemplateHashModelEx model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "HashEx"); map.put(Key.TYPE.toString(), Type.HASH_EX);
Map<String, Object> items = new HashMap<String, Object>(); Map<String, Object> items = new HashMap<String, Object>();
// keys() gets only values visible to template // keys() gets only values visible to template
TemplateCollectionModel keys = model.keys(); TemplateCollectionModel keys = model.keys();
@ -187,33 +247,33 @@ public abstract class BaseDumpDirective implements TemplateDirectiveModel {
TemplateModel value = model.get(key); TemplateModel value = model.get(key);
items.put(key, getData(value)); items.put(key, getData(value));
} }
map.put("value", items); map.put(Key.VALUE.toString(), items);
return map; return map;
} }
private Map<String, Object> getTemplateModelData(TemplateCollectionModel model) throws TemplateModelException { private Map<String, Object> getTemplateModelData(TemplateCollectionModel model) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Collection"); map.put(Key.TYPE.toString(), Type.COLLECTION);
List<Map<String, Object>> items = new ArrayList<Map<String, Object>>(); List<Map<String, Object>> items = new ArrayList<Map<String, Object>>();
TemplateModelIterator iModel = model.iterator(); TemplateModelIterator iModel = model.iterator();
while (iModel.hasNext()) { while (iModel.hasNext()) {
TemplateModel m = iModel.next(); TemplateModel m = iModel.next();
items.add(getData(m)); items.add(getData(m));
} }
map.put("value", items); map.put(Key.VALUE.toString(), items);
return map; return map;
} }
private Map<String, Object> getTemplateModelData(TemplateMethodModel model, String varName) throws TemplateModelException { private Map<String, Object> getTemplateModelData(TemplateMethodModel model, String varName) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Method"); map.put(Key.TYPE.toString(), Type.METHOD);
map.put("help", getHelp(model, varName)); map.put("help", getHelp(model, varName));
return map; return map;
} }
private Map<String, Object> getTemplateModelData(TemplateDirectiveModel model, String varName) throws TemplateModelException { private Map<String, Object> getTemplateModelData(TemplateDirectiveModel model, String varName) throws TemplateModelException {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.put("type", "Directive"); map.put(Key.TYPE.toString(), Type.DIRECTIVE);
map.put("help", getHelp(model, varName)); map.put("help", getHelp(model, varName));
return map; return map;
} }
@ -244,8 +304,8 @@ public abstract class BaseDumpDirective implements TemplateDirectiveModel {
log.debug("Found model with no known type"); log.debug("Found model with no known type");
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
Object unwrappedModel = DeepUnwrap.permissiveUnwrap(model); Object unwrappedModel = DeepUnwrap.permissiveUnwrap(model);
map.put("type", unwrappedModel.getClass().getName()); map.put(Key.TYPE.toString(), unwrappedModel.getClass().getName());
map.put("value", unwrappedModel.toString()); map.put(Key.VALUE.toString(), unwrappedModel.toString());
return map; return map;
} }

555
webapp/test/freemarker/ext/dump/DumpDirectiveTest.java
View file

@ -11,7 +11,7 @@ import java.io.StringWriter;
import java.sql.Time; import java.sql.Time;
import java.sql.Timestamp; import java.sql.Timestamp;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Calendar;
import java.util.Date; import java.util.Date;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet; import java.util.HashSet;
@ -25,6 +25,9 @@ import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import freemarker.core.Environment; import freemarker.core.Environment;
import freemarker.ext.dump.BaseDumpDirective.Type;
import freemarker.ext.dump.BaseDumpDirective.DateType;
import freemarker.ext.dump.BaseDumpDirective.Key;
import freemarker.template.Configuration; import freemarker.template.Configuration;
import freemarker.template.SimpleCollection; import freemarker.template.SimpleCollection;
import freemarker.template.Template; import freemarker.template.Template;
@ -40,6 +43,8 @@ public class DumpDirectiveTest {
private Template template; private Template template;
@Before @Before
public void setUp() { public void setUp() {
Configuration config = new Configuration(); Configuration config = new Configuration();
@ -62,12 +67,12 @@ public class DumpDirectiveTest {
String value = "Rover"; String value = "Rover";
dataModel.put(varName, value); dataModel.put(varName, value);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "String"); expectedDump.put(Key.TYPE.toString(), Type.STRING);
expected.put("value", value); expectedDump.put(Key.VALUE.toString(), value);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -79,12 +84,12 @@ public class DumpDirectiveTest {
boolean value = true; boolean value = true;
dataModel.put(varName, value); dataModel.put(varName, value);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Boolean"); expectedDump.put(Key.TYPE.toString(), Type.BOOLEAN);
expected.put("value", value); expectedDump.put(Key.VALUE.toString(), value);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -96,12 +101,12 @@ public class DumpDirectiveTest {
int value = 7; int value = 7;
dataModel.put(varName, value); dataModel.put(varName, value);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Number"); expectedDump.put(Key.TYPE.toString(), Type.NUMBER);
expected.put("value", value); expectedDump.put(Key.VALUE.toString(), value);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -113,13 +118,13 @@ public class DumpDirectiveTest {
Date now = new Date(); Date now = new Date();
dataModel.put(varName, now); dataModel.put(varName, now);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Date"); expectedDump.put(Key.TYPE.toString(), Type.DATE);
expected.put("dateType", "Unknown"); expectedDump.put(Key.DATE_TYPE.toString(), DateType.UNKNOWN);
expected.put("value", now); expectedDump.put(Key.VALUE.toString(), now);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -131,13 +136,13 @@ public class DumpDirectiveTest {
Timestamp ts = new Timestamp(1302297332043L); Timestamp ts = new Timestamp(1302297332043L);
dataModel.put(varName, ts); dataModel.put(varName, ts);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Date"); expectedDump.put(Key.TYPE.toString(), Type.DATE);
expected.put("dateType", "DateTime"); expectedDump.put(Key.DATE_TYPE.toString(), DateType.DATETIME);
expected.put("value", ts); expectedDump.put(Key.VALUE.toString(), ts);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -149,13 +154,13 @@ public class DumpDirectiveTest {
java.sql.Date date = new java.sql.Date(1302297332043L); java.sql.Date date = new java.sql.Date(1302297332043L);
dataModel.put(varName, date); dataModel.put(varName, date);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Date"); expectedDump.put(Key.TYPE.toString(), Type.DATE);
expected.put("dateType", "Date"); expectedDump.put(Key.DATE_TYPE.toString(), DateType.DATE);
expected.put("value", date); expectedDump.put(Key.VALUE.toString(), date);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -167,13 +172,13 @@ public class DumpDirectiveTest {
Time time = new Time(1302297332043L); Time time = new Time(1302297332043L);
dataModel.put(varName, time); dataModel.put(varName, time);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Date"); expectedDump.put(Key.TYPE.toString(), Type.DATE);
expected.put("dateType", "Time"); expectedDump.put(Key.DATE_TYPE.toString(), DateType.TIME);
expected.put("value", time); expectedDump.put(Key.VALUE.toString(), time);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
// RY test method and directive types with and without help methods // RY test method and directive types with and without help methods
@ -184,15 +189,15 @@ public class DumpDirectiveTest {
String varName = "square"; String varName = "square";
Map<String, Object> dataModel = new HashMap<String, Object>(); Map<String, Object> dataModel = new HashMap<String, Object>();
TemplateMethodModel value = new HelplessMethod(); TemplateMethodModel methodModel = new HelplessMethod();
dataModel.put(varName, value); dataModel.put(varName, methodModel);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Method"); expectedDump.put(Key.TYPE.toString(), Type.METHOD);
expected.put("help", null); expectedDump.put("help", null);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -201,15 +206,15 @@ public class DumpDirectiveTest {
String varName = "square"; String varName = "square";
Map<String, Object> dataModel = new HashMap<String, Object>(); Map<String, Object> dataModel = new HashMap<String, Object>();
TemplateMethodModel value = new HelpfulMethod(); TemplateMethodModel methodModel = new HelpfulMethod();
dataModel.put(varName, value); dataModel.put(varName, methodModel);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Method"); expectedDump.put(Key.TYPE.toString(), Type.METHOD);
expected.put("help", getMethodHelp(varName)); expectedDump.put("help", getMethodHelp(varName));
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -218,15 +223,15 @@ public class DumpDirectiveTest {
String varName = "square"; String varName = "square";
Map<String, Object> dataModel = new HashMap<String, Object>(); Map<String, Object> dataModel = new HashMap<String, Object>();
TemplateMethodModel value = new MethodWithBadHelp(); TemplateMethodModel methodModel = new MethodWithBadHelp();
dataModel.put(varName, value); dataModel.put(varName, methodModel);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Method"); expectedDump.put(Key.TYPE.toString(), Type.METHOD);
expected.put("help", null); expectedDump.put("help", null);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -235,15 +240,15 @@ public class DumpDirectiveTest {
String varName = "dump"; String varName = "dump";
Map<String, Object> dataModel = new HashMap<String, Object>(); Map<String, Object> dataModel = new HashMap<String, Object>();
TemplateDirectiveModel value = new HelplessDirective(); TemplateDirectiveModel directiveModel = new HelplessDirective();
dataModel.put(varName, value); dataModel.put(varName, directiveModel);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Directive"); expectedDump.put(Key.TYPE.toString(), Type.DIRECTIVE);
expected.put("help", null); expectedDump.put("help", null);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -252,15 +257,15 @@ public class DumpDirectiveTest {
String varName = "dump"; String varName = "dump";
Map<String, Object> dataModel = new HashMap<String, Object>(); Map<String, Object> dataModel = new HashMap<String, Object>();
TemplateDirectiveModel value = new HelpfulDirective(); TemplateDirectiveModel directiveModel = new HelpfulDirective();
dataModel.put(varName, value); dataModel.put(varName, directiveModel);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Directive"); expectedDump.put(Key.TYPE.toString(), Type.DIRECTIVE);
expected.put("help", getDirectiveHelp(varName)); expectedDump.put("help", getDirectiveHelp(varName));
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -269,15 +274,15 @@ public class DumpDirectiveTest {
String varName = "dump"; String varName = "dump";
Map<String, Object> dataModel = new HashMap<String, Object>(); Map<String, Object> dataModel = new HashMap<String, Object>();
TemplateDirectiveModel value = new DirectiveWithBadHelp(); TemplateDirectiveModel directiveModel = new DirectiveWithBadHelp();
dataModel.put(varName, value); dataModel.put(varName, directiveModel);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Directive"); expectedDump.put(Key.TYPE.toString(), Type.DIRECTIVE);
expected.put("help", null); expectedDump.put("help", null);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -292,19 +297,19 @@ public class DumpDirectiveTest {
list.add("oranges"); list.add("oranges");
dataModel.put(varName, list); dataModel.put(varName, list);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Sequence"); expectedDump.put(Key.TYPE.toString(), Type.SEQUENCE);
List<Map<String, Object>> dump = new ArrayList<Map<String, Object>>(); List<Map<String, Object>> listDump = new ArrayList<Map<String, Object>>(list.size());
for ( String str : list) { for ( String str : list) {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> itemDump = new HashMap<String, Object>();
map.put("type", "String"); itemDump.put(Key.TYPE.toString(), Type.STRING);
map.put("value", str); itemDump.put(Key.VALUE.toString(), str);
dump.add(map); listDump.add(itemDump);
} }
expected.put("value", dump); expectedDump.put(Key.VALUE.toString(), listDump);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -313,22 +318,22 @@ public class DumpDirectiveTest {
String varName = "fruit"; String varName = "fruit";
Map<String, Object> dataModel = new HashMap<String, Object>(); Map<String, Object> dataModel = new HashMap<String, Object>();
String[] list = { "apples", "bananas", "oranges" }; String[] arr = { "apples", "bananas", "oranges" };
dataModel.put(varName, list); dataModel.put(varName, arr);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Sequence"); expectedDump.put(Key.TYPE.toString(), Type.SEQUENCE);
List<Map<String, Object>> dump = new ArrayList<Map<String, Object>>(); List<Map<String, Object>> arrDump = new ArrayList<Map<String, Object>>(arr.length);
for ( String str : list) { for ( String str : arr) {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> itemDump = new HashMap<String, Object>();
map.put("type", "String"); itemDump.put(Key.TYPE.toString(), Type.STRING);
map.put("value", str); itemDump.put(Key.VALUE.toString(), str);
dump.add(map); arrDump.add(itemDump);
} }
expected.put("value", dump); expectedDump.put(Key.VALUE.toString(), arrDump);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -337,54 +342,61 @@ public class DumpDirectiveTest {
String varName = "stuff"; String varName = "stuff";
Map<String, Object> dataModel = new HashMap<String, Object>(); Map<String, Object> dataModel = new HashMap<String, Object>();
List<Object> list = new ArrayList<Object>(); List<Object> mixedList = new ArrayList<Object>();
list.add("apples");
list.add(4);
list.add(false);
List<String> animals = new ArrayList<String>();
animals.add("dog");
animals.add("cat");
animals.add("elephant");
Collections.sort(animals);
list.add(animals);
dataModel.put(varName, list);
Map<String, Object> expected = new HashMap<String, Object>(); String myString = "apples";
expected.put("name", varName); mixedList.add(myString);
expected.put("type", "Sequence");
List<Map<String, Object>> dump = new ArrayList<Map<String, Object>>(); int myInt = 4;
mixedList.add(myInt);
Map<String, Object> stringMap = new HashMap<String, Object>(); boolean myBool = true;
stringMap.put("type", "String"); mixedList.add(myBool);
stringMap.put("value", "apples");
dump.add(stringMap); List<String> myList = new ArrayList<String>();
myList.add("dog");
myList.add("cat");
myList.add("elephant");
mixedList.add(myList);
dataModel.put(varName, mixedList);
Map<String, Object> expectedDump = new HashMap<String, Object>();
expectedDump.put(Key.NAME.toString(), varName);
expectedDump.put(Key.TYPE.toString(), Type.SEQUENCE);
List<Map<String, Object>> mixedListDump = new ArrayList<Map<String, Object>>(mixedList.size());
Map<String, Object> stringDump = new HashMap<String, Object>();
stringDump.put(Key.TYPE.toString(), Type.STRING);
stringDump.put(Key.VALUE.toString(), myString);
mixedListDump.add(stringDump);
Map<String, Object> numberMap = new HashMap<String, Object>(); Map<String, Object> numberDump = new HashMap<String, Object>();
numberMap.put("type", "Number"); numberDump.put(Key.TYPE.toString(), Type.NUMBER);
numberMap.put("value", 4); numberDump.put(Key.VALUE.toString(), myInt);
dump.add(numberMap); mixedListDump.add(numberDump);
Map<String, Object> booleanMap = new HashMap<String, Object>(); Map<String, Object> booleanDump = new HashMap<String, Object>();
booleanMap.put("type", "Boolean"); booleanDump.put(Key.TYPE.toString(), Type.BOOLEAN);
booleanMap.put("value", false); booleanDump.put(Key.VALUE.toString(), myBool);
dump.add(booleanMap); mixedListDump.add(booleanDump);
Map<String, Object> sequenceMap = new HashMap<String, Object>(); Map<String, Object> myListDump = new HashMap<String, Object>();
sequenceMap.put("type", "Sequence"); myListDump.put(Key.TYPE.toString(), Type.SEQUENCE);
List<Map<String, Object>> animalDump = new ArrayList<Map<String, Object>>(); List<Map<String, Object>> itemsDump = new ArrayList<Map<String, Object>>(myList.size());
for ( String animal : animals ) { for ( String animal : myList ) {
Map<String, Object> animalMap = new HashMap<String, Object>(); Map<String, Object> itemDump = new HashMap<String, Object>();
animalMap.put("type", "String"); itemDump.put(Key.TYPE.toString(), Type.STRING);
animalMap.put("value", animal); itemDump.put(Key.VALUE.toString(), animal);
animalDump.add(animalMap); itemsDump.add(itemDump);
} }
sequenceMap.put("value", animalDump); myListDump.put(Key.VALUE.toString(), itemsDump);
dump.add(sequenceMap); mixedListDump.add(myListDump);
expected.put("value", dump); expectedDump.put(Key.VALUE.toString(), mixedListDump);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -401,19 +413,19 @@ public class DumpDirectiveTest {
} }
dataModel.put(varName, odds); dataModel.put(varName, odds);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Sequence"); expectedDump.put(Key.TYPE.toString(), Type.SEQUENCE);
List<Map<String, Object>> dump = new ArrayList<Map<String, Object>>(); List<Map<String, Object>> sequenceDump = new ArrayList<Map<String, Object>>(odds.size());
for ( int i : odds ) { for ( int i : odds ) {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> itemDump = new HashMap<String, Object>();
map.put("type", "Number"); itemDump.put(Key.TYPE.toString(), Type.NUMBER);
map.put("value", i); itemDump.put(Key.VALUE.toString(), i);
dump.add(map); sequenceDump.add(itemDump);
} }
expected.put("value", dump); expectedDump.put(Key.VALUE.toString(), sequenceDump);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -431,19 +443,19 @@ public class DumpDirectiveTest {
TemplateCollectionModel collection = new SimpleCollection(odds); TemplateCollectionModel collection = new SimpleCollection(odds);
dataModel.put(varName, collection); dataModel.put(varName, collection);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "Collection"); expectedDump.put(Key.TYPE.toString(), Type.COLLECTION);
List<Map<String, Object>> dump = new ArrayList<Map<String, Object>>(); List<Map<String, Object>> collectionDump = new ArrayList<Map<String, Object>>(odds.size());
for ( int i : odds ) { for ( int i : odds ) {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> itemDump = new HashMap<String, Object>();
map.put("type", "Number"); itemDump.put(Key.TYPE.toString(), Type.NUMBER);
map.put("value", i); itemDump.put(Key.VALUE.toString(), i);
dump.add(map); collectionDump.add(itemDump);
} }
expected.put("value", dump); expectedDump.put(Key.VALUE.toString(), collectionDump);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
} }
@Test @Test
@ -452,42 +464,165 @@ public class DumpDirectiveTest {
} }
// RY Do these with different BeansWrappers // RY Do these with different BeansWrappers
@Test @Test
public void dumpStringToStringMap() { public void dumpStringToStringMap() {
String varName = "capitals"; String varName = "capitals";
Map<String, Object> dataModel = new HashMap<String, Object>(); Map<String, Object> dataModel = new HashMap<String, Object>();
Map<String, String> capitals = new HashMap<String, String>(); Map<String, String> myMap = new HashMap<String, String>();
capitals.put("Albany", "New York"); myMap.put("Albany", "New York");
capitals.put("St. Paul", "Minnesota"); myMap.put("St. Paul", "Minnesota");
capitals.put("Austin", "Texas"); myMap.put("Austin", "Texas");
capitals.put("Sacramento", "California"); myMap.put("Sacramento", "California");
capitals.put("Richmond", "Virginia"); myMap.put("Richmond", "Virginia");
dataModel.put(varName, capitals); dataModel.put(varName, myMap);
Map<String, Object> expected = new HashMap<String, Object>(); Map<String, Object> expectedDump = new HashMap<String, Object>();
expected.put("name", varName); expectedDump.put(Key.NAME.toString(), varName);
expected.put("type", "HashEx"); expectedDump.put(Key.TYPE.toString(), Type.HASH_EX);
Map<String, Object> dump = new HashMap<String, Object>(); Map<String, Object> myMapDump = new HashMap<String, Object>(myMap.size());
for ( String key : capitals.keySet() ) { for ( String key : myMap.keySet() ) {
Map<String, String> capitalDump = new HashMap<String, String>(); Map<String, Object> itemDump = new HashMap<String, Object>();
capitalDump.put("type", "String"); itemDump.put(Key.TYPE.toString(), Type.STRING);
capitalDump.put("value", capitals.get(key)); itemDump.put(Key.VALUE.toString(), myMap.get(key));
dump.put(key, capitalDump); myMapDump.put(key, itemDump);
} }
expected.put("value", dump); expectedDump.put(Key.VALUE.toString(), myMapDump);
test(varName, dataModel, expected); test(varName, dataModel, expectedDump);
}
@Test
public void dumpStringToObjectMap() {
String varName = "stuff";
Map<String, Object> dataModel = new HashMap<String, Object>();
Map<String, Object> mixedMap = new HashMap<String, Object>();
String myString = "apples";
mixedMap.put("myString", myString);
boolean myBool = true;
mixedMap.put("myBoolean", myBool);
int myInt = 4;
mixedMap.put("myNumber", myInt);
Date now = new Date();
mixedMap.put("myDate", now);
List<String> myList = new ArrayList<String>();
myList.add("apples");
myList.add("bananas");
myList.add("oranges");
mixedMap.put("myList", myList);
Map<String, String> myMap = new HashMap<String, String>();
myMap.put("Great Expectations", "Charles Dickens");
myMap.put("Pride and Prejudice", "Jane Austen");
myMap.put("Middlemarch", "George Eliot");
myMap.put("Jude the Obscure", "Thomas Hardy");
mixedMap.put("myMap", myMap);
dataModel.put(varName, mixedMap);
Map<String, Object> expectedDump = new HashMap<String, Object>();
expectedDump.put(Key.NAME.toString(), varName);
expectedDump.put(Key.TYPE.toString(), Type.HASH_EX);
Map<String, Object> mixedMapDump = new HashMap<String, Object>(mixedMap.size());
Map<String, Object> myStringDump = new HashMap<String, Object>();
myStringDump.put(Key.TYPE.toString(), Type.STRING);
myStringDump.put(Key.VALUE.toString(), myString);
mixedMapDump.put("myString", myStringDump);
Map<String, Object> myBooleanDump = new HashMap<String, Object>();
myBooleanDump.put(Key.TYPE.toString(), Type.BOOLEAN);
myBooleanDump.put(Key.VALUE.toString(), myBool);
mixedMapDump.put("myBoolean", myBooleanDump);
Map<String, Object> myNumberDump = new HashMap<String, Object>();
myNumberDump.put(Key.TYPE.toString(), Type.NUMBER);
myNumberDump.put(Key.VALUE.toString(), myInt);
mixedMapDump.put("myNumber", myNumberDump);
Map<String, Object> myDateDump = new HashMap<String, Object>();
myDateDump.put(Key.TYPE.toString(), Type.DATE);
myDateDump.put(Key.DATE_TYPE.toString(), DateType.UNKNOWN);
myDateDump.put(Key.VALUE.toString(), now);
mixedMapDump.put("myDate", myDateDump);
Map<String, Object> myListDump = new HashMap<String, Object>();
myListDump.put(Key.TYPE.toString(), Type.SEQUENCE);
List<Map<String, Object>> listItemsDump = new ArrayList<Map<String, Object>>(myList.size());
for ( String item : myList ) {
Map<String, Object> itemDump = new HashMap<String, Object>();
itemDump.put(Key.TYPE.toString(), Type.STRING);
itemDump.put(Key.VALUE.toString(), item);
listItemsDump.add(itemDump);
}
myListDump.put(Key.VALUE.toString(), listItemsDump);
mixedMapDump.put("myList", myListDump);
Map<String, Object> myMapDump = new HashMap<String, Object>();
myMapDump.put(Key.TYPE.toString(), Type.HASH_EX);
Map<String, Object> mapItemsDump = new HashMap<String, Object>(myMap.size());
for ( String key : myMap.keySet() ) {
Map<String, Object> itemDump = new HashMap<String, Object>();
itemDump.put(Key.TYPE.toString(), Type.STRING);
itemDump.put(Key.VALUE.toString(), myMap.get(key));
mapItemsDump.put(key, itemDump);
}
myMapDump.put(Key.VALUE.toString(), mapItemsDump);
mixedMapDump.put("myMap", myMapDump);
expectedDump.put(Key.VALUE.toString(), mixedMapDump);
test(varName, dataModel, expectedDump);
}
@Test
public void dumpObject() {
String varName = "employee";
Map<String, Object> dataModel = new HashMap<String, Object>();
Calendar c = Calendar.getInstance();
c.set(75, Calendar.MAY, 5);
Employee jdoe = new Employee("John Doe", c.getTime(), 34523);
c.set(65, Calendar.AUGUST, 10);
Employee jsmith = new Employee("Jane Smith", c.getTime(), 11111);
c.set(80, Calendar.JUNE, 20);
Employee mjones = new Employee("Michael Jones", c.getTime(), 22222);
c.set(81, Calendar.NOVEMBER, 30);
Employee mturner = new Employee("Mary Turner", c.getTime(), 33333);
List<Employee> supervisees = new ArrayList<Employee>();
supervisees.add(mjones);
supervisees.add(mturner);
jdoe.setSupervisor(jsmith);
jdoe.setSupervisees(supervisees);
jdoe.setSalary(65000);
dataModel.put("employee", jdoe);
Map<String, Object> expectedDump = new HashMap<String, Object>();
} }
/////////////////////////// Private stub classes and helper methods /////////////////////////// /////////////////////////// Private stub classes and helper methods ///////////////////////////
private void test(String varName, Map<String, Object> dataModel, Map<String, Object> expected) { private void test(String varName, Map<String, Object> dataModel, Map<String, Object> expectedDump) {
try { try {
Environment env = template.createProcessingEnvironment(dataModel, new StringWriter()); Environment env = template.createProcessingEnvironment(dataModel, new StringWriter());
Map<String, Object> dumpData = new DumpDirective().getTemplateVariableData(varName, env); Map<String, Object> dumpData = new DumpDirective().getTemplateVariableData(varName, env);
assertEquals(expected, dumpData); assertEquals(expectedDump, dumpData);
} catch (Exception e) { } catch (Exception e) {
fail(e.getMessage()); fail(e.getMessage());
} }
@ -581,7 +716,7 @@ public class DumpDirectiveTest {
private Map<String, Object> getMethodHelp(String name) { private Map<String, Object> getMethodHelp(String name) {
Map<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>();
map.put("name", name); map.put(Key.NAME.toString(), name);
map.put("returns", "The square of the argument"); map.put("returns", "The square of the argument");
@ -596,5 +731,55 @@ public class DumpDirectiveTest {
return map; return map;
} }
private class Employee {
private String name;
private Date birthdate;
private int id;
private Employee supervisor;
private List<Employee> supervisees;
private float salary;
Employee(String name, Date birthdate, int id) {
this.name = name;
this.birthdate = birthdate;
this.id = id;
}
String getName() {
return name;
}
Date getBirthdate() {
return birthdate;
}
int getId() {
return id;
}
void setSupervisor(Employee supervisor) {
this.supervisor = supervisor;
}
public Employee getSupervisor() {
return supervisor;
}
void setSupervisees(List<Employee> supervisees) {
this.supervisees = supervisees;
}
public List<Employee> getSupervisees() {
return supervisees;
}
void setSalary(float salary) {
this.salary = salary;
}
float getSalary() {
return salary;
}
}
} }

29
webapp/web/templates/freemarker/body/partials/dump/dumpvar.ftl Normal file
View file

@ -0,0 +1,29 @@
<#-- $This file is distributed under the terms of the license in /doc/license.txt$ -->
<#-- Styles here are temporary; move to css file once stylesheets.add() works -->
<style>
div.dump.var {
padding-top: .75em;
padding-bottom: .75em;
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
margin-bottom: .5em;
}
div.dump.var p {
margin-bottom: .5em;
}
</style>
<div class="dump var">
<p><strong>Variable name:</strong> ${var.name}</p>
<p><strong>Type:</strong> ${var.type}</p>
<p><strong>Value:</strong> ${var.value}</p>
</div>
<#-- This will work after we move stylesheets to Configuration sharedVariables
${stylesheets.add('<link rel="stylesheet" href="/css/fmdump.css">')}
-->