wip
This commit is contained in:
Alexander Heldt
@@ -1,13 +1,11 @@
|
||||
import gleam/dict
|
||||
import gleam/float
|
||||
import gleam/int
|
||||
import gleam/list
|
||||
import gleam/io
|
||||
import gleam/string
|
||||
import gleeunit
|
||||
import gleeunit/should
|
||||
import musicplayer/ui/virtual_ansi
|
||||
|
||||
import musicplayer/ui/layout.{
|
||||
type Layout, type Section, Layout, Node, RenderOps, Section,
|
||||
}
|
||||
import musicplayer/ui/layout.{Layout, Node, Section}
|
||||
|
||||
pub fn main() -> Nil {
|
||||
gleeunit.main()
|
||||
@@ -102,133 +100,19 @@ container───────────────────────
|
||||
└──────────────────────────────────────────────────────────────────────────────┘
|
||||
"
|
||||
|
||||
let visual = render_to_visual(layout, Section("Root"), 80, 20)
|
||||
assert visual == string.trim(expected)
|
||||
}
|
||||
|
||||
pub type Screen =
|
||||
dict.Dict(#(Int, Int), String)
|
||||
|
||||
pub fn render_to_visual(
|
||||
layout: Layout,
|
||||
root: Section,
|
||||
width: Int,
|
||||
height: Int,
|
||||
) -> String {
|
||||
// 1. Define the Strategy: How to draw on a Dict
|
||||
let test_ops =
|
||||
RenderOps(
|
||||
draw_box: fn(screen, x, y, w, h) { plot_box(screen, x, y, w, h) },
|
||||
draw_text: fn(screen, text, x, y) { plot_text(screen, text, x, y) },
|
||||
)
|
||||
|
||||
// 2. Run the generic logic (reusing the exact math from your real app)
|
||||
let final_screen =
|
||||
layout.render_generic(
|
||||
layout,
|
||||
int.to_float(width),
|
||||
int.to_float(height),
|
||||
1,
|
||||
// Start X (1-based for ANSI compatibility)
|
||||
1,
|
||||
// Start Y
|
||||
0,
|
||||
// Root index
|
||||
root,
|
||||
dict.new(),
|
||||
// Initial Context
|
||||
test_ops,
|
||||
)
|
||||
|
||||
// 3. Convert the Grid to a Visual String
|
||||
screen_to_string(final_screen)
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Plotting Primitives (The "Graphics Engine" for Tests)
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
fn plot_text(screen: Screen, text: String, start_x: Int, y: Int) -> Screen {
|
||||
// We use to_graphemes to ensure Unicode characters (like emoji or box lines)
|
||||
// are treated as single visual units.
|
||||
text
|
||||
|> string.to_graphemes
|
||||
|> list.index_fold(screen, fn(acc, char, i) {
|
||||
dict.insert(acc, #(start_x + i, y), char)
|
||||
})
|
||||
}
|
||||
|
||||
fn plot_box(screen: Screen, x: Int, y: Int, w: Int, h: Int) -> Screen {
|
||||
let box_chars = #("┌", "┐", "└", "┘", "─", "│")
|
||||
let #(tl, tr, bl, br, hor, ver) = box_chars
|
||||
|
||||
// Don't draw impossible boxes
|
||||
case w < 2 || h < 2 {
|
||||
True -> screen
|
||||
let visual =
|
||||
virtual_ansi.render(layout, Section("Root"), layout.width, layout.height)
|
||||
case visual == string.trim(expected) {
|
||||
True -> Nil
|
||||
False -> {
|
||||
screen
|
||||
// 1. Corners
|
||||
|> dict.insert(#(x, y), tl)
|
||||
|> dict.insert(#(x + w - 1, y), tr)
|
||||
|> dict.insert(#(x, y + h - 1), bl)
|
||||
|> dict.insert(#(x + w - 1, y + h - 1), br)
|
||||
// 2. Top and Bottom edges
|
||||
|> plot_line_hor(x + 1, y, w - 2, hor)
|
||||
|> plot_line_hor(x + 1, y + h - 1, w - 2, hor)
|
||||
// 3. Side edges
|
||||
|> plot_line_ver(x, y + 1, h - 2, ver)
|
||||
|> plot_line_ver(x + w - 1, y + 1, h - 2, ver)
|
||||
io.println("Test failed")
|
||||
io.println("Expected:")
|
||||
io.println(string.trim(expected))
|
||||
|
||||
io.println("Got:")
|
||||
io.println(visual)
|
||||
|
||||
should.equal(visual, expected)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn plot_line_hor(
|
||||
screen: Screen,
|
||||
x: Int,
|
||||
y: Int,
|
||||
len: Int,
|
||||
char: String,
|
||||
) -> Screen {
|
||||
list.range(0, len - 1)
|
||||
|> list.fold(screen, fn(acc, i) { dict.insert(acc, #(x + i, y), char) })
|
||||
}
|
||||
|
||||
fn plot_line_ver(
|
||||
screen: Screen,
|
||||
x: Int,
|
||||
y: Int,
|
||||
len: Int,
|
||||
char: String,
|
||||
) -> Screen {
|
||||
list.range(0, len - 1)
|
||||
|> list.fold(screen, fn(acc, i) { dict.insert(acc, #(x, y + i), char) })
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Output Formatting
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
fn screen_to_string(screen: Screen) -> String {
|
||||
let keys = dict.keys(screen)
|
||||
|
||||
// Find the bounding box of the drawing
|
||||
let max_x = list.fold(keys, 0, fn(m, k) { int.max(m, k.0) })
|
||||
let max_y = list.fold(keys, 0, fn(m, k) { int.max(m, k.1) })
|
||||
|
||||
// We start from 1 because ANSI is 1-based
|
||||
let min_y = list.fold(keys, 1000, fn(m, k) { int.min(m, k.1) })
|
||||
|
||||
list.range(min_y, max_y)
|
||||
|> list.map(fn(y) {
|
||||
list.range(1, max_x)
|
||||
|> list.map(fn(x) {
|
||||
case dict.get(screen, #(x, y)) {
|
||||
Ok(char) -> char
|
||||
Error(_) -> " "
|
||||
// Fill gaps with space
|
||||
}
|
||||
})
|
||||
|> string.join("")
|
||||
})
|
||||
|> string.join("\n")
|
||||
}
|
||||
|
||||
113
test/musicplayer/ui/virtual_ansi.gleam
Normal file
113
test/musicplayer/ui/virtual_ansi.gleam
Normal file
@@ -0,0 +1,113 @@
|
||||
import gleam/dict
|
||||
import gleam/int
|
||||
import gleam/list
|
||||
import gleam/string
|
||||
|
||||
import musicplayer/ui/layout.{type Layout, type Section, Renders}
|
||||
|
||||
pub type Screen =
|
||||
dict.Dict(#(Int, Int), String)
|
||||
|
||||
pub fn render(layout: Layout, root: Section, width: Int, height: Int) -> String {
|
||||
let test_renders =
|
||||
Renders(
|
||||
box: fn(screen, x, y, w, h) { box(screen, x, y, w, h) },
|
||||
text: fn(screen, chars, x, y) { text(screen, chars, x, y) },
|
||||
)
|
||||
|
||||
let screen =
|
||||
layout.render_generic(
|
||||
layout,
|
||||
int.to_float(width),
|
||||
int.to_float(height),
|
||||
1,
|
||||
1,
|
||||
0,
|
||||
root,
|
||||
dict.new(),
|
||||
test_renders,
|
||||
)
|
||||
|
||||
screen_to_string(screen)
|
||||
}
|
||||
|
||||
pub fn screen_to_string(screen: Screen) -> String {
|
||||
let keys = dict.keys(screen)
|
||||
|
||||
// Find the bounding box of the drawing
|
||||
let max_x = list.fold(keys, 0, fn(m, k) { int.max(m, k.0) })
|
||||
let max_y = list.fold(keys, 0, fn(m, k) { int.max(m, k.1) })
|
||||
|
||||
// We start from 1 because ANSI is 1-based
|
||||
let min_y = list.fold(keys, 1000, fn(m, k) { int.min(m, k.1) })
|
||||
|
||||
list.range(min_y, max_y)
|
||||
|> list.map(fn(y) {
|
||||
list.range(1, max_x)
|
||||
|> list.map(fn(x) {
|
||||
case dict.get(screen, #(x, y)) {
|
||||
Ok(char) -> char
|
||||
Error(_) -> " "
|
||||
// Fill gaps with space
|
||||
}
|
||||
})
|
||||
|> string.join("")
|
||||
})
|
||||
|> string.join("\n")
|
||||
}
|
||||
|
||||
pub fn text(screen: Screen, text: String, start_x: Int, y: Int) -> Screen {
|
||||
// We use to_graphemes to ensure Unicode characters (like emoji or box lines)
|
||||
// are treated as single visual units
|
||||
text
|
||||
|> string.to_graphemes
|
||||
|> list.index_fold(screen, fn(acc, char, i) {
|
||||
dict.insert(acc, #(start_x + i, y), char)
|
||||
})
|
||||
}
|
||||
|
||||
pub fn box(screen: Screen, x: Int, y: Int, w: Int, h: Int) -> Screen {
|
||||
let box_chars = #("┌", "┐", "└", "┘", "─", "│")
|
||||
let #(tl, tr, bl, br, hor, ver) = box_chars
|
||||
|
||||
// Don't draw impossible boxes
|
||||
case w < 2 || h < 2 {
|
||||
True -> screen
|
||||
False -> {
|
||||
screen
|
||||
// 1. Corners
|
||||
|> dict.insert(#(x, y), tl)
|
||||
|> dict.insert(#(x + w - 1, y), tr)
|
||||
|> dict.insert(#(x, y + h - 1), bl)
|
||||
|> dict.insert(#(x + w - 1, y + h - 1), br)
|
||||
// 2. Top and Bottom edges
|
||||
|> horizontal_line(x + 1, y, w - 2, hor)
|
||||
|> horizontal_line(x + 1, y + h - 1, w - 2, hor)
|
||||
// 3. Side edges
|
||||
|> vertical_line(x, y + 1, h - 2, ver)
|
||||
|> vertical_line(x + w - 1, y + 1, h - 2, ver)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn horizontal_line(
|
||||
screen: Screen,
|
||||
x: Int,
|
||||
y: Int,
|
||||
len: Int,
|
||||
char: String,
|
||||
) -> Screen {
|
||||
list.range(0, len - 1)
|
||||
|> list.fold(screen, fn(acc, i) { dict.insert(acc, #(x + i, y), char) })
|
||||
}
|
||||
|
||||
fn vertical_line(
|
||||
screen: Screen,
|
||||
x: Int,
|
||||
y: Int,
|
||||
len: Int,
|
||||
char: String,
|
||||
) -> Screen {
|
||||
list.range(0, len - 1)
|
||||
|> list.fold(screen, fn(acc, i) { dict.insert(acc, #(x, y + i), char) })
|
||||
}
|
||||
Reference in New Issue
Block a user