x-ms-parameter-grouping for Ruby & Azure.Ruby Generator

AutoRest/Generators/Ruby/Azure.Ruby.Tests/RspecTests/paging_spec.rb

@@ -39,7 +39,9 @@
   end
 
   it 'should get multiple pages with offset' do
-    result = @client.paging.get_multiple_pages_with_offset_async(100).value!
+    options = PagingModule::Models::PagingGetMultiplePagesWithOffsetOptions.new
+    options.offset = 100
+    result = @client.paging.get_multiple_pages_with_offset_async(options).value!
     expect(result.response.status).to eq(200)
     expect(result.body.next_link).not_to be_nil
 

AutoRest/Generators/Ruby/Ruby.Tests/RspecTests/parameter_grouping_spec.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+$: << 'RspecTests/Generated/parameter_grouping'
+
+require 'rspec'
+require 'azure_parameter_grouping'
+
+include ParameterGroupingModule
+include ParameterGroupingModule::Models
+
+describe 'ParameterGrouping' do
+  before(:all) do
+    @base_url = ENV['StubServerURI']
+    dummyToken = 'dummy123@query343423'
+    @credentials = MsRest::TokenCredentials.new(dummyToken)
+    @client = AutoRestParameterGroupingTestService.new(@credentials, @base_url)
+
+    @body = 1234
+    @header = 'header'
+    @query = 21
+    @path = 'path'
+  end
+
+  it 'should accept valid required parameters' do
+    required_parameters = ParameterGroupingPostRequiredParameters.new
+    required_parameters.body = @body
+    required_parameters.custom_header = @header
+    required_parameters.query = @query
+    required_parameters.path = @path
+
+    result = @client.parameter_grouping.post_required_async(required_parameters).value!
+
+    expect(result.response.status).to eq(200)
+  end
+
+  it 'should accept required parameters but null optional parameters' do
+    required_parameters = ParameterGroupingPostRequiredParameters.new
+    required_parameters.body = @body
+    required_parameters.path = @path
+
+    result = @client.parameter_grouping.post_required_async(required_parameters).value!
+
+    expect(result.response.status).to eq(200)
+  end
+
+  it 'should reject required parameters with missing required property' do
+    required_parameters = ParameterGroupingPostRequiredParameters.new
+    required_parameters.path = @path
+
+    expect { @client.parameter_grouping.post_required_async(required_parameters).value! }.to raise_error(MsRest::ValidationError)
+  end
+
+  it 'should reject null required parameters' do
+    required_parameters = ParameterGroupingPostRequiredParameters.new
+    required_parameters.path = nil
+
+    expect { @client.parameter_grouping.post_required_async(required_parameters).value! }.to raise_error(MsRest::ValidationError)
+  end
+
+  it 'should accept valid optional parameters' do
+    optional_parameters = ParameterGroupingPostOptionalParameters.new
+    optional_parameters.custom_header = @header
+    optional_parameters.query = @query
+
+    result = @client.parameter_grouping.post_optional_async(optional_parameters).value!
+    expect(result.response.status).to eq(200)
+  end
+
+  it 'should accept null optional parameters' do
+    result = @client.parameter_grouping.post_optional_async(nil).value!
+    expect(result.response.status).to eq(200)
+  end
+
+  it 'should allow multiple parameter groups' do
+    first_parameter_group = FirstParameterGroup.new
+    second_parameter_group = ParameterGroupingPostMultiParamGroupsSecondParamGroup.new
+
+    first_parameter_group.header_one = @header
+    first_parameter_group.query_one = @query
+
+    second_parameter_group.header_two = 'header2'
+    second_parameter_group.query_two = 42
+
+    result = @client.parameter_grouping.post_multi_param_groups_async(first_parameter_group, second_parameter_group).value!
+    expect(result.response.status).to eq(200)
+  end
+
+  it 'should allow multiple parameter groups with some defaults omitted' do
+    first_parameter_group = FirstParameterGroup.new
+    second_parameter_group = ParameterGroupingPostMultiParamGroupsSecondParamGroup.new
+
+    first_parameter_group.header_one = @header
+
+    second_parameter_group.query_two = 42
+
+    result = @client.parameter_grouping.post_multi_param_groups_async(first_parameter_group, second_parameter_group).value!
+    expect(result.response.status).to eq(200)
+  end
+
+  it 'should allow parameter group objects to be shared between operations' do
+    first_parameter_group = FirstParameterGroup.new
+
+    first_parameter_group.header_one = @header
+    first_parameter_group.query_one = 42
+
+    result = @client.parameter_grouping.post_shared_parameter_group_object_async(first_parameter_group).value!
+    expect(result.response.status).to eq(200)
+  end
+end

AutoRest/Generators/Ruby/Ruby/RubyCodeGenerator.cs

