feat(meta): add a meta builder class

Author: jaredcnance

src/JsonApiDotNetCore/Builders/IMetaBuilder.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace JsonApiDotNetCore.Builders
+{
+    public interface IMetaBuilder
+    {
+        void Add(string key, object value);
+        void Add(Dictionary<string,object> values);
+        Dictionary<string, object> Build();
+    }
+}

src/JsonApiDotNetCore/Builders/MetaBuilder.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace JsonApiDotNetCore.Builders
+{
+    public class MetaBuilder : IMetaBuilder
+    {
+        private Dictionary<string, object> _meta = new Dictionary<string, object>();
+
+        public void Add(string key, object value)
+        {
+            _meta[key] = value;
+        }
+
+        /// <summary>
+        /// Joins the new dictionary with the current one. In the event of a key collision,
+        /// the new value will override the old.
+        /// </summary>
+        public void Add(Dictionary<string,object> values)
+        {
+            _meta = values.Keys.Union(_meta.Keys)
+                .ToDictionary(key => key, 
+                    key => values.ContainsKey(key) ? values[key] : _meta[key]);
+        }
+        
+        public Dictionary<string, object> Build()
+        {
+            return _meta;
+        }
+    }
+}

test/JsonApiDotNetCoreExampleTests/Unit/Builders/MetaBuilderTests.cs

@@ -0,0 +1,73 @@
+using Xunit;
+using JsonApiDotNetCore.Builders;
+using System.Collections.Generic;
+
+namespace JsonApiDotNetCoreExampleTests.Unit.Builders
+{
+    public class MetaBuilderTests
+    {
+        [Fact]
+        public void Can_Add_Key_Value()
+        {
+            // arrange
+            var builder = new MetaBuilder();
+            var key = "test";
+            var value = "testValue";
+
+            // act
+            builder.Add(key, value);
+            var result = builder.Build();
+
+            // assert
+            Assert.NotEmpty(result);
+            Assert.Equal(value, result[key]);
+        }
+
+        [Fact]
+        public void Can_Add_Multiple_Values()
+        {
+            // arrange
+            var builder = new MetaBuilder();
+            var input = new Dictionary<string, object> {
+            { "key1", "value1" },
+            { "key2", "value2" }
+           };
+
+            // act
+            builder.Add(input);
+            var result = builder.Build();
+
+            // assert
+            Assert.NotEmpty(result);
+            foreach (var entry in input)
+                Assert.Equal(input[entry.Key], result[entry.Key]);
+        }
+
+        [Fact]
+        public void When_Adding_Duplicate_Values_Keep_Newest()
+        {
+            // arrange
+            var builder = new MetaBuilder();
+            
+            var key = "key";
+            var oldValue = "oldValue";
+            var newValue = "newValue";
+            
+            builder.Add(key, oldValue);
+
+            var input = new Dictionary<string, object> {
+                { key, newValue },
+                { "key2", "value2" }
+            };
+
+            // act
+            builder.Add(input);
+            var result = builder.Build();
+
+            // assert
+            Assert.NotEmpty(result);
+            Assert.Equal(input.Count, result.Count);
+            Assert.Equal(input[key], result[key]);
+        }
+    }
+}