Merge pull request #2460 from Shenniey/copyOfMain

Adding logic to migrate to new javascript project experience

Author: Shenniey

Nodejs/MigrateToJsps/Jsps/EsprojFileModel.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml;
+using System.Xml.Serialization;
+
+namespace MigrateToJsps
+{
+    [XmlRoot(ElementName = "Project")]
+    public class EsprojFile
+    {
+        [XmlAttribute(AttributeName = "Sdk")]
+        public string Sdk = @"Microsoft.VisualStudio.JavaScript.Sdk/0.5.85-alpha";
+
+        [XmlElement(ElementName = "PropertyGroup")]
+        public EsprojPropertyGroup PropertyGroup { get; set; }
+    }
+
+    [XmlRoot(ElementName = "PropertyGroup")]
+    public class EsprojPropertyGroup
+    {
+        [XmlAnyElement("BuildCommandComment")]
+        public XmlComment BuildCommandComment = new XmlDocument().CreateComment("Command to run on project build");
+
+        [XmlElement(ElementName = "BuildCommand", IsNullable = false)]
+        public string BuildCommand;
+
+        [XmlAnyElement("CleanCommandComment")]
+        public XmlComment CleanCommandComment = new XmlDocument().CreateComment("Command to run on project clean");
+
+        [XmlElement(ElementName = "CleanCommand", IsNullable = false)]
+        public string CleanCommand;
+
+        [XmlElement(ElementName = "StartupCommand", IsNullable = false)]
+        public string StartupCommand;
+    }
+}

Nodejs/MigrateToJsps/Jsps/EsprojFileWriter.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+using System.Xml.Serialization;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace MigrateToJsps
+{
+    internal static class EsprojFileWriter
+    {
+        public static string WriteEsproj(string projectDir, string projectName, string startupFile, string port, Logger logger)
+        {
+            var fileName = projectName + ".esproj";
+            var filePath = Path.Combine(projectDir, fileName);
+
+            EsprojPropertyGroup propGroup = new EsprojPropertyGroup();
+            
+            var pkgJson = ReadPackageJson(projectDir);
+            if (pkgJson != null)
+            {
+                if (StartCmdExistsInPkgJson(pkgJson)) {
+                    var startupCmd = "npm run start";
+
+                    if (!string.IsNullOrEmpty(port))
+                    {
+                        startupCmd = $"set PORT={port} & " + startupCmd; 
+                    }
+                    propGroup.StartupCommand = startupCmd;
+                }
+
+                propGroup.BuildCommand = BuildCmdExistsInPkgJson(pkgJson) ? "npm run build" : " ";
+
+                propGroup.CleanCommand = CleanCmdExistsInPkgJson(pkgJson) ? "npm run clean" : " ";
+            }
+            else
+            {
+                propGroup.StartupCommand = "node " + startupFile;
+            }
+
+            EsprojFile esprojFile = new EsprojFile() { PropertyGroup = propGroup };
+
+            XmlSerializer serializer = new XmlSerializer(typeof(EsprojFile));
+
+            XmlWriterSettings settings = new XmlWriterSettings();
+            settings.Indent = true;
+            settings.OmitXmlDeclaration = true;
+
+            XmlSerializerNamespaces emptyNamespaces = new XmlSerializerNamespaces();
+            emptyNamespaces.Add("", "");
+
+            using (XmlWriter writer = XmlWriter.Create(filePath, settings))
+            {
+                serializer.Serialize(writer, esprojFile, emptyNamespaces);
+            }
+
+            logger.AddFile(filePath);
+
+            return filePath;
+        }
+
+        private static bool StartCmdExistsInPkgJson(JObject packageJson)
+        {
+            if (packageJson.ContainsKey("scripts"))
+            {
+                return packageJson["scripts"]["start"] != null;
+            }
+
+            return false;
+        }
+
+        private static bool BuildCmdExistsInPkgJson(JObject packageJson)
+        {
+            if (packageJson.ContainsKey("scripts"))
+            {
+                return packageJson["scripts"]["build"] != null;
+            }
+
+            return false;
+        }
+
+        private static bool CleanCmdExistsInPkgJson(JObject packageJson)
+        {
+            if (packageJson.ContainsKey("scripts"))
+            {
+                return packageJson["scripts"]["clean"] != null;
+            }
+
+            return false;
+        }
+
+        private static JObject ReadPackageJson(string projectDir)
+        {
+            string filePath = Path.Combine(projectDir, "package.json");
+            if (File.Exists(filePath))
+            {
+                string packageJsonContent = File.ReadAllText(filePath);
+
+                JObject packageJson = JsonConvert.DeserializeObject<JObject>(packageJsonContent);
+
+                return packageJson;
+            }
+
+            return null;
+        }
+
+        private static string GetSdkVersion()
+        {
+            // TODO: figure out if sdk is installed on machine?
+            // do i need to do that or will VS automatically install given version
+            throw new NotImplementedException();
+        }
+    }
+}

Nodejs/MigrateToJsps/Jsps/JspsProjectCreator.cs

@@ -0,0 +1,30 @@
+using System.IO;
+
+namespace MigrateToJsps
+{
+    internal class JspsProjectCreator
+    {
+        private string projectDir;
+        private NjsprojFileModel njsprojFileModel;
+        private Logger logger;
+
+        public JspsProjectCreator(string projectDir, NjsprojFileModel njsprojFileModel, Logger logger)
+        {
+            this.projectDir = projectDir;
+            this.njsprojFileModel = njsprojFileModel;
+
+            this.logger = logger;
+        }
+
+        public string CreateJspsProject() // to be called by outsiders
+        {
+            LaunchJsonWriter.CreateLaunchJson(projectDir, njsprojFileModel, this.logger);
+
+            NugetConfigWriter.GenerateNugetConfig(projectDir, this.logger);
+
+            var port = njsprojFileModel.NodejsPort;
+
+            return EsprojFileWriter.WriteEsproj(projectDir, njsprojFileModel.ProjectName, njsprojFileModel.StartupFile, port, this.logger);
+        }
+    }
+}

