public string Serialize(Contract contract, string template, List <Contract> contracts)
{
string contractName = contract.ContractName;
var contractNode = NodeHelper.GetContractNode(contract);
string documentation = contractNode.Documentation;
string contractTitle = DocumentationHelper.Get(documentation, "title");
string notice = DocumentationHelper.GetNotice(documentation);
var anchors = contracts.Select(item => $"- [{item.ContractName}]({item.ContractName}.md)").ToList();
var dependencies = NodeHelper.GetBaseContracts(contract) ?? new List <Node>();
var implementations = NodeHelper.GetImplementations(contract, contracts) ?? new List <Contract>();
var dependencyList = dependencies.Select(dependency => $"[{dependency.BaseName.Name}]({dependency.BaseName.Name}.md)").ToList();
var implementationList = implementations.Select(implementation => $"[{implementation.ContractName}]({implementation.ContractName}.md)").ToList();
string title = $"{contract.ContractName}.sol";
if (!string.IsNullOrWhiteSpace(contractTitle))
{
title = $"{Regex.Replace(contractTitle, @"\r\n?|\n", " ")} ({contract.ContractName}.sol)";
}
string contractInheritancePath = string.Empty;
string contractImplementations = string.Empty;
if (dependencyList.Any())
{
contractInheritancePath = $"**{string.Format(I18N.Extends, string.Join(", ", dependencyList))}**";
}
if (implementationList.Any())
{
contractImplementations = string.Join("", "**", string.Format(I18N.DerivedContracts, string.Join(", ", implementationList)), "**.");
}
template = template.Replace("{{ContractName}}", contractName);
template = template.Replace("{{ContractTitle}}", title);
template = template.Replace("{{ContractDescription}}", notice);
template = template.Replace("{{ContractInheritancePath}}", contractInheritancePath);
template = template.Replace("{{ContractImplementations}}", contractImplementations);
template = template.Replace("{{AllContractsAnchor}}", string.Join(Environment.NewLine, anchors));
template = template.Replace("{{ABI}}", JsonConvert.SerializeObject(contract.Abi, Formatting.Indented));
var builder = new ConstructorBuilder(contract);
return(builder.Build(template));
}
public string Build(string template)
{
var node = NodeHelper.GetConstructorNode(this.Contract);
string documentation = node.Documentation;
string description = DocumentationHelper.GetNotice(documentation);
var parameters = new List <string>();
var argBuilder = new StringBuilder();
var code = new StringBuilder();
var arguments = node.Modifiers?.FirstOrDefault()?.Arguments;
code.Append("```js");
code.Append(Environment.NewLine);
code.Append("constructor(");
if (arguments == null)
{
return(Clean(template));
}
foreach (var argument in arguments)
{
string argumentName = argument.Name;
string dataType = argument.TypeDescriptions.TypeString.Replace("contract ", "");
string argumentDocumentation = DocumentationHelper.Get(documentation, "param " + argumentName);
parameters.Add(dataType + " " + argumentName);
argBuilder.Append($"| {argumentName} | {dataType} | {Regex.Replace(argumentDocumentation, @"\r\n?|\n", " ")} | {Environment.NewLine}");
}
code.Append(string.Join(", ", parameters));
code.Append(") ");
code.Append(node.Visibility.ToString().ToLower());
code.Append(Environment.NewLine);
code.Append("```");
template = template.Replace("{{ConstructorHeading}}", $"## {I18N.Constructor}");
template = template.Replace("{{ConstructorDescription}}", description);
template = template.Replace("{{ConstructorCode}}", code.ToString());
template = template.Replace("{{ConstructorArguments}}", argBuilder.ToString());
template = template.Replace("{{ConstructorArgumentsHeading}}", $"**{I18N.Arguments}**");
template = template.Replace("{{TableHeader}}", TemplateHelper.TableHeader);
return(template);
}
public string Serialize(Contract contract, string template, List <Contract> contracts)
{
var functionNodes = NodeHelper.GetFunctions(contract).Where(x => !x.IsConstructor.HasValue || !x.IsConstructor.Value).ToList();
if (!functionNodes.Any())
{
return(Clean(template));
}
var definitionList = new List <string>();
var functionList = functionNodes.Select(node => $"- [{node.Name}](#{node.Name.ToLower()})").ToList();
template = template.Replace("{{FunctionTitle}}", $"## {I18N.Functions}");
foreach (var node in functionNodes)
{
string functionTemplate = TemplateHelper.Function;
string documentation = node.Documentation;
string description = DocumentationHelper.GetNotice(documentation);
var codeBuilder = new FunctionCodeBuilder(node);
var superBuilder = new SuperBuilder(node, contracts);
var referenceBuilder = new FunctionReferenceBuilder(node, contracts);
functionTemplate = functionTemplate.Replace("{{FunctionName}}", node.Name);
functionTemplate = functionTemplate.Replace("{{FQFunctionName}}", $"{contract.ContractName}.{node.Name}");
functionTemplate = functionTemplate.Replace("{{FunctionNameHeading}}", $"### {node.Name}");
functionTemplate = functionTemplate.Replace("{{Super}}", superBuilder.Build());
functionTemplate = functionTemplate.Replace("{{References}}", referenceBuilder.Build());
functionTemplate = functionTemplate.Replace("{{FunctionDescription}}", description);
functionTemplate = functionTemplate.Replace("{{FunctionCode}}", codeBuilder.Build());
var parameters = node.Parameters.Parameters.ToList();
var argumentBuilder = new ArgumentBuilder(node.Documentation, parameters);
functionTemplate = functionTemplate.Replace("{{TableHeader}}", parameters.Any() ? TemplateHelper.TableHeader : string.Empty);
functionTemplate = functionTemplate.Replace("{{FunctionArgumentsHeading}}", parameters.Any() ? $"**{I18N.Arguments}**" : string.Empty);
functionTemplate = functionTemplate.Replace("{{FunctionArguments}}", argumentBuilder.Build());
definitionList.Add(functionTemplate);
}
template = template.Replace("{{FunctionList}}", string.Join(Environment.NewLine, functionList));
template = template.Replace("{{AllFunctions}}", string.Join(Environment.NewLine, definitionList));
return(template);
}
public string Serialize(Contract contract, string template, List <Contract> contracts)
{
var modifierNodes = NodeHelper.GetModifiers(contract).ToList();
if (!modifierNodes.Any())
{
return(Clean(template));
}
var definitionList = new List <string>();
var modifierList = modifierNodes.Select(node => $"- [{node.Name}](#{node.Name.ToLower()})").ToList();
template = template.Replace("{{ModifierTitle}}", $"## {I18N.Modifiers}");
foreach (var node in modifierNodes)
{
string modifierTemplate = TemplateHelper.Modifier;
string documentation = node.Documentation;
string description = DocumentationHelper.GetNotice(documentation);
var argumentBuilder = new ArgumentBuilder(documentation, node.Parameters.Parameters);
var codeBuilder = new ModifierCodeBuilder(node);
modifierTemplate = modifierTemplate.Replace("{{ModifierArgumentsHeading}}", $"**{I18N.Arguments}**");
modifierTemplate = modifierTemplate.Replace("{{TableHeader}}", TemplateHelper.TableHeader);
modifierTemplate = modifierTemplate.Replace("{{ModifierNameHeading}}", $"### {node.Name}");
modifierTemplate = modifierTemplate.Replace("{{ModifierDescription}}", description);
modifierTemplate = modifierTemplate.Replace("{{ModifierCode}}", codeBuilder.Build());
modifierTemplate = modifierTemplate.Replace("{{ModifierArguments}}", argumentBuilder.Build());
definitionList.Add(modifierTemplate);
}
template = template.Replace("{{ModifierList}}", string.Join(Environment.NewLine, modifierList));
template = template.Replace("{{AllModifiers}}", string.Join(Environment.NewLine, definitionList));
return(template);
}
