cargo-e 0.3.2

// // // src/a_funny_docs.rs

// // // =============================
// // // Humorous Macro Definition
// // // =============================

// // /// **HA! DIDN'T GET IT THE FIRST TIME?**
// // ///
// // /// This macro is your second chance to be enlightened by the absurdity of our code base.
// // ///
// // /// Imagine a world where every line of code bursts with humor and genius—that's what you're about to experience.
// // /// If you're still scratching your head, don't worry; confusion is merely the first step toward brilliant epiphanies.
// // ///
// // /// **READ THIS, YOU ABSOLUTE GENIUS!**
// // /// For a comprehensive, mind-blowing guide that will forever change your perspective on code and life, please check out the
// // /// **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**.
// // ///
// // /// *Remember: If you missed it the first time, you'll never miss it again!*
// // ///
// // /// # Example
// // ///
// // /// ```rust
// // /// funny_macro!();
// // /// ```
// // #[macro_export]
// // #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// // macro_rules! funny_macro {
// //     () => {{
// //         println!("Your funny macro is in full swing! Have you checked out the ultimate guide yet?");
// //     }};
// // }

// // // =============================
// // // Humorous Module with Various Items
// // // =============================

// // /// A collection of humorous documentation items that serve no functional purpose
// // /// except to remind you that coding can be as funny as it is brilliant.
// // ///
// // /// This module is packed with a constant, function, struct, enum, trait, and type alias,
// // /// each with its own extended, side-splitting commentary. And yes, every item includes
// // /// an undeniably large and obvious link to the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**.
// // ///
// // /// If the feature flag `funny-docs` is disabled, these items will be hidden from your generated documentation.
// // #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// // pub mod a_funny_docs {
// //     // A constant with a humorous twist.
// //     #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// //     #[doc = "**CONSTANT COMEDY ALERT:**\nIf numbers could laugh, this constant would be chuckling at the absurdity of fixed values.\n\nFor the ultimate comedy in coding, visit the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
// //     pub const a_const: () = ();

// //     // A function that tells a joke.
// //     #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// //     #[doc = "**FUNCTION FUNNY BUSINESS:**\nThis function doesn't do much—it's here for the giggles. Every time it's called, the universe aligns with a pun.\n\nFor more hilarity, check out the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
// //     pub fn a_function() {
// //         println!("Function humor: a_function executed!");
// //     }

// //     // A struct that stands as a monument to mirth.
// //     #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// //     #[doc = "**STRUCTURE OF LAUGHTER:**\nThis struct is built on a foundation of humor. Its very existence is a testament to the power of a well-timed joke.\n\nFor the blueprint of comedy, see the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
// //     pub struct AStruct;

// //     // An enum whose variants are pure punchlines.
// //     #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// //     #[doc = "**ENUMERATE THE LAUGHTER:**\nThis enum's variants are as surprising as a punchline in the middle of a monologue. Discover the unexpected twist in every variant.\n\nFor more, check out the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
// //     pub enum AEnum {
// //         #[doc = "**AVARIANT, THE PUNCHLINE:**\nThis variant is the climax of our enum saga—laugh, cry, and then laugh again."]
// //         AVariant,
// //     }

// //     // A trait that defines a contract for comedic behavior.
// //     #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// //     #[doc = "**TRAIT OF TONGUE-IN-CHEEK:**\nThis trait defines behaviors with a side-splitting twist. Implement it if you want your types to perform like a stand-up comedian.\n\nFor in-depth trait-based hilarity, see the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
// //     pub trait ATrait {
// //         // You could define a dummy method here if desired.
// //     }

// //     // A type alias that proves brevity can be uproariously funny.
// //     #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// //     #[doc = "**ALIAS OF ABSURDITY:**\nThis type alias is like the punchline of a great joke: short, memorable, and guaranteed to leave an impression.\n\nWhen in doubt, refer to the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)** for a dose of coding comedy."]
// //     pub type AType = ();
// // }

// // // =============================
// // // Re-Exports for Public Visibility
// // // =============================

// // /// If you still haven't grasped the joke, take another look!
// // ///
// // /// Check out the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**,
// // /// where the ultimate comedic wisdom is laid out for your enlightenment.
// // #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// // pub use a_funny_docs as guide;

// // /// Behold the macro that brings the laughter!
// // /// If you didn't get it the first time, this macro is here to ensure you have a second shot at the comedy gold.
// // /// For the full comedic effect, please see the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**.
// // #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// // pub use funny_macro;

// // src/a_funny_docs.rs

// #![allow(dead_code)]

// // For dynamic type names.
// use paste::paste;

