com.robotsquid.squidhub 0.5.5 → 0.5.6

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.5.6
+
+⚠️ **Fixes an upload that did nothing and said nothing.** `SquidHub → Upload
+Build…` in 0.5.5 ran, reported no error, and uploaded no files.
+
+`yield return SomeOtherIEnumerator()` requires the coroutine driver to DESCEND
+into the nested routine. Unity's own runner does; the hand-rolled one here did
+not — it treated the nested iterator as an ordinary yielded value, discarded it,
+and carried on. So the request that starts a build never executed, the response
+stayed null, and the routine exited quietly on a null check.
+
+The driver is now `SquidHubPump`, which has no `UnityEditor` dependency and is
+unit-tested for exactly that nesting rule, three levels deep. The JSON field
+reader moved into the tested file too, since a null that looks like an answer is
+the same failure in a different costume, and the run now logs what it is doing
+so a silent no-op cannot recur.
+
 ## 0.5.5
 
 **Upload a build straight from Unity.** `SquidHub → Upload Build…` picks the

package/Editor/SquidHubBuildScan.cs

@@ -141,6 +141,29 @@ namespace SquidHub.Editor
             return "[" + string.Join(",", parts) + "]";
         }
 
+        /// <summary>
+        /// Reads one flat field out of a JSON response.
+        ///
+        /// ⚠️ A regex, not a parser, and deliberately only for the handful of
+        /// flat fields this flow reads. Shipping a parser in a package that
+        /// already asks the project to bring its own would be a second, worse
+        /// one to maintain.
+        ///
+        /// ⚠️ Returns null when absent, and the caller must treat that as a
+        /// failure rather than a value. Every silent no-op in this uploader has
+        /// come from a null that looked like an answer.
+        /// </summary>
+        public static string JsonField(string json, string name)
+        {
+            if (string.IsNullOrEmpty(json)) return null;
+            var match = System.Text.RegularExpressions.Regex.Match(
+                json,
+                "\"" + System.Text.RegularExpressions.Regex.Escape(name) +
+                    "\"\\s*:\\s*(?:\"([^\"]*)\"|(true|false|-?[0-9.]+))");
+            if (!match.Success) return null;
+            return match.Groups[1].Success ? match.Groups[1].Value : match.Groups[2].Value;
+        }
+
         internal static string JsonString(string value)
         {
             var sb = new System.Text.StringBuilder("\"");

package/Editor/SquidHubPump.cs

@@ -0,0 +1,53 @@
+// Running a coroutine outside a Unity player loop.
+//
+// ⚠️ Pure System.* — no UnityEditor — so the nesting rule below is covered by
+// tests under plain dotnet. It exists because getting this wrong produced a
+// completely silent failure: the upload menu item ran, reported nothing, and
+// uploaded nothing.
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace SquidHub.Editor
+{
+    /// <summary>
+    /// A coroutine driver that understands NESTED iterators.
+    ///
+    /// ⚠️ `yield return SomeOtherIEnumerator()` is the whole reason this is not
+    /// three lines. Unity's own runner descends into a yielded IEnumerator and
+    /// runs it to completion before resuming the parent. A naive driver that
+    /// only calls MoveNext() on the outer routine treats the nested one as an
+    /// ordinary value, discards it, and carries straight on — so the nested work
+    /// NEVER RUNS and nothing anywhere reports a problem.
+    /// </summary>
+    internal sealed class SquidHubPump
+    {
+        private readonly Stack<IEnumerator> _stack = new Stack<IEnumerator>();
+
+        public SquidHubPump(IEnumerator routine)
+        {
+            _stack.Push(routine);
+        }
+
+        public bool Done => _stack.Count == 0;
+
+        /// <summary>Advances by one step. Returns false once everything has finished.</summary>
+        public bool Step()
+        {
+            if (_stack.Count == 0) return false;
+
+            var current = _stack.Peek();
+            if (!current.MoveNext())
+            {
+                // ⚠️ Pop and return true, not false. The PARENT still has work
+                // left; reporting "done" because a child finished would abandon
+                // the rest of the upload silently.
+                _stack.Pop();
+                return _stack.Count > 0;
+            }
+
+            if (current.Current is IEnumerator nested) _stack.Push(nested);
+            return true;
+        }
+    }
+}

package/Editor/SquidHubPump.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4950b7b2580a1a30f9940f07fe016efc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/SquidHubUploader.cs

@@ -21,7 +21,7 @@ namespace SquidHub.Editor
 {
     internal static class SquidHubUploader
     {
-        private static IEnumerator _routine;
+        private static SquidHubPump _pump;
 
         [MenuItem("SquidHub/Upload Build…", priority = 11)]
         private static void UploadBuild()
@@ -79,9 +79,14 @@ namespace SquidHub.Editor
         // ⚠️ Driven by EditorApplication.update rather than blocking. Sleeping
         // the main thread would stop UnityWebRequest progressing at all, and the
         // Editor would appear to hang for the length of the upload.
+        //
+        // ⚠️ SquidHubPump, not a bare MoveNext(). `yield return SomeIEnumerator()`
+        // must DESCEND into the nested routine — a driver that does not simply
+        // discards it and carries on, which made the entire upload run, report
+        // nothing and do nothing. That nesting rule is unit-tested.
         private static void Run(IEnumerator routine)
         {
-            _routine = routine;
+            _pump = new SquidHubPump(routine);
             EditorApplication.update -= Pump;
             EditorApplication.update += Pump;
         }
@@ -90,16 +95,18 @@ namespace SquidHub.Editor
         {
             try
             {
-                if (_routine != null && _routine.MoveNext()) return;
+                if (_pump != null && _pump.Step()) return;
             }
             catch (Exception e)
             {
                 EditorUtility.ClearProgressBar();
                 Debug.LogError("[SquidHub] upload failed: " + e);
+                EditorUtility.DisplayDialog("SquidHub — upload failed", e.Message, "OK");
             }
-            _routine = null;
+            _pump = null;
             EditorApplication.update -= Pump;
             EditorUtility.ClearProgressBar();
+            Debug.Log("[SquidHub] upload run finished.");
         }
 
         private static IEnumerator Upload(BuildScan scan)
@@ -107,24 +114,31 @@ namespace SquidHub.Editor
             var endpoint = SquidHubUploadSettings.Endpoint;
             var key = SquidHubUploadSettings.Key;
 
+            Debug.Log($"[SquidHub] uploading {scan.Files.Count} file(s) to {endpoint}");
             EditorUtility.DisplayProgressBar("SquidHub", "Registering build…", 0f);
 
             var startBody = "{\"intent\":\"start\",\"files\":" + SquidHubBuildScan.FilesJson(scan.Files) + "}";
             string startResponse = null;
             yield return Post(endpoint + "/api/ingest", key, startBody, r => startResponse = r);
 
-            if (startResponse == null) yield break;
+            // ⚠️ Post reports its own failure and leaves this null. Returning
+            // quietly here is what made a failed start look like success.
+            if (startResponse == null)
+            {
+                Debug.LogError("[SquidHub] the start request returned nothing — upload abandoned.");
+                yield break;
+            }
 
-            if (Field(startResponse, "alreadyPublished") == "true")
+            if (SquidHubBuildScan.JsonField(startResponse, "alreadyPublished") == "true")
             {
                 EditorUtility.ClearProgressBar();
                 EditorUtility.DisplayDialog("SquidHub",
-                    "These exact bytes are already published as " + Field(startResponse, "buildHash") +
+                    "These exact bytes are already published as " + SquidHubBuildScan.JsonField(startResponse, "buildHash") +
                     ". Nothing to upload.", "OK");
                 yield break;
             }
 
-            var jobId = Field(startResponse, "jobId");
+            var jobId = SquidHubBuildScan.JsonField(startResponse, "jobId");
             if (string.IsNullOrEmpty(jobId))
             {
                 Fail("The server did not start a build job", startResponse);
@@ -167,7 +181,7 @@ namespace SquidHub.Editor
             EditorUtility.ClearProgressBar();
             if (doneResponse == null) yield break;
 
-            if (Field(doneResponse, "ok") != "true")
+            if (SquidHubBuildScan.JsonField(doneResponse, "ok") != "true")
             {
                 Fail("The server refused the build", doneResponse);
                 yield break;
@@ -177,7 +191,7 @@ namespace SquidHub.Editor
             // deliberate act in the console — saying "uploaded" without saying
             // that invites someone to assume their players already have it.
             EditorUtility.DisplayDialog("SquidHub",
-                "Registered " + Field(doneResponse, "buildHash") + ".\n\n" +
+                "Registered " + SquidHubBuildScan.JsonField(doneResponse, "buildHash") + ".\n\n" +
                 "It is not live yet — promote it in the publisher console when you are ready.",
                 "OK");
         }
@@ -214,18 +228,5 @@ namespace SquidHub.Editor
             EditorUtility.DisplayDialog("SquidHub — " + title, detail, "OK");
         }
 
-        /// <summary>
-        /// ⚠️ A regex, not a JSON parser, and only for the four flat fields this
-        /// flow reads. Shipping a parser in a package that already asks the
-        /// project to bring its own would be a second, worse one to maintain.
-        /// </summary>
-        private static string Field(string json, string name)
-        {
-            var match = Regex.Match(json, "\"" + Regex.Escape(name) + "\"\\s*:\\s*(\"([^\"]*)\"|true|false|[0-9]+)");
-            if (!match.Success) return null;
-            return match.Groups[2].Success && match.Value.Contains("\"" + match.Groups[2].Value + "\"")
-                ? match.Groups[2].Value
-                : match.Groups[1].Value;
-        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.robotsquid.squidhub",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "displayName": "SquidHub",
   "description": "Cloud saves, analytics and the coin economy for Unity WebGL games published on SquidHub. Installs the C# wrapper, the .jslib half and the page bridge, and rewrites the exported index.html so it survives the platform's CSP.",
   "unity": "2021.3",