Platify

Platify streamlines cross-platform Rust development by removing the boilerplate associated with #[cfg(...)] attributes.

Instead of cluttering your code with repetitive checks and manual dispatch logic, Platify allows you to define platform-specific behavior using a clean, declarative attribute syntax.

Features

• #[sys_function]: Automatically dispatches method calls to platform-specific implementations (e.g., fn run() -> fn run_impl()).
• #[sys_struct]: Generates platform-specific type aliases (e.g., MyStruct -> MyStructLinux).
• Smart Logic: Supports explicit include and exclude lists.
• Group Keywords: Use helpers like posix (Linux + macOS) or all.

Installation

Add this to your Cargo.toml:

[dependencies]

platify = "0.1.1"

Or run:

cargo add platify

Usage

1. Platform-Dependent Functions (#[sys_function])

This macro generates a default method that delegates the call to a suffixed implementation (e.g., _impl). It automatically applies the correct #[cfg] guards based on your configuration.

use platify::sys_function;

struct SystemManager;

impl SystemManager {
	// 1. Available on ALL supported platforms (default).
	//    Delegates to `reboot_impl`.
	#[sys_function]
	pub fn reboot(&self) -> Result<(), String>;

	// 2. ONLY available on Linux.
	#[sys_function(include(linux))]
	pub fn update_kernel(&self);

	// 3. Available on Linux and macOS, but NOT on Windows.
	#[sys_function(exclude(windows))]
	pub fn posix_magic(&self);
}

// Implementation details
impl SystemManager {
	fn reboot_impl(&self) -> Result<(), String> {
		println!("Rebooting...");
		Ok(())
	}

	#[cfg(target_os = "linux")]
	fn update_kernel_impl(&self) {
		println!("Updating Linux kernel...");
	}

	#[cfg(unix)]
	fn posix_magic_impl(&self) {
		println!("Doing POSIX magic...");
	}
}

2. Platform-Specific Struct Aliases (#[sys_struct])

Useful when you need specific types for FFI or OS interactions but want to keep a unified naming convention in your platform-agnostic code.

use platify::sys_struct;

#[sys_struct(include(windows))]
pub struct Handle {
	handle: u64
}

// This generates:
//
// #[cfg(target_os = "windows")]
// pub type HandleWindows = Handle;

Configuration Logic

You can control which platforms are targeted using include(...) and exclude(...).

How it is calculated

1. Start: If include is present, start with that set. If omitted, start with all.
2. Filter: Remove any platforms specified in exclude.
3. Result: The macro generates #[cfg(any(target_os = "..."))] for the remaining platforms.

Examples

• include(linux) → Only Linux.
• exclude(windows) → Linux + macOS.
• include(posix), exclude(macos) → Only Linux.

License

This project is licensed under the MIT License - see the LICENSE file for details.