// //
// // Dynamic naming macro example using the paste crate.
// //
// // To use this, add `paste = "1.0"` to your Cargo.toml dependencies.
// //

// /// Defines a new funny struct whose name always starts with an "A" followed by the provided identifier.
// ///
// /// # Example
// ///
// /// ```rust
// /// define_funny_struct!(CrazyDuck);
// /// // This creates a struct named `ACrazyDuck`
// /// ```
// #[macro_export]
// macro_rules! define_funny_struct {
//     ($name:ident) => {
//         paste::paste! {
//             #[doc = concat!("A hilariously named struct: `A", stringify!($name), "`! It's guaranteed to make your codebase smile. For more, check out the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**.")]
//             pub struct [<A $name>];
//         }
//     };
// }

// // =============================
// // Humorous Macro Definition
// // =============================

// /// **HA! DIDN'T GET IT THE FIRST TIME?**
// ///
// /// This macro is your second chance to be enlightened by the absurdity of our code base.
// ///
// /// Imagine a world where every line of code bursts with humor and genius—that's what you're about to experience.
// /// If you're still scratching your head, don't worry; confusion is merely the first step toward brilliant epiphanies.
// ///
// /// **READ THIS, YOU ABSOLUTE GENIUS!**
// /// For a comprehensive, mind-blowing guide that will forever change your perspective on code and life, please check out the
// /// **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**.
// ///
// /// *Remember: If you missed it the first time, you'll never miss it again!*
// ///
// /// # Example
// ///
// /// ```rust
// /// funny_macro!();
// /// ```
// #[macro_export]
// #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// macro_rules! funny_macro {
//     () => {{
//         println!("Your funny macro is in full swing! Have you checked out the ultimate guide yet?");
//     }};
// }

// // =============================
// // Humorous Module with Various Items
// // =============================

// /// A collection of humorous documentation items that serve no functional purpose
// /// except to remind you that coding can be as funny as it is brilliant.
// ///
// /// This module is packed with a constant, function, struct, enum, trait, type alias, and even a dynamically named struct,
// /// each with its own extended, side-splitting commentary. Every item includes the unmistakable link to the
// /// **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**.
// ///
// /// If the `funny-docs` feature is disabled, these items are hidden from your final generated documentation.
// #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// pub mod a_funny_docs {
//     // A constant with a humorous twist.
//     #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
//     #[doc = "**CONSTANT COMEDY ALERT:**\nIf numbers could laugh, this constant would be chuckling at the absurdity of fixed values.\n\nFor the ultimate comedy in coding, check out the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
//     pub const a_const: () = ();

//     // A function that tells a joke.
//     #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
//     #[doc = "**FUNCTION FUNNY BUSINESS:**\nThis function doesn't do much—it's here for the giggles. Every time it's called, the universe aligns with a pun.\n\nFor more hilarity, check out the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
//     pub fn a_function() {
//         println!("Function humor: a_function executed!");
//     }

//     // A struct that stands as a monument to mirth.
//     #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
//     #[doc = "**STRUCTURE OF LAUGHTER:**\nThis struct is built on a foundation of humor. Its very existence is a testament to the power of a well-timed joke.\n\nFor the blueprint of comedy, see the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
//     pub struct AStruct;

//     // An enum whose variants are pure punchlines.
//     #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
//     #[doc = "**ENUMERATE THE LAUGHTER:**\nThis enum's variants are as surprising as a punchline in the middle of a monologue. Discover the unexpected twist in every variant.\n\nFor more, check out the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
//     pub enum AEnum {
//         #[doc = "**AVARIANT, THE PUNCHLINE:**\nThis variant is the climax of our enum saga—laugh, cry, and then laugh again."]
//         AVariant,
//     }

//     // A trait that defines a contract for comedic behavior.
//     #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
//     #[doc = "**TRAIT OF TONGUE-IN-CHEEK:**\nThis trait defines behaviors with a side-splitting twist. Implement it if you want your types to perform like a stand-up comedian.\n\nFor in-depth trait-based hilarity, see the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
//     pub trait ATrait {
//         // A dummy method to exemplify behavior.
//         fn do_joke(&self) -> String;
//     }

//     // A type alias that proves brevity can be uproariously funny.
//     #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
//     #[doc = "**ALIAS OF ABSURDITY:**\nThis type alias is like the punchline of a great joke: short, memorable, and guaranteed to leave an impression.\n\nWhen in doubt, refer to the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)** for a dose of coding comedy."]
//     pub type AType = ();

//     // Use the dynamic naming macro to create a funny struct.
//     define_funny_struct!(CrazyDuck);
// }

// // =============================
// // Re-Exports for Public Visibility
// // =============================

