Home /Modules/common-rails/PrinterConfig.sleela

PrinterConfig.sleela

common-rails/PrinterConfig.sleela · 392 line(s) · sleela

#sleela 2.1
//
// PrinterConfig.sleela — object-oriented configuration for CommonRails printing.
// =============================================================================
// This is the OO (object-oriented design) edition of the CommonRails print
// configurations. Where CommonRails.sleela exposes printing as flat helper
// methods with long positional argument lists, this file models each printing
// concern as a configurable *object* (a Sleela `struct`): a developer builds
// the config objects they need, sets their fields, and hands them to a
// `Printer` to compose their own print method.
//
// Sleela structs are reference types created with `new`, with `.` field access
// and reference semantics (see impl/examples/struct_basic.sleela), so these
// configs behave like real objects: construct once, reuse, and pass around.
//
// The core value model still has no arrays or string-length/char indexing, so
// every content primitive takes an explicit character count, and a table is
// composed one row at a time rather than from a row array. Operators must be
// space-separated (`w - chars`, never `w-chars`) because the lexer folds a
// hyphen into an identifier.
//
// Run:   ./impl/build/sleela run   common-rails/PrinterConfig.sleela
// Check: ./impl/build/sleela check common-rails/PrinterConfig.sleela
//
// -----------------------------------------------------------------------------
//  Configuration objects
// -----------------------------------------------------------------------------

// How a single value is padded into a fixed width.
//   width     — the field width in characters
//   fill      — the fill string (usually " ", or "0" for zero-padding)
//   leftAlign — true: content then fill (left-aligned);
//               false: fill then content (right-aligned)
struct PadConfig {
    int width;
    String fill;
    boolean leftAlign;
}

// One table column: its header text (+ char count), its width, and alignment.
struct ColumnConfig {
    String header;
    int headerChars;
    int width;
    boolean leftAlign;
}

// The box-drawing glyph set that frames a table. Swapping these restyles every
// table without touching the rendering logic (e.g. heavy, double, or ASCII).
struct TableStyle {
    String tl;  String tm;  String tr;   // top-left / top-mid / top-right
    String ml;  String mm;  String mr;   // mid-left / cross / mid-right
    String bl;  String bm;  String br;   // bottom-left / bottom-mid / bottom-right
    String h;   String v;                // horizontal / vertical
    int inset;                           // spaces of padding inside each cell
}

// State-label styling: the fixed field the "[STATE]" label is laid into so the
// following messages align across lines.
struct StateStyle {
    int field;
}

// Top-level printer configuration — the "printer object" a developer tunes.
//   printWidth  — fixed-width line width (canonical default 80)
//   oidWidth    — zero-pad width for Object IDs
//   currentWidth— inner width of the "[Current: @Name]" field
//   squareSize  — progress-square side (21 → 441 cells)
//   full/light  — filled / empty progress glyphs
//   table       — the TableStyle used for framed output
//   state       — the StateStyle used for state-labelled lines
struct PrinterConfig {
    int printWidth;
    int oidWidth;
    int currentWidth;
    int squareSize;
    String full;
    String light;
    TableStyle table;
    StateStyle state;
}

// -----------------------------------------------------------------------------
//  The Printer — consumes the config objects above
// -----------------------------------------------------------------------------
class Printer {

    // ---- factories: build the config objects ----------------------------

    PadConfig pad(int width, String fill, boolean leftAlign) {
        PadConfig c = new PadConfig();
        c.width = width;
        c.fill = fill;
        c.leftAlign = leftAlign;
        return c;
    }

    // Convenience: a left-aligned, space-filled pad (the common case).
    PadConfig left(int width) {
        return pad(width, " ", true);
    }

    // Convenience: a right-aligned, space-filled pad.
    PadConfig right(int width) {
        return pad(width, " ", false);
    }

    // Convenience: a right-aligned, zero-filled pad (Object-ID style).
    PadConfig zeros(int width) {
        return pad(width, "0", false);
    }

    ColumnConfig column(String header, int headerChars, int width, boolean leftAlign) {
        ColumnConfig c = new ColumnConfig();
        c.header = header;
        c.headerChars = headerChars;
        c.width = width;
        c.leftAlign = leftAlign;
        return c;
    }

    // The default Unicode "light" box-drawing style.
    TableStyle lightTable() {
        TableStyle s = new TableStyle();
        s.tl = "┌";  s.tm = "┬";  s.tr = "┐";
        s.ml = "├";  s.mm = "┼";  s.mr = "┤";
        s.bl = "└";  s.bm = "┴";  s.br = "┘";
        s.h  = "─";  s.v  = "│";
        s.inset = 1;
        return s;
    }

