static void Main(string[] args) { using (TextReader input = File.OpenText(args[0])) { int indent = 0; Parser parser = new Parser(input); while(parser.MoveNext()) { if (parser.Current is StreamEnd || parser.Current is DocumentEnd || parser.Current is SequenceEnd || parser.Current is SequenceEnd || parser.Current is MappingEnd) { --indent; } for(int i = 0; i < indent; ++i) { Console.Write(" "); } Console.WriteLine(parser.Current.ToString()); if (parser.Current is StreamStart || parser.Current is DocumentStart || parser.Current is SequenceStart || parser.Current is MappingStart) { ++indent; } } } }
private static async Task Run(CliArgs args) { if (string.IsNullOrWhiteSpace(args.Target)) { args.Target = Path.ChangeExtension(args.Source, ".jsonl"); } long count = 0; using (var reader = new StreamReader(args.Source)) using (var writer = new StreamWriter(args.Target)) { var deserializer = new DeserializerBuilder().Build(); var parser = new YamlParser(reader); parser.Expect <StreamStart>(); while (parser.Current is DocumentStart) { object source = deserializer.Deserialize(parser); if (source != null) { await writer.WriteLineAsync(JsonConvert.SerializeObject(source)); count++; } } parser.Expect <StreamEnd>(); } Console.WriteLine($"Wrote {count} line(s) to {args.Target}"); }
public static IEnumerable <TargetObject> ConvertFromYaml(TargetObject targetObject, VisitTargetObject next) { // Only attempt to deserialize if the input is a string, file or URI if (!IsAcceptedType(targetObject)) { return new TargetObject[] { targetObject } } ; var d = new DeserializerBuilder() .IgnoreUnmatchedProperties() .WithTypeConverter(new PSObjectYamlTypeConverter()) .WithNodeTypeResolver(new PSObjectYamlTypeResolver()) .Build(); var reader = ReadAsReader(targetObject.Value, out InputFileInfo sourceInfo); var parser = new YamlDotNet.Core.Parser(reader); var result = new List <TargetObject>(); parser.TryConsume <StreamStart>(out _); while (parser.Current is DocumentStart) { var item = d.Deserialize <PSObject>(parser: parser); if (item == null) { continue; } result.AddRange(VisitItem(item, sourceInfo, next)); } return(result.Count == 0 ? EmptyArray : result.ToArray()); }
/// <summary> /// Throws YamlException /// </summary> /// <param name="metaModel"></param> /// <param name="textReader"></param> public void Deserialize(MetaModel.MetaModel metaModel, TextReader textReader) { Parser p = new Parser(textReader); EventReader r = new EventReader(p); r.Expect<StreamStart>(); r.Expect<DocumentStart>(); r.Expect<MappingStart>(); Scalar section = r.Peek<Scalar>(); if (section.Value.Equals(Icons)) { r.Expect<Scalar>(); DeserializeIcons(metaModel, r); section = r.Peek<Scalar>(); } if (section != null && section.Value.Equals(RecentFiles)) { r.Expect<Scalar>(); DeserializeRecentFiles(metaModel, r); section = r.Peek<Scalar>(); } if (section != null && section.Value.Equals(LastOpenedFile)) { r.Expect<Scalar>(); metaModel.LastOpenedFile = r.Expect<Scalar>().Value; section = r.Peek<Scalar>(); } if (section != null && section.Value.Equals(MapBackColor)) { r.Expect<Scalar>(); metaModel.MapEditorBackColor = (Color)(new ColorConverter().ConvertFromString(r.Expect<Scalar>().Value)); section = r.Peek<Scalar>(); } if (section != null && section.Value.Equals(NoteBackColor)) { r.Expect<Scalar>(); metaModel.NoteEditorBackColor = (Color)(new ColorConverter().ConvertFromString(r.Expect<Scalar>().Value)); section = r.Peek<Scalar>(); } if (section != null && section.Value.Equals(NodeStyles)) { r.Expect<Scalar>(); DeserializeNodeStyles(metaModel, r); //section = r.Peek<Scalar>(); //uncomment when adding another section } r.Expect<MappingEnd>(); r.Expect<DocumentEnd>(); r.Expect<StreamEnd>(); }
/// <summary> /// Parse Stream Reader. /// </summary> /// <param name="streamReader">Stream reader.</param> /// <returns>Deserialized.</returns> private T ParseStreamReader(StreamReader streamReader) { var deserializer = new DeserializerBuilder().Build(); var parser = new YamlDotNet.Core.Parser(streamReader); parser.Expect <StreamStart>(); while (parser.Accept <DocumentStart>()) { return(deserializer.Deserialize <T>(parser)); } return(null); }
public static IEnumerable <PSObject> ConvertFromYaml(PSObject sourceObject, VisitTargetObject next) { // Only attempt to deserialize if the input is a string, file or URI if (!IsAcceptedType(sourceObject: sourceObject)) { return new PSObject[] { sourceObject } } ; var d = new DeserializerBuilder() .IgnoreUnmatchedProperties() .WithTypeConverter(new PSObjectYamlTypeConverter()) .WithNodeTypeResolver(new PSObjectYamlTypeResolver()) .Build(); var reader = ReadAsReader(sourceObject, out PSSourceInfo source); var parser = new YamlDotNet.Core.Parser(reader); parser.Expect <StreamStart>(); var result = new List <PSObject>(); while (parser.Accept <DocumentStart>()) { var item = d.Deserialize <PSObject>(parser: parser); if (item == null) { continue; } NoteSource(item, source); var items = next(item); if (items == null) { continue; } result.AddRange(items); } if (result.Count == 0) { return(null); } return(result.ToArray()); }
private static T Parse(StreamReader r) { var deserializer = new DeserializerBuilder().Build(); var parser = new YamlDotNet.Core.Parser(r); // Consume the stream start event "manually" parser.Expect <StreamStart>(); while (parser.Accept <DocumentStart>()) // Deserialize the document { return(deserializer.Deserialize <T>(parser)); } return(null); }
private T ParseStreamReader(StreamReader streamReader) { var deserializer = new DeserializerBuilder().Build(); var parser = new YamlDotNet.Core.Parser(streamReader); // Consume the stream start event "manually" parser.TryConsume <StreamStart>(out _); while (parser.TryConsume <DocumentStart>(out _)) // Deserialize the document { return(deserializer.Deserialize <T>(parser)); } return(null); }
/// <summary> /// Reads this object's state from a YAML parser. /// </summary> /// <param name="parser"></param> void IYamlSerializable.ReadYaml(Parser parser) { events.Clear(); int depth = 0; do { if (!parser.MoveNext()) { throw new InvalidOperationException("The parser has reached the end before deserialization completed."); } events.Add(parser.Current); depth += parser.Current.NestingIncrease; } while (depth > 0); Debug.Assert(depth == 0); }
public void Execute(ITextView textView, ITextUndoHistoryRegistry textUndoHistoryRegistry) { var undoHistory = textUndoHistoryRegistry.RegisterHistory(textView); using (var transaction = undoHistory.CreateTransaction("Format Document")) { var text = textView.TextBuffer.CurrentSnapshot.GetText(); var formatted = new StringWriter(); var parser = new Parser(new Scanner(new StringReader(text), skipComments: false)); var emitter = new Emitter(formatted); while (parser.MoveNext()) { emitter.Emit(parser.Current); } var edit = textView.TextBuffer.CreateEdit(); edit.Replace(0, text.Length, formatted.ToString()); edit.Apply(); transaction.Complete(); } }
public T ParseFile(string file) { var thisAssembly = Assembly.GetExecutingAssembly(); string filePath = "DeviceDetectorNET." + string.Join(".", file.Split('/')); using (var stream = thisAssembly.GetManifestResourceStream(filePath)) { using (var r = new StreamReader(stream)) { var deserializer = new DeserializerBuilder().Build(); var parser = new YamlDotNet.Core.Parser(r); // Consume the stream start event "manually" parser.Expect <StreamStart>(); while (parser.Accept <DocumentStart>()) // Deserialize the document { return(deserializer.Deserialize <T>(parser)); } return(null); } } }
private void AssertDoesNotHaveNext(Parser parser) { Assert.False(parser.MoveNext()); }
private void AssertCurrent(Parser parser, ParsingEvent expected) { Console.WriteLine(expected.GetType().Name); Assert.True(expected.GetType().IsAssignableFrom(parser.Current.GetType()), string.Format("The event is not of the expected type. Exprected: {0}, Actual: {1}", expected.GetType().Name, parser.Current.GetType().Name)); foreach (var property in expected.GetType().GetProperties()) { if(property.PropertyType != typeof(Mark) && property.CanRead) { object value = property.GetValue(parser.Current, null); object expectedValue = property.GetValue(expected, null); if(expectedValue != null && Type.GetTypeCode(expectedValue.GetType()) == TypeCode.Object && expectedValue is IEnumerable) { Console.Write("\t{0} = {{", property.Name); bool isFirst = true; foreach(var item in (IEnumerable)value) { if(isFirst) { isFirst = false; } else { Console.Write(", "); } Console.Write(item); } Console.WriteLine("}"); if(expectedValue is ICollection && value is ICollection) { Assert.Equal(((ICollection)expectedValue).Count, ((ICollection)value).Count); } IEnumerator values = ((IEnumerable)value).GetEnumerator(); IEnumerator expectedValues = ((IEnumerable)expectedValue).GetEnumerator(); while(expectedValues.MoveNext()) { Assert.True(values.MoveNext()); Assert.Equal(expectedValues.Current, values.Current); } Assert.False(values.MoveNext()); } else { Console.WriteLine("\t{0} = {1}", property.Name, value); Assert.Equal(expectedValue, value); } } } }
private IList<ParsingEvent> ParsingEventsOf(string text) { var parser = new Parser(new StringReader(text)); return EnumerationOf(parser).ToList(); }
private void AssertDoesNotHaveNext(Parser parser) { Assert.IsFalse(parser.MoveNext(), "The parser should not contain more events."); }
private void ParseAndEmit(string name) { string testText = YamlFile(name).ReadToEnd(); Parser parser = new Parser(new StringReader(testText)); using(StringWriter output = new StringWriter()) { Emitter emitter = new Emitter(output, 2, int.MaxValue, false); while(parser.MoveNext()) { //Console.WriteLine(parser.Current.GetType().Name); Console.Error.WriteLine(parser.Current); emitter.Emit(parser.Current); } string result = output.ToString(); Console.WriteLine(); Console.WriteLine("------------------------------"); Console.WriteLine(); Console.WriteLine(testText); Console.WriteLine(); Console.WriteLine("------------------------------"); Console.WriteLine(); Console.WriteLine(result); Console.WriteLine(); Console.WriteLine("------------------------------"); Console.WriteLine(); /* Parser resultParser = new Parser(new StringReader(result)); while(resultParser.MoveNext()) { Console.WriteLine(resultParser.Current.GetType().Name); } */ /* if(testText != result) { Console.WriteLine(); Console.WriteLine("------------------------------"); Console.WriteLine(); Console.WriteLine("Expected:"); Console.WriteLine(); Console.WriteLine(testText); Console.WriteLine(); Console.WriteLine("------------------------------"); Console.WriteLine(); Console.WriteLine("Result:"); Console.WriteLine(); Console.WriteLine(result); Console.WriteLine(); Console.WriteLine("------------------------------"); Console.WriteLine(); } Assert.AreEqual(testText, result, "The emitter did not generate the correct text."); */ } }
private void AssertHasNext(Parser parser) { Assert.True(parser.MoveNext()); }
private void AssertHasNext(Parser parser) { Assert.IsTrue(parser.MoveNext(), "The parser does not contain more events."); }
private void AssertNext(Parser parser, ParsingEvent expected) { AssertHasNext(parser); AssertCurrent(parser, expected); }
public void NewLinesAreParsedAccordingToTheSpecification(string yaml, string expected) { var parser = new Parser(new StringReader(yaml)); AssertSequenceOfEventsFrom(Yaml.ParserForText(yaml), StreamStart, DocumentStart(Implicit), LiteralScalar(expected), DocumentEnd(Implicit), StreamEnd); }