Release CI (#1195)

* Revert "automated duplicating imported samples modifications (#595)"

This reverts commit a555894.

* made main package testable, revert due to a mistake

* initial commit to test CI

* path updated

* path updated for linux

* Packages version changes implemented

* Program renamed to Setup

* checkpoint before testing git

* git push added

* proper logging

* more log check

* more log test

* powershell added

* added missing command line argument

* reverted to run with bash

* removed powershell package

* exception support

* configure and push added

* deploy key added for push

* bad substitution fix

* github env vars setup

* checkpoint

* tags and dependency version changes

* manual workflow and release added

* release version from input

* cool-er title for release workflow

* Ignore serialization only, on some Package properties

* removed unused using statement

* documentation added

---------

Co-authored-by: robGG1997 <[email protected]>

Author: rob1997

.github/workflows/release.yaml

@@ -0,0 +1,48 @@
+name: Release ⬆️
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to Release'
+        required: true
+      release_notes:
+        description: 'Version Release Notes'
+        required: true
+
+env:
+  git_email: "${{ github.actor }}@users.noreply.github.com"
+  git_actor: "${{ github.actor }}"
+
+jobs:
+  setup:
+    name: Setup job
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          lfs: true
+          ssh-key: ${{ secrets.DEPLOY_KEY }}
+          
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 8.0.x
+
+      - name: Run
+        run: |
+          cd Setup
+          dotnet run -release:${{ github.event.inputs.version }} Setup/Setup.csproj
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.event.inputs.version }}
+          release_name: Release ${{ github.event.inputs.version }}
+          body: |
+            ${{ github.event.inputs.release_notes }}
+          draft: false
+          prerelease: false

Setup/Git.cs

@@ -0,0 +1,73 @@
+using Setup.Utils;
+
+namespace Setup;
+
+/// <summary>
+/// Git helper class.
+/// </summary>
+public static class Git
+{
+    private static bool _configured;
+    
+    public static void Add(string path)
+    {
+        $"git add \"{path}\" -f".RunWithBash();
+    }
+    
+    public static void Commit(string message, string[] tags = null)
+    {
+        if (!_configured)
+        {
+            Configure();
+        }
+        
+        $"git commit -m \"{message} [skip ci]\"".RunWithBash();
+
+        if (tags != null)
+        {
+            foreach (var tag in tags)
+            {
+                if (!string.IsNullOrEmpty(tag))
+                {
+                    Tag(tag);
+                }
+            }
+        }
+    }
+    
+    public static void Push(string[] tags = null)
+    {
+        "git push -f".RunWithBash();
+
+        if (tags != null)
+        {
+            foreach (string tag in tags)
+            {
+                if (!string.IsNullOrEmpty(tag))
+                {
+                    $"git push origin \"{tag}\"".RunWithBash();
+                }
+            }
+        }
+    }
+
+    public static void CommitAndPush(string message, string[] tags = null)
+    {
+        Commit(message, tags);
+        
+        Push(tags);
+    }
+    
+    public static void Tag(string tag)
+    {
+        $"git tag \"{tag}\"".RunWithBash();
+    }
+    
+    private static void Configure()
+    {
+        "git config user.email $git_email".RunWithBash();
+        "git config user.name $git_actor".RunWithBash();
+
+        _configured = true;
+    }
+}

Setup/Package.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Setup.Utils;
+
+namespace Setup
+{
+    /// <summary>
+    /// Unity package.json model for UPM.
+    /// https://docs.unity3d.com/Manual/upm-manifestPkg.html.
+    /// </summary>
+    public class Package
+    {
+        /// <summary>
+        /// Path of package from root of repository.
+        /// </summary>
+        [JsonIgnore]
+        public string Path { get; private set; }
+
+        [JsonProperty("name"), JsonIgnoreSerialization]
+        public string Name { get; private set; }
+        
+        [JsonProperty("version")]
+        public string Version { get; private set; }
+    
+        [JsonProperty("dependencies", NullValueHandling = NullValueHandling.Ignore)]
+        public Dictionary<string, string> Dependencies { get; private set; }
+
+        [JsonProperty("testables", NullValueHandling = NullValueHandling.Ignore), JsonIgnoreSerialization]
+        public string[] Testables { get; private set; }
+    
+        [JsonProperty("samples", NullValueHandling = NullValueHandling.Ignore), JsonIgnoreSerialization]
+        public Sample[] Samples { get; private set; }
+
+        // For Json Deserialize.
+        public Package()
+        {
+            
+        }
+        
+        public Package(string path)
+        {
+            Path = path;
+        }
+
+        /// <summary>
+        /// Sets Package Version.
+        /// </summary>
+        /// <param name="version">Version string.</param>
+        /// <exception cref="Exception">Exception thrown if version format doesn't match guidelines https://semver.org/.</exception>
+        public void SetVersion(string version)
+        {
+            string[] increments = version.Split('.');
+            
+            if (increments.Length != 3
+                || !increments.Any(i => int.TryParse(i, out _)
+                                        || int.Parse(i) < 0
+                                        || int.Parse(i) > 9))
+            {
+                throw new Exception("Incorrect Version Format https://semver.org/");
+            }
+            
+            Version = version;
+
+            string[] keys = Dependencies.Where(d => Setup.Packages.Any(p => p.Name == d.Key))
+                .Select(d => d.Key)
+                .ToArray();
+
+            foreach (string key in keys)
+            {
+                Dependencies[key] = version;
+            }
+        }
+
+        /// <summary>
+        /// Save altered package to <see cref="Path"/>.
+        /// </summary>
+        public void Save()
+        {
+            string json = File.ReadAllText(Path);
+            
+            JObject jObject = JObject.Parse(json);
+
+            jObject.Merge(
+                JObject.Parse(JsonConvert.SerializeObject(this,
+                    new JsonSerializerSettings { ContractResolver = new JsonPropertiesResolver() })),
+                new JsonMergeSettings { MergeArrayHandling = MergeArrayHandling.Merge });
+            
+            File.WriteAllText(Path, jObject.ToString(Formatting.Indented));
+        }
+    }
+
+    public struct Sample
+    {
+        [JsonProperty("path")]
+        public string Path { get; private set; }
+    }
+}

