public Post ParsePost(string content)
{
var splitted = ParseInternal(content);
var parsed = new DynamicYaml(splitted[0]);
return(new Post(parsed, splitted[1].Trim()));
}
public void MappingNodeSample()
{
dynamic dynamicYaml = new DynamicYaml(MappingYaml);
string receipt = (string)(dynamicYaml.Receipt);
var firstPartNo = dynamicYaml.Items[0].part_no;
}
public void NestedSequenceNodeSample()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
string firstNumberAsString = dynamicYaml[0, 0];
int firstNumberAsInt = dynamicYaml[0, 0];
}
// File typeIDs compressed with zopfli --deflate
// The static dump got from https://developers.eveonline.com/resource/resources
public List <Tuple <long, string> > ReadCompressedFile(string path)
{
var result = new List <Tuple <long, string> >();
using (var file = new FileStream(path, FileMode.Open))
{
using (var zipfile = new DeflateStream(file, CompressionMode.Decompress))
{
using (var textReader = new StreamReader(zipfile))
{
var yaml = new YamlStream();
yaml.Load(textReader);
// Examine the stream
var mapping =
(YamlMappingNode)yaml.Documents[0].RootNode;
foreach (var entry in mapping.Children)
{
dynamic en = new DynamicYaml(entry.Value);
//Console.WriteLine(((YamlScalarNode)entry.Key).Value);
string str = en.name.en;
result.Add(new Tuple <long, string>(long.Parse(((YamlScalarNode)entry.Key).Value), str));
}
}
}
}
return(result);
}
public void TestSimple()
{
var yamlMapping = new DynamicYaml(
@"name: This is a property
key: second key");
Assert.Equal(2, yamlMapping.RootNode.Children.Count);
// Test basic accessor
dynamic obj = yamlMapping.DynamicRootNode;
Assert.Equal("This is a property", (string)obj.name);
Assert.Equal("second key", (string)obj.key);
Assert.Null((string)obj.invalid);
// Test remove a key
var dyn = (DynamicYamlMapping)obj;
dyn.RemoveChild("name");
Assert.Null((string)obj.name);
// Test serialization back to a string
var text = yamlMapping.ToString().TrimEnd();
Assert.Equal("key: second key", text);
}
public void TestEnumConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumYaml);
StringComparison stringComparisonMode = dynamicYaml[0].stringComparisonMode;
stringComparisonMode.Should().Be(StringComparison.CurrentCultureIgnoreCase);
}
public void TestSequenceNode()
{
dynamic dynamicYaml = new DynamicYaml(SequenceYaml);
string firstName = dynamicYaml[0].name;
Assert.Equal(firstName, "Me");
}
public void TestEnumConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumYaml);
StringComparison stringComparisonMode = dynamicYaml[0].stringComparisonMode;
Assert.Equal(StringComparison.CurrentCultureIgnoreCase, stringComparisonMode);
}
public void TestSequenceNode()
{
dynamic dynamicYaml = new DynamicYaml(SequenceYaml);
string firstName = dynamicYaml[0].name;
firstName.Should().Be("Me");
}
public void TestMappingNode()
{
dynamic dynamicYaml = new DynamicYaml(MappingYaml);
var receipt = (string)(dynamicYaml.Receipt);
var firstPartNo = dynamicYaml.Items[0].part_no;
Assert.Equal(receipt, "Oz-Ware Purchase Invoice");
}
public void TestNonexistingMember()
{
dynamic dynamicYaml = new DynamicYaml(SequenceYaml);
var title = (string)(dynamicYaml[0].Title);
Assert.Null(title);
var id = (int?)(dynamicYaml[0].Id);
Assert.Null(id);
}
public void TestNonexistingMember()
{
dynamic dynamicYaml = new DynamicYaml(SequenceYaml);
string title = dynamicYaml[0].Title;
int? id = dynamicYaml[0].Id;
title.Should().BeNull();
id.Should().NotHaveValue();
}
public void TestDictionaryAccess()
{
dynamic dynamicYaml = new DynamicYaml(MappingYaml);
Dictionary <string, dynamic> dynamicDictionary = null;
Action action = () => { dynamicDictionary = dynamicYaml; };
action.ShouldNotThrow();
dynamicDictionary.Should().NotBeNull().And.NotBeEmpty();
}
public void TestEnumCollectionConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumSequenceYaml);
List <StringComparison> enumList = null;
Action action = () => { enumList = dynamicYaml; };
action.ShouldNotThrow();
enumList.Should().NotBeNull().And.NotBeEmpty();
}
public void TestEnumDictonaryConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumMappingYaml);
IDictionary <StringComparison, string> enumDict = null;
Action action = () => { enumDict = dynamicYaml; };
action.ShouldNotThrow();
enumDict.Should().NotBeNull().And.NotBeEmpty();
}
public void TestNestedSequenceNode()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
string firstNumberAsString = dynamicYaml[0, 0];
int firstNumberAsInt = dynamicYaml[0, 0];
firstNumberAsString.Should().Be("1");
firstNumberAsInt.Should().Be(1);
}
public void TestNullConversionsFailForNonNullTypes()
{
dynamic dynamicYaml = new DynamicYaml(NullTestYaml);
Assert.Throws <Microsoft.CSharp.RuntimeBinder.RuntimeBinderException>(
() =>
{
int object1 = dynamicYaml.field1;
});
}
public void TestCollectionAccess()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
List <dynamic> dynamicList = null;
Action action = () => { dynamicList = dynamicYaml; };
action.ShouldNotThrow();
dynamicList.Should().NotBeNull().And.NotBeEmpty();
}
public void TestNestedSequenceNode()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
string firstNumberAsString = dynamicYaml[0, 0];
Assert.Equal(firstNumberAsString, "1");
int firstNumberAsInt = dynamicYaml[0, 0];
Assert.Equal(firstNumberAsInt, 1);
}
public void TestBool()
{
dynamic dynamicYaml = new DynamicYaml(MappingYaml);
bool[] values = dynamicYaml.valid;
values[0].Should().BeTrue();
values[1].Should().BeTrue();
values[2].Should().BeFalse();
values[3].Should().BeFalse();
}
public void TestEnumArrayConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumSequenceYaml);
Assert.DoesNotThrow(() =>
{
StringComparison[] enumArray = dynamicYaml;
Assert.NotNull(enumArray);
Assert.NotEmpty(enumArray);
});
}
public void TestEnumArrayConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumSequenceYaml);
StringComparison[] enumArray = null;
Action action = () => { enumArray = dynamicYaml; };
action.ShouldNotThrow();
enumArray.Should().NotBeNull().And.NotBeEmpty();
}
public void TestCollectionConvert()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
List <dynamic> dynamicList = dynamicYaml;
List <int> intList = null;
Action action = () => { intList = dynamicList[0]; };
action.ShouldNotThrow();
intList.Should().NotBeNull().And.NotBeEmpty();
}
public void TestEnumCollectionConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumSequenceYaml);
Assert.DoesNotThrow(() =>
{
List <StringComparison> enumList = dynamicYaml;
Assert.NotNull(enumList);
Assert.NotEmpty(enumList);
});
}
public void TestArrayAccess()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
dynamic[] dynamicArray = null;
Action action = () => { dynamicArray = dynamicYaml; };
action.ShouldNotThrow();
dynamicArray.Should().NotBeNull().And.NotBeEmpty();
}
public void TestEnumDictonaryConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumMappingYaml);
Assert.DoesNotThrow(() =>
{
IDictionary <StringComparison, string> enumDict = dynamicYaml;
Assert.NotNull(enumDict);
Assert.NotEmpty(enumDict);
});
}
public void TestDictionaryConvert()
{
dynamic dynamicYaml = new DynamicYaml(MappingYaml);
Dictionary <string, dynamic> dynamicDictionary = dynamicYaml;
Dictionary <string, string> stringDictonary = null;
Action action = () => { stringDictonary = dynamicDictionary["customer"]; };
action.ShouldNotThrow();
stringDictonary.Should().NotBeNull().And.NotBeEmpty();
}
internal static bool TryMapValue(object value, out object result)
{
var node = value as YamlNode;
if (node != null)
{
result = new DynamicYaml(node);
return true;
}
result = null;
return false;
}
public void TestNullConversionsObject()
{
dynamic dynamicYaml = new DynamicYaml(NullTestYaml);
// DLR is not invoked for this call
// thus the TryConvert method cannot be called
// and this use case is unsupported
object object1 = dynamicYaml.field1;
object1.Should().NotBeNull();
object1.Should().BeOfType <DynamicYaml>();
}
public void TestArrayConvert()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
dynamic[] dynamicArray = dynamicYaml;
int[] intArray = null;
Action action = () => { intArray = dynamicArray[0]; };
action.ShouldNotThrow();
intArray.Should().NotBeNull().And.NotBeEmpty();
}
public void TestDynamicYamlIsSerializeable()
{
dynamic dynamicYaml = new DynamicYaml(MappingYaml);
var formatter = new BinaryFormatter();
var stream = new MemoryStream();
formatter.Serialize(stream, dynamicYaml);
stream.Position = 0;
dynamic result = formatter.Deserialize(stream);
Assert.Equal((YamlNode)dynamicYaml.yamlNode, (YamlNode)result.yamlNode);
}
public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
{
return inputs
.AsParallel()
.Select(x =>
{
try
{
Dictionary<string, object> items = new Dictionary<string, object>();
using (TextReader contentReader = new StringReader(x.Content))
{
YamlStream yamlStream = new YamlStream();
yamlStream.Load(contentReader);
if (yamlStream.Documents.Count > 0)
{
if (!string.IsNullOrEmpty(_key))
{
items[_key] = new DynamicYaml(yamlStream.Documents[0].RootNode);
}
if (_flatten)
{
foreach (YamlDocument document in yamlStream.Documents)
{
// Map scalar-to-scalar children
foreach (KeyValuePair<YamlNode, YamlNode> child in
((YamlMappingNode)document.RootNode).Children.Where(y => y.Key is YamlScalarNode && y.Value is YamlScalarNode))
{
items[((YamlScalarNode)child.Key).Value] = ((YamlScalarNode)child.Value).Value;
}
// Map simple sequences
foreach (KeyValuePair<YamlNode, YamlNode> child in
((YamlMappingNode) document.RootNode).Children.Where(y => y.Key is YamlScalarNode && y.Value is YamlSequenceNode && ((YamlSequenceNode)y.Value).All(z => z is YamlScalarNode)))
{
items[((YamlScalarNode)child.Key).Value] = ((YamlSequenceNode)child.Value).Select(a => ((YamlScalarNode)a).Value).ToArray();
}
}
}
}
}
return x.Clone(items);
}
catch (Exception ex)
{
context.Trace.Error("Error processing YAML for {0}: {1}", x.Source, ex.ToString());
}
return null;
})
.Where(x => x != null);
}
public void TestArrayConvert()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
dynamic[] dynamicArray = dynamicYaml;
int[] intArray = null;
Action action = () => { intArray = dynamicArray[0]; };
action.ShouldNotThrow();
intArray.Should().NotBeNull().And.NotBeEmpty();
}
public void TestNestedSequenceNode()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
string firstNumberAsString = dynamicYaml[0, 0];
int firstNumberAsInt = dynamicYaml[0, 0];
firstNumberAsString.Should().Be("1");
firstNumberAsInt.Should().Be(1);
}
public void TestCollectionConvert()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
List<dynamic> dynamicList = null;
Assert.DoesNotThrow(() =>
{
dynamicList = dynamicYaml;
Assert.NotNull(dynamicList);
Assert.NotEmpty(dynamicList);
});
Assert.DoesNotThrow(() =>
{
List<int> intList = dynamicList[0];
Assert.NotNull(intList);
Assert.NotEmpty(intList);
});
}
public void TestEnumArrayConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumSequenceYaml);
Assert.DoesNotThrow(() =>
{
StringComparison[] enumArray = dynamicYaml;
Assert.NotNull(enumArray);
Assert.NotEmpty(enumArray);
});
}
public void TestArrayAccess()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
dynamic[] dynamicArray = null;
Action action = () => { dynamicArray = dynamicYaml; };
action.ShouldNotThrow();
dynamicArray.Should().NotBeNull().And.NotBeEmpty();
}
public void TestNonexistingMember()
{
dynamic dynamicYaml = new DynamicYaml(SequenceYaml);
var title = (string)(dynamicYaml[0].Title);
Assert.Null(title);
var id = (int?)(dynamicYaml[0].Id);
Assert.Null(id);
}
public void TestArrayConvert()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
dynamic[] dynamicArray = null;
Assert.DoesNotThrow(() =>
{
dynamicArray = dynamicYaml;
Assert.NotNull(dynamicArray);
Assert.NotEmpty(dynamicArray);
});
Assert.DoesNotThrow(() =>
{
int[] intArray = dynamicArray[0];
Assert.NotNull(intArray);
Assert.NotEmpty(intArray);
});
}
public void TestEnumArrayConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumSequenceYaml);
StringComparison[] enumArray = null;
Action action = () => { enumArray = dynamicYaml; };
action.ShouldNotThrow();
enumArray.Should().NotBeNull().And.NotBeEmpty();
}
public void TestEnumCollectionConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumSequenceYaml);
List<StringComparison> enumList = null;
Action action = () => { enumList = dynamicYaml; };
action.ShouldNotThrow();
enumList.Should().NotBeNull().And.NotBeEmpty();
}
public void TestEnumConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumYaml);
StringComparison stringComparisonMode = dynamicYaml[0].stringComparisonMode;
stringComparisonMode.Should().Be(StringComparison.CurrentCultureIgnoreCase);
}
public void TestEnumDictonaryConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumMappingYaml);
IDictionary<StringComparison, string> enumDict = null;
Action action = () => { enumDict = dynamicYaml; };
action.ShouldNotThrow();
enumDict.Should().NotBeNull().And.NotBeEmpty();
}
public void TestMappingNode()
{
dynamic dynamicYaml = new DynamicYaml(MappingYaml);
var receipt = (string)(dynamicYaml.Receipt);
var firstPartNo = dynamicYaml.Items[0].part_no;
Assert.Equal(receipt, "Oz-Ware Purchase Invoice");
}
public void TestNamingConventions()
{
dynamic dynamicYaml = new DynamicYaml(NamingConventionsYaml);
string snake = dynamicYaml.snake_case;
snake.Should().Be("should work", "the key was typed in snake case");
string pascal = dynamicYaml.PascalCase;
pascal.Should().Be("should work as well", "the key was typed in pascal case");
string camel = dynamicYaml.camelCase;
camel.Should().Be("will also work", "the key was typed in camel case");
string upper = dynamicYaml.UPPER_CASE;
upper.Should().Be("works as well", "the key was typed in upper case");
}
public void TestDictionaryConvert()
{
dynamic dynamicYaml = new DynamicYaml(MappingYaml);
Dictionary<string, dynamic> dynamicDictionary = dynamicYaml;
Dictionary<string, string> stringDictonary = null;
Action action = () => { stringDictonary = dynamicDictionary["customer"]; };
action.ShouldNotThrow();
stringDictonary.Should().NotBeNull().And.NotBeEmpty();
}
private Dictionary<string, object> GetDocumentMetadata(YamlNode node)
{
Dictionary<string, object> metadata = new Dictionary<string, object>();
// Get the dynamic representation
if (!string.IsNullOrEmpty(_key))
{
metadata[_key] = new DynamicYaml(node);
}
// Also get the flat metadata if requested
if (_flatten)
{
YamlMappingNode mappingNode = node as YamlMappingNode;
if (mappingNode == null)
{
throw new InvalidOperationException("Cannot flatten YAML content that doesn't have a mapping node at the root (or within a root sequence).");
}
// Map scalar-to-scalar children
foreach (KeyValuePair<YamlNode, YamlNode> child in
mappingNode.Children.Where(y => y.Key is YamlScalarNode && y.Value is YamlScalarNode))
{
metadata[((YamlScalarNode)child.Key).Value] = ((YamlScalarNode)child.Value).Value;
}
// Map simple sequences
foreach (KeyValuePair<YamlNode, YamlNode> child in
mappingNode.Children.Where(y => y.Key is YamlScalarNode && y.Value is YamlSequenceNode && ((YamlSequenceNode)y.Value).All(z => z is YamlScalarNode)))
{
metadata[((YamlScalarNode)child.Key).Value] = ((YamlSequenceNode)child.Value).Select(a => ((YamlScalarNode)a).Value).ToArray();
}
}
return metadata;
}
public void TestNestedSequenceNode()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
string firstNumberAsString = dynamicYaml[0, 0];
Assert.Equal(firstNumberAsString, "1");
int firstNumberAsInt = dynamicYaml[0, 0];
Assert.Equal(firstNumberAsInt, 1);
}
public void TestSequenceNode()
{
dynamic dynamicYaml = new DynamicYaml(SequenceYaml);
string firstName = dynamicYaml[0].name;
Assert.Equal(firstName, "Me");
}
public void TestEnumConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumYaml);
StringComparison stringComparisonMode = dynamicYaml[0].stringComparisonMode;
Assert.Equal(StringComparison.CurrentCultureIgnoreCase, stringComparisonMode);
}
public void TestDictionaryAccess()
{
dynamic dynamicYaml = new DynamicYaml(MappingYaml);
Dictionary<string, dynamic> dynamicDictionary = null;
Action action = () => { dynamicDictionary = dynamicYaml; };
action.ShouldNotThrow();
dynamicDictionary.Should().NotBeNull().And.NotBeEmpty();
}
public void TestSequenceNode()
{
dynamic dynamicYaml = new DynamicYaml(SequenceYaml);
string firstName = dynamicYaml[0].name;
firstName.Should().Be("Me");
}
public void TestEnumDictonaryConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumMappingYaml);
Assert.DoesNotThrow(() =>
{
IDictionary<StringComparison, string> enumDict = dynamicYaml;
Assert.NotNull(enumDict);
Assert.NotEmpty(enumDict);
});
}
public void TestCollectionConvert()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
List<dynamic> dynamicList = dynamicYaml;
List<int> intList = null;
Action action = () => { intList = dynamicList[0]; };
action.ShouldNotThrow();
intList.Should().NotBeNull().And.NotBeEmpty();
}
public void TestEnumCollectionConvert()
{
dynamic dynamicYaml = new DynamicYaml(EnumSequenceYaml);
Assert.DoesNotThrow(() =>
{
List<StringComparison> enumList = dynamicYaml;
Assert.NotNull(enumList);
Assert.NotEmpty(enumList);
});
}
public void TestCollectionAccess()
{
dynamic dynamicYaml = new DynamicYaml(NestedSequenceYaml);
List<dynamic> dynamicList = null;
Action action = () => { dynamicList = dynamicYaml; };
action.ShouldNotThrow();
dynamicList.Should().NotBeNull().And.NotBeEmpty();
}
public void TestDictionaryConvert()
{
dynamic dynamicYaml = new DynamicYaml(MappingYaml);
Dictionary<string, dynamic> dynamicDictionary = null;
Assert.DoesNotThrow(() =>
{
dynamicDictionary = dynamicYaml;
Assert.NotNull(dynamicDictionary);
Assert.NotEmpty(dynamicDictionary);
});
Assert.DoesNotThrow(() =>
{
Dictionary<string, string> stringDictonary = dynamicDictionary["customer"];
Assert.NotNull(stringDictonary);
Assert.NotEmpty(stringDictonary);
});
}
public void TestBool()
{
dynamic dynamicYaml = new DynamicYaml(MappingYaml);
bool[] values = dynamicYaml.valid;
values[0].Should().BeTrue();
values[1].Should().BeTrue();
values[2].Should().BeFalse();
values[3].Should().BeFalse();
}
public void TestNonexistingMember()
{
dynamic dynamicYaml = new DynamicYaml(SequenceYaml);
string title = dynamicYaml[0].Title;
int? id = dynamicYaml[0].Id;
title.Should().BeNull();
id.Should().NotHaveValue();
}
public void TestNamingConventionsWithFirstLetterCaseInsensitivity()
{
dynamic dynamicYaml = new DynamicYaml(NamingConventionsYaml);
string snake = dynamicYaml.Snake_case;
snake.Should().Be("should work", "the key was typed in snake case");
string pascal = dynamicYaml.pascalCase;
pascal.Should().Be("should work as well", "the key was typed in pascal case");
string camel = dynamicYaml.CamelCase;
camel.Should().Be("will also work", "the key was typed in camel case");
string upper = dynamicYaml.uPPER_CASE;
upper.Should().Be("works as well", "the key was typed in upper case");
}
