com.robotsquid.squidhub 0.5.6 → 0.5.7

package/Editor/SquidHubJson.cs

@@ -0,0 +1,346 @@
+// A tiny ordered JSON document model.
+//
+// ⚠️ It exists because the manifest editor must PRESERVE KEYS IT DOES NOT
+// MODEL. A manifest may carry `skus`, `achievements` and `rewardTable` — none
+// of which this package understands — and round-tripping through a typed model
+// (Unity's JsonUtility included) drops every field the type does not declare.
+// The publisher would discover that when their catalogue emptied, one release
+// after the edit that did it.
+//
+// ⚠️ Member ORDER is preserved, and numbers keep their original text. A dialog
+// that rewrites `"saveSchemaVersion": 1` as `1.0`, or reshuffles a hand-authored
+// file, produces a diff nobody can review — and this file is committed.
+//
+// ⚠️ Pure System.* — no UnityEditor, no UnityEngine. Unit-tested under plain
+// `dotnet` in tools/test, the same rule SquidHubHtml and SquidHubBuildScan
+// follow, and for the same reason: this is where the real logic lives.
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+
+namespace SquidHub.Editor
+{
+    internal enum JsonKind { Null, Bool, Number, String, Array, Object }
+
+    internal sealed class JsonValue
+    {
+        public JsonKind Kind = JsonKind.Null;
+        public bool Bool;
+        /// <summary>The number exactly as it was written, so a round trip is byte-identical.</summary>
+        public string NumberText;
+        public string String;
+        public List<JsonValue> Items;
+        /// <summary>Ordered, because a rewritten manifest is a reviewable diff only if it keeps its shape.</summary>
+        public List<KeyValuePair<string, JsonValue>> Members;
+
+        public static JsonValue NewObject() =>
+            new JsonValue { Kind = JsonKind.Object, Members = new List<KeyValuePair<string, JsonValue>>() };
+
+        public static JsonValue NewArray() =>
+            new JsonValue { Kind = JsonKind.Array, Items = new List<JsonValue>() };
+
+        public static JsonValue Str(string value) =>
+            new JsonValue { Kind = JsonKind.String, String = value ?? "" };
+
+        public static JsonValue Of(bool value) => new JsonValue { Kind = JsonKind.Bool, Bool = value };
+
+        public static JsonValue Of(long value) => new JsonValue
+        {
+            Kind = JsonKind.Number,
+            NumberText = value.ToString(CultureInfo.InvariantCulture),
+        };
+
+        public static JsonValue Null() => new JsonValue { Kind = JsonKind.Null };
+
+        public JsonValue Get(string name)
+        {
+            if (Kind != JsonKind.Object) return null;
+            foreach (var member in Members)
+                if (member.Key == name) return member.Value;
+            return null;
+        }
+
+        /// <summary>Replaces in place when present — which is what keeps the key in its original position.</summary>
+        public void Set(string name, JsonValue value)
+        {
+            if (Kind != JsonKind.Object) throw new InvalidOperationException("not an object");
+            for (var i = 0; i < Members.Count; i++)
+            {
+                if (Members[i].Key != name) continue;
+                Members[i] = new KeyValuePair<string, JsonValue>(name, value);
+                return;
+            }
+            Members.Add(new KeyValuePair<string, JsonValue>(name, value));
+        }
+
+        public void Remove(string name)
+        {
+            if (Kind != JsonKind.Object) return;
+            for (var i = 0; i < Members.Count; i++)
+            {
+                if (Members[i].Key != name) continue;
+                Members.RemoveAt(i);
+                return;
+            }
+        }
+
+        /// <summary>The string, or <paramref name="fallback"/> for anything that is not one.</summary>
+        public string AsString(string fallback = "") => Kind == JsonKind.String ? String : fallback;
+
+        public bool AsBool(bool fallback = false) => Kind == JsonKind.Bool ? Bool : fallback;
+
+        /// <summary>
+        /// ⚠️ Returns the fallback for a non-integer, matching the server: it
+        /// refuses anything that is not a positive integer for
+        /// `saveSchemaVersion` rather than coercing it, because a NaN in the
+        /// column that decides whether a rollback is safe eats saves.
+        /// </summary>
+        public int AsInt(int fallback)
+        {
+            if (Kind != JsonKind.Number) return fallback;
+            return int.TryParse(NumberText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var parsed)
+                ? parsed
+                : fallback;
+        }
+
+        public List<string> AsStringList()
+        {
+            var result = new List<string>();
+            if (Kind != JsonKind.Array) return result;
+            foreach (var item in Items)
+                if (item.Kind == JsonKind.String) result.Add(item.String);
+            return result;
+        }
+
+        /// <summary>
+        /// A deep copy.
+        ///
+        /// ⚠️ Serialising must not MUTATE. `ToJson(forBuild: true)` strips keys
+        /// that describe a different set of bytes, and doing that in place also
+        /// stripped them from the manifest still open in the editor — so writing
+        /// a build folder silently edited the file the publisher had not saved.
+        /// A test caught it; the fix is that nothing serialises the live tree.
+        /// </summary>
+        public JsonValue Clone()
+        {
+            var copy = new JsonValue
+            {
+                Kind = Kind,
+                Bool = Bool,
+                NumberText = NumberText,
+                String = String,
+            };
+            if (Items != null)
+            {
+                copy.Items = new List<JsonValue>(Items.Count);
+                foreach (var item in Items) copy.Items.Add(item.Clone());
+            }
+            if (Members != null)
+            {
+                copy.Members = new List<KeyValuePair<string, JsonValue>>(Members.Count);
+                foreach (var member in Members)
+                    copy.Members.Add(new KeyValuePair<string, JsonValue>(member.Key, member.Value.Clone()));
+            }
+            return copy;
+        }
+
+        public static JsonValue ArrayOf(IEnumerable<string> values)
+        {
+            var array = NewArray();
+            foreach (var value in values) array.Items.Add(Str(value));
+            return array;
+        }
+    }
+
+    internal static class SquidHubJson
+    {
+        /// <summary>Parses JSON text. Throws <see cref="FormatException"/> on anything malformed.</summary>
+        public static JsonValue Parse(string text)
+        {
+            if (text == null) throw new FormatException("no JSON to read");
+            var index = 0;
+            var value = ParseValue(text, ref index);
+            SkipWhitespace(text, ref index);
+            if (index != text.Length) throw new FormatException("trailing content after the JSON value");
+            return value;
+        }
+
+        /// <summary>Two-space indented, newline-terminated — the shape the other manifests in the repo are written in.</summary>
+        public static string Write(JsonValue value)
+        {
+            var sb = new StringBuilder();
+            WriteValue(sb, value, 0);
+            return sb.Append('\n').ToString();
+        }
+
+        private static void WriteValue(StringBuilder sb, JsonValue value, int depth)
+        {
+            switch (value.Kind)
+            {
+                case JsonKind.Null: sb.Append("null"); break;
+                case JsonKind.Bool: sb.Append(value.Bool ? "true" : "false"); break;
+                case JsonKind.Number: sb.Append(value.NumberText); break;
+                case JsonKind.String: sb.Append(SquidHubBuildScan.JsonString(value.String)); break;
+
+                case JsonKind.Array:
+                    if (value.Items.Count == 0) { sb.Append("[]"); break; }
+                    sb.Append("[\n");
+                    for (var i = 0; i < value.Items.Count; i++)
+                    {
+                        Indent(sb, depth + 1);
+                        WriteValue(sb, value.Items[i], depth + 1);
+                        if (i < value.Items.Count - 1) sb.Append(',');
+                        sb.Append('\n');
+                    }
+                    Indent(sb, depth);
+                    sb.Append(']');
+                    break;
+
+                case JsonKind.Object:
+                    if (value.Members.Count == 0) { sb.Append("{}"); break; }
+                    sb.Append("{\n");
+                    for (var i = 0; i < value.Members.Count; i++)
+                    {
+                        Indent(sb, depth + 1);
+                        sb.Append(SquidHubBuildScan.JsonString(value.Members[i].Key)).Append(": ");
+                        WriteValue(sb, value.Members[i].Value, depth + 1);
+                        if (i < value.Members.Count - 1) sb.Append(',');
+                        sb.Append('\n');
+                    }
+                    Indent(sb, depth);
+                    sb.Append('}');
+                    break;
+            }
+        }
+
+        private static void Indent(StringBuilder sb, int depth) => sb.Append(' ', depth * 2);
+
+        private static JsonValue ParseValue(string text, ref int i)
+        {
+            SkipWhitespace(text, ref i);
+            if (i >= text.Length) throw new FormatException("unexpected end of JSON");
+
+            switch (text[i])
+            {
+                case '{': return ParseObject(text, ref i);
+                case '[': return ParseArray(text, ref i);
+                case '"': return JsonValue.Str(ParseString(text, ref i));
+                case 't': Expect(text, ref i, "true"); return JsonValue.Of(true);
+                case 'f': Expect(text, ref i, "false"); return JsonValue.Of(false);
+                case 'n': Expect(text, ref i, "null"); return JsonValue.Null();
+                default: return ParseNumber(text, ref i);
+            }
+        }
+
+        private static JsonValue ParseObject(string text, ref int i)
+        {
+            var result = JsonValue.NewObject();
+            i++; // '{'
+            SkipWhitespace(text, ref i);
+            if (i < text.Length && text[i] == '}') { i++; return result; }
+
+            while (true)
+            {
+                SkipWhitespace(text, ref i);
+                if (i >= text.Length || text[i] != '"') throw new FormatException("expected a key at " + i);
+                var key = ParseString(text, ref i);
+
+                SkipWhitespace(text, ref i);
+                if (i >= text.Length || text[i] != ':') throw new FormatException("expected ':' at " + i);
+                i++;
+
+                // ⚠️ Added, never Set: a duplicate key in the SOURCE file is
+                // preserved as written rather than quietly collapsed. We did not
+                // write it and cannot know which one the author meant.
+                result.Members.Add(new KeyValuePair<string, JsonValue>(key, ParseValue(text, ref i)));
+
+                SkipWhitespace(text, ref i);
+                if (i >= text.Length) throw new FormatException("unterminated object");
+                if (text[i] == ',') { i++; continue; }
+                if (text[i] == '}') { i++; return result; }
+                throw new FormatException("expected ',' or '}' at " + i);
+            }
+        }
+
+        private static JsonValue ParseArray(string text, ref int i)
+        {
+            var result = JsonValue.NewArray();
+            i++; // '['
+            SkipWhitespace(text, ref i);
+            if (i < text.Length && text[i] == ']') { i++; return result; }
+
+            while (true)
+            {
+                result.Items.Add(ParseValue(text, ref i));
+                SkipWhitespace(text, ref i);
+                if (i >= text.Length) throw new FormatException("unterminated array");
+                if (text[i] == ',') { i++; continue; }
+                if (text[i] == ']') { i++; return result; }
+                throw new FormatException("expected ',' or ']' at " + i);
+            }
+        }
+
+        private static string ParseString(string text, ref int i)
+        {
+            i++; // opening quote
+            var sb = new StringBuilder();
+            while (true)
+            {
+                if (i >= text.Length) throw new FormatException("unterminated string");
+                var c = text[i++];
+                if (c == '"') return sb.ToString();
+                if (c != '\\') { sb.Append(c); continue; }
+
+                if (i >= text.Length) throw new FormatException("unterminated escape");
+                var escape = text[i++];
+                switch (escape)
+                {
+                    case '"': sb.Append('"'); break;
+                    case '\\': sb.Append('\\'); break;
+                    case '/': sb.Append('/'); break;
+                    case 'b': sb.Append('\b'); break;
+                    case 'f': sb.Append('\f'); break;
+                    case 'n': sb.Append('\n'); break;
+                    case 'r': sb.Append('\r'); break;
+                    case 't': sb.Append('\t'); break;
+                    case 'u':
+                        if (i + 4 > text.Length) throw new FormatException("truncated \\u escape");
+                        sb.Append((char)Convert.ToInt32(text.Substring(i, 4), 16));
+                        i += 4;
+                        break;
+                    default: throw new FormatException("unknown escape \\" + escape);
+                }
+            }
+        }
+
+        private static JsonValue ParseNumber(string text, ref int i)
+        {
+            var start = i;
+            if (i < text.Length && (text[i] == '-' || text[i] == '+')) i++;
+            while (i < text.Length && (char.IsDigit(text[i]) || text[i] == '.' ||
+                                       text[i] == 'e' || text[i] == 'E' ||
+                                       text[i] == '-' || text[i] == '+')) i++;
+
+            var raw = text.Substring(start, i - start);
+            if (raw.Length == 0 ||
+                !double.TryParse(raw, NumberStyles.Float, CultureInfo.InvariantCulture, out _))
+            {
+                throw new FormatException("not a number at " + start + ": '" + raw + "'");
+            }
+            return new JsonValue { Kind = JsonKind.Number, NumberText = raw };
+        }
+
+        private static void Expect(string text, ref int i, string literal)
+        {
+            if (i + literal.Length > text.Length || text.Substring(i, literal.Length) != literal)
+                throw new FormatException("expected '" + literal + "' at " + i);
+            i += literal.Length;
+        }
+
+        private static void SkipWhitespace(string text, ref int i)
+        {
+            while (i < text.Length && (text[i] == ' ' || text[i] == '\t' || text[i] == '\n' || text[i] == '\r')) i++;
+        }
+    }
+}

package/Editor/SquidHubJson.cs.meta

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