/// <summary>
/// Transforms a Yarhl node using a chain of converters.
/// </summary>
/// <param name="node">The original node.</param>
/// <param name="converters">Converters list.</param>
/// <param name="parameters">Allowed parameters list.</param>
public static void Transform(this Node node, List <ConverterInfo> converters, List <ParameterInfo> parameters)
{
var yarhlConverters = PluginManager.Instance.GetConverters().Select(x => x.Metadata).ToList();
foreach (ConverterInfo converterInfo in converters)
{
ConverterMetadata metadata = yarhlConverters.Find(x => x.Name == converterInfo.TypeName);
if (metadata == null)
{
throw new UnknownConverterException($"Unknown converter: {converterInfo.TypeName}");
}
IConverter converter = (IConverter)Activator.CreateInstance(metadata.Type);
System.Reflection.MethodInfo initializer = metadata.Type.GetMethod("Initialize");
ParameterInfo parameter = parameters.Find(x => x.Id == converterInfo.ParameterId);
if (initializer != null && parameter != null)
{
_ = initializer.Invoke(converter, new object[] { parameter.Value });
}
node.ChangeFormat((IFormat)ConvertFormat.With(converter, node.Format));
}
}
public void CanConvertReturnsFalseForDifferentTypes()
{
var metadata = new ConverterMetadata {
InternalSources = new[] { typeof(string), typeof(int) },
};
Assert.That(metadata.CanConvert(typeof(DateTime)), Is.False);
}
public void CanConvertReturnsTrueForDerivedTypes()
{
var metadata = new ConverterMetadata {
InternalSources = typeof(Base),
};
Assert.That(metadata.CanConvert(typeof(Derived)), Is.True);
}
public void CanConvertReturnsTrueForTypeInList()
{
var metadata = new ConverterMetadata {
InternalSources = new[] { typeof(string), typeof(int) },
};
Assert.That(metadata.CanConvert(typeof(int)), Is.True);
}
public void CanConvertReturnsTrueForExactType()
{
var metadata = new ConverterMetadata {
InternalSources = typeof(int),
};
Assert.That(metadata.CanConvert(typeof(int)), Is.True);
}
public void GetDestinationsReturnOneElementArrayForSingleSource()
{
var metadata = new ConverterMetadata {
InternalDestinations = typeof(int),
};
Type[] dests = metadata.GetDestinations();
Assert.That(dests.Length, Is.EqualTo(1));
Assert.That(dests[0], Is.EqualTo(typeof(int)));
}
public void GetSourcesReturnOneElementArrayForSingleSource()
{
var metadata = new ConverterMetadata {
InternalSources = typeof(int),
};
Type[] sources = metadata.GetSources();
Assert.That(sources.Length, Is.EqualTo(1));
Assert.That(sources[0], Is.EqualTo(typeof(int)));
}
public void CanConvertSourceThrowsExceptionIfNullArgument()
{
var metadata = new ConverterMetadata {
InternalSources = new Type[] { typeof(int), typeof(string) },
};
Assert.That(
() => metadata.CanConvert(null),
Throws.ArgumentNullException);
}
public void GetDestinationsReturnTwoElementsArrayForListOfSources()
{
var metadata = new ConverterMetadata {
InternalDestinations = new Type[] { typeof(int), typeof(string) },
};
Type[] dests = metadata.GetDestinations();
Assert.That(dests.Length, Is.EqualTo(2));
Assert.That(dests[0], Is.EqualTo(typeof(int)));
Assert.That(dests[1], Is.EqualTo(typeof(string)));
}
public void GetAndSetProperties()
{
var metadata = new ConverterMetadata {
Name = "test",
Type = typeof(int),
InternalSources = typeof(string),
InternalDestinations = typeof(DateTime),
};
Assert.That(metadata.Name, Is.EqualTo("test"));
Assert.That(metadata.Type, Is.EqualTo(typeof(int)));
Assert.That(metadata.InternalSources, Is.EqualTo(typeof(string)));
Assert.That(metadata.InternalDestinations, Is.EqualTo(typeof(DateTime)));
}
public void CanConvertReturnsForSourceAndDestInSameOrderList()
{
var metadata = new ConverterMetadata {
InternalSources = new[] { typeof(int), typeof(DateTime) },
InternalDestinations = new[] { typeof(string), typeof(sbyte) },
};
Assert.That(
metadata.CanConvert(typeof(DateTime), typeof(sbyte)),
Is.True);
Assert.That(
metadata.CanConvert(typeof(DateTime), typeof(string)),
Is.False);
}
public void CanConvertReturnsForExactSourceAndDest()
{
var metadata = new ConverterMetadata {
InternalSources = typeof(int),
InternalDestinations = typeof(string),
};
Assert.That(
metadata.CanConvert(typeof(int), typeof(string)),
Is.True);
Assert.That(
metadata.CanConvert(typeof(string), typeof(string)),
Is.False);
Assert.That(
metadata.CanConvert(typeof(int), typeof(int)),
Is.False);
}
/// <summary>
/// Calls a translator converter.
/// </summary>
/// <param name="node">The original node.</param>
/// <param name="translation">The node with the translation.</param>
/// <param name="translator">The translator converter.</param>
public static void Translate(this Node node, Node translation, string translator)
{
var yarhlConverters = PluginManager.Instance.GetConverters().Select(x => x.Metadata).ToList();
ConverterMetadata metadata = yarhlConverters.Find(x => x.Name == translator);
if (metadata == null)
{
throw new UnknownConverterException($"Unknown converter: {translator}");
}
IConverter converter = (IConverter)Activator.CreateInstance(metadata.Type);
System.Reflection.MethodInfo initializer = metadata.Type.GetMethod("Initialize");
if (initializer != null)
{
_ = initializer.Invoke(converter, new object[] { translation.Format });
}
node.ChangeFormat((IFormat)ConvertFormat.With(converter, node.Format));
}
public void CanConvertReturnsForSourceAndDestDerived()
{
var metadata = new ConverterMetadata {
InternalSources = new[] { typeof(Base) },
InternalDestinations = new[] { typeof(Derived) },
};
Assert.That(
metadata.CanConvert(typeof(Derived), typeof(Base)),
Is.True);
metadata = new ConverterMetadata {
InternalSources = new[] { typeof(Derived) },
InternalDestinations = new[] { typeof(Base) },
};
Assert.That(
metadata.CanConvert(typeof(Base), typeof(Base)),
Is.False);
Assert.That(
metadata.CanConvert(typeof(Derived), typeof(Derived)),
Is.False);
}
public void GetSourcesReturnEmptyArrayForDefaultValue()
{
var metadata = new ConverterMetadata();
Assert.That(metadata.GetSources(), Is.Empty);
}
