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);
}
