private static void FindNodes(YamlMappingNode container, string name, List<KeyValuePair<YamlMappingNode, YamlNode>> matches)
{
var key = new YamlScalarNode(name);
YamlNode matchNode;
if (container.Children.TryGetValue(key, out matchNode))
{
matches.Add(new KeyValuePair<YamlMappingNode, YamlNode>(container, new YamlScalarNode(name)));
}
var nodes = container.Children.Values.OfType<YamlMappingNode>();
foreach (var node in nodes)
{
FindNodes(node, name, matches);
}
var sequenceNodes = container.Children.Values.OfType<YamlSequenceNode>();
foreach (var sequenceNode in sequenceNodes)
{
foreach (var node in sequenceNode.Children.OfType<YamlMappingNode>())
{
FindNodes(node, name, matches);
}
}
}
/// <summary>
/// Finds a child node by its name and enumerates its contents
/// </summary>
/// <param name="parent">Parent node</param>
/// <param name="groupName">Name of the group to find</param>
/// <returns>Returns a sequence of key-node pairs</returns>
public IEnumerable<KeyValuePair<string, YamlNode>> EnumerateNamedNodesOf(YamlNode parent, string groupName)
{
Contract.Requires(parent != null);
Contract.Requires(!String.IsNullOrWhiteSpace(groupName));
Contract.Ensures(Contract.Result<IEnumerable<KeyValuePair<string, YamlNode>>>() != null);
var mapping = parent as YamlMappingNode;
if (mapping != null)
{
var groupNameNode = new YamlScalarNode(groupName);
if (mapping.Children.ContainsKey(groupNameNode))
{
var groupSeq = mapping.Children[groupNameNode] as YamlSequenceNode;
if (groupSeq != null)
{
foreach (var item in EnumerateNodesOf(groupSeq))
{
if (item is YamlScalarNode)
{
yield return new KeyValuePair<string, YamlNode>(((YamlScalarNode)item).Value, null);
}
else if (item is YamlMappingNode)
{
var mappingChild = (YamlMappingNode)item;
yield return new KeyValuePair<string, YamlNode>(
GetScalarValue(mappingChild, "name"),
mappingChild);
}
}
}
}
}
}
/// <summary>
/// Gets a scalar value identified by its key
/// </summary>
/// <param name="parent">Parent node</param>
/// <param name="key">Key of the value</param>
/// <param name="errorMessage">Error message if the key does not exists</param>
/// <returns>Returns the scalar value</returns>
public string GetScalarValue(YamlNode parent, string key, string errorMessage = null)
{
Contract.Requires(parent != null);
Contract.Requires(key != null);
Contract.Ensures(Contract.Result<string>() != null);
try
{
var mapping = (YamlMappingNode)parent;
var pairs = EnumerateNodesOf(mapping);
var keyNode = new YamlScalarNode(key);
foreach (var pair in pairs)
{
if (keyNode.Equals(pair.Key))
{
if (pair.Value is YamlScalarNode)
{
var v = ((YamlScalarNode) pair.Value).Value;
if (v != null)
return v;
}
throw new InvalidSpecificationException(errorMessage ?? String.Format("No value for key {0}", key));
}
}
throw new InvalidSpecificationException(String.Format("Parent has no child with key {0}", key));
}
catch (Exception ex)
{
throw new InvalidSpecificationException(errorMessage ?? ex.Message, ex);
}
}
protected void EnterContext(YamlScalarNode scalar)
{
string value = IsNull(scalar)
? string.Empty
: scalar.Value;
EnterContext(value);
}
private void VisitYamlMappingNode(YamlScalarNode yamlNodeKey, YamlMappingNode yamlNodeValue)
{
EnterContext(yamlNodeKey.Value);
VisitYamlMappingNode(yamlNodeValue);
ExitContext();
}
protected override void Visit(YamlScalarNode scalar)
{
var key = ConfigurationPath.Combine(context.Reverse());
string value = IsNull(scalar)
? string.Empty
: scalar.Value;
this.items.Add(new KeyValuePair<string, string>(key, value));
}
private void VisitYamlScalarNode(YamlScalarNode yamlNodeKey, YamlScalarNode yamlNodeValue)
{
EnterContext(yamlNodeKey.Value);
var key = _currentPath;
if (_data.ContainsKey(key)) {
throw new FormatException(string.Format("FormatError_KeyIsDuplicated({0})", key));
}
_data[key] = yamlNodeValue.Value;
ExitContext();
}
protected override void Visit(YamlScalarNode scalar)
{
switch (_mappingIndentation)
{
case 1:
Model.Name = scalar.Value;
break;
case 2:
{
State parsed;
_state = !Enum.TryParse(scalar.Value, out parsed) ? State.None : parsed;
}
break;
case 3:
switch (_state)
{
case State.Commands:
_model.Commands.Add(new Command { Name = scalar.Value });
_current = _model.Commands[_model.Commands.Count - 1];
break;
case State.CommandDataTypes:
_model.CommandDataTypes.Add(new DataType { Name = scalar.Value });
_current = _model.CommandDataTypes[_model.CommandDataTypes.Count - 1];
break;
case State.Events:
_model.Events.Add(new Event { Name = scalar.Value });
_current = _model.Events[_model.Events.Count - 1];
break;
case State.EventDataTypes:
_model.EventDataTypes.Add(new DataType { Name = scalar.Value });
_current = _model.EventDataTypes[_model.EventDataTypes.Count - 1];
break;
case State.SharedDataTypes:
_model.SharedDataTypes.Add(new DataType { Name = scalar.Value });
_current = _model.SharedDataTypes[_model.SharedDataTypes.Count - 1];
break;
}
break;
case 4:
switch ((_scalarCount % 2))
{
case 0:
_current.Properties.Add(new Property { Name = scalar.Value });
break;
case 1:
_current.Properties[_current.Properties.Count - 1].DataType = scalar.Value;
break;
}
_scalarCount++;
break;
}
}
public static string getStartCommand(string stagingInfoFile)
{
string startCommand;
using (var stream = new StreamReader(stagingInfoFile))
{
var yaml = new YamlStream();
yaml.Load(stream);
var startCommandScalar = new YamlScalarNode("start_command");
var elements = ((YamlMappingNode)yaml.Documents[0].RootNode).Children;
startCommand = elements[startCommandScalar].ToString();
}
return startCommand;
}
public static string GetDetectedBuildpack(string stagingInfoFile)
{
string buildpack = string.Empty;
if (File.Exists(stagingInfoFile))
{
using (var stream = new StreamReader(stagingInfoFile))
{
var yaml = new YamlStream();
yaml.Load(stream);
var startCommandScalar = new YamlScalarNode("detected_buildpack");
var elements = ((YamlMappingNode)yaml.Documents[0].RootNode).Children;
buildpack = elements[startCommandScalar].ToString();
}
}
return buildpack;
}
static void Main(string[] args)
{
// Setup the input
var input = new StringReader(Document);
// Load the stream
var yaml = new YamlStream();
yaml.Load(input);
// Examine the stream
var mapping =
(YamlMappingNode)yaml.Documents[0].RootNode;
// Loop trough all child entries and print our keys
string key = string.Empty;
foreach (var entry in mapping.Children)
{
var myKey = ((YamlScalarNode)entry.Key).Value;
Console.WriteLine("Key: {0}", myKey);
if(myKey != "items")
{
continue;
}
YamlScalarNode myYamlScalarNode = new YamlScalarNode(myKey);
var tmpItem = mapping.Children[myYamlScalarNode];
// The next line will throw:
// An unhandled exception of type 'System.InvalidCastException' occurred in yamldotnet.exe
// Additional information: Unable to cast object of type 'YamlDotNet.RepresentationModel.YamlMappingNode' to type 'YamlDotNet.RepresentationModel.YamlSequenceNode'.
var items = (YamlSequenceNode)tmpItem;
foreach (YamlMappingNode item in items)
{
Console.WriteLine(
"{0}\t{1}",
item.Children[new YamlScalarNode("part_no")],
item.Children[new YamlScalarNode("descrip")]
);
}
Console.WriteLine("Press any key to exit.");
System.Console.ReadKey();
}
}
private static void WriteHtmlForScalarNode(StringWriter htmlwriter, YamlScalarNode scalar)
{
var regex = new Regex(@"(.*)\[(.*?)\]");
var match = regex.Match(scalar.ToString());
string href = null;
string caption = scalar.ToString();
if (match.Success)
{
caption = match.Groups[1].ToString();
href = match.Groups[2] + ".html";
}
if (href != null)
htmlwriter.Write("<a href='{0}'>", href);
htmlwriter.Write(caption);
if (href != null)
htmlwriter.Write("</a>");
}
private static bool IsNull(YamlScalarNode scalar)
{
if (string.IsNullOrEmpty(scalar.Value))
{
return true;
}
if (string.Equals(scalar.Tag, "tag:yaml.org,2002:null", StringComparison.OrdinalIgnoreCase))
{
return true;
}
if (string.Equals(scalar.Value, "null", StringComparison.OrdinalIgnoreCase))
{
return true;
}
if (string.Equals(scalar.Value, "~", StringComparison.OrdinalIgnoreCase))
{
return true;
}
return false;
}
protected override void Visit(YamlScalarNode scalar)
{
VisitNode(scalar);
}
/// <summary>
/// Gets an optional scalar value identified by its key
/// </summary>
/// <param name="parent">Parent node</param>
/// <param name="key">Key of the value</param>
/// <param name="defaultValue">Default value to be used if the key is not found in parent</param>
/// <returns>Returns either the scalar value read from the parent node, or the default value.</returns>
public string GetOptionalScalarValue(YamlNode parent, string key, string defaultValue)
{
Contract.Requires(parent != null);
Contract.Requires(key != null);
Contract.Ensures(Contract.Result<string>() != null || Contract.Result<string>() == defaultValue);
var mapping = parent as YamlMappingNode;
if (mapping != null)
{
var pairs = EnumerateNodesOf(mapping);
var keyNode = new YamlScalarNode(key);
foreach (var pair in pairs)
{
if (keyNode.Equals(pair.Key) &&
pair.Value is YamlScalarNode)
return ((YamlScalarNode)pair.Value).Value;
}
}
return defaultValue;
}
/// <summary>
/// Called after this object finishes visiting a <see cref="YamlScalarNode"/>.
/// </summary>
/// <param name="scalar">
/// The <see cref="YamlScalarNode"/> that has been visited.
/// </param>
protected virtual void Visited(YamlScalarNode scalar)
{
// Do nothing.
}
private bool TryGetValueByYamlKeyAndType(YamlScalarNode yamlKey, Type type, out object result)
{
if (mappingNode.Children.ContainsKey(yamlKey))
{
var value = mappingNode.Children[yamlKey];
if (YamlDoc.TryMapValue(value, out result))
{
return true;
}
}
return FailToGetValue(out result);
}
public override void Visit(YamlScalarNode scalar)
{
VisitNodeAndFindDuplicates(scalar);
}
protected override void Visit(YamlScalarNode scalar)
{
current.AppendChild(myDocument.CreateTextNode(scalar.Value));
}
private static FractalNode ParseYamlFile(YamlStream yaml)
{
var node = new FractalNode();
try
{
var mapping = (YamlMappingNode)yaml.Documents[0].RootNode;
//the mapping is index with yamlscalars and not strings
//So we need to build a new yamlscalarnode for every named entry
//Before checking them and adding them ot the node.
var titleScalar = new YamlScalarNode("Title");
if (mapping.Children.Keys.Contains(titleScalar))
node.Title = mapping.Children[titleScalar].ToString();
var nameScalar = new YamlScalarNode("Name");
if (mapping.Children.Keys.Contains(nameScalar))
node.Name = mapping.Children[nameScalar].ToString();
var textScalar = new YamlScalarNode("Text");
if (mapping.Children.Keys.Contains(textScalar))
node.Text = mapping.Children[textScalar].ToString();
var sideTitleScalar = new YamlScalarNode("SidebarTitle");
if (mapping.Children.Keys.Contains(sideTitleScalar))
node.SidebarTitle = mapping.Children[sideTitleScalar].ToString();
var sideTextScalar = new YamlScalarNode("SidebarText");
if (mapping.Children.Keys.Contains(sideTextScalar))
node.SidebarText = mapping.Children[sideTextScalar].ToString();
var sideUrlScalar = new YamlScalarNode("SidebarURL");
if (mapping.Children.Keys.Contains(sideUrlScalar))
node.SidebarUrl = mapping.Children[sideUrlScalar].ToString();
//Check for a nodes node, if it exists iterate over all its children
var nodesScalar = new YamlScalarNode("Nodes");
if (mapping.Children.Keys.Contains(nodesScalar))
{
var subnodes = (YamlSequenceNode) mapping.Children[nodesScalar];
foreach (YamlMappingNode subnode in subnodes)
{
var nodeWeighted = new FractalNodeWeighted();
//check for a type entry, and if it exists add it, Type is the one mandatory entry
var typeScalar = new YamlScalarNode("Type");
if(subnode.Children.Keys.Contains(typeScalar))
{
nodeWeighted.Type = subnode.Children[typeScalar].ToString();
}
else
{
break; //if there is no Type this entry isn't meaningful
}
//Parsing into an int can be tricky and users are likely to put in something that won't parse so we need more sanity checks here
var chanceScalar = new YamlScalarNode("PercentageChance");
if (subnode.Children.Keys.Contains(chanceScalar))
{
var amount = 1;
if (!int.TryParse(subnode.Children[chanceScalar].ToString(), out amount))
{
Console.WriteLine("Could not parse int from subnode: {0} defaulting to 1", subnode);
}
if( amount > 0 && amount <= 100)
{
nodeWeighted.PercentageChance = amount;
}
else
{
nodeWeighted.PercentageChance = 100;
}
}
else
{
nodeWeighted.PercentageChance = 100;
}
//need to do things a bit more complex because minimum may not exceed maximum
var maxScalar = new YamlScalarNode("MaxAmount");
if (subnode.Children.Keys.Contains(maxScalar))
{
var amount = 1;
if (!int.TryParse(subnode.Children[maxScalar].ToString(), out amount))
{
Console.WriteLine("Could not parse int from subnode: {0} defaulting to 1", subnode);
}
nodeWeighted.MaxAmount = amount;
}
else
{
nodeWeighted.MaxAmount = 1;
}
var minScalar = new YamlScalarNode("MinAmount");
if (subnode.Children.Keys.Contains(minScalar))
{
var amount = 1;
if (!int.TryParse(subnode.Children[minScalar].ToString(), out amount))
{
Console.WriteLine("Could not parse int from subnode: {0} defaulting to 1", subnode);
}
nodeWeighted.MinAmount = (amount > nodeWeighted.MaxAmount) ? nodeWeighted.MaxAmount : amount;
}
else
{
nodeWeighted.MinAmount = 1;
}
if(node.Nodes == null)
{
node.Nodes = new List<FractalNodeWeighted>();
}
node.Nodes.Add(nodeWeighted);
}
}
var choiceNodesScalar = new YamlScalarNode("ChoiceNodes");
if(mapping.Children.Keys.Contains(choiceNodesScalar))
{
var choiceNodes = (YamlSequenceNode) mapping.Children[choiceNodesScalar];
node.ChoiceNodes = new List<WeightedChoiceEntry>();
foreach (YamlSequenceNode choiceNode in choiceNodes)
{
var entry = new WeightedChoiceEntry {WeightedStrings = new Dictionary<string, int>()};
foreach (YamlSequenceNode subnode in choiceNode)
{
var subnodeData = subnode.Children;
var text = subnodeData[0].ToString();
var weight = 1;
if (!int.TryParse(subnodeData[1].ToString(), out weight))
{
Console.WriteLine("Could not parse int from subnode: {0} defaulting to 1", subnode);
}
entry.TotalWeight += weight;
entry.WeightedStrings.Add(text,weight);
}
node.ChoiceNodes.Add(entry);
}
}
}
catch (Exception e)
{
Console.WriteLine("Error parsing: {0}", _curFileName);
Console.WriteLine(e);
return null;
}
return node;
}
public override bool Equals(object other)
{
YamlScalarNode node = other as YamlScalarNode;
return(((node != null) && base.Equals(node)) && SafeEquals(this.Value, node.Value));
}
protected override void Visit(YamlScalarNode scalar)
{
VisitNode(scalar);
}
private void LoadPackager(Suite suite , Product product, YamlNode node)
{
var mapping = node as YamlMappingNode;
if (mapping != null)
{
var packagerKey = new YamlScalarNode("packager");
if (mapping.Children.ContainsKey(packagerKey))
{
var packagerNode = mapping.Children[packagerKey] as YamlMappingNode;
if (packagerNode != null)
{
string type = parser.GetScalarValue(packagerNode, "type", "Packager type is not defined");
var loader = parametersLoaders.FirstOrDefault(l => l.Supports(type));
IPackagerParameters param = null;
if (loader != null)
{
YamlNode paramNode;
if (packagerNode.Children.TryGetValue(new YamlScalarNode("param"), out paramNode))
{
param = loader.Load(suite, type, paramNode, parser) as IPackagerParameters;
}
else
{
param = loader.Load(suite, type, new YamlMappingNode(), parser) as IPackagerParameters;
}
}
product.Packager = new PackagerDefinition(type, param);
}
}
}
}
public void Reload(YamlNode node)
{
yamlNode = node;
mappingNode = yamlNode as YamlMappingNode;
sequenceNode = yamlNode as YamlSequenceNode;
scalarNode = yamlNode as YamlScalarNode;
children = null;
}
private bool TryGetValueByYamlKeyAndType(YamlScalarNode yamlKey, Type type, out object result)
{
if (mappingNode.Children.ContainsKey(yamlKey))
{
var value = mappingNode.Children[yamlKey];
if (YamlDoc.TryMapValue(value, out result))
{
return true;
}
}
return IsNullableType(type) ? SuccessfullyGetValue(out result, new DynamicYaml((YamlNode)null)) : FailToGetValue(out result);
}
protected override void Visit(YamlScalarNode scalar)
{
WriteIndent();
Console.WriteLine("Visit(YamlScalarNode, {0}, {1}) - {2}", scalar.Anchor, scalar.Tag, scalar.Value);
indent++;
}
/// <summary>
/// Initializes a new instance of the <see cref="YamlDocument"/> class with a single scalar node.
/// </summary>
public YamlDocument(string rootNode)
{
RootNode = new YamlScalarNode(rootNode);
}
/// <summary>
/// Called after this object finishes visiting a <see cref="YamlScalarNode"/>.
/// </summary>
/// <param name="scalar">
/// The <see cref="YamlScalarNode"/> that has been visited.
/// </param>
protected virtual void Visited(YamlScalarNode scalar)
{
// Do nothing.
}
public virtual void Visit(YamlScalarNode scalar)
{
}
private bool TryGetValueByKeyAndType(string key, Type type, out object result)
{
if (mappingNode == null)
{
return FailToGetValue(out result);
}
// try and get an exact match to the key first
if (TryGetValueByYamlKeyAndType(key, type, out result))
{
return true;
}
// otherwise try and match the key with a different cased first character
var yamlKey = new YamlScalarNode(key.InverseFirstCapital());
if (TryGetValueByYamlKeyAndType(yamlKey, type, out result))
{
return true;
}
return IsNullableType(type) ? SuccessfullyGetValue(new DynamicYaml((YamlNode)null), out result) : FailToGetValue(out result);
}
private bool TryGetValueByKeyAndType(string key,
Type type,
out object result)
{
if (mappingNode == null)
{
return FailToGetValue(out result);
}
var yamlKey = new YamlScalarNode(key.Decapitalize());
var yamlKey2 = new YamlScalarNode(key.Capitalize());
return TryGetValueByYamlKeyAndType(yamlKey, type, out result) ||
TryGetValueByYamlKeyAndType(yamlKey2, type, out result);
}
protected override void Visit(YamlScalarNode scalar)
{
// Do not assign anchors to scalars
}
protected override void Visited(YamlScalarNode scalar)
{
indent--;
WriteIndent();
Console.WriteLine("Visited(YamlScalarNode)");
}
void IYamlVisitor.Visit(YamlScalarNode scalar)
{
this.Visit(scalar);
this.Visited(scalar);
}
void IYamlVisitor.Visit(YamlScalarNode scalar)
{
Visit(scalar);
Visited(scalar);
}
protected virtual void Visited(YamlScalarNode scalar)
{
}
void IYamlVisitor.Visit(YamlScalarNode scalar)
{
Visit(scalar);
Visited(scalar);
}
public override bool Equals(object obj)
{
YamlScalarNode yamlScalarNode = obj as YamlScalarNode;
return(yamlScalarNode != null && Equals(yamlScalarNode) && YamlNode.SafeEquals(Value, yamlScalarNode.Value));
}
public override void Visit(YamlScalarNode scalar)
{
VisitNodeAndFindDuplicates(scalar);
}
protected override void Visit(YamlScalarNode scalar)
{
events.Add(new YamlNodeEvent(YamlNodeEventType.Scalar, scalar.Anchor, scalar.Tag, scalar.Value));
}