Setup/Release.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+
+namespace Setup;
+
+/// <summary>
+/// Release.
+/// </summary>
+public class Release
+{
+    private readonly Package[] _packages;
+    
+    private readonly string _version;
+    
+    public Release(string version)
+    {
+        _packages = Setup.Packages.ToArray();
+
+        _version = version;
+    }
+    
+    /// <summary>
+    /// Bumps the version and makes a release.
+    /// Commit and push with package.json versions bumped.
+    /// Tag the commits so another CI (open-upm) can pick them up.
+    /// </summary>
+    public void Run()
+    {
+        List<string> tags = new List<string>();
+
+        tags.Add(_version);
+        
+        foreach (Package package in _packages)
+        {
+            package.SetVersion(_version);
+
+            package.Save();
+            
+            Git.Add(package.Path);
+            
+            tags.Add($"{package.Name}/{_version}");
+        }
+        
+        Git.CommitAndPush($"Release {_version}", tags.ToArray());
+    }
+}

Setup/Setup.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using System.IO;
+using Newtonsoft.Json;
+
+namespace Setup
+{
+    internal class Setup
+    {
+        public static readonly List<Package> Packages = new List<Package>();
+        
+        // dotnet run -release:3.0.0 -duplicate_samples -publish_dependencies;
+        static void Main(string[] args)
+        {
+            // Initialize packages from file.
+            string json = File.ReadAllText("packages.json");
+
+            string[] paths = JsonConvert.DeserializeObject<string[]>(json);
+
+            for (int i = 0; i < paths.Length; i++)
+            {
+                string path = $"../{paths[i]}";
+                
+                Package package = new Package(path);
+                
+                JsonConvert.PopulateObject(File.ReadAllText(path), package);
+                
+                Packages.Add(package);
+            }
+            
+            // Parse arguments and Run operations based on that.
+            // TODO: use runnable and runner to run multiple operations sort orders.
+            foreach (var arg in args)
+            {
+                switch (arg)
+                {
+                    case not null when arg.StartsWith("-release"):
+                        
+                        string version = arg.Split(":")[1];
+                        
+                        Release release = new Release(version);
+                        
+                        release.Run();
+                        
+                        break;
+                }
+            }
+        }
+    }
+}

Setup/Setup.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <OutputType>Exe</OutputType>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    </ItemGroup>
+
+</Project>

Setup/Setup.sln

@@ -0,0 +1,16 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Setup", "Setup.csproj", "{9EE36F23-7E56-4398-B7DE-E683097CE49F}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9EE36F23-7E56-4398-B7DE-E683097CE49F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9EE36F23-7E56-4398-B7DE-E683097CE49F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9EE36F23-7E56-4398-B7DE-E683097CE49F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9EE36F23-7E56-4398-B7DE-E683097CE49F}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

Setup/Utils/JsonIgnoreSerializationAttribute.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Setup.Utils;
+
+/// <summary>
+/// Fir ignoring serialization of a property.
+/// Deserialization still works.
+/// </summary>
+[AttributeUsage(AttributeTargets.Property)]
+public class JsonIgnoreSerializationAttribute : Attribute
+{
+    
+}

Setup/Utils/JsonPropertiesResolver.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Newtonsoft.Json.Serialization;
+
+namespace Setup.Utils;
+
+/// <summary>
+/// Resolver for custom serialization.
+/// </summary>
+public class JsonPropertiesResolver : DefaultContractResolver
+{
+    protected override List<MemberInfo> GetSerializableMembers(Type objectType)
+    {
+        //Return properties that do NOT have the JsonIgnoreSerializationAttribute
+        return objectType.GetProperties()
+            .Where(pi => !Attribute.IsDefined(pi, typeof(JsonIgnoreSerializationAttribute)))
+            .ToList<MemberInfo>();
+    }
+}