inkling-loader 0.0.1__tar.gz

inkling_loader-0.0.1/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: inkling-loader
+Version: 0.0.1
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Terminals
+Classifier: Topic :: Utilities
+Classifier: License :: OSI Approved :: MIT License
+Summary: Reveal ASCII art as a progress indicator.
+Keywords: progress,ascii,terminal,loader,tqdm
+Author: Cody Taylor
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/codizzler/inkling
+Project-URL: Repository, https://github.com/codizzler/inkling
+
+# inkling (Python)
+
+Reveal ASCII art as a progress indicator, from Python. Same engine as the Rust crate,
+exposed as a tiny extension built with [PyO3](https://pyo3.rs). It installs as
+`inkling-loader` and imports as `inkling`.
+
+```sh
+pip install inkling-loader
+```
+
+Determinate, like `tqdm` but the bar is a drawing:
+
+```python
+from inkling import Loader
+
+with Loader(total=len(items), rainbow=True) as bar:
+    for it in items:
+        work(it)
+        bar.inc()
+```
+
+A download, setting the position as bytes arrive:
+
+```python
+bar = Loader(total=content_length, art_path="dragon.txt")
+for chunk in response:
+    file.write(chunk)
+    bar.inc(len(chunk))
+bar.finish()
+```
+
+| Method | Effect |
+| --- | --- |
+| `inc(delta=1)` | advance the position |
+| `set(pos)` | set the absolute position |
+| `set_length(total)` | change the total |
+| `set_message(text)` | caption beneath the art |
+| `finish()` / `finish_and_clear()` | finish, keeping or erasing the art |
+
+Constructor keywords: `total`, `art`, `art_path`, `rainbow`, `geodesic`, `reading`,
+`message`.
+
+## Building from source
+
+```sh
+pip install maturin
+maturin develop            # build and install into the current venv
+maturin build --release    # produce a wheel in target/wheels
+```
+
+Built from the [inkling](https://github.com/codizzler/inkling) Rust core. License: MIT.
+

inkling_loader-0.0.1/README.md

@@ -0,0 +1,51 @@
+# inkling (Python)
+
+Reveal ASCII art as a progress indicator, from Python. Same engine as the Rust crate,
+exposed as a tiny extension built with [PyO3](https://pyo3.rs). It installs as
+`inkling-loader` and imports as `inkling`.
+
+```sh
+pip install inkling-loader
+```
+
+Determinate, like `tqdm` but the bar is a drawing:
+
+```python
+from inkling import Loader
+
+with Loader(total=len(items), rainbow=True) as bar:
+    for it in items:
+        work(it)
+        bar.inc()
+```
+
+A download, setting the position as bytes arrive:
+
+```python
+bar = Loader(total=content_length, art_path="dragon.txt")
+for chunk in response:
+    file.write(chunk)
+    bar.inc(len(chunk))
+bar.finish()
+```
+
+| Method | Effect |
+| --- | --- |
+| `inc(delta=1)` | advance the position |
+| `set(pos)` | set the absolute position |
+| `set_length(total)` | change the total |
+| `set_message(text)` | caption beneath the art |
+| `finish()` / `finish_and_clear()` | finish, keeping or erasing the art |
+
+Constructor keywords: `total`, `art`, `art_path`, `rainbow`, `geodesic`, `reading`,
+`message`.
+
+## Building from source
+
+```sh
+pip install maturin
+maturin develop            # build and install into the current venv
+maturin build --release    # produce a wheel in target/wheels
+```
+
+Built from the [inkling](https://github.com/codizzler/inkling) Rust core. License: MIT.

inkling_loader-0.0.1/inkling/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "inkling-loader"
+version = "0.0.1"
+edition = "2021"
+rust-version = "1.74"
+description = "Reveal arbitrary ASCII art as a progress indicator by choosing the order its glyphs appear."
+repository = "https://github.com/codizzler/inkling"
+license = "MIT"
+keywords = ["progress", "ascii", "terminal", "tui", "animation"]
+categories = ["command-line-interface", "visualization"]
+
+# Published as `inkling-loader` (the short name `inkling` is taken), but imported as `inkling`.
+[lib]
+name = "inkling"
+
+[features]
+default = ["terminal"]
+# The core (art, rank, ordering, easing, frame) is pure std with zero
+# dependencies. Only the live terminal renderer pulls in crossterm.
+terminal = ["dep:crossterm"]
+
+[dependencies]
+crossterm = { version = "0.28", optional = true }

inkling_loader-0.0.1/inkling/assets/dragon.txt

@@ -0,0 +1,43 @@
+                                        ,   ,                                
+                                        $,  $,     ,                         
+                                        "ss.$ss. .s'                         
+                                ,     .ss$$$$$$$$$$s,                        
+                                $. s$$$$$$$$$$$$$$`$$Ss                      
+                                "$$$$$$$$$$$$$$$$$$o$$$       ,              
+                               s$$$$$$$$$$$$$$$$$$$$$$$$s,  ,s               
+                              s$$$$$$$$$"$$$$$$""""$$$$$$"$$$$$,             
+                              s$$$$$$$$$$s""$$$$ssssss"$$$$$$$$"             
+                             s$$$$$$$$$$'         `"""ss"$"$s""              
+                             s$$$$$$$$$$,              `"""""$  .s$$s        
+                             s$$$$$$$$$$$$s,...               `s$$'  `       
+                         `ssss$$$$$$$$$$$$$$$$$$$$####s.     .$$"$.   , s-   
+                           `""""$$$$$$$$$$$$$$$$$$$$#####$$$$$$"     $.$'    
+ Posable artist:                 "$$$$$$$$$$$$$$$$$$$$$####s""     .$$$|     
+   -Tua Xiong                      "$$$$$$$$$$$$$$$$$$$$$$$$##s    .$$" $    
+                                   $$""$$$$$$$$$$$$$$$$$$$$$$$$$$$$$"   `    
+                                  $$"  "$"$$$$$$$$$$$$$$$$$$$$S""""'         
+                             ,   ,"     '  $$$$$$$$$$$$$$$$####s             
+                             $.          .s$$$$$$$$$$$$$$$$$####"            
+                 ,           "$s.   ..ssS$$$$$$$$$$$$$$$$$$$####"            
+                 $           .$$$S$$$$$$$$$$$$$$$$$$$$$$$$#####"             
+                 Ss     ..sS$$$$$$$$$$$$$$$$$$$$$$$$$$$######""              
+                  "$$sS$$$$$$$$$$$$$$$$$$$$$$$$$$$########"                  
+           ,      s$$$$$$$$$$$$$$$$$$$$$$$$#########""'                      
+           $    s$$$$$$$$$$$$$$$$$$$$$#######""'      s'         ,           
+           $$..$$$$$$$$$$$$$$$$$$######"'       ....,$$....    ,$            
+            "$$$$$$$$$$$$$$$######"' ,     .sS$$$$$$$$$$$$$$$$s$$            
+              $$$$$$$$$$$$#####"     $, .s$$$$$$$$$$$$$$$$$$$$$$$$s.         
+   )          $$$$$$$$$$$#####'      `$$$$$$$$$###########$$$$$$$$$$$.       
+  ((          $$$$$$$$$$$#####       $$$$$$$$###"       "####$$$$$$$$$$      
+  ) \         $$$$$$$$$$$$####.     $$$$$$###"             "###$$$$$$$$$   s'
+ (   )        $$$$$$$$$$$$$####.   $$$$$###"                ####$$$$$$$$s$$' 
+ )  ( (       $$"$$$$$$$$$$$#####.$$$$$###'                .###$$$$$$$$$$"   
+ (  )  )   _,$"   $$$$$$$$$$$$######.$$##'                .###$$$$$$$$$$     
+ ) (  ( \.         "$$$$$$$$$$$$$#######,,,.          ..####$$$$$$$$$$$"     
+(   )$ )  )        ,$$$$$$$$$$$$$$$$$$####################$$$$$$$$$$$"       
+(   ($$  ( \     _sS"  `"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$S$$,       
+ )  )$$$s ) )  .      .   `$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$"'  `$$      
+  (   $$$Ss/  .$,    .$,,s$$$$$$##S$$$$$$$$$$$$$$$$$$$$$$$$S""        '      
+    \)_$$$$$$$$$$$$$$$$$$$$$$$##"  $$        `$$.        `$$.                
+        `"S$$$$$$$$$$$$$$$$$#"      $          `$          `$                
+            `"""""""""""""'         '           '           '

inkling_loader-0.0.1/inkling/assets/inkling.txt

@@ -0,0 +1,7 @@
+      ::::::::::: ::::    ::: :::    ::: :::        ::::::::::: ::::    :::  :::::::: 
+         :+:     :+:+:   :+: :+:   :+:  :+:            :+:     :+:+:   :+: :+:    :+: 
+        +:+     :+:+:+  +:+ +:+  +:+   +:+            +:+     :+:+:+  +:+ +:+         
+       +#+     +#+ +:+ +#+ +#++:++    +#+            +#+     +#+ +:+ +#+ :#:          
+      +#+     +#+  +#+#+# +#+  +#+   +#+            +#+     +#+  +#+#+# +#+   +#+#    
+     #+#     #+#   #+#+# #+#   #+#  #+#            #+#     #+#   #+#+# #+#    #+#     
+########### ###    #### ###    ### ########## ########### ###    ####  ########       

inkling_loader-0.0.1/inkling/assets/inkling3d.txt

@@ -0,0 +1,22 @@
+          _____                    _____                    _____                    _____            _____                    _____                    _____          
+         /\    \                  /\    \                  /\    \                  /\    \          /\    \                  /\    \                  /\    \         
+        /::\    \                /::\____\                /::\____\                /::\____\        /::\    \                /::\____\                /::\    \        
+        \:::\    \              /::::|   |               /:::/    /               /:::/    /        \:::\    \              /::::|   |               /::::\    \       
+         \:::\    \            /:::::|   |              /:::/    /               /:::/    /          \:::\    \            /:::::|   |              /::::::\    \      
+          \:::\    \          /::::::|   |             /:::/    /               /:::/    /            \:::\    \          /::::::|   |             /:::/\:::\    \     
+           \:::\    \        /:::/|::|   |            /:::/____/               /:::/    /              \:::\    \        /:::/|::|   |            /:::/  \:::\    \    
+           /::::\    \      /:::/ |::|   |           /::::\    \              /:::/    /               /::::\    \      /:::/ |::|   |           /:::/    \:::\    \   
+  ____    /::::::\    \    /:::/  |::|   | _____    /::::::\____\________    /:::/    /       ____    /::::::\    \    /:::/  |::|   | _____    /:::/    / \:::\    \  
+ /\   \  /:::/\:::\    \  /:::/   |::|   |/\    \  /:::/\:::::::::::\    \  /:::/    /       /\   \  /:::/\:::\    \  /:::/   |::|   |/\    \  /:::/    /   \:::\ ___\ 
+/::\   \/:::/  \:::\____\/:: /    |::|   /::\____\/:::/  |:::::::::::\____\/:::/____/       /::\   \/:::/  \:::\____\/:: /    |::|   /::\____\/:::/____/  ___\:::|    |
+\:::\  /:::/    \::/    /\::/    /|::|  /:::/    /\::/   |::|~~~|~~~~~     \:::\    \       \:::\  /:::/    \::/    /\::/    /|::|  /:::/    /\:::\    \ /\  /:::|____|
+ \:::\/:::/    / \/____/  \/____/ |::| /:::/    /  \/____|::|   |           \:::\    \       \:::\/:::/    / \/____/  \/____/ |::| /:::/    /  \:::\    /::\ \::/    / 
+  \::::::/    /                   |::|/:::/    /         |::|   |            \:::\    \       \::::::/    /                   |::|/:::/    /    \:::\   \:::\ \/____/  
+   \::::/____/                    |::::::/    /          |::|   |             \:::\    \       \::::/____/                    |::::::/    /      \:::\   \:::\____\    
+    \:::\    \                    |:::::/    /           |::|   |              \:::\    \       \:::\    \                    |:::::/    /        \:::\  /:::/    /    
+     \:::\    \                   |::::/    /            |::|   |               \:::\    \       \:::\    \                   |::::/    /          \:::\/:::/    /     
+      \:::\    \                  /:::/    /             |::|   |                \:::\    \       \:::\    \                  /:::/    /            \::::::/    /      
+       \:::\____\                /:::/    /              \::|   |                 \:::\____\       \:::\____\                /:::/    /              \::::/    /       
+        \::/    /                \::/    /                \:|   |                  \::/    /        \::/    /                \::/    /                \::/____/        
+         \/____/                  \/____/                  \|___|                   \/____/          \/____/                  \/____/                                  
+                                                                                                                                                                       

inkling_loader-0.0.1/inkling/assets/serpent.txt

@@ -0,0 +1,17 @@
+           /^\/^\
+         _|_O|  O|
+\/     /~     \_/ \
+ \____|__________/  \
+        \_______      \
+                `\     \                 \
+                  |     |                  \
+                 /      /                    \
+                /     /                       \\
+              /      /                         \ \
+             /     /                            \  \
+           /     /             _----_            \   \
+          /     /           _-~      ~-_         |   |
+         (      (        _-~    _--_    ~-_     _/   |
+          \      ~-____-~    _-~    ~-_    ~-_-~    /
+            ~-_           _-~          ~-_       _-~
+               ~--______-~                ~-___-~

inkling_loader-0.0.1/inkling/examples/download.rs

@@ -0,0 +1,138 @@
+//! A demo that reads like a real CLI tool installing something, with the dragon
+//! reveal as the download step. Paced like a true transfer and made for recording.
+//!
+//!   cargo run --example download                          # glow, built-in dragon
+//!   cargo run --example download -- rainbow               # rainbow palette
+//!   cargo run --example download -- geodesic serpent.txt  # geodesic spine trace
+//!   cargo run --example download -- rainbow art.txt       # rainbow, your own art
+
+use std::io::{self, Write};
+use std::thread;
+use std::time::{Duration, Instant};
+
+use crossterm::{
+    cursor::MoveTo,
+    execute,
+    style::{Color, Print, ResetColor, SetForegroundColor},
+    terminal::{Clear, ClearType},
+};
+use inkling::{ordering::Geodesic, render::Style, Loader};
+
+fn step(mark: &str, color: Color, msg: &str) {
+    let _ = execute!(
+        io::stdout(),
+        Print("  "),
+        SetForegroundColor(color),
+        Print(mark),
+        ResetColor,
+        Print(format!(" {msg}\r\n"))
+    );
+}
+
+fn pause(ms: u64) {
+    thread::sleep(Duration::from_millis(ms));
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    let rainbow = args.iter().any(|a| a == "rainbow");
+    let geodesic = args.iter().any(|a| a == "geodesic");
+    let art_path = args.iter().find(|a| a.ends_with(".txt")).cloned();
+    let started = Instant::now();
+    let gold = Color::Rgb {
+        r: 232,
+        g: 180,
+        b: 85,
+    };
+
+    // Clear to a fresh screen and print the tool banner.
+    let _ = execute!(
+        io::stdout(),
+        Clear(ClearType::All),
+        MoveTo(0, 0),
+        Print("\r\n  "),
+        SetForegroundColor(gold),
+        Print("dragonctl"),
+        ResetColor,
+        Print("  v0.2.0\r\n\r\n")
+    );
+
+    step("\u{2713}", Color::Green, "Initializing demo environment");
+    pause(450);
+    step("\u{2713}", Color::Green, "Updating base image index");
+    pause(500);
+    step("\u{2193}", Color::Cyan, "Downloading base image");
+    let _ = execute!(io::stdout(), Print("\r\n"));
+
+    // The download itself, paced unevenly: a connect stall, a hiccup, a burst, a
+    // mid stall, and a slow tail.
+    let total: u64 = 48 * 1024 * 1024;
+    let mb = 1024.0 * 1024.0;
+    let schedule: &[(f64, u64)] = &[
+        (0.0, 600),
+        (5.0, 300),
+        (8.0, 250),
+        (8.0, 650),
+        (16.0, 220),
+        (27.0, 180),
+        (38.0, 200),
+        (45.0, 450),
+        (56.0, 200),
+        (67.0, 220),
+        (78.0, 260),
+        (87.0, 320),
+        (93.0, 480),
+        (97.0, 520),
+        (100.0, 300),
+    ];
+
+    let style = if rainbow {
+        Style::rainbow()
+    } else {
+        Style::default()
+    };
+    let mut builder = Loader::builder().total(total).style(style);
+    if geodesic {
+        builder = builder.ordering(Geodesic::default());
+    }
+    if let Some(path) = &art_path {
+        let text = std::fs::read_to_string(path).unwrap_or_else(|e| {
+            eprintln!("could not read {path}: {e}");
+            std::process::exit(1);
+        });
+        builder = builder.art(inkling::Art::parse(&text));
+    }
+    let loader = builder.start();
+    for &(percent, dwell) in schedule {
+        let done = (percent / 100.0 * total as f64) as u64;
+        loader.set(done);
+        loader.set_message(format!(
+            "dragon.iso   {:.1} / {:.1} MB",
+            done as f64 / mb,
+            total as f64 / mb
+        ));
+        pause(dwell);
+    }
+    loader.finish();
+
+    // A finish that ties it together.
+    let _ = execute!(io::stdout(), Print("\r\n"));
+    step(
+        "\u{2713}",
+        Color::Green,
+        "Verified checksum  sha256:a1b2c3d4e5",
+    );
+    pause(400);
+    let _ = execute!(
+        io::stdout(),
+        Print("\r\n  "),
+        SetForegroundColor(Color::Green),
+        Print("Done"),
+        ResetColor,
+        Print(format!(
+            " in {:.1}s. dragon.iso (48.0 MB) ready.\r\n\r\n",
+            started.elapsed().as_secs_f64()
+        ))
+    );
+    let _ = io::stdout().flush();
+}

inkling_loader-0.0.1/inkling/examples/dragon.rs

@@ -0,0 +1,152 @@
+//! The dragon demo.
+//!
+//!   cargo run --example dragon                       # live reveal in your terminal
+//!   cargo run --example dragon -- --snapshots        # staged text frames (no TTY needed)
+//!   cargo run --example dragon -- --art path/to.txt  # bring your own ASCII art
+//!
+//! By default it reveals a procedurally generated serpent, a single, perfectly
+//! 8-connected stroke, so the geodesic spine-trace paints it tip-to-tip. Point
+//! `--art` at any file to watch arbitrary art reveal (imperfect art leans on the
+//! island fallback and still looks intentional).
+
+use std::io::IsTerminal;
+
+use inkling::{
+    art::Art,
+    frame,
+    ordering::{Geodesic, GeodesicReport, Ordering, StartHint},
+};
+
+fn main() {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    let snapshots = args.iter().any(|a| a == "--snapshots");
+
+    let art = match arg_value(&args, "--art") {
+        Some(path) => match std::fs::read_to_string(&path) {
+            Ok(text) => Art::parse(&text),
+            Err(e) => {
+                eprintln!("inkling: could not read {path}: {e}");
+                std::process::exit(1);
+            }
+        },
+        None => Art::parse(&serpent(64, 13)),
+    };
+
+    let ordering = Geodesic {
+        start: StartHint::TopLeft,
+    };
+    let GeodesicReport {
+        ink_cells,
+        connected_cells,
+        spine_length,
+    } = ordering.diagnose(&art);
+    let ranks = ordering.rank(&art);
+
+    eprintln!(
+        "inkling · {ink_cells} ink cells · {connected_cells} on the spine \
+         ({:.0}% connected) · spine length {spine_length}",
+        100.0 * connected_cells as f32 / ink_cells.max(1) as f32,
+    );
+
+    // Headless / piped / explicit: print staged text frames and exit.
+    if snapshots || !std::io::stdout().is_terminal() {
+        for p in [0.0, 0.2, 0.4, 0.6, 0.8, 1.0] {
+            println!("\n── progress {:>3.0}% {}", p * 100.0, "─".repeat(28));
+            print!("{}", frame::to_string(&art, &ranks, p));
+        }
+        return;
+    }
+
+    #[cfg(feature = "terminal")]
+    {
+        use inkling::{
+            easing::Easing,
+            render::{animate, Style},
+        };
+        use std::time::Duration;
+        if let Err(e) = animate(
+            &art,
+            &ranks,
+            Style::default(),
+            Duration::from_millis(3500),
+            Easing::EaseInOutCubic,
+        ) {
+            eprintln!("inkling: render error: {e}");
+        }
+    }
+}
+
+/// Read the value following `key` in `args` (supports `--key value` and `--key=value`).
+fn arg_value(args: &[String], key: &str) -> Option<String> {
+    let mut it = args.iter();
+    while let Some(a) = it.next() {
+        if a == key {
+            return it.next().cloned();
+        }
+        if let Some(v) = a.strip_prefix(&format!("{key}=")) {
+            return Some(v.to_string());
+        }
+    }
+    None
+}
+
+/// Generate an Eastern-style serpent as a single 8-connected stroke: a sine-wave
+/// body with crest spikes and a small head. Connectivity is guaranteed by
+/// filling any vertical gap between adjacent columns, so the spine-trace reveals
+/// it flawlessly from tail to head.
+// Columns are scanned by index because each row `y` is *computed* from `x`
+// (y = sine(x)); writing `grid[y][x]` is the clearest expression of that.
+#[allow(clippy::needless_range_loop)]
+fn serpent(width: usize, height: usize) -> String {
+    use std::f32::consts::TAU;
+
+    let amp = ((height as f32) - 3.0).max(1.0) / 2.0;
+    let mid = (height as f32 - 1.0) / 2.0;
+    let period = (width as f32) / 2.0; // two coils across the width
+
+    let y_at = |x: usize| -> usize {
+        let yf = mid - amp * ((x as f32) / period * TAU).sin();
+        yf.round().clamp(0.0, height as f32 - 1.0) as usize
+    };
+
+    let mut grid = vec![vec![' '; width]; height];
+    let mut prev_y = y_at(0);
+    for x in 0..width {
+        let y = y_at(x);
+        // Bridge any vertical gap so the body is one continuous stroke.
+        if x > 0 && y.abs_diff(prev_y) > 1 {
+            for row in grid[y.min(prev_y)..=y.max(prev_y)].iter_mut() {
+                if row[x] == ' ' {
+                    row[x] = '|';
+                }
+            }
+        }
+        grid[y][x] = match prev_y {
+            _ if x == 0 => '~',
+            py if y < py => '/',
+            py if y > py => '\\',
+            _ => '~',
+        };
+        prev_y = y;
+    }
+
+    // Spikes on the crests (local highs), one row above the body.
+    for x in 1..width.saturating_sub(1) {
+        let y = y_at(x);
+        if y > 0 && y < y_at(x - 1) && y <= y_at(x + 1) {
+            grid[y - 1][x] = '^';
+        }
+    }
+
+    // A small head at the leading (right) tip.
+    let (hx, hy) = (width - 1, y_at(width - 1));
+    grid[hy][hx] = '>';
+    if hy > 0 {
+        grid[hy - 1][hx.saturating_sub(1)] = 'o'; // eye
+    }
+
+    grid.into_iter()
+        .map(|row| row.into_iter().collect::<String>())
+        .collect::<Vec<_>>()
+        .join("\n")
+}

inkling_loader-0.0.1/inkling/examples/loader.rs

@@ -0,0 +1,73 @@
+//! A tour of Inkling as a loader.
+//!
+//!   cargo run --example loader            # determinate dragon loader
+//!   cargo run --example loader -- iter    # wrap an iterator
+//!   cargo run --example loader -- spinner # indeterminate spinner
+//!   cargo run --example loader -- threads # progress from worker threads
+//!   cargo run --example loader -- rainbow # lolcat-style rainbow palette
+//!
+//! On a real terminal the dragon paints itself as the work runs. Piped or in CI it
+//! prints the finished art once instead.
+
+use std::thread;
+use std::time::Duration;
+
+use inkling::{Loader, ProgressIteratorExt};
+
+fn work(ms: u64) {
+    thread::sleep(Duration::from_millis(ms));
+}
+
+fn main() {
+    match std::env::args().nth(1).as_deref() {
+        Some("iter") => {
+            for _ in (0..100).inkling() {
+                work(20);
+            }
+        }
+        Some("spinner") => {
+            let loader = Loader::spinner();
+            loader.set_message("Doing something mysterious");
+            work(2500);
+            loader.finish();
+        }
+        Some("threads") => {
+            let loader = Loader::new(120);
+            loader.set_message("Four workers, one dragon");
+            thread::scope(|s| {
+                for _ in 0..4 {
+                    let handle = loader.handle();
+                    s.spawn(move || {
+                        for _ in 0..30 {
+                            work(30);
+                            handle.inc(1);
+                        }
+                    });
+                }
+            });
+            loader.finish();
+        }
+        Some("rainbow") => {
+            let loader = Loader::builder()
+                .total(100)
+                .style(inkling::render::Style::rainbow())
+                .message("Tasting the rainbow")
+                .start();
+            for _ in 0..100 {
+                work(20);
+                loader.inc(1);
+            }
+            loader.finish();
+        }
+        _ => {
+            let total: u64 = 100;
+            let loader = Loader::new(total);
+            loader.set_message("Summoning the dragon");
+            for _ in 0..total {
+                work(20);
+                loader.inc(1);
+            }
+            loader.finish();
+        }
+    }
+}