force keyNode to be String for JavaBeans

fixes issue #522 - it is possible now use properties with names equal
to the values accepted as boolean in YAML 1.1

2 files changed, 25 insertions, 10 deletions

diff --git a/src/main/java/org/yaml/snakeyaml/constructor/Constructor.java b/src/main/java/org/yaml/snakeyaml/constructor/Constructor.java
index 8caffa82..0999ec35 100644
--- a/src/main/java/org/yaml/snakeyaml/constructor/Constructor.java
+++ b/src/main/java/org/yaml/snakeyaml/constructor/Constructor.java
@@ -216,7 +216,7 @@ public class Constructor extends SafeConstructor {
         // }
 
         protected Object constructJavaBean2ndStep(MappingNode node, Object object) {
-            flattenMapping(node);
+            flattenMapping(node, true);
             Class<? extends Object> beanType = node.getType();
             List<NodeTuple> nodeValue = node.getValue();
             for (NodeTuple tuple : nodeValue) {
@@ -229,8 +229,7 @@ public class Constructor extends SafeConstructor {
                             "Keys must be scalars but found: " + tuple.getKeyNode());
                 }
                 Node valueNode = tuple.getValueNode();
-                // keys can only be Strings
-                keyNode.setType(String.class);
+                // flattenMapping enforces keys to be Strings
                 String key = (String) constructObject(keyNode);
                 try {
                     TypeDescription memberDescription = typeDefinitions.get(beanType);
diff --git a/src/main/java/org/yaml/snakeyaml/constructor/SafeConstructor.java b/src/main/java/org/yaml/snakeyaml/constructor/SafeConstructor.java
index 2578bd3b..8e7ddb0c 100644
--- a/src/main/java/org/yaml/snakeyaml/constructor/SafeConstructor.java
+++ b/src/main/java/org/yaml/snakeyaml/constructor/SafeConstructor.java
@@ -72,15 +72,23 @@ public class SafeConstructor extends BaseConstructor {
     }
 
     protected void flattenMapping(MappingNode node) {
+        flattenMapping(node, false);
+    }
+
+    protected void flattenMapping(MappingNode node, boolean forceStringKeys) {
         // perform merging only on nodes containing merge node(s)
-        processDuplicateKeys(node);
+        processDuplicateKeys(node, forceStringKeys);
         if (node.isMerged()) {
             node.setValue(mergeNode(node, true, new HashMap<Object, Integer>(),
-                    new ArrayList<NodeTuple>()));
+                    new ArrayList<NodeTuple>(), forceStringKeys));
         }
     }
 
     protected void processDuplicateKeys(MappingNode node) {
+        processDuplicateKeys(node, false);
+    }
+
+    protected void processDuplicateKeys(MappingNode node, boolean forceStringKeys) {
         List<NodeTuple> nodeValue = node.getValue();
         Map<Object, Integer> keys = new HashMap<Object, Integer>(nodeValue.size());
         TreeSet<Integer> toRemove = new TreeSet<Integer>();
@@ -88,8 +96,12 @@ public class SafeConstructor extends BaseConstructor {
         for (NodeTuple tuple : nodeValue) {
             Node keyNode = tuple.getKeyNode();
             if (!keyNode.getTag().equals(Tag.MERGE)) {
+                if (forceStringKeys) {
+                    keyNode.setType(String.class);
+                    keyNode.setTag(Tag.STR);
+                }
                 Object key = constructObject(keyNode);
-                if (key != null) {
+                if (key != null && !forceStringKeys) {
                     try {
                         key.hashCode();// check circular dependencies
                     } catch (Exception e) {
@@ -132,7 +144,7 @@ public class SafeConstructor extends BaseConstructor {
      *         MappingNode)
      */
     private List<NodeTuple> mergeNode(MappingNode node, boolean isPreffered,
-            Map<Object, Integer> key2index, List<NodeTuple> values) {
+            Map<Object, Integer> key2index, List<NodeTuple> values, boolean forceStringKeys) {
         Iterator<NodeTuple> iter = node.getValue().iterator();
         while (iter.hasNext()) {
             final NodeTuple nodeTuple = iter.next();
@@ -143,7 +155,7 @@ public class SafeConstructor extends BaseConstructor {
                 switch (valueNode.getNodeId()) {
                 case mapping:
                     MappingNode mn = (MappingNode) valueNode;
-                    mergeNode(mn, false, key2index, values);
+                    mergeNode(mn, false, key2index, values, forceStringKeys);
                     break;
                 case sequence:
                     SequenceNode sn = (SequenceNode) valueNode;
@@ -157,7 +169,7 @@ public class SafeConstructor extends BaseConstructor {
                                     subnode.getStartMark());
                         }
                         MappingNode mnode = (MappingNode) subnode;
-                        mergeNode(mnode, false, key2index, values);
+                        mergeNode(mnode, false, key2index, values,forceStringKeys);
                     }
                     break;
                 default:
@@ -169,6 +181,10 @@ public class SafeConstructor extends BaseConstructor {
                 }
             } else {
                 // we need to construct keys to avoid duplications
+                if (forceStringKeys) {
+                    keyNode.setType(String.class);
+                    keyNode.setTag(Tag.STR);
+                }
                 Object key = constructObject(keyNode);
                 if (!key2index.containsKey(key)) { // 1st time merging key
                     values.add(nodeTuple);
@@ -269,7 +285,7 @@ public class SafeConstructor extends BaseConstructor {
             RADIX_MAX[radix] = new int[] { maxLen(Integer.MAX_VALUE,radix), maxLen(Long.MAX_VALUE,radix)};
         }
     }
-    
+
     private static int maxLen(final int max, final int radix) {
     	return  Integer.toString(max,radix).length();
     }