Add support for specifying properties from the typewriter cli (#178)

* Added a test for validating custom PHP namespace property from the TypeWriter CLI. Fixed test metadata.
* Add support for specifying key-value properties from the Typewriter CLI.
* Fix broken tests.
* Updated test metadata to match preprocessing
* Changes support E2E testing when different target platforms are used in a test run for Typewriter. The TemplateProcessor host needs to be reset for the case when we target a new language. Otherwise the wrong *CodeWriter will be used and an unsupported cast will occur in the templates when trying to cast host.CodeWriter to the platform specific CodeWriter. The change to ConfigurationService.Settings is also required to reset the settings for configuring the TemplateWriter.
* Updated typewriter tests to be more descriptive

Author: MIchaelMainer

README.md

@@ -48,16 +48,17 @@ Typewriter is a new solution for generating code files using the GraphODataTempl
 * **-g**, **-generationmode**: Specifies the generation mode. The values can be: `Full`, `Metadata`, or `Files`. `Full` (default) generation mode produces the output code files by cleaning the input metadata, parsing the documentation, and adding annotations before generating the output files. `Metadata` generation mode produces an output metadata file by cleaning metadata, documentation parsing, and adding documentation annotations. `Files` generation mode produces code files from an input metadata and bypasses the cleaning, documentation parsing, and adding documentation annotations.
 * **-f**, **-outputMetadataFileName**: The base output metadata filename. Only applicable for `-generationmode Metadata`. The default value is `cleanMetadataWithDescriptions` which is used with the value of the `-endpointVersion` to generate a metadata file named `cleanMetadataWithDescriptionsv1.0.xml`.
 * **-e**, **-endpointVersion**: The endpoint version used when naming a metadata file. Expected values are `v1.0` and `beta`. Only applicable for `-generationmode Metadata`.
+* **-p**, **-properties**: Specify properties to support generation logic in the T4 templates. Properties must take the form of *key-string:value-string*. Multiple properties can be specified by setting a space in between property. The only property currently supported is the *php.namespace* property to specify the generated model file namespace. This property is optional.
 
 ### Example typewriter usage
 
-#### Generate TypeScript typings from a CSDL (metadata) file without cleaning or annotating the CSDL. 
+#### Generate TypeScript typings from a CSDL (metadata) file without cleaning or annotating the CSDL.
 
 The output will go in to the `outputTypeScript` directory.
 
 `.\typewriter.exe -v Info -m D:\cleanMetadataWithDescriptions_v10.xml -o outputTypeScript -l TypeScript -g Files`
 
-#### Clean and annotate a metadata file with documentation annotations sourced from the documentation repo 
+#### Clean and annotate a metadata file with documentation annotations sourced from the documentation repo
 
 The output metadata file will go in to the `output2` directory. The output metadata file will be named `cleanMetadataWithDescriptionsv1.0.xml` based on the default values.
 
@@ -144,7 +145,7 @@ The type of template.
 
 #### Template Name
 
-To set the name of the template using the `Name` format string. You can insert `<Class>`, `<Property>`, `<Method>`, and `<Container>` the values will be replaced by the names of the corresponding object.  If you insert an item that doesn't exist it will be replaced with an empty string.  
+To set the name of the template using the `Name` format string. You can insert `<Class>`, `<Property>`, `<Method>`, and `<Container>` the values will be replaced by the names of the corresponding object.  If you insert an item that doesn't exist it will be replaced with an empty string.
 Note: You can also set the template name from inside the template by : `host.SetTemplateName("foo");`
 
 #### Template Editing
@@ -174,9 +175,9 @@ There are currently several steps we take to form the metadata into one that wil
   - Remove HasStream properties from ```onenotePage``` and ```onenoteEntityBaseModel```
   - Add ```ContainsTarget="true"``` to navigation properties that do not have a corresponding EntitySet. This currently applies to navigation properties that contain plannerBucket, plannerTask, plannerPlan, and plannerDelta.
   - Add long descriptions to types and properties from [docs](https://developer.microsoft.com/en-us/graph/docs/concepts/overview)
-  
+
 In order to build against metadata other than that stored in the [metadata](https://github.com/microsoftgraph/MSGraph-SDK-Code-Generator/tree/master/metadata) directory, you will need to perform the first four on this list.
-  
+
 ## Contributing
 
 Before we can accept your pull request, you'll need to electronically complete Microsoft's [Contributor License Agreement](https://cla.microsoft.com/). If you've done this for other Microsoft projects, then you're already covered.

Templates/PHP/Model/ComplexType.php.tt

@@ -5,14 +5,24 @@
 CustomT4Host host      = (CustomT4Host) Host;
 OdcmModel model        = host.CurrentModel;
 CodeWriterPHP writer   = (CodeWriterPHP) host.CodeWriter;
+TemplateWriterSettings settings = ConfigurationService.Settings;
 OdcmClass complex      = (OdcmClass)host.CurrentType;
 String complexName     = complex.Name.SanitizeEntityName();
+string targetNamespace = @"Microsoft\Graph\Model";
 String complexBaseName = "";
 if (complex.Base != null)
 	complexBaseName = complex.Base.Name.SanitizeEntityName();
+
+// TemplateWriterSettings.Properties are set at the Typewriter command line. Check the command line 
+// documentation for more information on how the TemplateWriterSettings.Properties is used.
+if (settings.Properties.ContainsKey("php.namespace"))
+{
+    targetNamespace = settings.Properties["php.namespace"];
+}      
+
 #>
 <#=writer.WriteHeader(writer.GetDocBlock(complexName.ToCheckedCase()))#>
-namespace Microsoft\Graph\Model;
+namespace <#=targetNamespace#>;
 <#=writer.GetClassBlock(complexName.ToCheckedCase().ToString(), "Model")#>
 <#
 if (complex.Base != null) {
@@ -118,7 +128,7 @@ foreach(var property in complex.Properties.Where(prop => prop.Type.GetTypeString
     public function get<#=propertyName.ToCheckedCase()#>()
     {
         if (array_key_exists("<#=property.Name.ToCamelize()#>", $this->_propDict)) {
-            if (is_a($this->_propDict["<#=property.Name.ToCamelize()#>"], "Microsoft\Graph\Model\<#=property.Type.GetTypeString()#>")) {
+            if (is_a($this->_propDict["<#=property.Name.ToCamelize()#>"], "<#=targetNamespace#>\<#=property.Type.GetTypeString()#>")) {
                 return $this->_propDict["<#=property.Name.ToCamelize()#>"];
             } else {
 <# if (property.Type.GetTypeString() == "\\GuzzleHttp\\Psr7\\Stream") { #>

Templates/PHP/Model/EntityType.php.tt

@@ -8,12 +8,22 @@ CodeWriterPHP writer	        = (CodeWriterPHP) host.CodeWriter;
 OdcmClass entity                = host.CurrentType.AsOdcmClass();
 TemplateWriterSettings settings = ConfigurationService.Settings;
 String entityName               = entity.Name.SanitizeEntityName();
+string targetNamespace          = @"Microsoft\Graph\Model";
 String entityBaseName           = "";
+
 if (entity.Base != null)
 	entityBaseName = entity.Base.Name.SanitizeEntityName();
+
+// TemplateWriterSettings.Properties are set at the Typewriter command line. Check the command line 
+// documentation for more information on how the TemplateWriterSettings.Properties is used.
+if (settings.Properties.ContainsKey("php.namespace"))
+{
+    targetNamespace = settings.Properties["php.namespace"];
+}      
+
 #>
 <#=writer.WriteHeader(writer.GetDocBlock(entityName.ToCheckedCase()))#>
-namespace Microsoft\Graph\Model;
+namespace <#=targetNamespace#>;
 
 <#=writer.GetClassBlock(entityName.ToCheckedCase().ToString(), "Model")#>
 <#
@@ -122,7 +132,7 @@ foreach(var property in entity.Properties.Where(prop => prop.Type.GetTypeString(
 if (property.Type.GetTypeString()[0] == '\\') { #>
             if (is_a($this->_propDict["<#=property.Name.ToCamelize()#>"], "<#=property.Type.GetTypeString()#>")) {
 <# } else { #>
-            if (is_a($this->_propDict["<#=property.Name.ToCamelize()#>"], "Microsoft\Graph\Model\<#=property.Type.GetTypeString()#>")) {
+            if (is_a($this->_propDict["<#=property.Name.ToCamelize()#>"], "<#=targetNamespace#>\<#=property.Type.GetTypeString()#>")) {
 <# } #>
                 return $this->_propDict["<#=property.Name.ToCamelize()#>"];
             } else {

Templates/PHP/Model/EnumType.php.tt

@@ -2,14 +2,23 @@
 <#@ template debug="true" hostspecific="true" language="C#" #>
 <#@ output extension="\\" #>
 <#
-CustomT4Host host       = (CustomT4Host) Host;
-OdcmModel model         = host.CurrentModel;
-CodeWriterPHP writer   = (CodeWriterPHP) host.CodeWriter;
+CustomT4Host host               = (CustomT4Host) Host;
+OdcmModel model                 = host.CurrentModel;
+CodeWriterPHP writer            = (CodeWriterPHP) host.CodeWriter;
+TemplateWriterSettings settings = ConfigurationService.Settings;
+string targetNamespace          = @"Microsoft\Graph\Model";
+var enumT                       = host.CurrentType.AsOdcmEnum();
+
+// TemplateWriterSettings.Properties are set at the Typewriter command line. Check the command line 
+// documentation for more information on how the TemplateWriterSettings.Properties is used.
+if (settings.Properties.ContainsKey("php.namespace"))
+{
+    targetNamespace = settings.Properties["php.namespace"];
+}      
 
-var enumT = host.CurrentType.AsOdcmEnum();
 #>
 <#=writer.WriteHeader(writer.GetDocBlock(enumT.Name.ToCheckedCase()))#>
-namespace Microsoft\Graph\Model;
+namespace <#=targetNamespace#>;
 
 use Microsoft\Graph\Core\Enum;
 

src/GraphODataTemplateWriter/Settings/ConfigurationService.cs

@@ -3,22 +3,46 @@
 namespace Microsoft.Graph.ODataTemplateWriter.Settings
 {
     using System;
+    using System.Collections.Generic;
     using System.Reflection;
     using System.Reflection.Emit;
     using Vipr.Core;
 
+    /// <summary>
+    /// The ConfigurationService configures the template writer with the target language and 
+    /// other properties used to direct how the code files are generated.
+    /// </summary>
     public static class ConfigurationService
     {
         private static IConfigurationProvider _configurationProvider;
         private static TemplateWriterSettings templateWriterSettings = null;
         private static string targetLanguage = null;
-        public static void Initialize(IConfigurationProvider configurationProvider, string targetLanguage = null)
+        private static Dictionary<string, string> properties = null;
+
+        public static void Initialize(IConfigurationProvider configurationProvider, string targetLanguage = null, IEnumerable<string> properties = null)
         {
             _configurationProvider = configurationProvider;
             if (!String.IsNullOrEmpty(targetLanguage))
             {
                 ConfigurationService.targetLanguage = targetLanguage;
             }
+            if (properties != null)
+            {
+                Dictionary<string, string> propertyDictionary = new Dictionary<string, string>();
+                foreach (string property in properties)
+                {
+                    string[] props = property.Split(':');
+
+                    if (props.Length != 2)
+                    {
+                        throw new ArgumentException("A property was set in a unexpected form from the typewriter commandline.", "-p -properties");
+                    }
+
+                    propertyDictionary.Add(props[0],props[1]);
+                }
+
+                ConfigurationService.properties = propertyDictionary;
+            }
         }
 
         private static TemplateWriterSettings LoadSettingsForLanguage()
@@ -29,6 +53,11 @@ private static TemplateWriterSettings LoadSettingsForLanguage()
             {
                 mainTWS.TargetLanguage = targetLanguage;
             }
+            if (properties != null)
+            {
+                mainTWS.Properties = properties;
+            }
+
 
             TemplateWriterSettings.mainSettingsObject = mainTWS;
 
@@ -72,7 +101,7 @@ public static TemplateWriterSettings Settings
         {
             get
             {
-                if (templateWriterSettings == null)
+                if (templateWriterSettings == null || templateWriterSettings.TargetLanguage != ConfigurationService.targetLanguage)
                 {
                     templateWriterSettings = _configurationProvider != null
                         ? LoadSettingsForLanguage()

src/GraphODataTemplateWriter/Settings/TemplateWriterSettings.cs

@@ -101,6 +101,12 @@ public Dictionary<string, List<Dictionary<string, string>>> TemplateMapping
 
         private readonly List<Dictionary<string, string>> templateConfiguration;
 
+        /// <summary>
+        /// A dictionary of strings that represent a property. These properties can be provided from the command line
+        /// and used in the templates.
+        /// </summary>
+        public Dictionary<string, string> Properties { get; set; }
+
         /// <summary>
         /// The dictionary created by combining the "Shared" and current language mapping.
         /// </summary>

src/GraphODataTemplateWriter/TemplateProcessor/TemplateProcessor.cs

@@ -25,14 +25,11 @@ public class TemplateProcessor : ITemplateProcessor
 
         protected static CustomT4Host Host(ITemplateInfo templateInfo, string templatesDirectory, OdcmObject odcmObject, OdcmModel odcmModel)
         {
-            if (_host == null)
-            {
-                _host = new CustomT4Host(templateInfo, templatesDirectory, odcmObject, odcmModel);
-            }
-            else
-            {
-                _host.Reset(templateInfo, templatesDirectory, odcmObject, odcmModel);
-            }
+            // Need to always set the host. Typically, this is run against a single platform when generating codefiels.
+            // In test cases, we need to target multiple platforms. Since much of this code is static, we need to make sure 
+            // reset the information provided to the template processor. This change fixes a bug when targeting 
+            // multiple platforms in a test.
+            _host = new CustomT4Host(templateInfo, templatesDirectory, odcmObject, odcmModel);
 
             return _host;
         }

src/GraphODataTemplateWriter/TemplateProcessor/TemplateWriter.cs

@@ -24,6 +24,25 @@ public class TemplateWriter : IConfigurable, IOdcmWriter
         private static Logger logger = LogManager.GetCurrentClassLogger();
 
         private string pathWriterClassNameFormatString;
+        
+        private string targetLanguage;
+        private IEnumerable<string> properties;
+
+        public TemplateWriter()
+        {
+        }
+
+        public TemplateWriter(string targetLanguage)  
+        {
+            this.targetLanguage = targetLanguage;
+        }
+
+        public TemplateWriter(string targetLanguage, IEnumerable<string> properties)
+        {
+            this.targetLanguage = targetLanguage;
+            this.properties = properties;
+        }
+
         private string PathWriterClassNameFormatString
         {
             get {
@@ -76,22 +95,10 @@ IEnumerable<TextFile> ProcessTemplates()
             }
         }
 
-        private string targetLanguage;
-
-        public TemplateWriter()
-        {
-
-        }
-
-        public TemplateWriter(string targetLanguage)
-        {
-            this.targetLanguage = targetLanguage;
-        }
-
         // IConfigurationProvider
         public void SetConfigurationProvider(IConfigurationProvider configurationProvider)
         {
-            ConfigurationService.Initialize(configurationProvider, this.targetLanguage);
+            ConfigurationService.Initialize(configurationProvider, this.targetLanguage, this.properties);
             FileNameCasing nameCasing;
             if(!Enum.TryParse(ConfigurationService.Settings.DefaultFileCasing, out nameCasing))
             {

src/Typewriter/Generator.cs

@@ -18,7 +18,7 @@ internal static class Generator
         /// <param name="options">The options bag</param>
         static internal void GenerateFiles(string csdlContents, Options options)
         {
-            var filesToWrite = MetadataToClientSource(csdlContents, options.Language);
+            var filesToWrite = MetadataToClientSource(csdlContents, options.Language, options.Properties);
             FileWriter.WriteAsync(filesToWrite, options.Output);
         }
 
@@ -65,13 +65,13 @@ static private string CleanMetadata(string csdlContents, Options options)
         /// <param name="edmxString">The EDMX file as a string.</param>
         /// <param name="targetLanguage">Specifies the target language. Possible values are csharp, php, etc.</param>
         /// <returns></returns>
-        static private IEnumerable<TextFile> MetadataToClientSource(string edmxString, string targetLanguage)
+        static private IEnumerable<TextFile> MetadataToClientSource(string edmxString, string targetLanguage, IEnumerable<string> properties)
         {
             if (String.IsNullOrEmpty(edmxString))
                 throw new ArgumentNullException("edmxString", "The EDMX file string contains no content.");
 
             var reader = new OdcmReader();
-            var writer = new TemplateWriter(targetLanguage);
+            var writer = new TemplateWriter(targetLanguage, properties);
             writer.SetConfigurationProvider(new ConfigurationProvider());
 
             var model = reader.GenerateOdcmModel(new List<TextFile> { new TextFile("$metadata", edmxString) });

src/Typewriter/Options.cs

@@ -1,4 +1,5 @@
 using CommandLine;
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 
 [assembly: InternalsVisibleTo("GraphODataTemplateWriter.Test")]
@@ -60,5 +61,10 @@ public class Options
 
         [Option('e', "endpointVersion", Default = "v1.0", HelpText = "The endpoint version. Expected values are 'v1.0' and 'beta'. Only applicable for GenerationMode.Metadata.")]
         public string EndpointVersion { get; set; }
+
+        [Option('p', "properties",  HelpText = "A space separated list of properties in the form of 'key:value'. These properties can be accessed in the " +
+            "templates from the TemplateWriterSettings object returned by ConfigurationService.Settings. The suggested convention for specifying a key should be " +
+            "the targeted template language name and the property name. For example, php.namespace:Microsoft\\Graph\\Beta\\Model would be a property to be consumed in the PHP templates.")]
+        public IEnumerable<string> Properties { get; set; }
     }
 }