@@ -114,6 +114,7 @@ public override string ImplementationFileExtension
         /// <param name="serviceClient"></param>
         public override void NormalizeClientModel(ServiceClient serviceClient)
         {
+            ParameterGroupExtensionHelper.AddParameterGroups(serviceClient);
             Extensions.ProcessParameterizedHost(serviceClient, Settings);
             PopulateAdditionalProperties(serviceClient);
             CodeNamer.NormalizeClientModel(serviceClient);

AutoRest/Generators/Ruby/Ruby/TemplateModels/MethodTemplateModel.cs

@@ -28,6 +28,10 @@ public MethodTemplateModel(Method source, ServiceClient serviceClient)
             this.LoadFrom(source);
             ParameterTemplateModels = new List<ParameterTemplateModel>();
             source.Parameters.ForEach(p => ParameterTemplateModels.Add(new ParameterTemplateModel(p)));
+
+            LogicalParameterTemplateModels = new List<ParameterTemplateModel>();
+            source.LogicalParameters.ForEach(p => LogicalParameterTemplateModels.Add(new ParameterTemplateModel(p)));
+
             ServiceClient = serviceClient;
         }
 
@@ -122,8 +126,11 @@ public virtual string SkipEncodingQueryParamsRbDict
         /// </summary>
         public virtual IEnumerable<ParameterTemplateModel> EncodingPathParams
         {
-            get { return AllPathParams.Where(p => !(p.Extensions.ContainsKey(Generator.Extensions.SkipUrlEncodingExtension) &&
-                    String.Equals(p.Extensions[Generator.Extensions.SkipUrlEncodingExtension].ToString(), "true", StringComparison.OrdinalIgnoreCase))); }
+            get
+            {
+                return AllPathParams.Where(p => !(p.Extensions.ContainsKey(Generator.Extensions.SkipUrlEncodingExtension) &&
+                  String.Equals(p.Extensions[Generator.Extensions.SkipUrlEncodingExtension].ToString(), "true", StringComparison.OrdinalIgnoreCase)));
+            }
         }
 
         /// <summary>
