Add support for merge keys

Merge keys are specified here[1] for YAML 1.1. While not part of
the YAML 1.2 specification, they're very useful and are supported
in other implementations[2][3][4] that target 1.2.

[1]: http://yaml.org/type/merge.html
[2]: https://github.com/go-yaml/yaml
[3]: https://github.com/ruby/psych
[4]: https://bitbucket.org/ruamel/yaml

Author: Ortham

include/yaml-cpp/node/detail/node.h

@@ -116,18 +116,48 @@ class node {
     value.add_dependency(*this);
   }
 
+  template <typename Key>
+  inline node* GetValueFromMergeKey(const Key& key, node* currentValue,
+                                    shared_memory_holder pMemory) const {
+    node* mergeValue =
+        static_cast<const node_ref&>(*m_pRef).get(std::string("<<"), pMemory);
+    if (mergeValue) {
+      if (mergeValue->type() == NodeType::Map) {
+        return &mergeValue->get(key, pMemory);
+      } else if (mergeValue->type() == NodeType::Sequence) {
+        for (const_node_iterator it = mergeValue->begin();
+             it != mergeValue->end(); ++it) {
+          if (it->pNode && it->pNode->type() == NodeType::Map) {
+            node* value = it->pNode->get(key, pMemory);
+            if (value && value->type() != NodeType::Undefined) {
+              return value;
+            }
+          }
+        }
+      }
+    }
+    return currentValue;
+  }
+
   // indexing
   template <typename Key>
   node* get(const Key& key, shared_memory_holder pMemory) const {
     // NOTE: this returns a non-const node so that the top-level Node can wrap
     // it, and returns a pointer so that it can be NULL (if there is no such
     // key).
-    return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
+    node* value = static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
+    if (!value || value->type() == NodeType::Undefined) {
+      return GetValueFromMergeKey(key, value, pMemory);
+    }
+    return value;
   }
   template <typename Key>
   node& get(const Key& key, shared_memory_holder pMemory) {
     node& value = m_pRef->get(key, pMemory);
     value.add_dependency(*this);
+    if (value.type() == NodeType::Undefined) {
+      return *GetValueFromMergeKey(key, &value, pMemory);
+    }
     return value;
   }
   template <typename Key>

test/integration/load_node_test.cpp

@@ -185,6 +185,32 @@ TEST(LoadNodeTest, DereferenceIteratorError) {
   EXPECT_THROW(node.begin()->begin()->Type(), InvalidNode);
 }
 
+TEST(NodeTest, MergeKeyScalarSupport) {
+  Node node = Load("{<<: {a: 1}}");
+  ASSERT_FALSE(!node["a"]);
+  EXPECT_EQ(1, node["a"].as<int>());
+}
+
+TEST(NodeTest, MergeKeyExistingKey) {
+  Node node = Load("{a: 1, <<: {a: 2}}");
+  ASSERT_FALSE(!node["a"]);
+  EXPECT_EQ(1, node["a"].as<int>());
+}
+
+TEST(NodeTest, MergeKeySequenceSupport) {
+  Node node = Load("<<: [{a: 1}, {a: 2, b: 3}]");
+  ASSERT_FALSE(!node["a"]);
+  ASSERT_FALSE(!node["b"]);
+  EXPECT_EQ(1, node["a"].as<int>());
+  EXPECT_EQ(3, node["b"].as<int>());
+}
+
+TEST(NodeTest, NestedMergeKeys) {
+  Node node = Load("{<<: {<<: {a: 1}}}");
+  ASSERT_FALSE(!node["a"]);
+  EXPECT_EQ(1, node["a"].as<int>());
+}
+
 TEST(NodeTest, EmitEmptyNode) {
   Node node;
   Emitter emitter;