link: bond: implement FromStr for bond enums

[cathay4t]

Introduced support for parsing bond option enums from string:

• BondMode
• BondArpValidate
• BondArpAllTargets
• BondPrimaryReselect
• BondFailOverMac
• BondXmitHashPolicy
• BondAdSelect

All conversions use DecodeError as the error type.

Unit tests are included for all seven FromStr implementations.

[codecov]

Codecov Report

❌ Patch coverage is 89.02439% with 9 lines in your changes missing coverage. Please review.
✅ Project coverage is 68.17%. Comparing base (1fb4bd7) to head (a2ab9a7).
⚠️ Report is 47 commits behind head on main.

Files with missing lines	Patch %	Lines
src/link/link_info/bond.rs	89.02%	9 Missing ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##             main     #263      +/-   ##
==========================================
+ Coverage   68.10%   68.17%   +0.07%     
==========================================
  Files         144      146       +2     
  Lines       10103    10402     +299     
==========================================
+ Hits         6881     7092     +211     
- Misses       3222     3310      +88     

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

[gemini-code-assist]

Code Review

This pull request implements std::str::FromStr for several bond-related enums, including BondMode, BondArpValidate, BondPrimaryReselect, BondXmitHashPolicy, BondArpAllTargets, BondFailOverMac, and BondAdSelect, along with corresponding unit tests. The reviewer noted that the from_str implementations use a non-idiomatic Rust pattern by wrapping the entire match block in Ok and using an early return for errors. It is recommended to match directly to Result<Self, Self::Err> by wrapping each successful arm in Ok and the fallback arm in Err.

[gemini-code-assist]

Using Ok(match s { ... _ => return Err(...) }) is non-idiomatic in Rust. It is cleaner and more idiomatic to match directly to Result<Self, Self::Err> by wrapping each successful arm in Ok and the fallback arm in Err.

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "balance-rr" => Ok(Self::BalanceRr),
            "active-backup" => Ok(Self::ActiveBackup),
            "balance-xor" => Ok(Self::BalanceXor),
            "broadcast" => Ok(Self::Broadcast),
            "802.3ad" => Ok(Self::Ieee8023Ad),
            "balance-tlb" => Ok(Self::BalanceTlb),
            "balance-alb" => Ok(Self::BalanceAlb),
            _ => Err(DecodeError::from(format!("unknown bond mode: {s}"))),
        }
    }

[gemini-code-assist]

Using Ok(match s { ... _ => return Err(...) }) is non-idiomatic in Rust. It is cleaner and more idiomatic to match directly to Result<Self, Self::Err> by wrapping each successful arm in Ok and the fallback arm in Err.

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "none" => Ok(Self::None),
            "active" => Ok(Self::Active),
            "backup" => Ok(Self::Backup),
            "all" => Ok(Self::All),
            "filter" => Ok(Self::Filter),
            "filter_active" => Ok(Self::FilterActive),
            "filter_backup" => Ok(Self::FilterBackup),
            _ => Err(DecodeError::from(format!("unknown bond arp validate: {s}"))),
        }
    }

[gemini-code-assist]

Using Ok(match s { ... _ => return Err(...) }) is non-idiomatic in Rust. It is cleaner and more idiomatic to match directly to Result<Self, Self::Err> by wrapping each successful arm in Ok and the fallback arm in Err.

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "always" => Ok(Self::Always),
            "better" => Ok(Self::Better),
            "failure" => Ok(Self::Failure),
            _ => Err(DecodeError::from(format!("unknown bond primary reselect: {s}"))),
        }
    }

[gemini-code-assist]

Using Ok(match s { ... _ => return Err(...) }) is non-idiomatic in Rust. It is cleaner and more idiomatic to match directly to Result<Self, Self::Err> by wrapping each successful arm in Ok and the fallback arm in Err.

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "layer2" => Ok(Self::Layer2),
            "layer34" => Ok(Self::Layer34),
            "layer23" => Ok(Self::Layer23),
            "encap23" => Ok(Self::Encap23),
            "encap34" => Ok(Self::Encap34),
            "vlan-src-mac" => Ok(Self::VlanSrcMac),
            _ => Err(DecodeError::from(format!("unknown bond xmit hash policy: {s}"))),
        }
    }

[gemini-code-assist]

Using Ok(match s { ... _ => return Err(...) }) is non-idiomatic in Rust. It is cleaner and more idiomatic to match directly to Result<Self, Self::Err> by wrapping each successful arm in Ok and the fallback arm in Err.

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "any" => Ok(Self::Any),
            "all" => Ok(Self::All),
            _ => Err(DecodeError::from(format!("unknown bond arp all targets: {s}"))),
        }
    }

[gemini-code-assist]

Using Ok(match s { ... _ => return Err(...) }) is non-idiomatic in Rust. It is cleaner and more idiomatic to match directly to Result<Self, Self::Err> by wrapping each successful arm in Ok and the fallback arm in Err.

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "none" => Ok(Self::None),
            "active" => Ok(Self::Active),
            "follow" => Ok(Self::Follow),
            _ => Err(DecodeError::from(format!("unknown bond fail over mac: {s}"))),
        }
    }

[gemini-code-assist]

Using Ok(match s { ... _ => return Err(...) }) is non-idiomatic in Rust. It is cleaner and more idiomatic to match directly to Result<Self, Self::Err> by wrapping each successful arm in Ok and the fallback arm in Err.

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "stable" => Ok(Self::Stable),
            "bandwidth" => Ok(Self::Bandwidth),
            "count" => Ok(Self::Count),
            _ => Err(DecodeError::from(format!("unknown bond ad select: {s}"))),
        }
    }