public object ConstructScalar(Node node)
{
ScalarNode scalar = node as ScalarNode;
if (scalar == null)
{
MappingNode mapNode = node as MappingNode;
if (mapNode != null)
{
foreach (KeyValuePair <Node, Node> entry in mapNode.Nodes)
{
if ("tag:yaml.org,2002:value" == entry.Key.Tag)
{
return(ConstructScalar(entry.Value));
}
}
}
throw new ConstructorException("expected a scalar or mapping node, but found: " + node);
}
string value = scalar.Value;
if (value.Length > 1 && value[0] == ':' && scalar.Style == '\0')
{
return(SymbolTable.StringToId(value.Substring(1)));
}
return(value);
}
public static Range ConstructRubyRange(IConstructor /*!*/ ctor, Node node)
{
object begin = null;
object end = null;
bool excludeEnd = false;
ScalarNode scalar = node as ScalarNode;
if (scalar != null)
{
string value = scalar.Value;
int dotsIdx;
if ((dotsIdx = value.IndexOf("...")) != -1)
{
begin = ParseObject(ctor, value.Substring(0, dotsIdx));
end = ParseObject(ctor, value.Substring(dotsIdx + 3));
excludeEnd = true;
}
else if ((dotsIdx = value.IndexOf("..")) != -1)
{
begin = ParseObject(ctor, value.Substring(0, dotsIdx));
end = ParseObject(ctor, value.Substring(dotsIdx + 2));
}
else
{
throw new ConstructorException("Invalid Range: " + value);
}
}
else
{
MappingNode mapping = node as MappingNode;
if (mapping == null)
{
throw new ConstructorException("Invalid Range: " + node);
}
foreach (KeyValuePair <Node, Node> n in mapping.Nodes)
{
string key = ctor.ConstructScalar(n.Key).ToString();
switch (key)
{
case "begin":
begin = ctor.ConstructObject(n.Value);
break;
case "end":
end = ctor.ConstructObject(n.Value);
break;
case "excl":
TryConstructYamlBool(ctor, n.Value, out excludeEnd);
break;
default:
throw new ConstructorException(string.Format("'{0}' is not allowed as an instance variable name for class Range", key));
}
}
}
return(new Range(ctor.Scope.RubyContext, begin, end, excludeEnd));
}
public static object CreateMap([NotNull]BlockParam/*!*/ block, Out/*!*/ self, [DefaultProtocol]MutableString taguri, object yamlStyle) {
var rep = self._representer;
var map = new MappingNode(rep.ToTag(taguri), new Dictionary<Node, Node>(), RubyYaml.ToYamlFlowStyle(yamlStyle));
object blockResult;
if (block.Yield(map, out blockResult)) {
return blockResult;
}
return map;
}
public static object CreateMap([NotNull] BlockParam /*!*/ block, Out /*!*/ self, [DefaultProtocol] MutableString taguri, object yamlStyle)
{
var rep = self._representer;
var map = new MappingNode(rep.ToTag(taguri), new Dictionary <Node, Node>(), RubyYaml.ToYamlFlowStyle(yamlStyle));
object blockResult;
if (block.Yield(map, out blockResult))
{
return(blockResult);
}
return(map);
}
private static object ConstructRubyStruct(RubyConstructor /*!*/ ctor, string /*!*/ structName, Node /*!*/ node)
{
MappingNode mapping = node as MappingNode;
if (mapping == null)
{
throw new ConstructorException("can only construct struct from mapping node");
}
if (structName.Length == 0)
{
// TODO:
throw new NotSupportedException("anonymous structs not supported");
}
RubyContext context = ctor.GlobalScope.Context;
RubyModule module;
// TODO: MRI calls "members" on an arbitrary object
// MRI checks Struct first, then falls back to Object
if (!context.TryGetModule(ctor.GlobalScope, "Struct::" + structName, out module) &&
!context.TryGetModule(ctor.GlobalScope, structName, out module))
{
throw RubyExceptions.CreateTypeError("Undefined struct `{0}'", structName);
}
RubyClass cls = module as RubyClass;
if (cls == null)
{
throw RubyExceptions.CreateTypeError("`{0}' is not a class", structName);
}
RubyStruct newStruct = RubyStruct.Create(cls);
foreach (var pair in ctor.ConstructMapping(mapping))
{
var attributeName = pair.Key as MutableString;
int index;
// TODO: encoding
if (attributeName != null && newStruct.TryGetIndex(attributeName.ToString(), out index))
{
newStruct[index] = pair.Value;
}
}
return(newStruct);
}
public object ConstructPairs(Node mappingNode)
{
MappingNode map = mappingNode as MappingNode;
if (map == null)
{
throw new ConstructorException("expected a mapping node, but found: " + mappingNode);
}
List <object[]> result = new List <object[]>();
foreach (KeyValuePair <Node, Node> entry in map.Nodes)
{
result.Add(new object[] { ConstructObject(entry.Key), ConstructObject(entry.Value) });
}
return(result);
}
private static object ConstructPrivateObject(RubyConstructor /*!*/ ctor, string className, Node node)
{
MappingNode mapping = node as MappingNode;
if (mapping == null)
{
throw new ConstructorException("can only construct private type from mapping node");
}
RubyModule module;
RubyGlobalScope globalScope = ctor.GlobalScope;
if (globalScope.Context.TryGetModule(globalScope, className, out module))
{
if (!module.IsClass)
{
throw new ConstructorException("Cannot construct module");
}
Hash values = ctor.ConstructMapping(mapping);
// TODO: call allocate here:
object result = null;
RubyMethodInfo method = module.GetMethod("yaml_initialize") as RubyMethodInfo;
if (method != null)
{
result = RubyMarshal.Utils.CreateObjectAndSetIvars((RubyClass)module);
ctor._yamlInitializeSite.Target(ctor._yamlInitializeSite, result, className, values);
}
else
{
var dict = new Dictionary <string, object>(values.Count);
foreach (var kvp in EnumerateAttributes(globalScope.Context, values))
{
dict.Add(kvp.Key, kvp.Value);
}
result = RubyMarshal.Utils.CreateObjectAndSetIvars((RubyClass)module, dict);
}
return(result);
}
else
{
//TODO: YAML::Object
throw new NotImplementedError("YAML::Object is not implemented yet");
}
}
/// <summary>
/// Returns the value of the scalar.
/// </summary>
public string ConstructScalar(Node /*!*/ node)
{
ScalarNode scalar = node as ScalarNode;
if (scalar == null)
{
MappingNode mapNode = node as MappingNode;
if (mapNode != null)
{
foreach (KeyValuePair <Node, Node> entry in mapNode.Nodes)
{
if (entry.Key.Tag == "tag:yaml.org,2002:value")
{
return(ConstructScalar(entry.Value));
}
}
}
throw new ConstructorException("expected a scalar or mapping node, but found: " + node);
}
return(scalar.Value);
}
public static object ConstructRubyStruct(IConstructor ctor, string className, Node node)
{
MappingNode mapping = node as MappingNode;
if (mapping == null)
{
throw new ConstructorException("can only construct struct from mapping node");
}
RubyScope scope = ctor.Scope;
RubyModule module;
RubyClass cls;
if (scope.RubyContext.TryGetModule(scope.GlobalScope, className, out module))
{
cls = module as RubyClass;
if (cls == null)
{
throw new ConstructorException("Struct type name must be Ruby class");
}
}
else
{
RubyModule structModule = scope.RubyContext.GetModule(typeof(RubyStruct));
cls = RubyUtils.GetConstant(scope, structModule, className, false) as RubyClass;
if (cls == null)
{
throw new ConstructorException(String.Format("Cannot find struct class \"{0}\"", className));
}
}
RubyStruct newStruct = RubyStruct.Create(cls);
foreach (var pair in ctor.ConstructMapping(mapping))
{
RubyStructOps.SetValue(newStruct, SymbolTable.StringToId(pair.Key.ToString()), pair.Value);
}
return(newStruct);
}
public static object ConstructPrivateObject(IConstructor ctor, string className, Node node)
{
MappingNode mapping = node as MappingNode;
if (mapping == null)
{
throw new ConstructorException("can only construct private type from mapping node");
}
RubyModule module;
RubyScope scope = ctor.Scope;
if (scope.RubyContext.TryGetModule(scope.GlobalScope, className, out module))
{
if (!module.IsClass)
{
throw new ConstructorException("Cannot construct module");
}
Hash values = ctor.ConstructMapping(mapping);
RubyMethodInfo method = (module.GetMethod("yaml_initialize") as RubyMethodInfo);
if (method != null)
{
object result = RubyUtils.CreateObject((RubyClass)module);
_YamlInitialize.Target(_YamlInitialize, scope.RubyContext, result, className, values);
return(result);
}
else
{
return(RubyUtils.CreateObject((RubyClass)module, values, true));
}
}
else
{
//TODO: YAML::Object
throw new NotImplementedError("YAML::Object is not implemented yet");
}
}
private Node ComposeNode(Node parent, object index)
{
Node result;
YamlEvent @event = _parser.PeekEvent();
NodeEvent nodeEvent = @event as NodeEvent;
string anchor = (nodeEvent != null) ? nodeEvent.Anchor : null;
if (nodeEvent is AliasEvent)
{
_parser.GetEvent();
if (!_anchors.TryGetValue(anchor, out result))
{
throw new ComposerException("found undefined alias: " + anchor);
}
return(result);
}
result = null;
//_resolver.descendResolver(parent, index);
if (@event is ScalarEvent)
{
ScalarEvent ev = (ScalarEvent)_parser.GetEvent();
string tag = ev.Tag;
if (tag == null || tag == "!")
{
tag = Resolver.Resolve(typeof(ScalarNode), ev.Value, ev.Implicit);
}
result = new ScalarNode(tag, ev.Value, ev.Style);
if (null != anchor)
{
AddAnchor(anchor, result);
}
}
else if (@event is SequenceStartEvent)
{
SequenceStartEvent start = (SequenceStartEvent)_parser.GetEvent();
string tag = start.Tag;
if (tag == null || tag == "!")
{
tag = Resolver.Resolve(typeof(SequenceNode), null, start.Implicit);
}
SequenceNode seqResult = new SequenceNode(tag, new List <Node>(), start.FlowStyle);
result = seqResult;
if (null != anchor)
{
AddAnchor(anchor, seqResult);
}
int ix = 0;
while (!(_parser.PeekEvent() is SequenceEndEvent))
{
seqResult.Nodes.Add(ComposeNode(seqResult, ix++));
}
_parser.GetEvent();
}
else if (@event is MappingStartEvent)
{
MappingStartEvent start = (MappingStartEvent)_parser.GetEvent();
string tag = start.Tag;
if (tag == null || tag == "!")
{
tag = Resolver.Resolve(typeof(MappingNode), null, start.Implicit);
}
MappingNode mapResult = new MappingNode(tag, new Dictionary <Node, Node>(), start.FlowStyle);
result = mapResult;
if (null != anchor)
{
AddAnchor(anchor, result);
}
while (!(_parser.PeekEvent() is MappingEndEvent))
{
YamlEvent key = _parser.PeekEvent();
Node itemKey = ComposeNode(mapResult, null);
Node composed = ComposeNode(mapResult, itemKey);
if (!mapResult.Nodes.ContainsKey(itemKey))
{
mapResult.Nodes.Add(itemKey, composed);
}
}
_parser.GetEvent();
}
//_resolver.ascendResolver();
return(result);
}
//TODO: remove Ruby-specific stuff from this layer
public Hash ConstructMapping(Node mappingNode)
{
MappingNode map = mappingNode as MappingNode;
if (map == null)
{
throw new ConstructorException("expected a mapping node, but found: " + mappingNode);
}
Hash mapping = new Hash(_globalScope.Context);
LinkedList <Hash> merge = null;
foreach (KeyValuePair <Node, Node> entry in map.Nodes)
{
Node key_v = entry.Key;
Node value_v = entry.Value;
if (key_v.Tag == "tag:yaml.org,2002:merge")
{
if (merge != null)
{
throw new ConstructorException("while constructing a mapping: found duplicate merge key");
}
SequenceNode sequence;
merge = new LinkedList <Hash>();
if (value_v is MappingNode)
{
merge.AddLast(ConstructMapping(value_v));
}
else if ((sequence = value_v as SequenceNode) != null)
{
foreach (Node subNode in sequence.Nodes)
{
if (!(subNode is MappingNode))
{
throw new ConstructorException("while constructing a mapping: expected a mapping for merging, but found: " + subNode);
}
merge.AddFirst(ConstructMapping(subNode));
}
}
else
{
throw new ConstructorException("while constructing a mapping: expected a mapping or list of mappings for merging, but found: " + value_v);
}
}
else if (key_v.Tag == "tag:yaml.org,2002:value")
{
if (mapping.ContainsKey("="))
{
throw new ConstructorException("while construction a mapping: found duplicate value key");
}
mapping.Add("=", ConstructObject(value_v));
}
else
{
object kk = ConstructObject(key_v);
object vv = ConstructObject(value_v);
LinkNode linkNode = vv as LinkNode;
if (linkNode != null)
{
AddFixer(linkNode.Linked, delegate(Node node, object real) {
IDictionaryOps.SetElement(_globalScope.Context, mapping, kk, real);
});
}
IDictionaryOps.SetElement(_globalScope.Context, mapping, kk, vv);
}
}
if (null != merge)
{
merge.AddLast(mapping);
mapping = new Hash(_globalScope.Context);
foreach (Hash m in merge)
{
foreach (KeyValuePair <object, object> e in m)
{
IDictionaryOps.SetElement(_globalScope.Context, mapping, e.Key, e.Value);
}
}
}
return(mapping);
}
public static object GetValue(MappingNode/*!*/ self) {
return self.Nodes;
}
public static void Add(YamlCallSiteStorage/*!*/ siteStorage, MappingNode/*!*/ self, object key, object value) {
RubyRepresenter rep = new RubyRepresenter(siteStorage);
self.Nodes.Add(rep.RepresentItem(key), rep.RepresentItem(value));
}
public static object SetStyle(MappingNode/*!*/ self, object value) {
self.FlowStyle = RubyYaml.ToYamlFlowStyle(value);
return value;
}
public static object GetValue(MappingNode /*!*/ self)
{
return(self.Nodes);
}
public static void Add(YamlCallSiteStorage /*!*/ siteStorage, MappingNode /*!*/ self, object key, object value)
{
RubyRepresenter rep = new RubyRepresenter(siteStorage);
self.Nodes.Add(rep.RepresentItem(key), rep.RepresentItem(value));
}
public static object SetStyle(MappingNode /*!*/ self, object value)
{
self.FlowStyle = RubyYaml.ToYamlFlowStyle(value);
return(value);
}
private Node ComposeNode(Node parent, object index) {
Node result;
YamlEvent @event = _parser.PeekEvent();
NodeEvent nodeEvent = @event as NodeEvent;
string anchor = (nodeEvent != null) ? nodeEvent.Anchor : null;
if (nodeEvent is AliasEvent) {
_parser.GetEvent();
if (!_anchors.TryGetValue(anchor, out result)) {
throw new ComposerException("found undefined alias: " + anchor);
}
return result;
}
result = null;
//_resolver.descendResolver(parent, index);
if (@event is ScalarEvent) {
ScalarEvent ev = (ScalarEvent)_parser.GetEvent();
string tag = ev.Tag;
if (ev.Type == ScalarValueType.Unknown) {
Debug.Assert(tag == null || tag == "!");
tag = ResolverScanner.Recognize(ev.Value) ?? Tags.Str;
}
result = new ScalarNode(tag, ev.Value, ev.Style);
if (anchor != null) {
AddAnchor(anchor, result);
}
} else if (@event is SequenceStartEvent) {
SequenceStartEvent start = (SequenceStartEvent)_parser.GetEvent();
SequenceNode seqResult = new SequenceNode(start.Tag != "!" ? start.Tag : null, new List<Node>(), start.FlowStyle);
result = seqResult;
if (anchor != null) {
AddAnchor(anchor, seqResult);
}
int ix = 0;
while (!(_parser.PeekEvent() is SequenceEndEvent)) {
seqResult.Nodes.Add(ComposeNode(seqResult, ix++));
}
_parser.GetEvent();
} else if (@event is MappingStartEvent) {
MappingStartEvent start = (MappingStartEvent)_parser.GetEvent();
MappingNode mapResult = new MappingNode(start.Tag != "!" ? start.Tag : null, new Dictionary<Node, Node>(), start.FlowStyle);
result = mapResult;
if (anchor != null) {
AddAnchor(anchor, result);
}
while (!(_parser.PeekEvent() is MappingEndEvent)) {
YamlEvent key = _parser.PeekEvent();
Node itemKey = ComposeNode(mapResult, key);
Node composed = ComposeNode(mapResult, itemKey);
if (!mapResult.Nodes.ContainsKey(itemKey)) {
mapResult.Nodes.Add(itemKey, composed);
}
}
_parser.GetEvent();
}
//_resolver.ascendResolver();
return result;
}
