/// <inheritdoc/>
internal override void Process(JObject source, JObject transform, JsonTransformationContextLogger logger)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (transform == null)
{
throw new ArgumentNullException(nameof(transform));
}
foreach (JProperty transformNode in transform.Properties()
.Where(p => JdtUtilities.IsJdtSyntax(p.Name)))
{
string verb = JdtUtilities.GetJdtSyntax(transformNode.Name);
if (verb != null)
{
if (!this.ValidVerbs.Contains(verb))
{
throw JdtException.FromLineInfo(string.Format(Resources.ErrorMessage_InvalidVerb, verb), ErrorLocation.Transform, transformNode);
}
}
}
this.Successor.Process(source, transform, logger);
}
/// <summary>
/// Gets all the properties within the object that correspond to JDT syntax
/// </summary>
/// <param name="objectToSearch">The object to search</param>
/// <returns>An enumerable of properties that start with the JDT prefix</returns>
internal static IEnumerable <JProperty> GetJdtProperties(this JObject objectToSearch)
{
if (objectToSearch == null)
{
throw new ArgumentNullException(nameof(objectToSearch));
}
return(objectToSearch.Properties().Where(p => JdtUtilities.IsJdtSyntax(p.Name)));
}
/// <summary>
/// Clones a <see cref="JObject"/> preserving the line information
/// </summary>
/// <param name="objectToClone">The object to clone</param>
/// <returns>A clone of the object with its line info</returns>
internal static JObject CloneWithLineInfo(this JObject objectToClone)
{
var loadSettings = new JsonLoadSettings()
{
LineInfoHandling = JdtUtilities.GetLineInfoHandling()
};
using (var objectReader = objectToClone.CreateReader())
{
return(JObject.Load(objectReader, loadSettings));
}
}
private void SetTransform(Stream transformStream)
{
this.loadSettings = new JsonLoadSettings()
{
CommentHandling = CommentHandling.Ignore,
LineInfoHandling = JdtUtilities.GetLineInfoHandling()
};
using (StreamReader transformStreamReader = new StreamReader(transformStream))
using (JsonTextReader transformReader = new JsonTextReader(transformStreamReader))
{
this.transformObject = JObject.Load(transformReader, this.loadSettings);
}
}
/// <inheritdoc/>
internal override void Process(JObject source, JObject transform, JsonTransformationContextLogger logger)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (transform == null)
{
throw new ArgumentNullException(nameof(transform));
}
// JDT Verbs are not handled here
foreach (JProperty transformNode in transform.Properties()
.Where(p => !JdtUtilities.IsJdtSyntax(p.Name)))
{
JToken nodeToTransform;
if (source.TryGetValue(transformNode.Name, out nodeToTransform))
{
// If the node is present in both transform and source, analyze the types
// If both are objects, that is a recursive transformation, not handled here
if (nodeToTransform.Type == JTokenType.Array && transformNode.Value.Type == JTokenType.Array)
{
// If the original and transform are arrays, merge the contents together
((JArray)nodeToTransform).Merge(transformNode.Value.DeepClone());
}
else if (nodeToTransform.Type != JTokenType.Object || transformNode.Value.Type != JTokenType.Object)
{
// TO DO: Verify if object has JDT verbs. They shouldn't be allowed here because they won't be processed
// If the contents are different, execute the replace
source[transformNode.Name] = transformNode.Value.DeepClone();
}
}
else
{
// If the node is not present in the original, add it
source.Add(transformNode.DeepClone());
}
}
this.Successor.Process(source, transform, logger);
}
/// <inheritdoc/>
internal override void Process(JObject source, JObject transform, JsonTransformationContextLogger logger)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (transform == null)
{
throw new ArgumentNullException(nameof(transform));
}
// Nodes that should be removed from the transform after they are handled
var nodesToRemove = new List <string>();
foreach (JProperty transformNode in transform.Properties()
.Where(p => p.Value.Type == JTokenType.Object && !JdtUtilities.IsJdtSyntax(p.Name)))
{
// We recurse into objects that do not correspond to JDT verbs and that exist in both source and transform
JToken sourceChild;
if (source.TryGetValue(transformNode.Name, out sourceChild) && sourceChild.Type == JTokenType.Object)
{
ProcessTransform((JObject)sourceChild, (JObject)transformNode.Value, logger);
// If we have already recursed into that node, it should be removed from the transform
nodesToRemove.Add(transformNode.Name);
}
}
// Remove all of the previously handled nodes
// This is necessary so that a rename does not cause a node to be hadled twice
nodesToRemove.ForEach(node => transform.Remove(node));
// Continue to next transformation
this.Successor.Process(source, transform, logger);
}