From ecdbb3cfa7083f82b0a415cf59a16af60b3453f5 Mon Sep 17 00:00:00 2001
From: Condorra <kvox990h@anonaddy.me>
Date: Fri, 27 Sep 2024 22:45:12 +1000
Subject: [PATCH] Allow listing aliases with #alias with no args.

---
 src/lua_engine.rs        |  2 +-
 src/lua_engine/frames.rs | 57 ++++++++++++++++++++++++++++++++++++----
 src/lua_engine/muds.rs   |  2 +-
 3 files changed, 54 insertions(+), 7 deletions(-)

diff --git a/src/lua_engine.rs b/src/lua_engine.rs
index 5be168d..ec9f730 100644
--- a/src/lua_engine.rs
+++ b/src/lua_engine.rs
@@ -246,7 +246,7 @@ pub fn install_lua_globals(
             register_class_function!(mud_class_table, mudoutput_dont);
             register_class_function!(mud_class_table, mudoutput_subnegotiation);
             register_class_function!(mud_class_table, mudinput_line);
-            register_class_function!(mud_class_table, "new", new_mud);
+            register_stateless_class_function!(mud_class_table, "new", new_mud);
 
             macro_rules! register_class_nop {
                 ($class_table: ident, $sym: ident) => {
diff --git a/src/lua_engine/frames.rs b/src/lua_engine/frames.rs
index 67fbb02..9e87496 100644
--- a/src/lua_engine/frames.rs
+++ b/src/lua_engine/frames.rs
@@ -5,8 +5,9 @@ use crate::{
     GlobalLayoutCell, GlobalLayoutState, GlobalMemoCell, TermFrame,
 };
 use gc_arena::{Gc, Rootable};
+use itertools::Itertools;
 use piccolo::{
-    self, async_sequence, Callback, CallbackReturn, Context, FromValue, Function, IntoValue,
+    self, async_sequence, Callback, CallbackReturn, Context, Error, FromValue, Function, IntoValue,
     SequenceReturn, StashedTable, StashedUserData, StashedValue, Table, UserData, Value, Variadic,
 };
 use std::{rc::Rc, str};
@@ -17,10 +18,15 @@ use super::call_checking_metatable;
 pub fn alias<'gc, 'a>(ctx: Context<'gc>) -> Callback<'gc> {
     Callback::from_fn(&ctx, move |ctx, _ex, mut stack| {
         let info: Table = ctx.get_global("info")?;
-        let cur_frame: TermFrame =
+        let cur_frame_id: TermFrame =
             try_unwrap_frame(ctx, &info.get(ctx, ctx.intern_static(b"current_frame"))?)?;
         let frames: Table = ctx.get_global("frames")?;
-        let cur_frame: Table = frames.get(ctx, cur_frame.0 as i64)?;
+        let cur_frame: Table = frames.get(ctx, cur_frame_id.0 as i64)?;
+        let aliases: UserData = cur_frame.get(ctx, "aliases")?;
+
+        if stack.is_empty() {
+            return list_aliases(cur_frame_id, aliases, ctx);
+        }
 
         let alias_match: piccolo::String = piccolo::String::from_value(
             ctx,
@@ -40,8 +46,6 @@ pub fn alias<'gc, 'a>(ctx: Context<'gc>) -> Callback<'gc> {
             ))?;
         }
 
-        let aliases: UserData = cur_frame.get(ctx, "aliases")?;
-
         stack.push_back(aliases.into_value(ctx));
         stack.push_back(alias_match.into_value(ctx));
         stack.push_back(sub_to.into_value(ctx));
@@ -57,6 +61,49 @@ pub fn alias<'gc, 'a>(ctx: Context<'gc>) -> Callback<'gc> {
     })
 }
 
+fn list_aliases<'gc>(
+    frame: TermFrame,
+    aliases: UserData<'gc>,
+    ctx: Context<'gc>,
+) -> Result<CallbackReturn<'gc>, Error<'gc>> {
+    let seq = async_sequence(&ctx, |locals, mut seq| {
+        let frame = locals.stash(&ctx, intern_id(ctx, frame));
+        let aliases = locals.stash(&ctx, aliases);
+        async move {
+            call_checking_metatable::<StashedUserData>(&mut seq, aliases, "lua_table", &[]).await?;
+            let echo_func = seq.try_enter(|ctx, locals, _ex, mut stack| {
+                let alias_tab: Table = stack.consume(ctx)?;
+                stack.push_back(locals.fetch(&frame).into_value(ctx));
+                stack.push_back(
+                    alias_tab
+                        .iter()
+                        .map(|(k, v)| {
+                            Ok::<String, Error>(format!(
+                                "{} => {}",
+                                &String::from_value(ctx, k)?,
+                                &String::from_value(ctx, v)?
+                            ))
+                        })
+                        .collect::<Result<Vec<String>, Error>>()?
+                        .iter()
+                        .join("\r\n")
+                        .into_value(ctx),
+                );
+                Ok(locals.stash(
+                    &ctx,
+                    ctx.get_global::<Table>("commands")?
+                        .get::<&str, Function>(ctx, "echo_frame")?,
+                ))
+            })?;
+
+            seq.call(&echo_func, 0).await?;
+
+            Ok(SequenceReturn::Return)
+        }
+    });
+    Ok(CallbackReturn::Sequence(seq))
+}
+
 pub fn echo_frame_raw<'gc, 'a>(
     ctx: Context<'gc>,
     global_memo: &'a GlobalMemoCell,
diff --git a/src/lua_engine/muds.rs b/src/lua_engine/muds.rs
index b147189..14b74fe 100644
--- a/src/lua_engine/muds.rs
+++ b/src/lua_engine/muds.rs
@@ -471,7 +471,7 @@ pub(super) fn mudinput_line<'gc>(
     })
 }
 
-pub(super) fn new_mud<'gc>(ctx: Context<'gc>, _global_memo: &GlobalMemoCell) -> Callback<'gc> {
+pub(super) fn new_mud<'gc>(ctx: Context<'gc>) -> Callback<'gc> {
     Callback::from_fn(&ctx, move |ctx, _ex, mut stack| {
         let mud: Table = Table::from_value(
             ctx,