// /// If you still haven't grasped the joke, take another look!
// ///
// /// Check out the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**,
// /// where the ultimate comedic wisdom is laid out for your enlightenment.
// #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// pub use a_funny_docs as guide;

// /// Behold the macro that brings the laughter!
// /// If you didn't get it the first time, this macro is here to ensure you have a second shot at the comedy gold.
// /// For the full comedic effect, please see the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**.
// #[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
// pub use funny_macro;

// // =============================
// // Inline Tests to Exercise Everything
// // =============================
// #[cfg(test)]
// mod tests {
//     use super::a_funny_docs::*;
//     use super::*;

//     #[test]
//     fn test_constant() {
//         // Exercise the constant.
//         let _ = a_const;
//     }

//     #[test]
//     fn test_function() {
//         // Exercise the function.
//         a_function();
//     }

//     #[test]
//     fn test_struct() {
//         // Instantiate the struct.
//         let _instance = AStruct;
//     }

//     #[test]
//     fn test_enum() {
//         // Match on the enum.
//         match AEnum::AVariant {
//             AEnum::AVariant => (),
//         }
//     }

//     struct Dummy;

//     impl a_funny_docs::ATrait for Dummy {
//         fn do_joke(&self) -> String {
//             "I'm a dummy telling a dummy joke!".to_string()
//         }
//     }

//     #[test]
//     fn test_trait() {
//         let dummy = Dummy;
//         assert_eq!(dummy.do_joke(), "I'm a dummy telling a dummy joke!");
//     }

//     #[test]
//     fn test_type_alias() {
//         // Use the type alias.
//         let _x: AType = ();
//     }

//     #[test]
//     fn test_dynamic_struct() {
//         // Using the dynamically named struct from the macro.
//         // This type was generated by `define_funny_struct!(CrazyDuck)` and is named `ACrazyDuck`.
//         let _instance: crate::a_funny_docs::ACrazyDuck = crate::a_funny_docs::ACrazyDuck;
//     }

//     #[test]
//     fn test_funny_macro() {
//         // Capture the output of the funny macro.
//         funny_macro!();
//     }
// }

#![allow(dead_code)]
#![allow(non_upper_case_globals)]

// Bring in the paste crate for dynamic naming.
#[cfg(feature = "uses_paste")]
use paste::paste;

// ----------------------------------------------------------------
// Dynamic Naming Macro (Local Version)
// ----------------------------------------------------------------

/// Defines a new funny struct whose name always starts with an "A" followed by the provided identifier.
///
/// # Example
///
/// ```rust
/// #[cfg(feature = "uses_paste")]
/// use paste::paste;
/// cargo_e::define_funny_struct!(CrazyDuck);
/// // This creates a struct named `ACrazyDuck`
/// ```
#[cfg(feature = "uses_paste")]
#[macro_export]
macro_rules! define_funny_struct {
    ($name:ident) => {
        paste! {
            #[doc = concat!(
                "A hilariously named struct: `A",
                stringify!($name),
                "`! It's guaranteed to make your codebase smile. For more, check out the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."
            )]
            pub struct [<A $name>];
        }
    };
}

// ----------------------------------------------------------------
// Humorous Macro Definition (Exported)
// ----------------------------------------------------------------

/// **HA! DIDN'T GET IT THE FIRST TIME?**
///
/// This macro is your second chance to be enlightened by the absurdity of our code base.
///
/// Imagine a world where every line of code bursts with humor and genius—that's what you're about to experience.
/// If you're still scratching your head, don't worry; confusion is merely the first step toward brilliant epiphanies.
///
/// **READ THIS, YOU ABSOLUTE GENIUS!**
/// For a comprehensive, mind-blowing guide that will forever change your perspective on code and life, please check out the
/// **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**.
///
/// *Remember: If you missed it the first time, you'll never miss it again!*
///
/// # Example
///
/// ```rust
/// cargo_e::funny_macro!();
/// ```
#[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
#[macro_export]
macro_rules! funny_macro {
    () => {{
        println!("Your funny macro is in full swing! Have you checked out the ultimate guide yet?");
    }};
}

// ----------------------------------------------------------------
// Humorous Items Defined Directly
// ----------------------------------------------------------------

#[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
#[doc = "**CONSTANT COMEDY ALERT:**\nIf numbers could laugh, this constant would be chuckling at the absurdity of fixed values.\n\nFor the ultimate comedy in coding, check out the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
pub const A_CONST: () = ();

#[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
#[doc = "**FUNCTION FUNNY BUSINESS:**\nThis function doesn't do much—it's here for the giggles. Every time it's called, the universe aligns with a pun.\n\nFor more hilarity, check out the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
pub fn a_function() {
    println!("Function humor: a_function executed!");
}

