refactor: migrate renderers to RenderResult and stdout macros

Replace buffer-based renderers with explicit RenderResult returns and
use cargo-styled output macros for consistency.

5 files changed, 99 insertions, 65 deletions

diff --git a/mingling_cli/src/linter/cmd_explain.rs b/mingling_cli/src/linter/cmd_explain.rs
index d1758e1..5346255 100644
--- a/mingling_cli/src/linter/cmd_explain.rs
+++ b/mingling_cli/src/linter/cmd_explain.rs
@@ -1,6 +1,6 @@
-use crate::{Next, linter::registry::ResLintRegistry};
+use crate::{Next, eprintln_cargo, linter::registry::ResLintRegistry};
 use mingling::{
-    Grouped, LazyRes, Routable, ShellContext, Suggest, SuggestItem,
+    Grouped, LazyRes, RenderResult, Routable, ShellContext, Suggest, SuggestItem,
     macros::{
         arg, buffer, chain, completion, dispatcher, metadata, pack, pack_err, r_println, renderer,
         routeify,
@@ -71,22 +71,29 @@ pub fn render_explain_lint(r: ResultExplainLint) {
     r_println!("{}", r.summary);
 }
 
-#[renderer(buffer)]
-pub fn render_error_no_explain_lint_provided(_: ErrorNoExplainLintProvided) {
-    r_println!("No lint name provided");
-    r_println!("");
-    r_println!("Usage: mling explain <LINT>");
+#[renderer]
+pub fn render_error_no_explain_lint_provided(_: ErrorNoExplainLintProvided) -> RenderResult {
+    let mut r = RenderResult::new();
+    eprintln_cargo!(r, "No lint name provided");
+    r_println!(r, "");
+    r_println!(r, "Usage: mling explain <LINT>");
+    r
 }
 
-#[renderer(buffer)]
-pub fn render_error_no_such_lint(err: ErrorNoSuchLint, registry: &mut LazyRes<ResLintRegistry>) {
+#[renderer]
+pub fn render_error_no_such_lint(
+    err: ErrorNoSuchLint,
+    registry: &mut LazyRes<ResLintRegistry>,
+) -> RenderResult {
+    let mut r = RenderResult::new();
     let registry = registry.get_ref();
-    r_println!("No such lint: \"{}\"", err.info);
-    r_println!("");
-    r_println!("Available lints:");
+    eprintln_cargo!(r, "No such lint: \"{}\"", err.info);
+    r_println!(r, "");
+    r_println!(r, "Available lints:");
     for entry in registry.lints.iter() {
-        r_println!("  {}", entry.name);
+        r_println!(r, "  {}", entry.name);
     }
+    r
 }
 
 #[completion(EntryExplain)]
diff --git a/mingling_cli/src/pkg_mgr.rs b/mingling_cli/src/pkg_mgr.rs
index f244fa7..080c50f 100644
--- a/mingling_cli/src/pkg_mgr.rs
+++ b/mingling_cli/src/pkg_mgr.rs
@@ -8,11 +8,11 @@ pub mod cmd_uninstall;
 use std::path::PathBuf;
 
 use mingling::{
-    Program,
-    macros::{buffer, pack_err, program_setup, r_println, renderer},
+    Program, RenderResult,
+    macros::{pack_err, program_setup, r_println, renderer},
 };
 
-use crate::ThisProgram;
+use crate::{ThisProgram, eprintln_cargo, hprintln_cargo};
 
 pack_err!(ErrorRootPackageNotFound);
 pack_err!(ErrorNoDataDirectory);
@@ -33,24 +33,35 @@ pub fn package_manager_setup(program: &mut Program<ThisProgram>) {
     program.with_resource(ResPackagesDir { path });
 }
 
-#[renderer(buffer)]
-pub fn render_error_root_package_not_found(_: ErrorRootPackageNotFound) {
-    r_println!("error: failed to determine the root package");
-    r_println!("");
-    r_println!("Run `mling install` / `mling uninstall` inside a Cargo workspace");
+#[renderer]
+pub fn render_error_root_package_not_found(_: ErrorRootPackageNotFound) -> RenderResult {
+    let mut r = RenderResult::new();
+    eprintln_cargo!(r, "failed to determine the root package");
+    r_println!(r, "");
+    hprintln_cargo!(
+        r,
+        "Run `mling install` / `mling uninstall` inside a Cargo workspace"
+    );
+    r
 }
 
-#[renderer(buffer)]
-pub fn render_error_no_data_directory(_: ErrorNoDataDirectory) {
-    r_println!("error: failed to determine the data directory");
+#[renderer]
+pub fn render_error_no_data_directory(_: ErrorNoDataDirectory) -> RenderResult {
+    let mut r = RenderResult::new();
+    eprintln_cargo!(r, "failed to determine the data directory");
+    r
 }
 
-#[renderer(buffer)]
-pub fn render_error_package_spec_invalid(err: ErrorPackageSpecInvalid) {
-    r_println!("error: invalid package spec: {}", err.info);
+#[renderer]
+pub fn render_error_package_spec_invalid(err: ErrorPackageSpecInvalid) -> RenderResult {
+    let mut r = RenderResult::new();
+    eprintln_cargo!(r, "invalid package spec: {}", err.info);
+    r
 }
 
-#[renderer(buffer)]
-pub fn render_error_package_name_required(_: ErrorPackageNameRequired) {
-    r_println!("error: a package name is required");
+#[renderer]
+pub fn render_error_package_name_required(_: ErrorPackageNameRequired) -> RenderResult {
+    let mut r = RenderResult::new();
+    eprintln_cargo!(r, "a package name is required");
+    r
 }
diff --git a/mingling_cli/src/pkg_mgr/cmd_install.rs b/mingling_cli/src/pkg_mgr/cmd_install.rs
index a399e83..c84f6e2 100644
--- a/mingling_cli/src/pkg_mgr/cmd_install.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_install.rs
@@ -2,15 +2,16 @@ use std::{env, fs, io, path::PathBuf, process::Command};
 
 use cargo_metadata::TargetKind;
 use mingling::{
-    Grouped, LazyRes, Routable,
-    macros::{buffer, chain, command, metadata, pack_err, r_println, renderer, routeify},
+    Grouped, LazyRes, RenderResult, Routable,
+    macros::{chain, command, metadata, pack_err, r_println, renderer, routeify},
     metadata::Description,
 };
 
 use crate::{
-    Next,
+    Next, eprintln_cargo,
     metadata::setup::ResMetadata,
     pkg_mgr::{ErrorNoDataDirectory, ErrorRootPackageNotFound, ResPackagesDir},
+    println_cargo,
 };
 
 pack_err!(ErrorBuildFailed = String);
@@ -159,20 +160,26 @@ pub fn handle_state_install_copy(
     .to_chain()
 }
 
-#[renderer(buffer)]
-pub fn render_result_install(r: ResultInstall) {
-    r_println!("Installed to {}", r.install_dir.display());
-    for file in r.installed {
-        r_println!("  {}", file.display());
+#[renderer]
+pub fn render_result_install(result: ResultInstall) -> RenderResult {
+    let mut r = RenderResult::new();
+    println_cargo!(r, "Installed: {}", result.install_dir.display());
+    for file in result.installed {
+        r_println!(r, "  {}", file.display());
     }
+    r
 }
 
-#[renderer(buffer)]
-pub fn render_error_build_failed(err: ErrorBuildFailed) {
-    r_println!("error: {}", err.info);
+#[renderer]
+pub fn render_error_build_failed(err: ErrorBuildFailed) -> RenderResult {
+    let mut r = RenderResult::new();
+    eprintln_cargo!(r, "{}", err.info);
+    r
 }
 
-#[renderer(buffer)]
-pub fn render_error_binary_not_found(err: ErrorBinaryNotFound) {
-    r_println!("error: binary not found: {}", err.info);
+#[renderer]
+pub fn render_error_binary_not_found(err: ErrorBinaryNotFound) -> RenderResult {
+    let mut r = RenderResult::new();
+    eprintln_cargo!(r, "binary not found: {}", err.info);
+    r
 }
diff --git a/mingling_cli/src/pkg_mgr/cmd_pkg_disable.rs b/mingling_cli/src/pkg_mgr/cmd_pkg_disable.rs
index 679421c..041bb09 100644
--- a/mingling_cli/src/pkg_mgr/cmd_pkg_disable.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_pkg_disable.rs
@@ -1,20 +1,18 @@
 use std::{fs, io};
 
 use mingling::{
-    Grouped, Routable, ShellContext, Suggest, SuggestItem,
-    macros::{
-        arg, buffer, chain, command, completion, metadata, pack, pack_err, r_println, renderer,
-        routeify,
-    },
+    Grouped, RenderResult, Routable, ShellContext, Suggest, SuggestItem,
+    macros::{arg, chain, command, completion, metadata, pack, pack_err, renderer, routeify},
     metadata::Description,
     picker::{EntryPicker, PickerArg},
 };
 
 use crate::{
-    Next,
+    Next, eprintln_cargo,
     pkg_mgr::{
         ErrorNoDataDirectory, ErrorPackageNameRequired, ErrorPackageSpecInvalid, ResPackagesDir,
     },
+    println_cargo,
 };
 
 /// Positional argument: package name
@@ -78,14 +76,18 @@ pub fn handle_state_pkg_disable(p: StatePkgDisable, packages_dir: &ResPackagesDi
     .to_chain()
 }
 
-#[renderer(buffer)]
-pub fn render_result_pkg_disable(r: ResultPkgDisable) {
-    r_println!("Disabled {}", r.name);
+#[renderer]
+pub fn render_result_pkg_disable(result: ResultPkgDisable) -> RenderResult {
+    let mut r = RenderResult::new();
+    println_cargo!(r, "Disabled: {}", result.name);
+    r
 }
 
-#[renderer(buffer)]
-pub fn render_error_package_not_enabled(err: ErrorPackageNotEnabled) {
-    r_println!("error: package is not enabled: {}", err.info);
+#[renderer]
+pub fn render_error_package_not_enabled(err: ErrorPackageNotEnabled) -> RenderResult {
+    let mut r = RenderResult::new();
+    eprintln_cargo!(r, "package is not enabled: {}", err.info);
+    r
 }
 
 #[completion(EntryPkgDisable)]
diff --git a/mingling_cli/src/pkg_mgr/cmd_pkg_enable.rs b/mingling_cli/src/pkg_mgr/cmd_pkg_enable.rs
index b545a4d..8f6a234 100644
--- a/mingling_cli/src/pkg_mgr/cmd_pkg_enable.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_pkg_enable.rs
@@ -1,20 +1,18 @@
 use std::{fs, io};
 
 use mingling::{
-    Grouped, Routable, ShellContext, Suggest, SuggestItem,
-    macros::{
-        arg, buffer, chain, command, completion, metadata, pack, pack_err, r_println, renderer,
-        routeify,
-    },
+    Grouped, RenderResult, Routable, ShellContext, Suggest, SuggestItem,
+    macros::{arg, chain, command, completion, metadata, pack, pack_err, renderer, routeify},
     metadata::Description,
     picker::{EntryPicker, PickerArg},
 };
 
 use crate::{
-    Next,
+    Next, eprintln_cargo,
     pkg_mgr::{
         ErrorNoDataDirectory, ErrorPackageNameRequired, ErrorPackageSpecInvalid, ResPackagesDir,
     },
+    println_cargo,
 };
 
 /// Positional argument: package spec (`foo`, `foo@0`, `foo@0.1`, `foo@0.1.2`)
@@ -102,9 +100,18 @@ pub fn handle_state_pkg_enable(p: StatePkgEnable, packages_dir: &ResPackagesDir)
     ResultPkgEnable { name, version }.to_chain()
 }
 
-#[renderer(buffer)]
-pub fn render_result_pkg_enable(r: ResultPkgEnable) {
-    r_println!("Enabled {}@{}", r.name, r.version);
+#[renderer]
+pub fn render_result_pkg_enable(result: ResultPkgEnable) -> RenderResult {
+    let mut r = RenderResult::new();
+    println_cargo!(r, "Enabled: {}@{}", result.name, result.version);
+    r
+}
+
+#[renderer]
+pub fn render_error_no_matching_version(err: ErrorNoMatchingVersion) -> RenderResult {
+    let mut r = RenderResult::new();
+    eprintln_cargo!(r, "no matching version for: {}", err.info);
+    r
 }
 
 #[completion(EntryPkgEnable)]