Nodejs/MigrateToJsps/Jsps/LaunchJson/Compound.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace MigrateToJsps
+{
+    [JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
+    internal class Compound
+    {
+        /// <summary>
+        /// The friendly name of the compound configuration
+        /// </summary>
+        [JsonProperty("name")]
+        public string Name { get; set; }
+
+        /// <summary>
+        /// A string array containing the friendly names of the launch configs that this compound will start
+        /// </summary>
+        [JsonProperty("configurations")]
+        public string[] Configurations { get; set; }
+
+        /// <summary>
+        /// Indicates whether terminating one session will terminate all debugging sessions
+        /// </summary>
+        [JsonProperty("stopAll")]
+        public bool? StopAll { get; set; }
+
+        /// <summary>
+        /// Task to run before any of the compound configurations start
+        /// </summary>
+        [JsonProperty("preLaunchTask")]
+        public string PreLaunchTask { get; set; }
+
+        public string ToJsonString() => JsonConvert.SerializeObject(this, Formatting.Indented);
+
+        public bool IsEqualToJson(JToken jsonToCompare)
+        {
+            JToken config = JToken.FromObject(this);
+            return JToken.DeepEquals(config, jsonToCompare);
+        }
+    }
+}

Nodejs/MigrateToJsps/Jsps/LaunchJson/Configuration.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json;
+
+namespace MigrateToJsps
+{
+    [JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
+    internal class Configuration
+    {
+        /// <summary>
+        /// The friendly name of the launch configuration
+        /// </summary>
+        [JsonProperty("name")]
+        public string Name { get; set; }
+
+        /// <summary>
+        /// The type of configuration (chrome, edge, or node)
+        /// </summary>
+        [JsonProperty("type")]
+        public string Type { get; set; }
+
+        /// <summary>
+        /// The debug request type ("launch" or "attach")
+        /// </summary>
+        [JsonProperty("request")]
+        public string Request { get; set; }
+
+        /// <summary>
+        /// The url to open a browser to
+        /// </summary>
+        [JsonProperty("url")]
+        public string Url { get; set; }
+
+        /// <summary>
+        /// User data directory to use when launching browser
+        /// </summary>
+        [JsonProperty("userDataDir")]
+        public object UserDataDir { get; set; }
+
+        /// <summary>
+        /// This specifies the workspace absolute path to the webserver root. Used to resolve paths like `/app.js` to files on disk. Shorthand for a pathMapping for "/"
+        /// </summary>
+        [JsonProperty("webRoot")]
+        public string WebRoot { get; set; }
+
+        /// <summary>
+        /// Optional current working directory for the runtime executable.
+        /// </summary>
+        [JsonProperty("cwd")]
+        public string Cwd { get; set; }
+
+        /// <summary>
+        /// This specifies the workspace absolute path to the program being debugged (currently only applies to Node launch configurations)
+        /// </summary>
+        [JsonProperty("program")]
+        public string Program { get; set; }
+
+        /// <summary>
+        /// Tells the debugger which files to skip over 
+        /// </summary>
+        [JsonProperty("skipFiles")]
+        public string[] Skipfiles { get; set; }
+
+        /// <summary>
+        /// Automatically stops the progam after launch (only applies to Node launch configurations)
+        /// </summary>
+        [JsonProperty("stopOnEntry")]
+        public bool? StopOnEntry { get; set; }
+
+        /// <summary>
+        /// Specifies which console -- only used for Node
+        /// </summary>
+        [JsonProperty("console")]
+        public string Console { get; set; }
+
+        /// <summary>
+        /// Environment variables passed to the program
+        /// </summary>
+        [JsonProperty("env")]
+        public JObject Env { get; set; }
+
+        /// <summary>
+        /// Other configuration properties which aren't explicitly listed in this class
+        /// </summary>
+        [JsonExtensionData]
+        public Dictionary<string, JToken> ConfigurationProperties { get; private set; }
+
+        public string ToJsonString() => JsonConvert.SerializeObject(this, Formatting.Indented);
+
+        public bool IsEqualToJson(JToken jsonToCompare)
+        {
+            JToken config = JToken.FromObject(this);
+            return JToken.DeepEquals(config, jsonToCompare);
+        }
+    }
+}

Nodejs/MigrateToJsps/Jsps/LaunchJson/LaunchJson.cs

@@ -0,0 +1,41 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System.Collections.Generic;
+using System.Configuration;
+
+namespace MigrateToJsps
+{
+    [JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
+    internal class LaunchJson
+    {
+        /// <summary>
+        /// The friendly name of the launch configuration
+        /// </summary>
+        [JsonProperty("version")]
+        public string Version = "0.2.0";
+
+        /// <summary>
+        /// The type of configuration (chrome, edge, or node)
+        /// </summary>
+        [JsonProperty("configurations")]
+        public Configuration[] Configurations { get; set; }
+
+        /// <summary>
+        /// The debug request type ("launch" or "attach")
+        /// </summary>
+        [JsonProperty("compounds")]
+        public Compound[] Compounds { get; set; }
+
+        /// <summary>
+        /// Other launch.json properties which aren't explicitly listed in this class
+        /// </summary>
+        [JsonExtensionData]
+        public Dictionary<string, JToken> LaunchJsonProperties { get; private set; }
+
+        public string ToJsonString()
+        {
+            return JsonConvert.SerializeObject(this, Formatting.Indented);
+        }
+    }
+
+}