//--- Class Methods ---
public static DeserializerBuilder WithCloudFormationFunctions(this DeserializerBuilder builder)
{
foreach (var tag in CloudFormationFunctionNodeDeserializer.SupportedTags)
{
builder = builder.WithTagMapping(tag, typeof(CloudFormationListFunction));
}
return(builder
.WithTagMapping("!Transform", typeof(CloudFormationMapFunction)));
}
/// <summary>
/// Generates a deserializer suitable for deserialzing <see cref="RuleSet"/> for use with this class (see also <see cref="LoadRules(string)"/>)
/// </summary>
/// <returns></returns>
public static IDeserializer GetDeserializer()
{
var builder = new DeserializerBuilder();
builder.WithTagMapping("!SocketRule", typeof(SocketRule));
builder.WithTagMapping("!WhiteListRule", typeof(WhiteListRule));
builder.WithTagMapping("!IsIdentifiableRule", typeof(IsIdentifiableRule));
return(builder.Build());
}
protected static Item ParseYamlMarkdown(string yamlmd)
{
var builder = new DeserializerBuilder();
foreach (var mapping in ClassMapping)
{
builder = builder.WithTagMapping($"!{mapping.Key}", mapping.Value);
}
var yamlDeserializer = builder
.WithNamingConvention(PascalCaseNamingConvention.Instance)
.Build();
var parser = new Parser(new System.IO.StringReader(yamlmd));
parser.Consume <StreamStart>();
parser.Consume <DocumentStart>();
var post = yamlDeserializer.Deserialize(parser);
parser.Consume <DocumentEnd>();
//parser.MoveNext();
var item = post as Item;
item.Markdown = yamlmd.Substring(parser.Current.End.Index + 1);
return(post as Item);
}
public static IDeserializer GetDeserializer(string filePath = null)
{
// if (_desrializer != null) {
// return _desrializer;
// }
var builder = new DeserializerBuilder();
builder = builder
.IgnoreFields()
.IgnoreUnmatchedProperties()
.WithNamingConvention(CamelCaseNamingConvention.Instance);
if (RegisteredTags?.Count > 0)
{
foreach (var t in RegisteredTags)
{
var type = t.GetType();
var tagKey = type.GetCustomAttributes(typeof(YamlTagAttribute), true)
.FirstOrDefault() is YamlTagAttribute att
? att.TagName
: null;
builder = builder.WithTagMapping($"!{tagKey}", type);
}
builder = builder
.WithTypeConverter(
new FileTypeConverter(RegisteredTags, filePath),
s => s.OnTop());
}
// _desrializer = builder.Build();
// return _desrializer;
return(builder.Build());
}
public void NotSpecifyingObjectFactoryUsesDefault()
{
var text = "!empty {}";
DeserializerBuilder.WithTagMapping("!empty", typeof(EmptyBase));
var result = Deserializer.Deserialize(UsingReaderFor(text));
result.Should().BeOfType <EmptyBase>();
}
public void ObjectFactoryIsInvoked()
{
AssumingDeserializerWith(new LambdaObjectFactory(t => new EmptyDerived()));
var text = "!empty {}";
DeserializerBuilder.WithTagMapping("!empty", typeof(EmptyBase));
var result = Deserializer.Deserialize(UsingReaderFor(text));
result.Should().BeOfType <EmptyDerived>();
}
static void Main(string[] args)
{
// Build YAML Parser
var listOfAbilities = (
from domainAssembly in AppDomain.CurrentDomain.GetAssemblies()
from assemblyType in domainAssembly.GetTypes()
where assemblyType.IsSubclassOf(typeof(Ability)) && !assemblyType.IsAbstract
select assemblyType
).ToArray();
var listOfRaces = (
from domainAssembly in AppDomain.CurrentDomain.GetAssemblies()
from assemblyType in domainAssembly.GetTypes()
where assemblyType.IsSubclassOf(typeof(Race)) && !assemblyType.IsAbstract
select assemblyType
).ToArray();
var deserializerBuilder = new DeserializerBuilder()
.WithNamingConvention(CamelCaseNamingConvention.Instance);
foreach (var type in listOfAbilities.Concat(listOfRaces))
{
deserializerBuilder.WithTagMapping("!" + type.Name, type);
}
var deserializer = deserializerBuilder.Build();
// Load Parties
List <Party> parties = new List <Party>();
foreach (var arg in args)
{
string input = System.IO.File.ReadAllText(arg);
parties.Add(deserializer.Deserialize <Party>(input));
}
if (!IsValid(parties))
{
Console.WriteLine("One or more parties are not valid. Exiting.");
return;
}
// Pick combat type
if (parties.Count == 2)
{
Duel(parties);
}
else if (parties.Count > 2)
{
Brawl(parties);
}
else
{
Console.WriteLine("You must run this with at least 2 parties");
}
}
public void DeserializeCustomTags()
{
var stream = Yaml.StreamFrom("tags.yaml");
DeserializerBuilder.WithTagMapping("tag:yaml.org,2002:point", typeof(Point));
var result = Deserializer.Deserialize(stream);
result.Should().BeOfType <Point>().And
.Subject.As <Point>()
.ShouldBeEquivalentTo(new { X = 10, Y = 20 }, o => o.ExcludingMissingMembers());
}
/// <summary>
/// Converts the input RAML stream to an Open API Specification document.
/// </summary>
/// <param name="inputPath">The path to the RAML file.</param>
public OpenApiDocument ConvertToOpenApiDocument(string inputPath)
{
var builder = new DeserializerBuilder();
var includeNodeDeserializer = new YamlIncludeNodeDeserializer(new YamlIncludeNodeDeserializerOptions
{
DirectoryName = Path.GetDirectoryName(inputPath),
Deserializer = builder.Build()
});
_deserializer = builder
.WithTagMapping(Constants.IncludeTag, typeof(IncludeRef))
.WithNodeDeserializer(includeNodeDeserializer, s => s.OnTop())
.Build();
var result = _deserializer.Deserialize <Dictionary <object, object> >(File.ReadAllText(inputPath));
// Step 1 - Get all types and schemas
var types = result.GetAsDictionary("types");
if (types != null)
{
foreach (var type in types.Where(x => !_types.ContainsKey(x.Key)))
{
_types.Add(type.Key, type.Value);
}
}
var schemas = result.GetAsDictionary("schemas");
if (schemas != null)
{
foreach (var schema in schemas.Where(x => !_types.ContainsKey(x.Key)))
{
_types.Add(schema.Key, schema.Value);
}
}
// Step 2 - Get Info, Servers and Components
_doc = new OpenApiDocument
{
Info = MapInfo(result),
Servers = MapServers(result),
Components = MapComponents(_types)
};
// Step 3 - Get Paths
_doc.Paths = MapPaths(result);
// Check if valid
var text = _doc.Serialize(OpenApiSpecVersion.OpenApi3_0, OpenApiFormat.Json);
return(_doc);
}
public static T Parse <T>(string readText, string debugFilename, ErrorHandler handle_error = null, List <Tuple <string, Type> > tagMappings = null)
{
try
{
if (handle_error == null)
{
handle_error = LogError;
}
readText = readText.Replace("\t", " ");
Action <string> unmatchedLogFn = delegate(string error)
{
handle_error(new Error
{
file = new FileHandle
{
full_path = debugFilename
},
text = readText,
message = error,
severity = Error.Severity.Recoverable
}, false);
};
DeserializerBuilder deserializerBuilder = new DeserializerBuilder();
deserializerBuilder.IgnoreUnmatchedProperties(unmatchedLogFn);
if (tagMappings != null)
{
foreach (Tuple <string, Type> tagMapping in tagMappings)
{
deserializerBuilder = deserializerBuilder.WithTagMapping(tagMapping.first, tagMapping.second);
}
}
Deserializer deserializer = deserializerBuilder.Build();
StringReader input = new StringReader(readText);
return(deserializer.Deserialize <T>(input));
}
catch (Exception ex)
{
handle_error(new Error
{
file = new FileHandle
{
full_path = debugFilename
},
text = readText,
message = ex.Message,
inner_exception = ex.InnerException,
severity = Error.Severity.Fatal
}, false);
}
return(default(T));
}
internal Deserializer CreateDefaultDeserializer()
{
var mappings = this.moduleFinder.GetAllModulesForModulesNamespace();
var builder = new DeserializerBuilder();
foreach (var mapping in mappings)
{
System.Diagnostics.Debug.WriteLine($"Added custom tag for yaml mapping: {mapping.Name} - {mapping.Type.Name}");
builder = builder.WithTagMapping(mapping.Name, mapping.Type);
}
return(builder.Build());
}
public static IDeserializer Build(string directoryName)
{
var builder = new DeserializerBuilder();
var includeNodeDeserializerOptions = new YamlIncludeNodeDeserializerOptions
{
DirectoryName = directoryName
};
var includeNodeDeserializer = new YamlIncludeNodeDeserializer(includeNodeDeserializerOptions);
return(builder
.WithTagMapping(string.Empty, typeof(IncludeRef))
.WithTagMapping(Constants.IncludeTag, typeof(IncludeRef))
.WithNodeDeserializer(includeNodeDeserializer, s => s.OnTop())
.Build());
}
public SequencePersistence()
{
var deserializerBuilder = new DeserializerBuilder();
deserializerBuilder
.WithTagMapping("tag:yaml.org,2002:abort", typeof(AbortCondition))
.WithTagMapping("tag:yaml.org,2002:output", typeof(OutputEvent))
.WithNamingConvention(new CamelCaseNamingConvention());
deserializer = deserializerBuilder.Build();
var serializerBuilder = new SerializerBuilder();
serializerBuilder
.WithTagMapping("tag:yaml.org,2002:abort", typeof(AbortCondition))
.WithTagMapping("tag:yaml.org,2002:output", typeof(OutputEvent))
.WithNamingConvention(new CamelCaseNamingConvention());
serializer = serializerBuilder.Build();
}
public static PhotonViewPrefabMaster Load(TextReader reader)
{
var views = Assembly.GetExecutingAssembly().GetTypes()
.Where(typeof(PhotonViewComponent).IsAssignableFrom);
var builder = new DeserializerBuilder();
foreach (var view in views)
{
builder.WithTagMapping($"!{view.Name}", view);
}
var deserializer = builder.Build();
var photonViews = deserializer.Deserialize <PhotonView[]>(reader)
.ToDictionary(e => e.Name);
return(new PhotonViewPrefabMaster(photonViews));
}
public YamlFormatter(IEnumerable <Type> knownTypes) : base(knownTypes)
{
SerializerBuilder serializerBuilder = new SerializerBuilder()
.WithNamingConvention(PascalCaseNamingConvention.Instance)
.EnsureRoundtrip()
.IgnoreFields();
DeserializerBuilder deserializerBuilder = new DeserializerBuilder()
.WithNamingConvention(PascalCaseNamingConvention.Instance)
.IgnoreUnmatchedProperties()
.IgnoreFields();
foreach (Type type in KnownTypes)
{
serializerBuilder = serializerBuilder.WithTagMapping($"!{type.FullName}", type);
deserializerBuilder = deserializerBuilder.WithTagMapping($"!{type.FullName}", type);
}
_serializer = serializerBuilder.Build();
_deserializer = deserializerBuilder.Build();
}
public ConfigService()
{
config = new Config
{
Channels = new System.Collections.ObjectModel.ObservableCollection <Channel>()
};
var deserializerBuilder = new DeserializerBuilder();
deserializerBuilder
.WithTagMapping("tag:yaml.org,2002:input", typeof(InputChannel))
.WithNamingConvention(new CamelCaseNamingConvention());
deserializer = deserializerBuilder.Build();
var serializerBuilder = new SerializerBuilder();
serializerBuilder
.WithTagMapping("tag:yaml.org,2002:input", typeof(InputChannel))
.WithNamingConvention(new CamelCaseNamingConvention());
serializer = serializerBuilder.Build();
}
public static MapConfig ReadFromString(string yamlString, IEnumerable <Type> customCommands)
{
var commandMapping = new Dictionary <string, Type>()
{
{ CommandUtils.GetCommandYamlName(typeof(ReplaceCommandSet)), typeof(ReplaceCommandSet) },
{ CommandUtils.GetCommandYamlName(typeof(SetFlowCommand)), typeof(SetFlowCommand) },
{ CommandUtils.GetCommandYamlName(typeof(LookupCommand)), typeof(LookupCommand) },
{ CommandUtils.GetCommandYamlName(typeof(TypeConvertCommand)), typeof(TypeConvertCommand) },
{ CommandUtils.GetCommandYamlName(typeof(SetCommand)), typeof(SetCommand) },
{ CommandUtils.GetCommandYamlName(typeof(ConcatCommand)), typeof(ConcatCommand) },
{ CommandUtils.GetCommandYamlName(typeof(GetValueCommand)), typeof(GetValueCommand) },
{ CommandUtils.GetCommandYamlName(typeof(GetNotEmptyValueCommand)), typeof(GetNotEmptyValueCommand) },
{ CommandUtils.GetCommandYamlName(typeof(IfCommand)), typeof(IfCommand) },
{ CommandUtils.GetCommandYamlName(typeof(TraceCommand)), typeof(TraceCommand) },
{ CommandUtils.GetCommandYamlName(typeof(CommandSet <CommandBase>)), typeof(CommandSet <CommandBase>) },
{ CommandUtils.GetCommandYamlName(typeof(GetTargetCommand)), typeof(GetTargetCommand) },
{ CommandUtils.GetCommandYamlName(typeof(MessageCommand)), typeof(MessageCommand) },
{ "csv", typeof(CsvDataSource) },
{ "composite-source", typeof(CompositeDataSource) },
{ "excel", typeof(ExcelDataSource) },
{ "sql", typeof(SqlDataSource) },
};
var builder = new DeserializerBuilder();
customCommands
.Select(type => new KeyValuePair <string, Type>(type.Name, type))
.Union(commandMapping)
.ToList()
.ForEach(type => builder = builder.WithTagMapping("!" + type.Key, type.Value));
var deserializer = builder.Build();
var mapConfig = deserializer.Deserialize <MapConfig>(yamlString);
mapConfig.Initialize();
return(mapConfig);
}
