private ComputedTag[] BuildComputedTagFromDerived(string symbolKey, Generator generator)
{
var result = new ComputedTag
{
Key = symbolKey,
Expression = $"{generator.ValueTransform}({generator.ValueSource})"
};
if (!string.IsNullOrWhiteSpace(generator.Replaces))
{
return new[]
{
result,
new ComputedTag
{
Key = generator.Replaces,
Expression = result.Expression
}
}
}
;
return(new[] { result });
}
public TemplateMetadata Map(DotNetTemplateMetadata dotNetMetadata)
{
var tags = new List <Tag>();
var conditionalTags = new List <ConditionalTag>();
var computedTags = new List <ComputedTag>();
if (!string.IsNullOrWhiteSpace(dotNetMetadata.SourceName))
{
tags.Add(new Tag
{
Key = TemplateMetadataReader.PROJECT_NAME_KEY,
Name = TemplateMetadataReader.PROJECT_NAME,
DefaultValue = dotNetMetadata.SourceName,
Regex = dotNetMetadata.SourceName
});
}
foreach (var symbol in dotNetMetadata.Symbols)
{
var generator = symbol.Value;
string dataType = generator.Datatype?.ToString();
if (generator.Type == SymbolType.Parameter)
{
if (string.Compare(dataType, "bool", true) == 0)
{
conditionalTags.Add(BuildConditionalTag(symbol.Key, generator));
}
else if (string.Compare(dataType, "choice", true) == 0)
{
tags.Add(BuildOptionsTag(symbol.Key, generator));
}
else
{
tags.Add(BuildInputTag(symbol.Key, generator));
}
}
else if (generator.Type == SymbolType.Computed)
{
computedTags.Add(BuildComputedTag(symbol.Key, generator));
}
else if (generator.Type == SymbolType.Derived)
{
computedTags.AddRange(BuildComputedTagFromDerived(symbol.Key, generator));
}
else if (generator.Type == SymbolType.Generated)
{
computedTags.AddRange(BuildComputedTagFromGenerated(symbol.Key, generator));
}
}
foreach (var source in dotNetMetadata.Sources)
{
foreach (var modifier in source.Modifiers)
{
ConditionalTag conditionalTag = conditionalTags.Find(x => modifier.Condition.Contains(x.Key));
if (conditionalTag != null)
{
if (modifier.Condition.Contains($"!{conditionalTag.Key}"))
{
if (modifier.Exclude != null)
{
conditionalTag.FilesToInclude = GetFilesToExclude(modifier);
}
}
else
{
if (modifier.Include != null)
{
conditionalTag.FilesToInclude = GetFilesToInclude(modifier);
}
}
}
ComputedTag computedTag = computedTags.Find(x => modifier.Condition.Contains(x.Key));
if (computedTag != null)
{
if (modifier.Condition.Contains($"!{computedTag.Key}"))
{
if (modifier.Exclude != null)
{
computedTag.FilesToInclude = GetFilesToExclude(modifier);
}
}
else
{
if (modifier.Include != null)
{
computedTag.FilesToInclude = GetFilesToInclude(modifier);
}
}
}
}
}
return(new TemplateMetadata
{
TemplateType = "dotnet",
Tags = tags,
ConditionalTags = conditionalTags,
ComputedTags = computedTags
});
}
private ComputedTag[] BuildComputedTagFromGenerated(string symbolKey, Generator generator)
{
ComputedTag result = null;
if (generator.GeneratorGenerator == GeneratorEnum.Constant)
{
if (generator.Parameters.HasValue)
{
result = new ComputedTag
{
Key = symbolKey,
Expression = generator.Parameters.Value.ParametersClass.Value
};
}
}
else if (generator.GeneratorGenerator == GeneratorEnum.Casing)
{
if (generator.Parameters.HasValue)
{
var valueTransform = generator.Parameters.Value.ParametersClass.ToLower == true ? "lowerCase" : "upperCase";
result = new ComputedTag
{
Key = symbolKey,
Expression = $"{valueTransform}({generator.Parameters.Value.ParametersClass.Source})"
};
}
}
else if (generator.GeneratorGenerator == GeneratorEnum.Coalesce)
{
if (generator.Parameters.HasValue)
{
var parameters = generator.Parameters.Value.ParametersClass;
result = new ComputedTag
{
Key = symbolKey,
Expression = $"{parameters.SourceVariableName} != null ? {parameters.SourceVariableName} : {parameters.FallbackVariableName}"
};
}
}
else if (generator.GeneratorGenerator == GeneratorEnum.Evaluate)
{
if (generator.Parameters.HasValue)
{
var parameters = generator.Parameters.Value.ParametersClass;
result = new ComputedTag
{
Key = symbolKey,
Expression = parameters.Action
};
}
}
else if (generator.GeneratorGenerator == GeneratorEnum.Guid)
{
if (generator.Parameters.HasValue)
{
var parameters = generator.Parameters.Value.ParametersClass;
result = new ComputedTag
{
Key = symbolKey,
Expression = Guid.NewGuid().ToString(parameters.Format ?? "")
};
}
}
else if (generator.GeneratorGenerator == GeneratorEnum.Port)
{
if (generator.Parameters.HasValue)
{
var parameters = generator.Parameters.Value.ParametersClass;
result = new ComputedTag
{
Key = symbolKey,
Expression = $"{parameters.Fallback}"
};
}
}
else if (generator.GeneratorGenerator == GeneratorEnum.Now)
{
if (generator.Parameters.HasValue)
{
var parameters = generator.Parameters.Value.ParametersClass;
result = new ComputedTag
{
Key = symbolKey,
Expression = parameters.Utc == true?DateTime.UtcNow.ToString(parameters.Format) : DateTime.Now.ToString(parameters.Format)
};
}
}
else if (generator.GeneratorGenerator == GeneratorEnum.Random)
{
if (generator.Parameters.HasValue)
{
var parameters = generator.Parameters.Value.ParametersClass;
result = new ComputedTag
{
Key = symbolKey,
Expression = $"{new Random().Next((int) parameters.Low, (int) parameters.High)}"
};
}
}
else if (generator.GeneratorGenerator == GeneratorEnum.Regex)
{
if (generator.Parameters.HasValue)
{
var parameters = generator.Parameters.Value.ParametersClass;
result = new ComputedTag
{
Key = symbolKey,
Expression = parameters.Utc == true?DateTime.UtcNow.ToString(parameters.Format) : DateTime.Now.ToString(parameters.Format)
};
}
}
else
{
throw new NotImplementedException();
}
if (!string.IsNullOrWhiteSpace(generator.Replaces))
{
return new[]
{
result,
new ComputedTag
{
Key = generator.Replaces,
Expression = result.Expression
}
}
}
;
return(new[] { result });
}