@@ -133,7 +140,7 @@ public virtual IEnumerable<ParameterTemplateModel> SkipEncodingPathParams
         {
             get
             {
-                return AllPathParams.Where(p => 
+                return AllPathParams.Where(p =>
                     (p.Extensions.ContainsKey(Generator.Extensions.SkipUrlEncodingExtension) &&
                     String.Equals(p.Extensions[Generator.Extensions.SkipUrlEncodingExtension].ToString(), "true", StringComparison.OrdinalIgnoreCase) &&
                     !p.Extensions.ContainsKey("hostParameter")));
@@ -145,7 +152,7 @@ public virtual IEnumerable<ParameterTemplateModel> SkipEncodingPathParams
         /// </summary>
         public virtual IEnumerable<ParameterTemplateModel> AllPathParams
         {
-            get { return ParameterTemplateModels.Where(p => p.Location == ParameterLocation.Path); }
+            get { return LogicalParameterTemplateModels.Where(p => p.Location == ParameterLocation.Path); }
         }
 
         /// <summary>
@@ -169,7 +176,10 @@ public virtual IEnumerable<ParameterTemplateModel> EncodingQueryParams
         /// </summary>
         public virtual IEnumerable<ParameterTemplateModel> AllQueryParams
         {
-            get { return ParameterTemplateModels.Where(p => p.Location == ParameterLocation.Query); }
+            get
+            {
+                return LogicalParameterTemplateModels.Where(p => p.Location == ParameterLocation.Query);
+            }
         }
 
         /// <summary>
@@ -207,7 +217,9 @@ public virtual string SetDefaultHeaders
         /// Gets the list of method paramater templates.
         /// </summary>
         public List<ParameterTemplateModel> ParameterTemplateModels { get; private set; }
-
+
+        private List<ParameterTemplateModel> LogicalParameterTemplateModels { get; set; }
+
         /// <summary>
         /// Gets the list of parameter which need to be included into HTTP header.
         /// </summary>
@@ -271,7 +283,7 @@ public string MethodParameterDeclaration
                             PrimaryType type = parameter.Type as PrimaryType;
                             if (type != null)
                             {
-                                if (type.Type == KnownPrimaryType.Boolean || type.Type == KnownPrimaryType.Double || 
+                                if (type.Type == KnownPrimaryType.Boolean || type.Type == KnownPrimaryType.Double ||
                                     type.Type == KnownPrimaryType.Int || type.Type == KnownPrimaryType.Long || type.Type == KnownPrimaryType.String)
                                 {
                                     format = "{0} = " + parameter.DefaultValue;
@@ -323,7 +335,7 @@ public IEnumerable<ParameterTemplateModel> LocalParameters
         /// </summary>
         public ParameterTemplateModel RequestBody
         {
-            get { return ParameterTemplateModels.FirstOrDefault(p => p.Location == ParameterLocation.Body); }
+            get { return LogicalParameterTemplateModels.FirstOrDefault(p => p.Location == ParameterLocation.Body); }
         }
 
         /// <summary>
@@ -452,6 +464,58 @@ public virtual string BuildUrl(string variableName)
             return builder.ToString();
         }
 
+        /// <summary>
+        /// Build parameter mapping from parameter grouping transformation.
+        /// </summary>
+        /// <returns></returns>
+        public virtual string BuildInputParameterMappings()
+        {
+            var builder = new IndentedStringBuilder("  ");
+            if (InputParameterTransformation.Count > 0)
+            {
+                builder.Indent();
+                foreach (var transformation in InputParameterTransformation)
+                {
+                    if (transformation.OutputParameter.Type is CompositeType &&
+                        transformation.OutputParameter.IsRequired)
+                    {
+                        builder.AppendLine("{0} = {1}.new",
+                            transformation.OutputParameter.Name,
+                            transformation.OutputParameter.Type.Name);
+                    }
+                    else
+                    {
+                        builder.AppendLine("{0} = nil", transformation.OutputParameter.Name);
+                    }
+                }
+                foreach (var transformation in InputParameterTransformation)
+                {
+                    builder.AppendLine("unless {0}", BuildNullCheckExpression(transformation))
+                           .AppendLine().Indent();
+                    var outputParameter = transformation.OutputParameter;
+                    if (transformation.ParameterMappings.Any(m => !string.IsNullOrEmpty(m.OutputParameterProperty)) &&
+                        transformation.OutputParameter.Type is CompositeType)
+                    {
+                        //required outputParameter is initialized at the time of declaration
+                        if (!transformation.OutputParameter.IsRequired)
+                        {
+                            builder.AppendLine("{0} = {1}.new",
+                                transformation.OutputParameter.Name,
+                                transformation.OutputParameter.Type.Name);
+                        }
+                    }
+
+                    foreach (var mapping in transformation.ParameterMappings)
+                    {
+                        builder.AppendLine("{0}{1}", transformation.OutputParameter.Name, mapping);
+                    }
+
+                    builder.Outdent().AppendLine("end");
+                }
+            }
+            return builder.ToString();
+        }
+
         /// <summary>
         /// Gets the formatted status code.
         /// </summary>
@@ -517,5 +581,30 @@ private string UrlPathNameFromPathPattern(string urlPathParamName)
             }
             return urlPathParamName;
         }
+
+        /// <summary>
+        /// Builds null check expression for the given <paramref name="transformation"/>.
+        /// </summary>
+        /// <param name="transformation">ParameterTransformation for which to build null check expression.</param>
+        /// <returns></returns>
+        private static string BuildNullCheckExpression(ParameterTransformation transformation)
+        {
+            if (transformation == null)
+            {
+                throw new ArgumentNullException("transformation");
+            }
+            if (transformation.ParameterMappings.Count == 1)
+            {
+                return string.Format(CultureInfo.InvariantCulture,
+                    "{0}.nil?",transformation.ParameterMappings[0].InputParameter.Name);
+            }
+            else
+            {
+                return string.Join(" || ",
+                transformation.ParameterMappings.Select(m =>
+                    string.Format(CultureInfo.InvariantCulture,
+                    "({0}.nil?)", m.InputParameter.Name)));
+            }
+        }
     }
 }

AutoRest/Generators/Ruby/Ruby/Templates/MethodTemplate.cshtml

@@ -101,13 +101,16 @@ def @(Model.Name)_async(@(Model.MethodParameterDeclaration))
   @:@(parameter.Type.ValidateType(Model.Scope, parameter.Name))
       }
 }
+@EmptyLine
+@(Model.BuildInputParameterMappings())
+@EmptyLine
   request_headers = {}
-@if (Model.Parameters.Any(p => p.Location == ParameterLocation.Header))
+@if (Model.LogicalParameters.Any(p => p.Location == ParameterLocation.Header))
 {
   @EmptyLine
   @:# Set Headers
   @:@(Model.SetDefaultHeaders)
-  foreach (var parameter in Model.Parameters.Where(p => p.Location == ParameterLocation.Header))
+  foreach (var parameter in Model.LogicalParameters.Where(p => p.Location == ParameterLocation.Header))
   {
     if (parameter.SerializedName.ToLower() == "Content-Type".ToLower())
     {

gulpfile.js

@@ -86,7 +86,8 @@ var rubyMappings = {
   'http_infrastructure':['../../../TestServer/swagger/httpInfrastructure.json','HttpInfrastructureModule'],
   'required_optional':['../../../TestServer/swagger/required-optional.json','RequiredOptionalModule'],
   'report':['../../../TestServer/swagger/report.json','ReportModule'],
-  'model_flattening':['../../../TestServer/swagger/model-flattening.json', 'ModelFlatteningModule'],
+  'model_flattening':['../../../TestServer/swagger/model-flattening.json', 'ModelFlatteningModule'],  
+  'parameter_grouping':['../../../TestServer/swagger/azure-parameter-grouping.json', 'ParameterGroupingModule'],
 };
 
 var defaultAzureMappings = {