FilesExpand file tree

 main

/

LiveRenderer.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

135 lines (114 loc) · 3.28 KB

 main

/

LiveRenderer.cs

Copy path

Top

File metadata and controls

• Code
• Blame

135 lines (114 loc) · 3.28 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

/// <summary>

/// Renders live progress for parallel operations. In interactive mode: completed results

/// scroll up permanently, in-progress repos show with an animated spinner. When stdout is

/// piped: results are written plain to stdout as they complete.

/// </summary>

internal sealed class LiveRenderer : IDisposable

{

private static readonly string[] Spinner = ["\u28cb", "\u2819", "\u2839", "\u2838", "\u283c", "\u2834", "\u2826", "\u2827", "\u2807", "\u280f"];

private readonly int _total;

private readonly bool _interactive;

private readonly Lock _lock = new();

private readonly List<string> _inProgress = [];

private readonly Queue<RepoResult> _pendingResults = new();

private readonly Timer _timer;

private int _completed;

private int _renderedNewlines;

private int _frame;

internal LiveRenderer(int total)

{

_total = total;

_interactive = !Output.IsPlain;

if (_interactive)

{

Console.Write("\x1b[?25l"); // hide cursor

}

_timer = new Timer(OnTick, null, 0, 80);

}

internal void StartRepo(string relativePath)

{

lock (_lock)

{

_inProgress.Add(relativePath);

}

}

internal void CompleteRepo(RepoResult result)

{

lock (_lock)

{

_inProgress.Remove(result.RelativePath);

_pendingResults.Enqueue(result);

_completed++;

}

}

private void OnTick(object? state)

{

lock (_lock)

{

if (_interactive)

{

RenderInteractive();

}

else

{

RenderPiped();

}

}

}

private void RenderInteractive()

{

// Erase the previous spinner area

EraseSpinnerArea();

// Print completed results — these become permanent output

FlushResults();

// Render in-progress repos with spinner

string spin = $"\x1b[33m{Spinner[_frame % Spinner.Length]}\x1b[0m";

_frame++;

int newlines = 0;

foreach (string path in _inProgress)

{

Console.WriteLine($" {spin} {path}");

newlines++;

}

// Counter line (no trailing newline so cursor stays on this line)

Console.Write($" \x1b[90m[{_completed}/{_total}]\x1b[0m");

_renderedNewlines = newlines;

}

private void RenderPiped()

{

FlushResults();

}

private void FlushResults()

{

while (_pendingResults.TryDequeue(out RepoResult? result))

{

Output.WriteResult(result);

}

}

private void EraseSpinnerArea()

{

// Move to column 0, then up past all newlines we emitted, then clear to end of screen

Console.Write("\x1b[G");

if (_renderedNewlines > 0)

{

Console.Write($"\x1b[{_renderedNewlines}A");

}

Console.Write("\x1b[J");

}

public void Dispose()

{

_timer.Dispose();

lock (_lock)

{

if (_interactive)

{

EraseSpinnerArea();

}

FlushResults();

if (_interactive)

{

Console.Write("\x1b[?25h"); // show cursor

}

}

}

}