public override async ValueTask ScanAsync(ScanFileContext context) { using var textReader = new StreamReader(context.Content); var reader = new MergingParser(new Parser(textReader)); var yaml = new YamlStream(); yaml.Load(reader); foreach (var document in yaml.Documents) { var rootNode = (YamlMappingNode)document.RootNode; var jobsNode = GetProperty(rootNode, "jobs", StringComparison.OrdinalIgnoreCase); if (jobsNode is YamlMappingNode jobs) { foreach (var child in jobs.Children) // Enumerate jobs { if (child.Value is YamlMappingNode jobNode) { var stepsNode = GetProperty(jobNode, "steps", StringComparison.OrdinalIgnoreCase); if (stepsNode is YamlSequenceNode steps) { foreach (var step in steps.OfType <YamlMappingNode>()) { var uses = GetProperty(step, "uses", StringComparison.OrdinalIgnoreCase); if (uses is YamlScalarNode usesValue && usesValue.Value != null) { var value = usesValue.Value; if (value.StartsWith(DockerPrefix, StringComparison.OrdinalIgnoreCase)) // https://docs.github.com/en/free-pro-team@latest/actions/reference/workflow-syntax-for-github-actions#example-using-a-docker-hub-action { var index = value.AsSpan()[DockerPrefix.Length..].LastIndexOf(':');
/// <summary> /// Parses DataFile as a SpecFile /// </summary> /// <param name="file">File to read</param> /// <exception cref="ParseException">Raised if file cannot be parsed</exception> /// <returns>Parsed spec file</returns> public static SpecFile Parse(DataFile file) { try { using var reader = file.AsStringReader(); var parser = new MergingParser(new Parser(reader)); var deserializer = new DeserializerBuilder() .WithNamingConvention(CamelCaseNamingConvention.Instance) .Build(); return(deserializer.Deserialize <SpecFile>(parser)); } catch (YamlException ex) { var sb = new StringBuilder(ex.Message); var inner = ex.InnerException; while (inner != null) { sb.AppendLine(inner.Message); inner = inner.InnerException; } throw new ParseException(sb.ToString()); } catch (KeyNotFoundException ex) { var err = $"Malformed YAML, try running through an online validator: {ex.Message}"; throw new ParseException(err); } }
public void MergingDoesNotProduceDuplicateAnchors() { var parser = new MergingParser(Yaml.ParserForText(@" anchor: &default key1: &myValue value1 key2: value2 alias: <<: *default key2: Overriding key2 key3: value3 useMyValue: key: *myValue ")); var result = Deserializer.Deserialize <Dictionary <string, Dictionary <string, string> > >(new EventReader(parser)); var alias = result["alias"]; alias.Should() .Contain("key1", "value1", "key1 should be inherited from the backreferenced mapping") .And.Contain("key2", "Overriding key2", "key2 should be overriden by the actual mapping") .And.Contain("key3", "value3", "key3 is defined in the actual mapping"); result["useMyValue"].Should() .Contain("key", "value1", "key should be copied"); }
/// <summary> /// Converts the YAML string to JSON string. /// </summary> /// <param name="yaml">YAML string.</param> /// <param name="skipXYarm">If set to 'true', ignores top level properties starting with 'x-yarm'.</param> /// <returns>Returns JSON string converted.</returns> public static string ToJson(this string yaml, bool skipXYarm = true) { if (string.IsNullOrWhiteSpace(yaml)) { return(null); } object deserialized; try { var reader = new MergingParser(new Parser(new StringReader(yaml))); deserialized = new Deserializer().Deserialize(reader); } catch (Exception ex) { throw new InvalidYamlException(ex.Message); } var json = skipXYarm ? JsonConvert.SerializeObject(deserialized, Formatting.Indented, new IgnoreXYarmJsonConverter()) : JsonConvert.SerializeObject(deserialized, Formatting.Indented); return(json); }
public void Given_Yaml_When_Serialised_ShouldNotReturn_XYarm() { var deserialised = (object)null; using (var reader = new StringReader(xYarmYaml)) { var parser = new MergingParser(new Parser(reader)); deserialised = new Deserializer().Deserialize(parser); } var written = (string)null; var converter = new IgnoreXYarmJsonConverter(); using (var tw = new StringWriter()) using (var writer = new JsonTextWriter(tw)) { converter.WriteJson(writer, deserialised, new JsonSerializer()); written = tw.ToString(); } var dic = (IDictionary <string, JToken>)JsonConvert.DeserializeObject <JObject>(written); dic.ContainsKey("x-yarm-very-ignored").Should().BeFalse(); dic.ContainsKey("x-yarm").Should().BeFalse(); dic["key1"].Value <string>().Should().Be("value"); dic["key2"].Value <string>().Should().Be("value2"); dic["key3"]["x-yarm-not-ignored"].Value <string>().Should().Be("mhm"); }
public static T Deserialize <T>(TextReader stream) { // allow merging in yaml back references var parser = new MergingParser(new Parser(stream)); var deserializer = Deserializer; return(deserializer.Deserialize <T>(parser)); }
public FixtureData() { using var streamReader = RealFileSystem.File.OpenText(ResolvePath(FixtureFile)); var parser = new MergingParser(new Parser(streamReader)); var deserializer = new DeserializerBuilder().Build(); this.fixtureModels = deserializer .Deserialize <List <FixtureModel> >(parser) .ToDictionary(f => f.Name); }
public void ExampleFromSpecificationIsHandledCorrectly() { var parser = new MergingParser(Yaml.ParserForText(@" obj: - &CENTER { x: 1, y: 2 } - &LEFT { x: 0, y: 2 } - &BIG { r: 10 } - &SMALL { r: 1 } # All the following maps are equal: results: - # Explicit keys x: 1 y: 2 r: 10 label: center/big - # Merge one map << : *CENTER r: 10 label: center/big - # Merge multiple maps << : [ *CENTER, *BIG ] label: center/big - # Override #<< : [ *BIG, *LEFT, *SMALL ] # This does not work because, in the current implementation, # later keys override former keys. This could be fixed, but that # is not trivial because the deserializer allows aliases to refer to # an anchor that is defined later in the document, and the way it is # implemented, the value is assigned later when the anchored value is # deserialized. << : [ *SMALL, *LEFT, *BIG ] x: 1 label: center/big ")); var result = Deserializer.Deserialize <Dictionary <string, List <Dictionary <string, string> > > >(new EventReader(parser)); int index = 0; foreach (var mapping in result["results"]) { mapping.Should() .Contain("x", "1", "'x' should be '1' in result #{0}", index) .And.Contain("y", "2", "'y' should be '2' in result #{0}", index) .And.Contain("r", "10", "'r' should be '10' in result #{0}", index) .And.Contain("label", "center/big", "'label' should be 'center/big' in result #{0}", index); ++index; } }
//[CakeNamespaceImport("YamlDotNet")] public static T DeserializeYaml <T> (this ICakeContext context, string yaml) { T result = default(T); var d = new YamlDotNet.Serialization.Deserializer(); using (var tr = new StringReader(yaml)) { var reader = new MergingParser(new Parser(tr)); result = d.Deserialize <T>(reader); } return(result); }
//[CakeNamespaceImport("YamlDotNet")] public static T DeserializeYamlFromFile <T>(this ICakeContext context, FilePath filename) { T result = default(T); var d = new YamlDotNet.Serialization.Deserializer(); using (var tr = File.OpenText(filename.MakeAbsolute(context.Environment).FullPath)) { var reader = new MergingParser(new Parser(tr)); result = d.Deserialize <T>(reader); } return(result); }
public void BackreferencesAreMergedWithMappings() { var stream = Yaml.StreamFrom("backreference.yaml"); var parser = new MergingParser(new Parser(stream)); var result = Deserializer.Deserialize <Dictionary <string, Dictionary <string, string> > >(new EventReader(parser)); var alias = result["alias"]; alias.Should() .Contain("key1", "value1", "key1 should be inherited from the backreferenced mapping") .And.Contain("key2", "Overriding key2", "key2 should be overriden by the actual mapping") .And.Contain("key3", "value3", "key3 is defined in the actual mapping"); }
public static T DeserializeYaml <T>(this ICakeContext context, string yaml, DeserializeYamlSettings settings) { T result = default(T); var d = BuildDeserializer(settings); using (var tr = new StringReader(yaml)) { var reader = new MergingParser(new Parser(tr)); result = d.Deserialize <T>(reader); } return(result); }
public T ProcessContentForEnvironment(IContentReader reader, string environment) { var baseContent = reader.ReadContent(); var envContent = reader.ReadContent(environment); var stringReader = new StringReader(string.Join("", baseContent, envContent)); var parser = new MergingParser(new Parser(stringReader)); var deserializer = new DeserializerBuilder() .WithNamingConvention(new CamelCaseNamingConvention()) .Build(); return(deserializer.Deserialize <T>(parser)); }
public static CartoProject FromFile(string fileContent, string fileExt) { CartoProject cartoProject = null; switch (fileExt.ToLower()) { case ".mml": cartoProject = JsonConvert.DeserializeObject <CartoProject>(fileContent); if (cartoProject.Interactivity != null) { try { Dictionary <string, object> dict = JsonConvert.DeserializeObject <Dictionary <string, object> >(cartoProject.Interactivity.ToString()); cartoProject.Interactivity = dict; } catch { } try { bool enabled = JsonConvert.DeserializeObject <bool>(cartoProject.Interactivity.ToString()); cartoProject.Interactivity = enabled; } catch { } } break; case ".yaml": case ".yml": using (StringReader input = new StringReader(fileContent)) { Deserializer deserializer = new Deserializer(namingConvention: new CamelCaseNamingConvention(), ignoreUnmatched: true); var parser = new MergingParser(new YamlDotNet.Core.Parser(input)); cartoProject = deserializer.Deserialize <CartoProject>(new EventReader(parser)); } break; default: throw new Exception("Unknown extension of the CartoCSS project."); } cartoProject.PrepeareFormat(true); return(cartoProject); }
/// <summary> /// Initialize the repo with configuration from a Yaml-file. /// </summary> /// <param name="configurationAsYamlFilePath">If null it defaults to 'flexversion.yml'</param> /// <param name="repoPath">If null current working directory is assumed.</param> /// <param name="arguments"></param> public FlexVersion(string configurationAsYamlFilePath = null, string repoPath = null, params string[] arguments) { _repoPath = repoPath ?? Environment.CurrentDirectory; configurationAsYamlFilePath = configurationAsYamlFilePath ?? @".\flexversion.yml"; if (!File.Exists(configurationAsYamlFilePath)) { throw new ArgumentException($"The configuration-file cannot be found at '{configurationAsYamlFilePath}'"); } var deserializer = new Deserializer(); var parser = new MergingParser(new Parser(File.OpenText(configurationAsYamlFilePath))); _flexVersionConfiguration = deserializer.Deserialize <FlexVersionConfiguration>(parser); ParseArguments(arguments); }
public static Map ReadFromFile(string fileContent, string fileName) { string path = Path.GetDirectoryName(fileName); CartoProject cartoProject = null; switch (Path.GetExtension(fileName).ToLower()) { case ".mml": cartoProject = JsonConvert.DeserializeObject <CartoProject>(fileContent); if (cartoProject.Interactivity != null) { try { Dictionary <string, object> dict = JsonConvert.DeserializeObject <Dictionary <string, object> >(cartoProject.Interactivity.ToString()); cartoProject.Interactivity = dict; } catch { } try { bool enabled = JsonConvert.DeserializeObject <bool>(cartoProject.Interactivity.ToString()); cartoProject.Interactivity = enabled; } catch { } } break; case ".yaml": using (StringReader input = new StringReader(fileContent)) { Deserializer deserializer = new Deserializer(namingConvention: new CamelCaseNamingConvention(), ignoreUnmatched: true); var parser = new MergingParser(new YamlDotNet.Core.Parser(input)); cartoProject = deserializer.Deserialize <CartoProject>(new EventReader(parser)); } break; default: throw new Exception("Unknown extension of the CartoCSS project."); } Map map = null; if (cartoProject.Stylesheet != null && cartoProject.Stylesheet.Length > 0 && cartoProject.Layers.Length > 0) { ICartoTranslator cartoTranslator = CartoGeneratorConverterFactory.CreateTranslator(cartoProject.Generator); CartoParser parser = new CartoParser(); parser.NodeProvider = new CartoNodeProvider(); Env env = new Env(); List <Ruleset> ruleSets = new List <Ruleset>(); List <CartoDefinition> definitions = new List <CartoDefinition>(); foreach (string styleName in cartoProject.Stylesheet) { string styleFileName = Path.Combine(path, styleName); try { Ruleset ruleSet = parser.Parse(File.ReadAllText(styleFileName), styleFileName, env); ruleSets.Add(ruleSet); // Get an array of Ruleset objects, flattened // and sorted according to specificitySort var defs = new List <CartoDefinition>(); defs = ruleSet.Flatten(defs, null, env); defs.Sort(new SpecificitySorter()); definitions.AddRange(defs); env.Frames.Push(ruleSet); } catch (Exception ex) { Exception ex2 = new IOException(string.Format("An error occured during parsing of the style '{0}'.", styleFileName) + ex.Message); LogFactory.WriteLogEntry(Logger.Default, ex2); throw ex2; } } string interactivityLayer = null; if (cartoProject.GetInteractivity() != null && cartoProject.GetInteractivity().ContainsKey("layer")) { interactivityLayer = cartoProject.GetInteractivity()["layer"].ToString(); } map = CreateMap(cartoProject, definitions, env, cartoTranslator); foreach (CartoLayer cartoLayer in cartoProject.Layers) { CartoDatasource datasource = cartoLayer.Datasource; StyledLayer styledLayer = CreateStyledLayer(cartoLayer, map, cartoTranslator); try { string[] classes = (cartoLayer.Class.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)); Dictionary <string, bool> classIndex = new Dictionary <string, bool>(classes.Length); for (int i = 0; i < classes.Length; i++) { classIndex[classes[i]] = true; } var matching = definitions.FindAll(delegate(CartoDefinition def) { return(def.AppliesTo(cartoLayer.Name, classIndex)); }); if (matching.Count > 0) { List <CartoStyle> rules = InheritDefinitions(matching, env); if (rules.Count > 0) { SortStyles(rules, env); for (int k = 0; k < rules.Count; k++) { CartoStyle cartoStyle = rules[k]; cartoStyle.Fold(env); string styleName = cartoLayer.Name + (cartoStyle.Attachment != "__default__" ? "-" + cartoStyle.Attachment : ""); FeatureTypeStyle style = CreateStyle(styleName, cartoStyle, env, cartoTranslator); if (style.Rules.Count > 0) { styledLayer.Styles.Add(style); } } cartoTranslator.ProcessStyles(styledLayer.Styles); } if (!string.IsNullOrEmpty(interactivityLayer) && interactivityLayer.Equals(styledLayer.Name)) { styledLayer.Enabled = false; } map.AddLayer(styledLayer); } } catch (Exception ex) { Exception ex2 = new IOException(string.Format("Unable to create data source provider with type '{0}' for the layer '{1}'.", datasource.Type, cartoLayer.Name) + ex.Message); LogFactory.WriteLogEntry(Logger.Default, ex2); } } } return(map); }