    // A plain ASCII style for terminals without box-drawing glyphs.
    TableStyle asciiTable() {
        TableStyle s = new TableStyle();
        s.tl = "+";  s.tm = "+";  s.tr = "+";
        s.ml = "+";  s.mm = "+";  s.mr = "+";
        s.bl = "+";  s.bm = "+";  s.br = "+";
        s.h  = "-";  s.v  = "|";
        s.inset = 1;
        return s;
    }

    StateStyle stateStyle(int field) {
        StateStyle s = new StateStyle();
        s.field = field;
        return s;
    }

    // The canonical CommonRails printer: 80 columns, 10-digit Object IDs, a
    // 39-wide Current field, a 21x21 square, █/░ glyphs, and the light table.
    PrinterConfig defaults() {
        PrinterConfig p = new PrinterConfig();
        p.printWidth = 80;
        p.oidWidth = 10;
        p.currentWidth = 39;
        p.squareSize = 21;
        p.full = "█";
        p.light = "░";
        p.table = lightTable();
        p.state = stateStyle(10);
        return p;
    }

    // ---- measured-string core -------------------------------------------

    String repeat(String s, int n) {
        String out = "";
        int i = 0;
        while (i < n) {
            out = out + s;
            i = i + 1;
        }
        return out;
    }

    int digitCount(int v) {
        int n = v;
        if (n < 0) { n = -n; }
        int count = 1;
        while (n >= 10) { n = n / 10; count = count + 1; }
        return count;
    }

    // Apply a PadConfig to content with a known character count.
    String applyPad(PadConfig cfg, String content, int chars) {
        int gap = cfg.width - chars;
        if (gap < 0) { gap = 0; }
        String run = repeat(cfg.fill, gap);
        if (cfg.leftAlign) {
            return content + run;
        }
        return run + content;
    }

    // Zero-pad a non-negative int to a width using a zeros() PadConfig.
    String padInt(PadConfig cfg, int value) {
        int v = value;
        if (v < 0) { v = -v; }
        return applyPad(cfg, "" + v, digitCount(v));
    }

    // ---- fixed-width lines ----------------------------------------------

    void line(PrinterConfig cfg, String content, int chars) {
        print(applyPad(left(cfg.printWidth), content, chars));
    }

    void field(String content, int chars, int width) {
        print(applyPad(left(width), content, chars));
    }

    // ---- professional component line ------------------------------------

    String current(PrinterConfig cfg, String name, int nameChars) {
        String inner = "Current: @" + name;
        int gap = cfg.currentWidth - (10 + nameChars);
        if (gap < 0) { gap = 0; }
        return "[" + inner + repeat(" ", gap) + "]";
    }

    void component(PrinterConfig cfg, String name, int nameChars, int oid, int dateSeq, String message) {
        String oidStr = padInt(zeros(cfg.oidWidth), oid);
        String out = "-- : "
            + "[Object ID: " + oidStr + "] "
            + "[Date: " + dateSeq + "] "
            + current(cfg, name, nameChars) + " "
            + ". " + message + " .";
        print(out);
    }

    // ---- state-labelled line --------------------------------------------

    void stateLine(PrinterConfig cfg, String state, int stateChars, String message, int messageChars) {
        String label = "[" + state + "]";
        int labelChars = stateChars + 2;
        int fieldWidth = cfg.state.field;
        if (fieldWidth < labelChars + 1) {
            fieldWidth = labelChars + 1;
        }
        String content = applyPad(left(fieldWidth), label, labelChars) + message;
        line(cfg, content, fieldWidth + messageChars);
    }

    // ---- tables (driven by TableStyle + ColumnConfig) -------------------

    // One horizontal rule given the three junction glyphs and the two columns.
    String rule(TableStyle st, String leftG, String midG, String rightG, ColumnConfig a, ColumnConfig b) {
        int wa = a.width + st.inset + st.inset;
        int wb = b.width + st.inset + st.inset;
        return leftG + repeat(st.h, wa) + midG + repeat(st.h, wb) + rightG;
    }

    void tableTop(TableStyle st, ColumnConfig a, ColumnConfig b) {
        print(rule(st, st.tl, st.tm, st.tr, a, b));
    }
    void tableSep(TableStyle st, ColumnConfig a, ColumnConfig b) {
        print(rule(st, st.ml, st.mm, st.mr, a, b));
    }
    void tableBottom(TableStyle st, ColumnConfig a, ColumnConfig b) {
        print(rule(st, st.bl, st.bm, st.br, a, b));
    }

