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 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 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 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 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 TestDictionaryAccess() { dynamic dynamicYaml = new DynamicYaml(MappingYaml); Dictionary<string, dynamic> dynamicDictionary = null; Action action = () => { dynamicDictionary = dynamicYaml; }; action.ShouldNotThrow(); dynamicDictionary.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 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 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"); }