chore(trixy): Rename `language_macros` to `trixy`

The motivation behind this change is to comply with the naming scheme:
starting crate names with `tri`

Cargo.lock

@@ -1358,16 +1358,6 @@ dependencies = [
  "thiserror",
 ]
 
-[[package]]
-name = "language_macros"
-version = "0.1.0"
-dependencies = [
- "convert_case",
- "proc-macro2",
- "quote",
- "syn 2.0.41",
-]
-
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -2797,7 +2787,6 @@ dependencies = [
  "directories",
  "indexmap 2.1.0",
  "keymaps",
- "language_macros",
  "matrix-sdk",
  "mlua",
  "once_cell",
@@ -2805,10 +2794,21 @@ dependencies = [
  "serde",
  "tokio",
  "tokio-util",
+ "trixy",
  "tui",
  "tui-textarea",
 ]
 
+[[package]]
+name = "trixy"
+version = "0.1.0"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.41",
+]
+
 [[package]]
 name = "try-lock"
 version = "0.2.5"

Cargo.toml

@@ -18,7 +18,7 @@ matrix-sdk = "0.6"
 tokio = { version = "1.35", features = ["macros", "rt-multi-thread"] }
 
 # lua stuff
-language_macros = { path = "./language_macros" }
+trixy = { path = "./trixy" }
 keymaps = { path = "./keymaps", features = ["crossterm"] }
 mlua = { version = "0.9.2", features = ["lua54", "async", "send", "serialize"] }
 once_cell = "1.19.0"

language_macros/src/command_enum_parsing/mod.rs

@@ -1,110 +0,0 @@
-use syn::{braced, parse::Parse, punctuated::Punctuated, token, Attribute, Ident, Token, Type};
-
-pub type NamespacePath = Punctuated<Ident, Token![::]>;
-
-mod kw {
-    syn::custom_keyword!(commands);
-    syn::custom_keyword!(namespace);
-    syn::custom_keyword!(declare);
-}
-
-#[derive(Debug)]
-pub struct DataCommandEnum {
-    #[allow(dead_code)]
-    commands_token: kw::commands,
-
-    #[allow(dead_code)]
-    brace_token: token::Brace,
-
-    pub fields: Punctuated<Field, Token![,]>,
-}
-
-#[derive(Debug)]
-pub enum Field {
-    Function(FunctionDeclaration),
-    Namespace(Namespace),
-}
-#[derive(Debug)]
-pub struct Namespace {
-    #[allow(dead_code)]
-    namespace_token: kw::namespace,
-
-    pub path: NamespacePath,
-
-    #[allow(dead_code)]
-    brace_token: token::Brace,
-
-    pub fields: Punctuated<Field, Token![,]>,
-}
-#[derive(Debug)]
-pub struct FunctionDeclaration {
-    #[allow(dead_code)]
-    function_token: kw::declare,
-
-    pub name: Ident,
-
-    #[allow(dead_code)]
-    colon_token: Token![:],
-
-    pub ty: Type,
-}
-
-impl Parse for DataCommandEnum {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        let content;
-        Ok(DataCommandEnum {
-            commands_token: input.parse()?,
-            brace_token: braced!(content in input),
-            fields: content.parse_terminated(Field::parse, Token![,])?,
-        })
-    }
-}
-impl Parse for Field {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        let lookahead = input.lookahead1();
-        if input.peek(Token![#]) {
-            // FIXME(@soispha): We ignore doc comments, which should probably be replaced by adding
-            // them to the output <2023-09-19>
-            let _output = input.call(Attribute::parse_outer).unwrap_or(vec![]);
-            let lookahead = input.lookahead1();
-
-            if lookahead.peek(kw::namespace) {
-                input.parse().map(Field::Namespace)
-            } else if lookahead.peek(kw::declare) {
-                input.parse().map(Field::Function)
-            } else {
-                Err(lookahead.error())
-            }
-        } else {
-            if lookahead.peek(kw::declare) {
-                input.parse().map(Field::Function)
-            } else if lookahead.peek(kw::namespace) {
-                input.parse().map(Field::Namespace)
-            } else {
-                Err(lookahead.error())
-            }
-        }
-    }
-}
-
-impl Parse for FunctionDeclaration {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        Ok(FunctionDeclaration {
-            function_token: input.parse()?,
-            name: input.parse()?,
-            colon_token: input.parse()?,
-            ty: input.parse()?,
-        })
-    }
-}
-impl Parse for Namespace {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        let content;
-        Ok(Namespace {
-            namespace_token: input.parse()?,
-            path: NamespacePath::parse_separated_nonempty(input)?,
-            brace_token: braced!(content in input),
-            fields: content.parse_terminated(Field::parse, Token![,])?,
-        })
-    }
-}