    // A data row: pads each cell per its column's width + alignment.
    void tableRow(TableStyle st, ColumnConfig a, String c0, int c0Chars, ColumnConfig b, String c1, int c1Chars) {
        String pad = repeat(" ", st.inset);
        String cell0 = applyPad(pad(a.width, " ", a.leftAlign), c0, c0Chars);
        String cell1 = applyPad(pad(b.width, " ", b.leftAlign), c1, c1Chars);
        print(st.v + pad + cell0 + pad + st.v + pad + cell1 + pad + st.v);
    }

    // The header row uses each column's own header text and alignment.
    void tableHeader(TableStyle st, ColumnConfig a, ColumnConfig b) {
        tableRow(st, a, a.header, a.headerChars, b, b.header, b.headerChars);
    }

    // Compose a full two-column table from the config objects: top, header,
    // separator, two data rows, bottom. A developer calls the pieces directly
    // for any number of rows; this is the common two-row convenience.
    void table2(PrinterConfig cfg, ColumnConfig a, ColumnConfig b,
                String r0c0, int r0c0Chars, String r0c1, int r0c1Chars,
                String r1c0, int r1c0Chars, String r1c1, int r1c1Chars) {
        TableStyle st = cfg.table;
        tableTop(st, a, b);
        tableHeader(st, a, b);
        tableSep(st, a, b);
        tableRow(st, a, r0c0, r0c0Chars, b, r0c1, r0c1Chars);
        tableRow(st, a, r1c0, r1c0Chars, b, r1c1, r1c1Chars);
        tableBottom(st, a, b);
    }

    // ---- progress square + pixel ----------------------------------------

    int clampPercent(int percent) {
        int p = percent;
        if (p < 0) { p = 0; }
        if (p > 100) { p = 100; }
        return p;
    }

    int percentToCells(PrinterConfig cfg, int percent) {
        int p = clampPercent(percent);
        int total = cfg.squareSize * cfg.squareSize;
        return (p * total) / 100;
    }

    void square(PrinterConfig cfg, int filledCells) {
        int size = cfg.squareSize;
        int total = size * size;
        int filled = filledCells;
        if (filled < 0) { filled = 0; }
        if (filled > total) { filled = total; }

        int displayRow = 0;
        while (displayRow < size) {
            String row = "";
            int displayCol = 0;
            while (displayCol < size) {
                int fillRow = (size - 1) - displayRow;
                int fillCol = (size - 1) - displayCol;
                int fillIndex = fillRow * size + fillCol;
                if (fillIndex < filled) {
                    row = row + cfg.full;
                } else {
                    row = row + cfg.light;
                }
                displayCol = displayCol + 1;
            }
            print(row);
            displayRow = displayRow + 1;
        }
    }

    void pixel(PrinterConfig cfg, int filledCells) {
        if (filledCells > 0) {
            print(cfg.full);
        } else {
            print(cfg.light);
        }
    }

    // -------------------------------------------------------------------------
    //  Demonstration: a developer composing their own print method from the
    //  configuration objects above.
    // -------------------------------------------------------------------------
    void main() {
        print("=== PrinterConfig — object-oriented CommonRails printing ===");
        print("");

        // 1) Build a printer. Start from defaults, then tune a field.
        PrinterConfig cfg = defaults();

        // 2) Padding objects, reused across calls.
        print("  PadConfig objects (left / right / zeros)");
        print("[" + applyPad(left(10), "left", 4) + "]");
        print("[" + applyPad(right(10), "right", 5) + "]");
        print("[" + padInt(zeros(10), 1234) + "]");
        print("");

        // 3) Professional component + state lines through the config.
        component(cfg, "SearchEngineClient", 18, 1234, 1, "category images now crawling");
        stateLine(cfg, "START", 5, "CommonRails printing initialized", 32);
        stateLine(cfg, "COMPLETE", 8, "fixed-width output ready", 24);
        print("");

        // 4) A table built from ColumnConfig objects + the config's TableStyle.
        print("  table from ColumnConfig objects (light style)");
        ColumnConfig comp = column("Component", 9, 18, true);
        ColumnConfig stat = column("State", 5, 10, true);
        table2(cfg, comp, stat,
            "SearchEngineClient", 18, "WORKING", 7,
            "CommonRails", 11, "COMPLETE", 8);
        print("");

        // 5) Restyle every table by swapping one object — the TableStyle.
        print("  same table, ASCII style (swap TableStyle only)");
        cfg.table = asciiTable();
        table2(cfg, comp, stat,
            "SearchEngineClient", 18, "WORKING", 7,
            "CommonRails", 11, "COMPLETE", 8);
        print("");

        // 6) Progress, driven by the printer's square size + glyphs.
        print("  progress: single cell, then 100%");
        square(cfg, 1);
        print("");
        square(cfg, percentToCells(cfg, 100));
        print("");
        print("done");
    }
}