feat!: rename contract-trait-macro to contracttrait-macro

admin_sep/Cargo.toml

@@ -11,7 +11,7 @@ doctest = false
 
 [dependencies]
 soroban-sdk = { version = "22.0.7" }
-contract-trait-macro = { path = "../contract-trait-macro" }
+contracttrait-macro = { path = "../contracttrait-macro" }
 
 [dev-dependencies]
 soroban-sdk = { version = "22.0.7", features = ["testutils"] }

admin_sep/src/administratable.rs

@@ -1,4 +1,4 @@
-use contract_trait_macro::contracttrait;
+use crate::contracttrait;
 use soroban_sdk::{Address, Env, Symbol, symbol_short};
 
 /// Trait for using an admin address to control access.

admin_sep/src/lib.rs

@@ -1,5 +1,5 @@
 #![no_std]
-pub use contract_trait_macro::*;
+pub use contracttrait_macro::*;
 
 mod administratable;
 mod constructor;

admin_sep/src/upgradable.rs

@@ -1,4 +1,4 @@
-use contract_trait_macro::contracttrait;
+use crate::contracttrait;
 
 use crate::administratable::{Administratable, AdministratableExt};
 

contract-trait-macro/Cargo.toml → contracttrait-macro/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "contract-trait-macro"
+name = "contracttrait-macro"
 version = "0.8.6"
 edition = "2021"
 description = "Macros needed by loam-sdk"

contracttrait-macro/src/lib.rs

@@ -0,0 +1,91 @@
+#![recursion_limit = "128"]
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+
+mod args;
+mod contracttrait;
+mod error;
+mod util;
+
+/// # Creates a Contract Trait
+/// 
+/// A contract trait is defines an interface of a contract and declaritive macro with the same name.
+/// 
+/// When writing a soroban contract, you must expose a methods in an implementation with `#[contractimpl]`.
+/// This works for implementations of traits, but the implementation must define all methods of the trait.
+/// 
+/// For example, consider the following trait and a default implementation:
+/// 
+/// ```ignore
+/// trait Administratable {
+///    fn admin(env: &Env) -> Address;
+///    fn set_admin(env: &Env, new_admin: &Address);
+/// }
+/// 
+/// struct Admin;
+/// impl Administratable for Admin {
+///    fn admin(env: &Env) -> Address {
+///  //...
+/// 
+/// }
+/// 
+/// #[contract]
+/// pub struct Contract;
+/// #[contractimpl]
+/// impl Administratable Contract {
+///     fn admin(env: &Env) -> Address {
+///        Admin::admin(env)
+///     }
+///     fn set_admin(env: &Env, new_admin: &Address) {
+///       Admin::set_admin(env, new_admin);
+///     }
+/// } 
+/// ```
+///
+/// Now this works, but it is not very convenient and is very verbose.
+/// One way to make this more convenient is to use an associated type in the trait:
+/// 
+/// ```ignore
+/// trait Administratable {
+///   type Impl: Administratable;
+///   fn admin(env: &Env) -> Address {
+///     Self::Impl::admin(env)}
+///   }
+///   fn set_admin(env: &Env, new_admin: &Address) {
+///      Self::Impl::set_admin(env, new_admin);
+///   }
+/// }
+/// ```
+/// 
+/// 
+/// # Panics
+///
+/// This macro will panic if:
+/// - The input `TokenStream` cannot be parsed into a valid Rust item.
+/// - The `contracttrait::generate` function fails to generate the companion trait.
+///
+#[proc_macro_attribute]
+pub fn contracttrait(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let (parsed_args, parsed) = match args::parse(attr, item) {
+        Ok((args, item)) => (args, item),
+        Err(e) => return Into::<proc_macro2::TokenStream>::into(e).into(),
+    };
+    contracttrait::generate(&parsed_args, &parsed).into()
+}
+
+/// Derives a contract trait for the given Contract struct.
+/// 
+/// ```ignore
+/// #[contract]
+/// #[derive_contract(Administratable, Upgradable(ext = AdministratableExt))]
+/// pub struct Contract;
+/// ```
+#[proc_macro_attribute]
+pub fn derive_contract(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let (parsed_args, parsed) = match args::parse(attr, item) {
+        Ok((args, item)) => (args, item),
+        Err(e) => return Into::<proc_macro2::TokenStream>::into(e).into(),
+    };
+    contracttrait::derive_contract(&parsed_args, &parsed).into()
+}