#[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
#[doc = "**STRUCTURE OF LAUGHTER:**\nThis struct is built on a foundation of humor. Its very existence is a testament to the power of a well-timed joke.\n\nFor the blueprint of comedy, see the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
pub struct AStruct;

#[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
#[doc = "**ENUMERATE THE LAUGHTER:**\nThis enum's variants are as surprising as a punchline in the middle of a monologue. Discover the unexpected twist in every variant.\n\nFor more, check out the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
pub enum AEnum {
    #[doc = "**AVARIANT, THE PUNCHLINE:**\nThis variant is the climax of our enum saga—laugh, cry, and then laugh again."]
    AVariant,
}

#[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
#[doc = "**TRAIT OF TONGUE-IN-CHEEK:**\nThis trait defines behaviors with a side-splitting twist. Implement it if you want your types to perform like a stand-up comedian.\n\nFor in-depth trait-based hilarity, see the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)**."]
pub trait ATrait {
    fn do_joke(&self) -> String;
}

#[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
#[doc = "**ALIAS OF ABSURDITY:**\nThis type alias is like the punchline of a great joke: short, memorable, and guaranteed to leave an impression.\n\nWhen in doubt, refer to the **[ULTIMATE GUIDE FOR YOU TO READ](./index.html)** for a dose of coding comedy."]
pub type AType = ();

// ----------------------------------------------------------------
// Use the Dynamic Naming Macro to Create a Funny Struct
// ----------------------------------------------------------------
#[cfg(feature = "uses_paste")]
define_funny_struct!(CrazyDuck);
// This creates a struct named `ACrazyDuck` in this module.

// ----------------------------------------------------------------
// Re-Exports for Public Visibility
// ----------------------------------------------------------------

#[cfg_attr(not(feature = "funny-docs"), doc(hidden))]
#[doc = "If you still haven't grasped the joke, take another look!\n\nCheck out the **[ULTIMATE GUIDE FOR YOU TO READ](../index.html)**, where the ultimate comedic wisdom is laid out for your enlightenment."]
pub mod guide {
    pub use super::*;
}

// ----------------------------------------------------------------
// Inline Tests to Exercise Everything
// ----------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    // This approach uses std::mem::drop to consume the value of A_CONST (even though it's just ())
    // without creating a binding. It's a neat trick to silence the "no effect" warning while keeping
    // the intent fun and explicit.
    #[allow(dropping_copy_types)]
    fn test_epic_void_drop() {
        // Instead of binding A_CONST to underscore, we simply drop it.
        // This is our unique way of showing that we care about nothing!
        // calls to `std::mem::drop` with a value that implements `Copy` does nothing
        // `#[warn(dropping_copy_types)]` on by default
        std::mem::drop(A_CONST);
        //calls to `std::mem::drop` with a value that implements `Copy` does nothing
    }

    #[test]
    /// Tests that `a_function` does what it does—presumably, something functionally awesome.
    fn test_function() {
        a_function();
    }

    #[test]
    /// Creates an instance of `AStruct` to prove that structs can be instantiated
    /// even if they don't have a personality (or much else) to show.
    fn test_struct() {
        let _instance = AStruct;
    }

    #[test]
    /// Matches against `AEnum::AVariant`—because even enums like to have their moment in the spotlight.
    fn test_enum() {
        match AEnum::AVariant {
            AEnum::AVariant => (),
        }
    }

    /// Implements `ATrait` for a dummy type just to confirm that even dummy jokes are valid,
    /// and that our trait really does have a punchline.
    struct Dummy;

    impl ATrait for Dummy {
        fn do_joke(&self) -> String {
            "I'm a dummy telling a dummy joke!".to_string()
        }
    }

    #[test]
    /// Creates a dummy and verifies that the joke is as laughable as expected.
    fn test_trait() {
        let dummy = Dummy;
        assert_eq!(dummy.do_joke(), "I'm a dummy telling a dummy joke!");
    }

    #[test]
    /// Tests that the type alias `AType` works as intended,
    /// because even type aliases deserve a little bit of the limelight.
    fn test_type_alias() {
        let _x: AType = ();
    }

    #[test]
    /// Tests the dynamic struct `ACrazyDuck`—a wild duck that defies both logic and gravity.
    fn test_dynamic_struct() {
        // ACrazyDuck is defined directly in this module.
        let _instance: ACrazyDuck = ACrazyDuck;
    }

    #[test]
    /// Executes the `funny_macro!` macro, proving that even macros can bring a little humor to your code.
    fn test_funny_macro() {
        funny_macro!();
    }
}