public void Draw(PackageManifest manifest)
{
manifest.author.name = EditorGUILayout.TextField("Author organization: ", manifest.author.name);
manifest.author.email = EditorGUILayout.TextField("Author email: ", manifest.author.email);
manifest.author.url = EditorGUILayout.TextField("Author website: ", manifest.author.url);
string selectedLicense = licenseList[licenseIndex];
if (selectedLicense != manifest.license)
{
licenseIndex = Array.FindIndex(licenseList, x => x == manifest.license);
}
licenseIndex = EditorGUILayout.Popup("License: ", licenseIndex, licenseList);
manifest.repository.url = EditorGUILayout.TextField("GIT repository: ", manifest.repository.url);
EditorGUILayout.LabelField("Publication configuration");
manifest.publishConfig.registry = registrySelector.SelectRegistry("\t", manifest.publishConfig.registry);
// Set fields in manifest
manifest.license = licenseList[licenseIndex];
}
private static void OpenPackage()
{
PackageManifest manifest = HalodiPackageCreatorController.GetPackageManifest(Selection.activeObject, false);
if (manifest != null)
{
EditorUtility.RevealInFinder(Path.Combine(manifest.info.assetPath, Paths.PackageManifest));
}
}
private static void PublishPackageMenu()
{
PackageManifest manifest = HalodiPackageCreatorController.GetPackageManifest(Selection.activeObject, true);
if (manifest != null)
{
PublicationView.PublishPackages(manifest.info);
}
}
internal static void EmptySamplesDirectory(PackageManifest manifest)
{
DirectoryInfo SamplesDirectory = new DirectoryInfo(Path.Combine(HalodiPackageCreatorController.GetPackageDirectory(manifest), Paths.PackageSamplesFolder));
if (SamplesDirectory.Exists)
{
SamplesDirectory.Delete(true);
}
}
private static void EmbedPackageMenu()
{
PackageManifest manifest = HalodiPackageCreatorController.GetPackageManifest(Selection.activeObject, false);
if (manifest != null)
{
EmbedPackage(manifest);
}
}
private static string CreateLicense(PackageManifest manifest)
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("# License");
builder.AppendLine();
builder.Append("Copyright (C) "); builder.AppendLine(DateTime.Now.ToString("yyyy"));
builder.AppendLine();
builder.Append(manifest.displayName); builder.AppendLine(" can not be copied and/or distributed without the express permission of the author(s).");
return builder.ToString();
}
internal static void CopySamples(PackageManifest manifest)
{
string AssetSampleDirectory = HalodiPackageCreatorController.GetAssetsSampleDirectory(manifest);
if (Directory.Exists(AssetSampleDirectory))
{
EmptySamplesDirectory(manifest);
string SamplesDirectory = Path.Combine(HalodiPackageCreatorController.GetPackageDirectory(manifest), Paths.PackageSamplesFolder);
AssetDatabaseUtilities.CopyDirectory(HalodiPackageCreatorController.GetAssetsSampleDirectory(manifest), SamplesDirectory, true);
}
}
public PublicationPackageView(PackageManifest package)
{
this.publish = false;
this.package = package;
this.RegistrySelector = new RegistrySelector();
if (package.publishConfig != null && !string.IsNullOrEmpty(package.publishConfig.registry))
{
this.registry = package.publishConfig.registry;
}
}
private static string CreateReadme(PackageManifest manifest)
{
StringBuilder builder = new StringBuilder();
builder.Append("# "); builder.AppendLine(manifest.displayName);
builder.AppendLine();
builder.AppendLine(manifest.description);
return builder.ToString();
}
internal static void EmbedPackage(PackageManifest package)
{
if (package.IsEmbedded)
{
Debug.LogWarning("Cannot embed already embedded package");
}
else
{
EmbedPackageView embedView = EditorWindow.GetWindow <EmbedPackageView>(true, "Embed package", true);
embedView.manifest = package;
}
}
private static bool PublishPackageMenuValidation()
{
PackageManifest manifest = HalodiPackageCreatorController.GetPackageManifest(Selection.activeObject, true);
if (manifest != null)
{
return(manifest.info.source == UnityEditor.PackageManager.PackageSource.Embedded);
}
else
{
return(false);
}
}
private static string CreateChangelog(PackageManifest manifest)
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("# ChangeLog");
builder.AppendLine();
builder.AppendLine();
builder.Append("## "); builder.Append(manifest.version); builder.Append(" - "); builder.AppendLine(DateTime.Now.ToString("yyyy-MM-dd"));
builder.Append("- Package created");
return builder.ToString();
}
private static void EmbedPackageProgress(System.Diagnostics.Process process, PackageManifest manifest)
{
if (process.HasExited)
{
EditorUtility.ClearProgressBar();
Debug.Log("Git clone finished with exit code " + process.ExitCode);
process.Dispose();
}
else
{
EditorUtility.DisplayProgressBar("Cloning " + manifest.name, "Cloning " + manifest.name, 0.5f);
EditorApplication.delayCall += () => EmbedPackageProgress(process, manifest);
}
}
internal static void Publish(PackageManifest manifest, string registry)
{
try
{
CopySamples(manifest);
manifest.OnAfterDeserialize();
string PackageFolder = Path.Combine(AssetDatabaseUtilities.GetRelativeToProjectRoot(Paths.PackagesFolder), manifest.package_name);
NPMPublish.Publish(PackageFolder, registry);
}
finally
{
EmptySamplesDirectory(manifest);
}
}
internal void Store(PackageManifest manifest)
{
JObject manifestJSON = JObject.Parse(HalodiPackageCreatorController.GetPackageManifestObject(manifest).text);
JObject author = new JObject(
new JProperty("name", manifest.author.name),
new JProperty("email", manifest.author.email),
new JProperty("url", manifest.author.url));
manifestJSON["author"] = author;
manifestJSON["license"] = manifest.license;
JObject publicationConfig = new JObject(
new JProperty("registry", manifest.publishConfig.registry)
);
manifestJSON["publishConfig"] = publicationConfig;
if (string.IsNullOrWhiteSpace(manifest.repository.url))
{
manifest.repository.type = "";
}
else
{
manifest.repository.type = "git";
}
JObject repo = new JObject(
new JProperty("type", manifest.repository.type),
new JProperty("url", manifest.repository.url)
);
manifestJSON["repository"] = repo;
AssetDatabaseUtilities.CreateTextFile(manifestJSON.ToString(), HalodiPackageCreatorController.GetPackageDirectory(manifest), Paths.PackageManifest);
AssetDatabaseUtilities.UpdateAssetDatabase();
}
internal static void CreatePackage(PackageManifest manifest)
{
manifest.OnBeforeSerialize();
try
{
AssetDatabase.StartAssetEditing();
string PackageFolderName = manifest.package_name;
string packageFolder = AssetDatabaseUtilities.CreateFolder(AssetDatabaseUtilities.GetRelativeToProjectRoot(Paths.PackagesFolder), PackageFolderName);
AssemblyDefinition runtime = AssetDatabaseUtilities.CreateAssemblyFolder(packageFolder, Paths.RuntimeFolder, manifest.name, false, false, null);
AssemblyDefinition editor = AssetDatabaseUtilities.CreateAssemblyFolder(packageFolder, Paths.EditorFolder, manifest.name, false, true, new List <string> {
runtime.name
});
string testFolder = AssetDatabaseUtilities.CreateFolder(packageFolder, Paths.TestFolder);
AssemblyDefinition runtimeTests = AssetDatabaseUtilities.CreateAssemblyFolder(testFolder, Paths.RuntimeFolder, manifest.name, true, false, new List <string> {
runtime.name
});
AssetDatabaseUtilities.CreateAssemblyFolder(testFolder, Paths.EditorFolder, manifest.name, true, true, new List <string> {
runtime.name, editor.name
});
AssetDatabaseUtilities.CreateJSONFile(manifest, packageFolder, Paths.PackageManifest);
AssetDatabaseUtilities.CreateTextFile(CreateReadme(manifest), packageFolder, Paths.Readme);
AssetDatabaseUtilities.CreateTextFile(CreateLicense(manifest), packageFolder, Paths.License);
AssetDatabaseUtilities.CreateTextFile(CreateChangelog(manifest), packageFolder, Paths.Changelog);
}
finally
{
AssetDatabase.StopAssetEditing();
AssetDatabaseUtilities.UpdateAssetDatabase();
}
}
internal static void AddSample(PackageManifest manifest, PackageManifest.Sample sample)
{
string assetDirectory = GetAssetDirectory(manifest);
string samplesDirectory = GetAssetsSampleDirectory(manifest);
if (!sample.path.StartsWith(Paths.PackageSamplesFolder + "/"))
{
throw new System.Exception("Invalid sample directory");
}
Directory.CreateDirectory(samplesDirectory);
string sampleFolderName = sample.path.Substring(Paths.PackageSamplesFolder.Length + 1);
string sampleFolder = Path.Combine(samplesDirectory, sampleFolderName);
Directory.CreateDirectory(sampleFolder);
CreateGitKeep.Create(sampleFolder);
JObject manifestJSON = JObject.Parse(GetPackageManifestObject(manifest).text);
var samplesJSON = (JArray)manifestJSON["samples"];
JObject next = new JObject(
new JProperty("displayName", sample.displayName),
new JProperty("description", sample.description),
new JProperty("path", sample.path));
samplesJSON.Add(next);
AssetDatabaseUtilities.CreateTextFile(manifestJSON.ToString(), GetPackageDirectory(manifest), Paths.PackageManifest);
AssetDatabaseUtilities.UpdateAssetDatabase();
}
internal static void EmbedPackageFromGit(PackageManifest manifest)
{
string targetDirectory = Path.Combine(AssetDatabaseUtilities.GetRelativeToProjectRoot(Paths.PackagesFolder), manifest.package_name);
if (File.Exists(targetDirectory))
{
Debug.LogWarning("Package directory " + targetDirectory + " already exists");
return;
}
string gitCommand = "clone \"" + manifest.repository.url + "\"" + " " + "\"" + targetDirectory + "\"";
try
{
System.Diagnostics.Process process = new System.Diagnostics.Process();
process.StartInfo.UseShellExecute = false;
process.StartInfo.FileName = "git";
process.StartInfo.Arguments = gitCommand;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.OutputDataReceived += StdOut;
process.ErrorDataReceived += StdErr;
process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();
EditorApplication.delayCall += () => EmbedPackageProgress(process, manifest);
}
catch (Exception e)
{
Debug.Log("Cannot find git executable: " + e.Message);
}
}
internal static void EditPackage(PackageManifest package)
{
HalodiEditPackageView editView = EditorWindow.GetWindow <HalodiEditPackageView>(true, "Edit package", true);
editView.manifest = package;
}
private void SelectPackage(PackageManifest package)
{
UnityEngine.Object instance = HalodiPackageCreatorController.GetPackageManifestObject(package);
Selection.activeObject = instance;
CloseWindow();
}
private void EditPackage(PackageManifest package)
{
HalodiEditPackageView.EditPackage(package);
SelectPackage(package);
}
private void AddSample(PackageManifest package)
{
HalodiAddSampleView.AddSample(package);
CloseWindow();
}
internal static string GetAssetsSampleDirectory(PackageManifest manifest)
{
return(Path.Combine(GetAssetDirectory(manifest), Paths.AssetsSamplesFolder));
}
internal static string GetPackageDirectory(PackageManifest manifest)
{
return(manifest.filesystem_location);
}
public static void AddSample(PackageManifest package)
{
HalodiAddSampleView addSampleView = EditorWindow.GetWindow <HalodiAddSampleView>(true, "Add sample", true);
addSampleView.manifest = package;
}
void OnDisable()
{
manifest = null;
}
private void Pack(PackageManifest package)
{
PublicationController.Pack(package);
}
void OnEnable()
{
extendedUI = new ExtendedPackagePropertiesUI();
manifest = new PackageManifest();
}
void OnEnable()
{
manifest = new PackageManifest();
registrySelector = new RegistrySelector();
licenseList = SPDXLicenseList.Load().ToStringArray();
}
private static bool OpenPackageValidation()
{
PackageManifest manifest = HalodiPackageCreatorController.GetPackageManifest(Selection.activeObject, false);
return(manifest != null);
}
