29954885845

Committed 22 Jul 2026 08:22PM UTC coverage: 63.479% (+0.01%) from 63.465%

Build # 29954885845

Build Type

push

github

Committed by

tyevco

Commit Message

fix: Resolve CodeQL alerts in src tier

Fixes 46 of 183 CodeQL alerts across src/ runtime libraries; the
remaining 137 are deliberately dismissed with per-alert rationale in
dismissals.tsv (false positive / won't fix / used in tests).

- catch-of-all-exceptions: type SaveManager and EncryptedPersistenceApi
  save-slot probe catches (IOException, UnauthorizedAccessException,
  InvalidDataException, EndOfStreamException, JsonException); narrow
  TestBridgeClient message parsing to JsonException, EntitySnapshot
  conversion to InvalidCastException/FormatException/OverflowException,
  UdpTransport disconnect send to SocketException/ObjectDisposedException,
  and UIColorPicker hex parsing to FormatException/OverflowException/
  ArgumentException. Bridge/IPC dispatch, logging, hot-reload and
  background-worker containment boundaries are kept and documented.
- loss-of-precision: float-typed arithmetic in WavDecoder,
  SilkAudioContext, AudioClipAsset, GridCoordinate, SilkTextRenderer,
  UdpTransport, ParallelProfiler; FleeAction's intentional integer
  centering made explicit via an int local.
- local-shadows-member: rename shadowing locals in GraphRenderSystem;
  rename Silk2DRenderer's projection field to screenProjection and
  EnsureCapacity parameters (interface parameter names kept for S927).
- constant-condition: drop redundant checksum conjunct in Ghost/Replay
  file formats, hoist device null check out of PauseAll loop, and
  replace the always-false ownsEntity/existingTypes conjunct in
  NetworkServerPlugin owner-state validation.
- useless-upcast/cast-to-self: assign World directly to capability
  fields in StateControllerImpl; drop redundant collection-expression
  casts in AssetManifest/AssetEntry.
- complex-condition: pattern-match Unicode range checks in text shapers.
- inefficient-containskey: TryGetValue in LogAssertions.
- equality-on-floats, obsolete prefab mock calls, ref-parameter counts:
  dismissed as exact-by-construction, test-only m... (continued)

Coverage Stats

8347 of 12508 branches covered (66.73%)

Branch coverage included in aggregate %.

24 of 52 new or added lines in 20 files covered. (46.15%)

105 existing lines in 9 files now uncovered.

50060 of 79502 relevant lines covered (62.97%)

0.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/KeenEyes.Localization/TextShaping/BidirectionalTextShaper.cs

using System.Text;

namespace KeenEyes.Localization.TextShaping;

/// <summary>
/// Text shaper that handles bidirectional text (mixed LTR and RTL content).
/// </summary>
/// <remarks>
/// <para>
/// This shaper implements a simplified version of the Unicode Bidirectional Algorithm (UBA)
/// to properly order text that contains both left-to-right and right-to-left characters.
/// </para>
/// <para>
/// Common use cases:
/// <list type="bullet">
///   <item><description>English text with Arabic words</description></item>
///   <item><description>Hebrew text with English technical terms</description></item>
///   <item><description>Numbers in RTL text</description></item>
/// </list>
/// </para>
/// </remarks>
/// <example>
/// <code>
/// var shaper = new BidirectionalTextShaper();
/// string result = shaper.Shape("Hello مرحبا World", Locale.EnglishUS);
/// // Returns: "Hello ابحرم World" (Arabic reversed for LTR base)
/// </code>
/// </example>
public sealed class BidirectionalTextShaper : ITextShaper
{
    private readonly ArabicTextShaper arabicShaper = new();

    /// <inheritdoc />
    public IEnumerable<ScriptType> SupportedScripts =>
    [
        ScriptType.Latin,
        ScriptType.Arabic,
        ScriptType.Hebrew,
        ScriptType.Cyrillic,
        ScriptType.Greek
    ];

    /// <inheritdoc />
    public bool SupportsScript(ScriptType script) => script switch
    {
        ScriptType.Latin => true,
        ScriptType.Arabic => true,
        ScriptType.Hebrew => true,
        ScriptType.Cyrillic => true,
        ScriptType.Greek => true,
        _ => false
    };

    /// <inheritdoc />
    public string Shape(string text, Locale locale)
    {
        if (string.IsNullOrEmpty(text))
        {
            return text;
        }

        // Determine base direction from locale
        var baseDirection = locale.TextDirection;

        // Split into runs of same-direction text
        var runs = IdentifyDirectionalRuns(text);

        // If no RTL content found, return as-is (with Arabic shaping if needed)
        if (!runs.Any(r => r.IsRtl))
        {
            return text;
        }

        // Process and reorder runs
        var result = new StringBuilder(text.Length);

        if (baseDirection == TextDirection.LeftToRight)
        {
            ProcessLtrBase(runs, result);
        }
        else
        {
            ProcessRtlBase(runs, result);
        }

        return result.ToString();
    }

    /// <inheritdoc />
    public ShapingResult ShapeWithInfo(string text, Locale locale)
    {
        var runs = IdentifyDirectionalRuns(text);
        bool hasRtl = runs.Any(r => r.IsRtl);
        bool hasLtr = runs.Any(r => !r.IsRtl);

        string shapedText = Shape(text, locale);

        var scripts = new List<ScriptType>();
        foreach (var run in runs)
        {
            if (run.IsRtl)
            {
                scripts.Add(ScriptType.Arabic); // Simplified - could detect Hebrew vs Arabic
            }
            else if (run.Text.Any(char.IsLetter))
            {
                scripts.Add(ScriptType.Latin);
            }
        }

        return new ShapingResult(
            ShapedText: shapedText,
            OriginalText: text,
            BaseDirection: locale.TextDirection,
            ContainsRtl: hasRtl,
            IsMixedDirection: hasRtl && hasLtr,
            DetectedScripts: scripts.Distinct().ToList());
    }

    private void ProcessLtrBase(List<DirectionalRun> runs, StringBuilder result)
    {
        foreach (var run in runs)
        {
            if (run.IsRtl)
            {
                // Shape Arabic text and reverse for display in LTR context
                string shaped = arabicShaper.Shape(run.Text, Locale.Arabic);
                result.Append(ReverseString(shaped));
            }
            else
            {
                result.Append(run.Text);
            }
        }
    }

    private void ProcessRtlBase(List<DirectionalRun> runs, StringBuilder result)
    {
        // In RTL base, process runs in reverse order
        for (int i = runs.Count - 1; i >= 0; i--)
        {
            var run = runs[i];
            if (run.IsRtl)
            {
                // Shape Arabic text (already in correct order for RTL display)
                string shaped = arabicShaper.Shape(run.Text, Locale.Arabic);
                result.Append(shaped);
            }
            else
            {
                // LTR text needs to be kept as-is within the RTL flow
                result.Append(run.Text);
            }
        }
    }

    private static List<DirectionalRun> IdentifyDirectionalRuns(string text)
    {
        var runs = new List<DirectionalRun>();
        if (string.IsNullOrEmpty(text))
        {
            return runs;
        }

        var currentRun = new StringBuilder();
        bool? currentIsRtl = null;

        foreach (char c in text)
        {
            bool isRtl = IsRtlCharacter(c);
            bool isNeutral = IsNeutralCharacter(c);

            if (isNeutral)
            {
                // Neutral characters (spaces, punctuation) join the current run
                currentRun.Append(c);
            }
            else if (currentIsRtl == null || currentIsRtl == isRtl)
            {
                currentIsRtl = isRtl;
                currentRun.Append(c);
            }
            else
            {
                // Direction change - save current run
                if (currentRun.Length > 0)
                {
                    runs.Add(new DirectionalRun(currentRun.ToString(), currentIsRtl.Value));
                    currentRun.Clear();
                }
                currentIsRtl = isRtl;
                currentRun.Append(c);
            }
        }

        // Add final run
        if (currentRun.Length > 0)
        {
            runs.Add(new DirectionalRun(currentRun.ToString(), currentIsRtl ?? false));
        }

        return runs;
    }

    private static bool IsRtlCharacter(char c)
    {
        // Arabic: U+0600-U+06FF, U+FB50-U+FDFF, U+FE70-U+FEFF
        // Hebrew: U+0590-U+05FF
        return c is (>= '\u0600' and <= '\u06FF')
            or (>= '\uFB50' and <= '\uFDFF')
            or (>= '\uFE70' and <= '\uFEFF')
            or (>= '\u0590' and <= '\u05FF');
    }

    private static bool IsNeutralCharacter(char c)
    {
        // Spaces, digits, and common punctuation are neutral
        return char.IsWhiteSpace(c) ||
               char.IsDigit(c) ||
               char.IsPunctuation(c) ||
               char.IsSymbol(c);
    }

    private static string ReverseString(string s)
    {
        char[] arr = s.ToCharArray();
        Array.Reverse(arr);
        return new string(arr);
    }

    private readonly record struct DirectionalRun(string Text, bool IsRtl);
}

1	using System.Text;
2
3	namespace KeenEyes.Localization.TextShaping;
4
5	/// <summary>
6	/// Text shaper that handles bidirectional text (mixed LTR and RTL content).
7	/// </summary>
8	/// <remarks>
9	/// <para>
10	/// This shaper implements a simplified version of the Unicode Bidirectional Algorithm (UBA)
11	/// to properly order text that contains both left-to-right and right-to-left characters.
12	/// </para>
13	/// <para>
14	/// Common use cases:
15	/// <list type="bullet">
16	/// <item><description>English text with Arabic words</description></item>
17	/// <item><description>Hebrew text with English technical terms</description></item>
18	/// <item><description>Numbers in RTL text</description></item>
19	/// </list>
20	/// </para>
21	/// </remarks>
22	/// <example>
23	/// <code>
24	/// var shaper = new BidirectionalTextShaper();
25	/// string result = shaper.Shape("Hello مرحبا World", Locale.EnglishUS);
26	/// // Returns: "Hello ابحرم World" (Arabic reversed for LTR base)
27	/// </code>
28	/// </example>
29	public sealed class BidirectionalTextShaper : ITextShaper
30	{
31	private readonly ArabicTextShaper arabicShaper = new();	×
32
33	/// <inheritdoc />
34	public IEnumerable<ScriptType> SupportedScripts =>
35	[	×
36	ScriptType.Latin,	×
37	ScriptType.Arabic,	×
38	ScriptType.Hebrew,	×
39	ScriptType.Cyrillic,	×
40	ScriptType.Greek	×
41	];	×
42
43	/// <inheritdoc />
44	public bool SupportsScript(ScriptType script) => script switch	×
45	{	×
46	ScriptType.Latin => true,	×
47	ScriptType.Arabic => true,	×
48	ScriptType.Hebrew => true,	×
49	ScriptType.Cyrillic => true,	×
50	ScriptType.Greek => true,	×
51	_ => false	×
52	};	×
53
54	/// <inheritdoc />
55	public string Shape(string text, Locale locale)
56	{
57	if (string.IsNullOrEmpty(text))	×
58	{
59	return text;	×
60	}
61
62	// Determine base direction from locale
63	var baseDirection = locale.TextDirection;	×
64
65	// Split into runs of same-direction text
66	var runs = IdentifyDirectionalRuns(text);	×
67
68	// If no RTL content found, return as-is (with Arabic shaping if needed)
69	if (!runs.Any(r => r.IsRtl))	×
70	{
71	return text;	×
72	}
73
74	// Process and reorder runs
75	var result = new StringBuilder(text.Length);	×
76
77	if (baseDirection == TextDirection.LeftToRight)	×
78	{
79	ProcessLtrBase(runs, result);	×
80	}
81	else
82	{
83	ProcessRtlBase(runs, result);	×
84	}
85
86	return result.ToString();	×
87	}
88
89	/// <inheritdoc />
90	public ShapingResult ShapeWithInfo(string text, Locale locale)
91	{
92	var runs = IdentifyDirectionalRuns(text);	×
93	bool hasRtl = runs.Any(r => r.IsRtl);	×
94	bool hasLtr = runs.Any(r => !r.IsRtl);	×
95
96	string shapedText = Shape(text, locale);	×
97
98	var scripts = new List<ScriptType>();	×
99	foreach (var run in runs)	×
100	{
101	if (run.IsRtl)	×
102	{
103	scripts.Add(ScriptType.Arabic); // Simplified - could detect Hebrew vs Arabic	×
104	}
105	else if (run.Text.Any(char.IsLetter))	×
106	{
107	scripts.Add(ScriptType.Latin);	×
108	}
109	}
110
111	return new ShapingResult(	×
112	ShapedText: shapedText,	×
113	OriginalText: text,	×
114	BaseDirection: locale.TextDirection,	×
115	ContainsRtl: hasRtl,	×
116	IsMixedDirection: hasRtl && hasLtr,	×
117	DetectedScripts: scripts.Distinct().ToList());	×
118	}
119
120	private void ProcessLtrBase(List<DirectionalRun> runs, StringBuilder result)
121	{
122	foreach (var run in runs)	×
123	{
124	if (run.IsRtl)	×
125	{
126	// Shape Arabic text and reverse for display in LTR context
127	string shaped = arabicShaper.Shape(run.Text, Locale.Arabic);	×
128	result.Append(ReverseString(shaped));	×
129	}
130	else
131	{
132	result.Append(run.Text);	×
133	}
134	}
135	}	×
136
137	private void ProcessRtlBase(List<DirectionalRun> runs, StringBuilder result)
138	{
139	// In RTL base, process runs in reverse order
140	for (int i = runs.Count - 1; i >= 0; i--)	×
141	{
142	var run = runs[i];	×
143	if (run.IsRtl)	×
144	{
145	// Shape Arabic text (already in correct order for RTL display)
146	string shaped = arabicShaper.Shape(run.Text, Locale.Arabic);	×
147	result.Append(shaped);	×
148	}
149	else
150	{
151	// LTR text needs to be kept as-is within the RTL flow
152	result.Append(run.Text);	×
153	}
154	}
155	}	×
156
157	private static List<DirectionalRun> IdentifyDirectionalRuns(string text)
158	{
159	var runs = new List<DirectionalRun>();	×
160	if (string.IsNullOrEmpty(text))	×
161	{
162	return runs;	×
163	}
164
165	var currentRun = new StringBuilder();	×
166	bool? currentIsRtl = null;	×
167
168	foreach (char c in text)	×
169	{
170	bool isRtl = IsRtlCharacter(c);	×
171	bool isNeutral = IsNeutralCharacter(c);	×
172
173	if (isNeutral)	×
174	{
175	// Neutral characters (spaces, punctuation) join the current run
176	currentRun.Append(c);	×
177	}
178	else if (currentIsRtl == null \|\| currentIsRtl == isRtl)	×
179	{
180	currentIsRtl = isRtl;	×
181	currentRun.Append(c);	×
182	}
183	else
184	{
185	// Direction change - save current run
186	if (currentRun.Length > 0)	×
187	{
188	runs.Add(new DirectionalRun(currentRun.ToString(), currentIsRtl.Value));	×
189	currentRun.Clear();	×
190	}
191	currentIsRtl = isRtl;	×
192	currentRun.Append(c);	×
193	}
194	}
195
196	// Add final run
197	if (currentRun.Length > 0)	×
198	{
199	runs.Add(new DirectionalRun(currentRun.ToString(), currentIsRtl ?? false));	×
200	}
201
202	return runs;	×
203	}
204
205	private static bool IsRtlCharacter(char c)
206	{
207	// Arabic: U+0600-U+06FF, U+FB50-U+FDFF, U+FE70-U+FEFF
208	// Hebrew: U+0590-U+05FF
NEW 209	return c is (>= '\u0600' and <= '\u06FF')	×
NEW 210	or (>= '\uFB50' and <= '\uFDFF')	×
NEW 211	or (>= '\uFE70' and <= '\uFEFF')	×
NEW 212	or (>= '\u0590' and <= '\u05FF');	×
213	}
214
215	private static bool IsNeutralCharacter(char c)
216	{
217	// Spaces, digits, and common punctuation are neutral
218	return char.IsWhiteSpace(c) \|\|	×
219	char.IsDigit(c) \|\|	×
220	char.IsPunctuation(c) \|\|	×
221	char.IsSymbol(c);	×
222	}
223
224	private static string ReverseString(string s)
225	{
226	char[] arr = s.ToCharArray();	×
227	Array.Reverse(arr);	×
228	return new string(arr);	×
229	}
230
231	private readonly record struct DirectionalRun(string Text, bool IsRtl);
232	}

orion-ecs / keen-eye / 29954885845

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous