com.elestrago.unity.package-tools 2.0.7

package/Editor/Tools/PackageJsonModel.cs

@@ -0,0 +1,149 @@
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+
+namespace Playdarium.PackageTool.Tools
+{
+	public class PackageJsonModel
+	{
+		[JsonProperty("name")] public string Name;
+		[JsonProperty("version")] public string Version;
+		[JsonProperty("displayName")] public string DisplayName;
+		[JsonProperty("description")] public string Description;
+		[JsonProperty("category")] public string Category;
+		[JsonProperty("unity")] public string Unity;
+		[JsonProperty("homepage")] public string Homepage;
+		[JsonProperty("documentationUrl")] public string DocumentationUrl;
+		[JsonProperty("changelogUrl")] public string ChangelogUrl;
+		[JsonProperty("licensesUrl")] public string LicensesUrl;
+		[JsonProperty("license")] public string License;
+		[JsonProperty("keywords")] public string[] Keywords;
+		[JsonProperty("dependencies")] public Dictionary<string, string> Dependencies;
+		[JsonProperty("samples")] public Sample[] Samples;
+		[JsonProperty("author")] public Author Author;
+		[JsonProperty("repository")] public Repository Repository;
+		[JsonProperty("bugs")] public Bugs Bugs;
+
+
+		public static PackageJsonModel CreateFromManifest(PackageManifestConfig manifest)
+		{
+			var model = new PackageJsonModel
+			{
+				Name = manifest.packageName,
+				Version = manifest.packageVersion,
+				DisplayName = manifest.displayName,
+				Description = manifest.description,
+				Category = manifest.category,
+				Unity = manifest.unityVersion,
+				Homepage = manifest.homepage,
+				License = manifest.license
+			};
+
+			model.Keywords = manifest.keywords != null && manifest.keywords.Length > 0
+				? manifest.keywords
+					.Where(k => !string.IsNullOrEmpty(k))
+					.Distinct()
+					.ToArray()
+				: null;
+
+			model.Author = !string.IsNullOrEmpty(manifest.author.name)
+				? new Author(manifest.author.name, manifest.author.email, manifest.author.url)
+				: null;
+
+			model.Dependencies = manifest.dependencies != null && manifest.dependencies.Length > 0
+				? manifest.dependencies
+					.Where(d => !d.IsEmpty())
+					.ToDictionary(d => d.packageName, d => d.packageVersion)
+				: null;
+
+			model.Samples = manifest.samples != null && manifest.samples.Length > 0
+				? manifest.samples
+					.Where(s => !s.IsEmpty())
+					.Select(s => new Sample(s.displayName, s.description, s.path))
+					.ToArray()
+				: null;
+
+			if (!string.IsNullOrEmpty(manifest.homepage))
+			{
+				var homepage = manifest.homepage;
+				if (homepage.EndsWith("/"))
+					homepage = homepage.Remove(homepage.Length - 2, 1);
+
+				model.Homepage = homepage;
+				model.DocumentationUrl = $"{homepage}/-/blob/main/README.md";
+				model.ChangelogUrl = $"{homepage}/-/blob/main/CHANGELOG.md";
+				model.LicensesUrl = $"{homepage}/-/blob/main/LICENSE";
+				model.Repository = new Repository("git", $"{homepage}.git");
+				model.Bugs = new Bugs($"{homepage}/-/issues");
+			}
+
+			return model;
+		}
+	}
+
+	public class Author
+	{
+		[JsonProperty("name")] public string Name;
+		[JsonProperty("email")] public string Email;
+		[JsonProperty("url")] public string URL;
+
+		public Author()
+		{
+		}
+
+		public Author(string name, string email, string url)
+		{
+			Name = name;
+			Email = email;
+			URL = url;
+		}
+	}
+
+	public class Repository
+	{
+		[JsonProperty("type")] public string Type;
+		[JsonProperty("url")] public string URL;
+
+		public Repository()
+		{
+		}
+
+		public Repository(string type, string url)
+		{
+			Type = type;
+			URL = url;
+		}
+	}
+
+	public class Bugs
+	{
+		[JsonProperty("url")] public string URL;
+
+		public Bugs()
+		{
+		}
+
+		public Bugs(string url)
+		{
+			URL = url;
+		}
+	}
+
+	public class Sample
+	{
+		[JsonProperty("displayName")] public string DisplayName;
+		[JsonProperty("description")] public string Description;
+		[JsonProperty("path")] public string Path;
+
+		public Sample()
+		{
+		}
+
+		public Sample(string displayName, string description, string path)
+		{
+			DisplayName = displayName;
+			Description = description;
+			Path = path;
+		}
+	}
+}