trixy/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "language_macros"
+name = "trixy"
 version = "0.1.0"
 edition = "2021"
 

trixy/src/config/mod.rs

@@ -0,0 +1,103 @@
+//! This module is responsible for parsing the config passed to the macro call:
+//! For example:
+//! ```no_run
+//! trixy_generate! {
+//!     path: ./trintrix_command_interface.tri
+//!     languages: rust, lua, c
+//! }
+//! ```
+
+use std::path::PathBuf;
+
+use proc_macro2::Ident;
+use syn::{parse::Parse, punctuated::Punctuated, LitStr, Result, Token};
+
+mod kw {
+    syn::custom_keyword!(path);
+    syn::custom_keyword!(languages);
+}
+
+#[derive(Debug)]
+pub enum Language {
+    Rust,
+    Lua,
+    C,
+}
+
+#[derive(Debug)]
+struct Languages {
+    #[allow(dead_code)]
+    languages: kw::languages,
+    #[allow(dead_code)]
+    colon: Token![:],
+    raw: Punctuated<Language, Token![,]>,
+}
+
+#[derive(Debug)]
+struct Path {
+    #[allow(dead_code)]
+    path: kw::path,
+    #[allow(dead_code)]
+    colon: Token![:],
+    raw: PathBuf,
+}
+
+#[derive(Debug)]
+pub struct TrixyConfig {
+    /// The Path to the base command interface config file
+    path: Path,
+
+    /// The languages the commands should be exposed in
+    languages: Languages,
+}
+impl TrixyConfig {
+    pub fn get_path(&self) -> PathBuf {
+        self.path.raw
+    }
+}
+
+impl Parse for TrixyConfig {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        Ok(Self {
+            path: input.parse()?,
+            languages: input.parse()?,
+        })
+    }
+}
+
+impl Parse for Path {
+    fn parse(input: syn::parse::ParseStream) -> Result<Self> {
+        let path: kw::path = input.parse()?;
+        let colon: Token![:] = input.parse()?;
+        let raw = PathBuf::from(input.parse::<LitStr>()?.value());
+        Ok(Self { path, colon, raw })
+    }
+}
+
+impl Parse for Languages {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let languages: kw::languages = input.parse()?;
+        let colon: Token![:] = input.parse()?;
+        let raw = Punctuated::<Language, Token![,]>::parse_separated_nonempty(input)?;
+        Ok(Self {
+            languages,
+            colon,
+            raw,
+        })
+    }
+}
+
+impl Parse for Language {
+    fn parse(input: syn::parse::ParseStream) -> Result<Self> {
+        let ident: Ident = input.parse()?;
+        match &ident.to_string()[..] {
+            "rust" | "Rust" => Ok(Self::Rust),
+            "lua" | "Lua" => Ok(Self::Lua),
+            "c" | "C" => Ok(Self::C),
+            other => Err(input.error(format!(
+                "The language: `{}` is not a registered language!",
+                other
+            ))),
+        }
+    }
+}

trixy/src/lib.rs

@@ -1,12 +1,16 @@
 use command_enum_parsing::DataCommandEnum;
+use config::TrixyConfig;
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
 use syn::parse_macro_input;
 
+use crate::trixy_lang::parse_trixy_lang;
 
-mod generate;
 mod command_enum_parsing;
+mod config;
+mod generate;
+mod trixy_lang;
 
 /// This is the heart of the command api
 /// It mainly does two things:
@@ -74,18 +78,20 @@ mod command_enum_parsing;
 /// }
 /// ```
 #[proc_macro]
-pub fn parse_command_enum(input: TokenStream) -> TokenStream {
+pub fn trixy_generate(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DataCommandEnum);
+    let input = parse_macro_input!(input as TrixyConfig);
 
-    // Build the language wrappers
+    let trixy_code = parse_trixy_lang(input.get_path());
-    let lua_wrapper: TokenStream2 = generate::lua_wrapper(&input);
+    todo!()
+    // // Build the language wrappers
+    // let lua_wrapper: TokenStream2 = generate::lua_wrapper(&input);
+    //
+    // // Build the final enum
+    // let command_enum = generate::command_enum(&input);
 
-    // Build the final enum
+    // let output = quote! {
-    let command_enum = generate::command_enum(&input);
+    //     #command_enum
-
+    //     #lua_wrapper
-    let output = quote! {
+    // };
-        #command_enum
+    // output.into()
-        #lua_wrapper
-    };
-    output.into()
 }