public void AppendWorksWithNull()
{
IndentedStringBuilder sb = new IndentedStringBuilder();
var expected = "";
var result = sb.Indent().Append(null);
Assert.Equal(expected, result.ToString());
}
/// <summary>
/// Generates code for model deserialization.
/// </summary>
/// <param name="variableName">Variable deserialize model from.</param>
/// <param name="type">The type of the model.</param>
/// <returns>The code for вуserialization in string format.</returns>
public override string DeserializeProperty(string variableName, IType type)
{
var builder = new IndentedStringBuilder(" ");
string serializationLogic = type.AzureDeserializeType(this.Scope, variableName);
return builder.AppendLine(serializationLogic).ToString();
}
public void AppendDoesNotAddIndentation(string input)
{
IndentedStringBuilder sb = new IndentedStringBuilder();
var expected = input;
var result = sb.Indent().Append(input);
Assert.Equal(expected, result.ToString());
}
public string GetOperationsRequiredFiles()
{
var sb = new IndentedStringBuilder();
this.MethodGroups.ForEach(method => sb.AppendLine("{0}",
this.GetRequiredFormat(RubyCodeNamer.UnderscoreCase(method) + ".rb")));
return sb.ToString();
}
/// <summary>
/// Generates Ruby code in form of string for deserializing polling response.
/// </summary>
/// <param name="variableName">Variable name which keeps the response.</param>
/// <param name="type">Type of response.</param>
/// <returns>Ruby code in form of string for deserializing polling response.</returns>
public string DeserializePollingResponse(string variableName, IType type)
{
var builder = new IndentedStringBuilder(" ");
string serializationLogic = type.DeserializeType(this.Scope, variableName);
return builder.AppendLine(serializationLogic).ToString();
}
public override string ConstructModelMapper()
{
var modelMapper = this.ConstructMapper(SerializedName, null, true, true);
var builder = new IndentedStringBuilder(" ");
builder.AppendLine("return {{{0}}};", modelMapper);
return builder.ToString();
}
/// <summary>
/// Generate code to build the URL from a url expression and method parameters.
/// </summary>
/// <param name="inputVariableName">The variable to prepare url from.</param>
/// <param name="outputVariableName">The variable that will keep the url.</param>
/// <returns>Code for URL generation.</returns>
public override string BuildUrl(string inputVariableName, string outputVariableName)
{
var builder = new IndentedStringBuilder(" ");
// Filling path parameters (which are directly in the url body).
foreach (var pathParameter in ParameterTemplateModels.Where(p => p.Location == ParameterLocation.Path))
{
string variableName = pathParameter.Type.ToString(pathParameter.Name);
string addPathParameterString = String.Format(CultureInfo.InvariantCulture, "{0}['{{{1}}}'] = ERB::Util.url_encode({2})",
inputVariableName,
pathParameter.SerializedName,
variableName);
if (pathParameter.Extensions.ContainsKey(AzureCodeGenerator.SkipUrlEncodingExtension))
{
addPathParameterString = String.Format(CultureInfo.InvariantCulture, "{0}['{{{1}}}'] = {2}",
inputVariableName,
pathParameter.SerializedName,
variableName);
}
builder.AppendLine(addPathParameterString);
}
// Adding prefix in case of not absolute url.
if (!this.IsAbsoluteUrl)
{
builder.AppendLine("{0} = URI.join({1}.base_url, {2})", outputVariableName, ClientReference, inputVariableName);
}
else
{
builder.AppendLine("{0} = URI.parse({1})", outputVariableName, inputVariableName);
}
// Filling query parameters (which are directly in the url query part).
var queryParametres = ParameterTemplateModels.Where(p => p.Location == ParameterLocation.Query).ToList();
builder.AppendLine("properties = {}");
foreach (var param in queryParametres)
{
if (param.Extensions.ContainsKey(AzureCodeGenerator.SkipUrlEncodingExtension))
{
builder.AppendLine("properties['{0}'] = {1} unless {1}.nil?", param.SerializedName, param.Name);
}
else
{
builder.AppendLine("properties['{0}'] = ERB::Util.url_encode({1}.to_s) unless {1}.nil?", param.SerializedName, param.Name);
}
}
builder.AppendLine("properties.reject!{ |key, value| value.nil? }");
builder.AppendLine("{0}.query = properties.map{{ |key, value| \"#{{key}}=#{{value}}\" }}.compact.join('&')", outputVariableName);
builder.AppendLine(@"fail URI::Error unless {0}.to_s =~ /\A#{{URI::regexp}}\z/", outputVariableName);
return builder.ToString();
}
public string GetModelsRequiredFiles()
{
var sb = new IndentedStringBuilder();
this.GetOrderedModels().Where(m => !m.Extensions.ContainsKey(ExternalExtension)).ForEach(model => sb.AppendLine("{0}",
this.GetRequiredFormat("models/" + RubyCodeNamer.UnderscoreCase(model.Name) + ".rb")));
this.EnumTypes.ForEach(enumType => sb.AppendLine(this.GetRequiredFormat("models/" + RubyCodeNamer.UnderscoreCase(enumType.Name) + ".rb")));
return sb.ToString();
}
/// <summary>
/// Generates code for model serialization.
/// </summary>
/// <param name="variableName">Variable serialize model from.</param>
/// <param name="type">The type of the model.</param>
/// <param name="isRequired">Is property required.</param>
/// <param name="defaultNamespace">The namespace.</param>
/// <returns>The code for serialization in string format.</returns>
public string SerializeProperty(string variableName, IType type, bool isRequired, string defaultNamespace)
{
// TODO: handle if property required via "unless serialized_property.nil?"
var builder = new IndentedStringBuilder(" ");
string serializationLogic = type.SerializeType(this.Scope, variableName, defaultNamespace);
builder.AppendLine(serializationLogic);
return builder.ToString();
// return builder.AppendLine("{0} = JSON.generate({0}, quirks_mode: true)", variableName).ToString();
}
public void AppendMultilinePreservesIndentation()
{
IndentedStringBuilder sb = new IndentedStringBuilder();
var expected = string.Format("start{0} line2{0} line31{0} line32{0}", Environment.NewLine);
var result = sb
.AppendLine("start").Indent()
.AppendLine("line2").Indent()
.AppendLine(string.Format("line31{0}line32", Environment.NewLine));
Assert.Equal(expected, result.ToString());
sb = new IndentedStringBuilder();
expected = string.Format("start{0} line2{0} line31{0} line32{0}", Environment.NewLine);
result = sb
.AppendLine("start").Indent()
.AppendLine("line2").Indent()
.AppendLine(string.Format("line31{0}line32", Environment.NewLine));
Assert.Equal(expected, result.ToString());
}
public void AppendMultilinePreservesIndentation()
{
IndentedStringBuilder sb = new IndentedStringBuilder();
var expected = "start\r\n line2\r\n line31\n line32\r\n";
var result = sb
.AppendLine("start").Indent()
.AppendLine("line2").Indent()
.AppendLine("line31\nline32");
Assert.Equal(expected, result.ToString());
sb = new IndentedStringBuilder();
expected = "start\r\n line2\r\n line31\r\n line32\r\n";
result = sb
.AppendLine("start").Indent()
.AppendLine("line2").Indent()
.AppendLine("line31\r\nline32");
Assert.Equal(expected, result.ToString());
}
protected override void TransformPagingGroupedParameter(IndentedStringBuilder builder, AzureMethodTemplateModel nextMethod, bool filterRequired = false)
{
if (this.InputParameterTransformation.IsNullOrEmpty())
{
return;
}
var groupedType = this.InputParameterTransformation.First().ParameterMappings[0].InputParameter;
var nextGroupType = nextMethod.InputParameterTransformation.First().ParameterMappings[0].InputParameter;
if (nextGroupType.Name == groupedType.Name)
{
return;
}
var nextGroupTypeName = _namer.GetTypeName(nextGroupType.Name) + "Inner";
if (filterRequired && !nextGroupType.IsRequired)
{
return;
}
if (!groupedType.IsRequired)
{
builder.AppendLine("{0} {1} = null;", nextGroupTypeName, nextGroupType.Name.ToCamelCase());
builder.AppendLine("if ({0} != null) {{", groupedType.Name.ToCamelCase());
builder.Indent();
builder.AppendLine("{0} = new {1}();", nextGroupType.Name.ToCamelCase(), nextGroupTypeName);
}
else
{
builder.AppendLine("{1} {0} = new {1}();", nextGroupType.Name.ToCamelCase(), nextGroupTypeName);
}
foreach (var outParam in nextMethod.InputParameterTransformation.Select(t => t.OutputParameter))
{
builder.AppendLine("{0}.with{1}({2}.{3}());", nextGroupType.Name.ToCamelCase(), outParam.Name.ToPascalCase(), groupedType.Name.ToCamelCase(), outParam.Name.ToCamelCase());
}
if (!groupedType.IsRequired)
{
builder.Outdent().AppendLine(@"}");
}
}
/// <summary>
/// Generate code to construct the query string from an array of query parameter strings containing 'key=value'
/// </summary>
/// <param name="variableName">The variable reference for the url</param>
/// <param name="builder">The string builder for url construction</param>
private static void AddQueryParametersToUrl(string variableName, IndentedStringBuilder builder)
{
builder.AppendLine("if (queryParameters.length > 0) {")
.Indent()
.AppendLine("{0} += '?' + queryParameters.join('&');", variableName).Outdent()
.AppendLine("}");
}
/// <summary>
/// Generate code to replace path parameters in the url template with the appropriate values
/// </summary>
/// <param name="variableName">The variable name for the url to be constructed</param>
/// <param name="builder">The string builder for url construction</param>
protected virtual void BuildPathParameters(string variableName, IndentedStringBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
foreach (var pathParameter in LogicalParameters.Where(p => p.Location == ParameterLocation.Path))
{
var pathReplaceFormat = "{0} = {0}.replace('{{{1}}}', encodeURIComponent({2}));";
if (pathParameter.SkipUrlEncoding())
{
pathReplaceFormat = "{0} = {0}.replace('{{{1}}}', {2});";
}
builder.AppendLine(pathReplaceFormat, variableName, pathParameter.SerializedName,
pathParameter.Type.ToString(pathParameter.Name));
}
}
/// <summary>
/// Genrate code to build an array of query parameter strings in a variable named 'queryParameters'. The
/// array should contain one string element for each query parameter of the form 'key=value'
/// </summary>
/// <param name="builder">The stringbuilder for url construction</param>
protected virtual void BuildQueryParameterArray(IndentedStringBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
builder.AppendLine("var queryParameters = [];");
foreach (var queryParameter in LogicalParameters
.Where(p => p.Location == ParameterLocation.Query))
{
var queryAddFormat = "queryParameters.push('{0}=' + encodeURIComponent({1}));";
if (queryParameter.SkipUrlEncoding())
{
queryAddFormat = "queryParameters.push('{0}=' + {1});";
}
if (!queryParameter.IsRequired)
{
builder.AppendLine("if ({0} !== null && {0} !== undefined) {{", queryParameter.Name)
.Indent()
.AppendLine(queryAddFormat,
queryParameter.SerializedName, queryParameter.GetFormattedReferenceValue()).Outdent()
.AppendLine("}");
}
else
{
builder.AppendLine(queryAddFormat,
queryParameter.SerializedName, queryParameter.GetFormattedReferenceValue());
}
}
}
public string GetDeserializationString(IType type, string valueReference = "result", string responseVariable = "parsedResponse")
{
var builder = new IndentedStringBuilder(" ");
if (type is CompositeType)
{
builder.AppendLine("var resultMapper = new client.models['{0}']().mapper();", type.Name);
}
else
{
builder.AppendLine("var resultMapper = {{{0}}};", type.ConstructMapper(responseVariable, null, false, false));
}
builder.AppendLine("{1} = client.deserialize(resultMapper, {0}, '{1}');", responseVariable, valueReference);
return builder.ToString();
}
/// <summary>
/// Generate code to remove duplicated forward slashes from a URL in code
/// </summary>
/// <param name="urlVariableName"></param>
/// <returns></returns>
public virtual string RemoveDuplicateForwardSlashes(string urlVariableName)
{
var builder = new IndentedStringBuilder(" ");
builder.AppendLine("// trim all duplicate forward slashes in the url");
builder.AppendLine("var regex = /([^:]\\/)\\/+/gi;");
builder.AppendLine("{0} = {0}.replace(regex, '$1');", urlVariableName);
return builder.ToString();
}
public string DeserializeResponse(IType type, string valueReference = "result", string responseVariable = "parsedResponse")
{
if (type == null)
{
throw new ArgumentNullException("type");
}
var builder = new IndentedStringBuilder(" ");
builder.AppendLine("var {0} = null;", responseVariable)
.AppendLine("try {")
.Indent()
.AppendLine("{0} = JSON.parse(responseBody);", responseVariable)
.AppendLine("{0} = JSON.parse(responseBody);", valueReference);
var deserializeBody = GetDeserializationString(type, valueReference, responseVariable);
if (!string.IsNullOrWhiteSpace(deserializeBody))
{
builder.AppendLine("if ({0} !== null && {0} !== undefined) {{", responseVariable)
.Indent()
.AppendLine(deserializeBody)
.Outdent()
.AppendLine("}");
}
builder.Outdent()
.AppendLine("} catch (error) {")
.Indent()
.AppendLine(DeserializationError)
.Outdent()
.AppendLine("}");
return builder.ToString();
}
public static string CheckNull(string valueReference, string executionBlock)
{
var sb = new IndentedStringBuilder();
sb.AppendLine("if ({0} != null)", valueReference)
.AppendLine("{").Indent()
.AppendLine(executionBlock).Outdent()
.AppendLine("}");
return sb.ToString();
}
public virtual string AddIndividualResponseHeader(HttpStatusCode? code)
{
IType headersType = null;
if (HasResponseHeader)
{
if (code != null)
{
headersType = this.ReturnType.Headers;
}
else
{
headersType = this.Responses[code.Value].Headers;
}
}
var builder = new IndentedStringBuilder(" ");
if (headersType == null)
{
if (code == null)
{
builder.AppendLine("header_dict = {}");
}
else
{
return string.Empty;
}
}
else
{
builder.AppendLine("header_dict = {").Indent();
AddHeaderDictionary(builder, (CompositeType)headersType);
builder.Outdent().AppendLine("}");
}
return builder.ToString();
}
public virtual string AddResponseHeader()
{
if (HasResponseHeader)
{
var builder = new IndentedStringBuilder(" ");
builder.AppendLine("client_raw_response.add_headers(header_dict)");
return builder.ToString();
}
else
{
return string.Empty;
}
}
public virtual string BuildUrlPath(string variableName)
{
var builder = new IndentedStringBuilder(" ");
var pathParameterList = this.LogicalParameters.Where(p => p.Location == ParameterLocation.Path).ToList();
if (pathParameterList.Any())
{
builder.AppendLine("path_format_arguments = {").Indent();
for (int i = 0; i < pathParameterList.Count; i ++)
{
builder.AppendLine("'{0}': {1}{2}{3}",
pathParameterList[i].SerializedName,
BuildSerializeDataCall(pathParameterList[i], "url"),
pathParameterList[i].IsRequired ? string.Empty :
string.Format(CultureInfo.InvariantCulture, "if {0} else ''", pathParameterList[i].Name),
i == pathParameterList.Count-1 ? "" : ",");
}
builder.Outdent().AppendLine("}");
builder.AppendLine("{0} = {0}.format(**path_format_arguments)", variableName);
}
return builder.ToString();
}
/// <summary>
/// Generate code to perform required validation on a type
/// </summary>
/// <param name="type">The type to validate</param>
/// <param name="scope">A scope provider for generating variable names as necessary</param>
/// <param name="valueReference">A reference to the value being validated</param>
/// <returns>The code to validate the reference of the given type</returns>
public static string ValidateType(this IType type, IScopeProvider scope, string valueReference)
{
if (scope == null)
{
throw new ArgumentNullException("scope");
}
CompositeType model = type as CompositeType;
SequenceType sequence = type as SequenceType;
DictionaryType dictionary = type as DictionaryType;
if (model != null && model.ShouldValidateChain())
{
return CheckNull(valueReference, string.Format(CultureInfo.InvariantCulture,
"{0}.Validate();", valueReference));
}
if (sequence != null && sequence.ShouldValidateChain())
{
var elementVar = scope.GetVariableName("element");
var innerValidation = sequence.ElementType.ValidateType(scope, elementVar);
if (!string.IsNullOrEmpty(innerValidation))
{
var sb = new IndentedStringBuilder();
sb.AppendLine("foreach (var {0} in {1})", elementVar, valueReference)
.AppendLine("{").Indent()
.AppendLine(innerValidation).Outdent()
.AppendLine("}");
return CheckNull(valueReference, sb.ToString());
}
}
else if (dictionary != null && dictionary.ShouldValidateChain())
{
var valueVar = scope.GetVariableName("valueElement");
var innerValidation = dictionary.ValueType.ValidateType(scope, valueVar);
if (!string.IsNullOrEmpty(innerValidation))
{
var sb = new IndentedStringBuilder();
sb.AppendLine("if ({0} != null)", valueReference)
.AppendLine("{").Indent()
.AppendLine("foreach (var {0} in {1}.Values)",valueVar,valueReference)
.AppendLine("{").Indent()
.AppendLine(innerValidation).Outdent()
.AppendLine("}").Outdent()
.AppendLine("}");
return CheckNull(valueReference, sb.ToString());
}
}
return null;
}
public virtual string BuildGroupedParameterMappings()
{
var builder = new IndentedStringBuilder(" ");
if (InputParameterTransformation.Count > 0)
{
// Declare all the output paramaters outside the try block
foreach (var transformation in InputParameterTransformation)
{
builder.AppendLine("var {0};", transformation.OutputParameter.Name);
}
builder.AppendLine("try {").Indent();
foreach (var transformation in InputParameterTransformation)
{
builder.AppendLine("if ({0})", BuildNullCheckExpression(transformation))
.AppendLine("{").Indent();
var outputParameter = transformation.OutputParameter;
bool noCompositeTypeInitialized = true;
if (transformation.ParameterMappings.Any(m => !string.IsNullOrEmpty(m.OutputParameterProperty)) &&
transformation.OutputParameter.Type is CompositeType)
{
builder.AppendLine("{0} = new client.models['{1}']();",
transformation.OutputParameter.Name,
transformation.OutputParameter.Type.Name);
noCompositeTypeInitialized = false;
}
foreach (var mapping in transformation.ParameterMappings)
{
builder.AppendLine("{0}{1};",
transformation.OutputParameter.Name,
mapping);
if (noCompositeTypeInitialized)
{
// If composite type is initialized based on the above logic then it shouuld not be validated.
builder.AppendLine(outputParameter.Type.ValidateType(Scope, outputParameter.Name, outputParameter.IsRequired));
}
}
builder.Outdent()
.AppendLine("}");
}
builder.Outdent()
.AppendLine("} catch (error) {")
.Indent()
.AppendLine("return callback(error);")
.Outdent()
.AppendLine("}");
}
return builder.ToString();
}
/// <summary>
/// Generate code to build the headers from method parameters
/// </summary>
/// <param name="variableName">The variable to store the headers in.</param>
/// <returns></returns>
public virtual string BuildHeaders(string variableName)
{
var builder = new IndentedStringBuilder(" ");
foreach (var headerParameter in this.LogicalParameters.Where(p => p.Location == ParameterLocation.Header))
{
if (headerParameter.IsRequired)
{
builder.AppendLine("{0}['{1}'] = {2}",
variableName,
headerParameter.SerializedName,
BuildSerializeDataCall(headerParameter, "header"));
}
else
{
builder.AppendLine("if {0} is not None:", headerParameter.Name)
.Indent()
.AppendLine("{0}['{1}'] = {2}",
variableName,
headerParameter.SerializedName,
BuildSerializeDataCall(headerParameter, "header"))
.Outdent();
}
}
return builder.ToString();
}
/// <summary>
/// Generates input mapping code block.
/// </summary>
/// <returns></returns>
public virtual string BuildInputMappings()
{
var builder = new IndentedStringBuilder(" ");
if (InputParameterTransformation.Count > 0)
{
if (AreWeFlatteningParameters())
{
return BuildFlattenParameterMappings();
}
else
{
return BuildGroupedParameterMappings();
}
}
return builder.ToString();
}
protected void AddHeaderDictionary(IndentedStringBuilder builder, CompositeType headersType)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
if (headersType == null)
{
throw new ArgumentNullException("headersType");
}
foreach (var prop in headersType.Properties)
{
if (this.ServiceClient.EnumTypes.Contains(prop.Type))
{
builder.AppendLine(String.Format(CultureInfo.InvariantCulture, "'{0}': models.{1},", prop.SerializedName, prop.Type.ToPythonRuntimeTypeString()));
}
else
{
builder.AppendLine(String.Format(CultureInfo.InvariantCulture, "'{0}': '{1}',", prop.SerializedName, prop.Type.ToPythonRuntimeTypeString()));
}
}
}
public string BuildOptionalMappings()
{
IEnumerable<Property> optionalParameters =
((CompositeType)OptionsParameterTemplateModel.Type)
.Properties.Where(p => p.Name != "customHeaders");
var builder = new IndentedStringBuilder(" ");
foreach (var optionalParam in optionalParameters)
{
string defaultValue = "undefined";
if (!string.IsNullOrWhiteSpace(optionalParam.DefaultValue))
{
defaultValue = optionalParam.DefaultValue;
}
builder.AppendLine("var {0} = ({1} && {1}.{2} !== undefined) ? {1}.{2} : {3};",
optionalParam.Name, OptionsParameterTemplateModel.Name, optionalParam.Name, defaultValue);
}
return builder.ToString();
}
/// <summary>
/// Generates input mapping code block.
/// </summary>
/// <returns></returns>
public virtual string BuildInputMappings()
{
var builder = new IndentedStringBuilder(" ");
foreach (var transformation in InputParameterTransformation)
{
if (transformation.ParameterMappings.Any(m => !string.IsNullOrEmpty(m.OutputParameterProperty)) &&
transformation.OutputParameter.Type is CompositeType)
{
builder.AppendLine("{0} = models.{1}()",
transformation.OutputParameter.Name,
transformation.OutputParameter.Type.Name);
}
else
{
builder.AppendLine("{0} = None",
transformation.OutputParameter.Name);
}
builder.AppendLine("if {0}:", BuildNullCheckExpression(transformation))
.Indent();
foreach (var mapping in transformation.ParameterMappings)
{
builder.AppendLine("{0}{1}",
transformation.OutputParameter.Name,
mapping);
}
builder.Outdent();
}
return builder.ToString();
}
/// <summary>
/// Generate code to build the URL from a url expression and method parameters
/// </summary>
/// <param name="variableName">The variable to store the url in.</param>
/// <returns></returns>
public virtual string BuildUrl(string variableName)
{
var builder = new IndentedStringBuilder(" ");
BuildPathParameters(variableName, builder);
if (HasQueryParameters())
{
BuildQueryParameterArray(builder);
AddQueryParametersToUrl(variableName, builder);
}
return builder.ToString();
}