package/Editor/Tools/PackageJsonModel.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e43ecbe8455b4ef9b6bf85c330a346f2
+timeCreated: 1661432129

package/Editor/Tools/PackageManifestTools.cs

@@ -0,0 +1,77 @@
+/*
+MIT License
+
+Copyright (c) 2020 Jeff Campbell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using UnityEditor;
+
+namespace Playdarium.PackageTool.Tools
+{
+	/// <summary>
+	/// Helper methods for the Package Manifest Tools
+	/// </summary>
+	internal static class PackageManifestTools
+	{
+		private static readonly JsonSerializerSettings Settings = new()
+		{
+			NullValueHandling = NullValueHandling.Ignore,
+			DefaultValueHandling = DefaultValueHandling.Ignore
+		};
+
+		/// <summary>
+		/// Returns a Json <see cref="string"/> representation of the <see cref="PackageManifestConfig"/>
+		/// <paramref name="manifest"/>.
+		/// </summary>
+		/// <param name="manifest"></param>
+		/// <returns></returns>
+		public static string GenerateJson(PackageManifestConfig manifest)
+		{
+			var packageJsonModel = PackageJsonModel.CreateFromManifest(manifest);
+			return JsonConvert.SerializeObject(packageJsonModel, Formatting.Indented, Settings);
+		}
+
+		/// <summary>
+		/// Retrieves all <see cref="PackageManifestConfig"/> instances in the project.
+		/// </summary>
+		public static PackageManifestConfig[] GetAllConfigs()
+		{
+			var assetList = new List<PackageManifestConfig>();
+
+			const string TYPE_FILTER = "t:PackageManifestConfig";
+
+			var configGuids = AssetDatabase.FindAssets(TYPE_FILTER);
+			foreach (var configGuid in configGuids)
+			{
+				var assetPath = AssetDatabase.GUIDToAssetPath(configGuid);
+				var config = AssetDatabase.LoadAssetAtPath<PackageManifestConfig>(assetPath);
+				if (config != null)
+				{
+					assetList.Add(config);
+				}
+			}
+
+			return assetList.ToArray();
+		}
+	}
+}

package/Editor/Tools/PackageManifestTools.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f01b690fa8e7429c99fe6e03eba34080
+timeCreated: 1554742298

package/Editor/Tools/UnityFileTools.cs

@@ -0,0 +1,132 @@
+/*
+MIT License
+
+Copyright (c) 2020 Jeff Campbell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace Playdarium.PackageTool.Tools
+{
+	/// <summary>
+	/// Helper methods for dealing with files/directories in the Unity Assets folder.
+	/// </summary>
+	internal static class UnityFileTools
+	{
+		/// <summary>
+		/// Gather all of the files/folders for the package and export them to the pre-defined location
+		/// at <see cref="PackageManifestConfig.legacyPackageDestinationPath"/>.
+		/// </summary>
+		/// <param name="config"></param>
+		public static void CompileLegacyPackage(PackageManifestConfig config)
+		{
+			FileTools.CopyDocumentationToDirectory(config);
+
+			// Gathers all of the files/folders for export as a legacy package.
+			var assetPaths = new List<string>(GetAllAssetPathsRecursively(config));
+			var fileName = string.Format(
+				EditorConstants.UNITY_PACKAGE_NAME_FORMAT,
+				config.displayName.Replace(EditorConstants.EMPTY_SPACE, EditorConstants.UNDERSCORE),
+				config.packageVersion);
+			var finalFilePath = Path.GetFullPath(Path.Combine(
+				Path.Combine(
+					EditorConstants.ProjectPath,
+					config.legacyPackageDestinationPath),
+				fileName));
+
+			// Show the UI and kick off the package export.
+			if (!Application.isBatchMode)
+			{
+				EditorUtility.DisplayProgressBar(
+					EditorConstants.PROGRESS_BAR_TITLE_LEGACY,
+					EditorConstants.COMPILING_PROGRESS_MESSAGE,
+					0);
+			}
+
+			AssetDatabase.ExportPackage(assetPaths.ToArray(), finalFilePath);
+
+			if (!Application.isBatchMode)
+			{
+				EditorUtility.RevealInFinder(finalFilePath);
+				EditorUtility.ClearProgressBar();
+			}
+		}
+
+		/// <summary>
+		/// Returns a list of relative Unity asset paths contained in
+		/// <see cref="PackageManifestConfig.sourcePaths"/> where each path begins with the Assets
+		/// folder.
+		/// </summary>
+		/// <param name="packageManifest"></param>
+		/// <returns></returns>
+		private static List<string> GetAllAssetPathsRecursively(PackageManifestConfig packageManifest)
+		{
+			var assetPaths = new List<string>();
+			var assetFolder = packageManifest.sourcePath;
+			// If any of the paths we're looking at match the ignore paths from the user, skip them
+			if (!packageManifest.packageIgnorePaths.Any(x =>
+				    Path.GetFullPath(Path.Combine(EditorConstants.ProjectPath, assetFolder))
+					    .Contains(Path.GetFullPath(Path.Combine(EditorConstants.ProjectPath, x)))))
+				assetPaths.AddRange(GetAllAssetPathsRecursively(assetFolder, packageManifest));
+
+			return assetPaths;
+		}
+
+		/// <summary>
+		/// Returns a list of relative Unity asset paths contained in <paramref name="assetFolder"/>
+		/// where each path begins with the Assets folder.
+		/// </summary>
+		/// <param name="assetFolder"></param>
+		/// <param name="packageManifest"></param>
+		/// <returns></returns>
+		private static List<string> GetAllAssetPathsRecursively(string assetFolder,
+			PackageManifestConfig packageManifest)
+		{
+			var assetPaths = new List<string>
+			{
+				assetFolder,
+				string.Format(EditorConstants.META_FORMAT, assetFolder)
+			};
+
+			var fullProjectPath = Path.GetFullPath(EditorConstants.ProjectPath);
+
+			var allFilesFullPaths = FileTools.GetAllFilesRecursively(assetFolder);
+			foreach (var fileFullPath in allFilesFullPaths)
+			{
+				// If any of the paths we're looking at match the ignore paths from the user, skip them
+				if (packageManifest.packageIgnorePaths.Any(x =>
+					    fileFullPath.Contains(Path.GetFullPath(Path.Combine(fullProjectPath, x)))))
+				{
+					continue;
+				}
+
+				var relativeAssetPath = fileFullPath.Replace(fullProjectPath, string.Empty);
+				assetPaths.Add(relativeAssetPath);
+			}
+
+			return assetPaths;
+		}
+	}
+}

package/Editor/Tools/UnityFileTools.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ff534982569146739f3f4656a968fb14
+timeCreated: 1560494658

package/Editor/Tools.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7ef519d9429340e3a5e6b8af5257ba1d
+timeCreated: 1554742284

package/Editor/Utils/PackageInitialize/PackageInitializeTemplates.cs

@@ -0,0 +1,171 @@
+using System;
+
+namespace Playdarium.PackageTool.Utils.PackageInitialize
+{
+	public static class PackageInitializeTemplates
+	{
+		public static string CreateChangelog(string homepage) => @$"# Changelog
+
+---
+
+## [v0.0.0]({homepage}/-/tags/v0.0.0)
+
+### Added
+
+- For new features.
+
+### Changed
+
+- For changes in existing functionality.
+
+### Deprecated
+
+- For soon-to-be removed features.
+
+### Removed
+
+- For now removed features.
+
+### Fixed
+
+- For any bug fixes.
+
+### Security
+
+- In case of vulnerabilities.
+";
+
+		public static string CreateReadme(
+			string authorName,
+			string scope,
+			string packageName,
+			string packageTitle,
+			string homepage,
+			string license
+		)
+		{
+			return $@"# {packageTitle}
+
+[![NPM package](https://img.shields.io/npm/v/{packageName}?logo=npm&logoColor=fff&label=NPM+package&color=limegreen)](https://www.npmjs.com/package/{packageName})
+[![License: {license}](https://img.shields.io/badge/License-{license.Replace(' ', '_')}-yellow.svg)](https://opensource.org/licenses/{license})
+
+## Installing
+
+Using the native Unity Package Manager introduced in 2017.2, you can add this library as a package by modifying your
+`manifest.json` file found at `/ProjectName/Packages/manifest.json` to include it as a dependency. See the example below
+on how to reference it.
+
+### Install via OpenUPM
+
+The package is available on the [npmjs](https://www.npmjs.com/package/{packageName}/)
+registry.
+
+#### Add registry scope
+
+```
+{{
+  ""dependencies"": {{
+    ...
+  }},
+  ""scopedRegistries"": [
+    {{
+      ""name"": ""{authorName}"",
+      ""url"": ""https://registry.npmjs.org"",
+      ""scopes"": [
+        ""{scope}""
+      ]
+    }}
+  ]
+}}
+```
+
+#### Add package in PackageManager
+
+Open `Window -> Package Manager` choose `Packages: My Regestries` and install package
+
+### Install via GIT URL
+
+```
+""{packageName}"": ""{homepage}.git#upm""
+```
+";
+		}
+
+		public static string CreateLicense(string authorName) => @$"MIT License
+
+Copyright (c) {DateTimeOffset.Now.Year} {authorName}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the ""Software""), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.";
+
+		public static string CiScript => @"
+##############################################################
+#                                                            #
+#   This file is auto generated by Playdarium.PackageTool    #
+#                                                            #
+##############################################################
+
+workflow:
+  rules:
+    - if: $CI_COMMIT_BRANCH =~ /^main$/
+      changes:
+        paths:
+          - 'Release/package.json'
+      when: always
+    - when: never
+
+stages:
+  - deploy
+
+deploy-npm:
+  stage: deploy
+  image: node:lts-alpine
+  before_script:
+    - |
+      export PACKAGE_VERSION=$(grep -o '""version"": ""[^""]*""' ./Release/package.json | awk -F'""' '{print $4}')
+      export GIT_URL=https://$GITLAB_USER_NAME:$GITLAB_TOKEN@$CI_SERVER_HOST/$CI_PROJECT_PATH.git
+    - apk update
+    - apk add git
+    - git config --global user.name ""$GITLAB_USER_NAME""
+    - git config --global user.email ""$GITLAB_USER_EMAIL""
+    - git clone -b upm $GIT_URL ./upm-package
+  script:
+    - echo ""Create package version $PACKAGE_VERSION""
+    - cd ./upm-package
+    - git rm -r *
+    - git rm .gitlab-ci.yml || true
+    - git rm -rf .idea || true
+    - cp -r ../Release/* .
+    - git add .
+    - git commit -m ""[$PACKAGE_VERSION] GitLab CI auto package publish""
+    - git push $GIT_URL upm
+    - cd ..
+
+    - echo ""Push tag v$PACKAGE_VERSION""
+    - git tag -a v$PACKAGE_VERSION -m 'GitLab CI auto tag publish'
+    - git push --tags $GIT_URL
+
+    - echo ""Publish to NPM""
+    - cd ./upm-package
+    - echo ""registry=https://registry.npmjs.org/"" >> "".npmrc""
+    - echo ""//registry.npmjs.org/:_authToken=$NPM_TOKEN"" >> "".npmrc""
+    - npm publish
+
+";
+	}
+}

package/Editor/Utils/PackageInitialize/PackageInitializeTemplates.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: dc1786a472dc49208ba3feaaf186a2ea
+timeCreated: 1662377271

package/Editor/Utils/PackageInitialize/PackageInitializeUtil.cs

@@ -0,0 +1,111 @@
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace Playdarium.PackageTool.Utils.PackageInitialize
+{
+	public static class PackageInitializeUtil
+	{
+		public const string ASSETS_FOLDER_NAME = "Assets";
+		public const string RELEASE_FOLDER_NAME = "Release";
+
+		private const string DOCUMENTATION_FOLDER_NAME = "Documentation~";
+
+		private const string PACKAGE_MANIFEST_FOLDER_NAME = "PackageManifest";
+		private const string PACKAGE_MANIFEST_CONFIG_FILE_NAME = "PackageManifestConfig.asset";
+
+		private const string README_FILE_NAME = "README.md";
+		private const string CHANGELOG_FILE_NAME = "CHANGELOG.md";
+		private const string LICENSE_FILE_NAME = "LICENSE";
+
+		private const string CI_FILE_PATH = "./";
+		private const string CI_FILE_NAME = ".gitlab-ci.yml";
+
+		private static readonly string AssetPath = Application.dataPath;
+
+		private static readonly string ProjectPath = Application.dataPath
+			.Replace(ASSETS_FOLDER_NAME, string.Empty)
+			.TrimEnd('\\', '/');
+
+		public static void Init(string scope, PackageManifestConfig config)
+		{
+			config.sourcePath = Path.Combine(ASSETS_FOLDER_NAME, config.author.name);
+
+			CreateFolderInProject(config.sourcePath);
+			CreateFolderInProject(DOCUMENTATION_FOLDER_NAME);
+			CreateFolderInProject(config.packageDestinationPath);
+
+			CreatePackageManifestConfig(config);
+			CreateFileAtPath(
+				ProjectPath,
+				README_FILE_NAME,
+				PackageInitializeTemplates.CreateReadme(config.author.name, scope, config.packageName,
+					config.displayName, config.homepage, config.license)
+			);
+			CreateFileAtPath(ProjectPath, CHANGELOG_FILE_NAME,
+				PackageInitializeTemplates.CreateChangelog(config.homepage));
+			CreateFileAtPath(ProjectPath, LICENSE_FILE_NAME,
+				PackageInitializeTemplates.CreateLicense(config.author.name));
+			CreateFileAtPath(Path.Combine(ProjectPath, CI_FILE_PATH), CI_FILE_NAME,
+				PackageInitializeTemplates.CiScript);
+
+			AssetDatabase.Refresh();
+		}
+
+		private static void CreatePackageManifestConfig(PackageManifestConfig config)
+		{
+			var packageConfigPath = Path.Combine(Application.dataPath, PACKAGE_MANIFEST_FOLDER_NAME);
+			if (!Directory.Exists(packageConfigPath))
+				Directory.CreateDirectory(packageConfigPath);
+
+			var configPath = Path.Combine("Assets", PACKAGE_MANIFEST_FOLDER_NAME, PACKAGE_MANIFEST_CONFIG_FILE_NAME);
+			var asset = AssetDatabase.LoadAssetAtPath<PackageManifestConfig>(configPath);
+			if (asset != null)
+			{
+				Debug.Log(
+					$"[{nameof(PackageInitializeUtil)}] {nameof(PackageManifestConfig)} already exist at path '{configPath}'");
+				return;
+			}
+
+			AssetDatabase.CreateAsset(config, configPath);
+			AssetDatabase.SaveAssets();
+		}
+
+		public static void CreateFileAtPath(
+			string path,
+			string fileName,
+			string content
+		)
+		{
+			var filePath = Path.Combine(path, fileName);
+			if (File.Exists(filePath))
+			{
+				Debug.Log($"[{nameof(PackageInitializeUtil)}] File already exist '{filePath}'");
+				return;
+			}
+
+			if (!Directory.Exists(path))
+				Directory.CreateDirectory(path);
+
+			File.WriteAllText(filePath, content);
+		}
+
+		public static void CreateFolderInProject(string directoryPath)
+		{
+			var dir = Path.Combine(ProjectPath, directoryPath);
+			if (Directory.Exists(dir))
+				return;
+
+			Directory.CreateDirectory(dir);
+		}
+
+		public static void CreateFolderInAssets(string directoryPath)
+		{
+			var dir = Path.Combine(AssetPath, directoryPath);
+			if (Directory.Exists(dir))
+				return;
+
+			Directory.CreateDirectory(dir);
+		}
+	}
+}

package/Editor/Utils/PackageInitialize/PackageInitializeUtil.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4fd7b5f54fc14974aa908bb1a0e20d02
+timeCreated: 1662377046