Rust SPDX许可证解析库spdx-rs使用指南

概述

spdx-rs是一个用于解析和验证SPDX许可证标识符和表达式的Rust库。它支持SPDX许可证列表中的所有标准许可证标识符，并能解析复杂的SPDX许可证表达式。

主要功能

• 解析和验证SPDX许可证标识符
• 解析和验证SPDX许可证表达式
• 支持SPDX 3.0规范
• 提供详细的错误信息

安装

在Cargo.toml中添加依赖：

[dependencies]
spdx = "0.8.0"

基本使用方法

验证单个许可证标识符

use spdx::LicenseId;

fn main() {
    match LicenseId::parse("MIT") {
        Ok(license) => println!("有效的SPDX许可证: {:?}", license),
        Err(e) => println!("无效的许可证标识符: {}", e),
    }
}

解析许可证表达式

use spdx::Expression;

fn main() {
    let expr = "MIT OR Apache-2.0";
    match Expression::parse(expr) {
        Ok(parsed) => println!("解析成功: {}", parsed),
        Err(e) => println!("解析失败: {}", e),
    }
}

检查表达式有效性

use spdx::Expression;

fn main() {
    let expr = "(MIT AND Apache-2.0) OR GPL-3.0-only WITH Classpath-exception-2.0";
    match Expression::parse(expr) {
        Ok(parsed) => {
            println!("表达式有效: {}", parsed);
            println!("包含的许可证:");
            for req in parsed.requirements() {
                println!("- {}", req.license.id());
            }
        }
        Err(e) => println!("无效表达式: {}", e),
    }
}

高级用法

自定义许可证解析

use spdx::{Expression, ParseOptions};

fn main() {
    let options = ParseOptions {
        allow_lower_case: true,  // 允许小写许可证标识符
        ..Default::default()
    };
    
    let expr = "mit or apache-2.0";
    match Expression::parse_with_options(expr, &options) {
        Ok(parsed) => println!("解析成功: {}", parsed),
        Err(e) => println!("解析失败: {}", e),
    }
}

检查许可证是否满足特定条件

use spdx::{LicenseId, LicenseExceptionId};

fn main() {
    let license = LicenseId::parse("GPL-3.0-only").unwrap();
    let exception = LicenseExceptionId::parse("Classpath-exception-2.0").unwrap();
    
    println!("GPL-3.0-only是自由软件许可证: {}", license.is_fsf_libre());
    println!("Classpath-exception-2.0是FSF批准的例外: {}", exception.is_fsf_exception());
}

实际应用示例

在项目中使用许可证检查

use spdx::Expression;

struct Project {
    name: String,
    license: String,
}

fn check_project_license(project: &Project) {
    match Expression::parse(&project.license) {
        Ok(expr) => {
            println!("项目 {} 使用有效的SPDX许可证表达式", project.name);
            if expr.evaluate(|req| {
                req.license.id().is_fsf_libre()
            }) {
                println!("  -> 符合自由软件定义");
            }
        }
        Err(e) => println!("项目 {} 的许可证无效: {}", project.name, e),
    }
}

fn main() {
    let projects = vec![
        Project {
            name: "MyApp".to_string(),
            license: "MIT OR Apache-2.0".to_string(),
        },
        Project {
            name: "OtherLib".to_string(),
            license: "Invalid-License".to_string(),
        },
    ];
    
    for project in projects {
        check_project_license(&project);
    }
}

错误处理

spdx-rs提供了详细的错误信息，帮助调试许可证表达式问题：

use spdx::Expression;

fn main() {
    let expr = "MIT AND (Apache-2.0 OR )";
    if let Err(e) = Expression::parse(expr) {
        println!("错误位置: {}", e.span);
        println!("错误原因: {}", e.reason);
        if let Some(help) = e.help {
            println!("建议: {}", help);
        }
    }
}

完整示例

下面是一个完整的示例，展示了如何使用spdx-rs库进行许可证验证和表达式解析：

use spdx::{LicenseId, LicenseExceptionId, Expression, ParseOptions};

fn main() {
    // 示例1: 验证单个许可证标识符
    println!("--- 验证单个许可证标识符 ---");
    let licenses_to_check = ["MIT", "Apache-2.0", "Invalid-License"];
    for license_str in licenses_to_check {
        match LicenseId::parse(license_str) {
            Ok(license) => println!("'{}' 是有效的SPDX许可证", license_str),
            Err(e) => println!("'{}' 无效: {}", license_str, e),
        }
    }

    // 示例2: 解析复杂许可证表达式
    println!("\n--- 解析复杂许可证表达式 ---");
    let complex_expr = "(MIT AND Apache-2.0) OR (GPL-3.0-only WITH Classpath-exception-2.0)";
    match Expression::parse(complex_expr) {
        Ok(expr) => {
            println!("表达式解析成功:");
            println!("规范化形式: {}", expr);
            println!("包含的许可证:");
            for req in expr.requirements() {
                println!("- {}", req.license.id());
                if let Some(exception) = req.exception {
                    println!("  带有例外: {}", exception);
                }
            }
        }
        Err(e) => println!("解析失败: {}", e),
    }

    // 示例3: 自定义解析选项
    println!("\n--- 自定义解析选项 ---");
    let options = ParseOptions {
        allow_lower_case: true,
        ..Default::default()
    };
    let lower_case_expr = "mit or apache-2.0";
    match Expression::parse_with_options(lower_case_expr, &options) {
        Ok(expr) => println!("成功解析小写表达式: {}", expr),
        Err(e) => println!("解析失败: {}", e),
    }

    // 示例4: 检查许可证属性
    println!("\n--- 检查许可证属性 ---");
    let gpl_license = LicenseId::parse("GPL-3.0-only").unwrap();
    let exception = LicenseExceptionId::parse("Classpath-exception-2.0").unwrap();
    println!("{} 是OSI批准的: {}", gpl_license, gpl_license.is_osi_approved());
    println!("{} 是自由软件许可证: {}", gpl_license, gpl_license.is_fsf_libre());
    println!("{} 是FSF批准的例外: {}", exception, exception.is_fsf_exception());

    // 示例5: 错误处理
    println!("\n--- 错误处理示例 ---");
    let invalid_expr = "MIT AND (Apache-2.0 OR )";
    if let Err(e) = Expression::parse(invalid_expr) {
        println!("发现错误:");
        println!("位置: {}", e.span);
        println!("原因: {}", e.reason);
        if let Some(help) = e.help {
            println!("建议: {}", help);
        }
    }
}

总结

spdx-rs库为Rust项目提供了强大的SPDX许可证解析和验证能力，非常适合需要处理软件许可证的工具和应用程序。通过简单的API，开发者可以轻松集成SPDX标准到自己的项目中。