Struct spdx::expression::Expression

pub struct Expression { /* fields omitted */ }

An SPDX license expression that is both syntactically and semantically valid, and can be evaluated

use spdx::Expression;

let this_is_fine = Expression::parse("MIT OR Apache-2.0").unwrap();
assert!(this_is_fine.evaluate(|req| {
    if let spdx::LicenseItem::Spdx { id, .. } = req.license {
        // Both MIT and Apache-2.0 are OSI approved, so this expression
        // evaluates to true
        return id.is_osi_approved();
    }

   false
}));

assert!(!this_is_fine.evaluate(|req| {
    if let spdx::LicenseItem::Spdx { id, .. } = req.license {
        // This is saying we don't accept any licenses that are OSI approved
        // so the expression will evaluate to false as both sides of the OR
        // are now rejected
        return !id.is_osi_approved();
    }

    false
}));

// `NOPE` is not a valid SPDX license identifier, so this expression
// will fail to parse
let _this_is_not = Expression::parse("MIT OR NOPE").unwrap_err();

Implementations

impl Expression

pub fn parse(original: &str) -> Result<Self, ParseError<'_>>

Given a license expression, attempts to parse and validate it as a valid SPDX expression. Uses ParseMode::Strict.

The validation can fail for many reasons:

• The expression contains invalid characters
• An unknown/invalid license or exception identifier was found. Only SPDX short identifiers are allowed
• The expression contained unbalanced parentheses
• A license or exception immediately follows another license or exception, without a valid AND, OR, or WITH operator separating them
• An AND, OR, or WITH doesn’t have a license or ) preceding it

spdx::Expression::parse("MIT OR Apache-2.0 WITH LLVM-exception").unwrap();

pub fn parse_mode(
    original: &str,
    mode: ParseMode
) -> Result<Self, ParseError<'_>>

Parses an expression with the specified ParseMode. With ParseMode::Lax it permits some non-SPDX syntax, such as imprecise license names and “/” used instead of “OR” in exprssions.

spdx::Expression::parse_mode(
    "mit/Apache-2.0 WITH LLVM-exception",
    spdx::ParseMode::Lax
).unwrap();

impl Expression

pub fn requirements(&self) -> impl Iterator<Item = &ExpressionReq>

Returns each of the license requirements in the license expression, but not the operators that join them together

let expr = spdx::Expression::parse("MIT AND BSD-2-Clause").unwrap();

assert_eq!(
    &expr.requirements().map(|er| er.req.license.id()).collect::<Vec<_>>(), &[
        spdx::license_id("MIT"),
        spdx::license_id("BSD-2-Clause")
    ]
);

pub fn iter(&self) -> impl Iterator<Item = &ExprNode>

Returns both the license requirements and the operators that join them together. Note that the expression is returned in post fix order.

use spdx::expression::{ExprNode, Operator};
let expr = spdx::Expression::parse("Apache-2.0 OR MIT").unwrap();

let mut ei = expr.iter();

assert!(ei.next().is_some()); // Apache
assert!(ei.next().is_some()); // MIT
assert_eq!(*ei.next().unwrap(), ExprNode::Op(Operator::Or));

pub fn evaluate<AF: FnMut(&LicenseReq) -> bool>(&self, allow_func: AF) -> bool

Evaluates the expression, using the provided function to determine if the licensee meets the requirements for each license term. If enough requirements are satisfied the evaluation will return true.

use spdx::Expression;

let this_is_fine = Expression::parse("MIT OR Apache-2.0").unwrap();
assert!(this_is_fine.evaluate(|req| {
    // If we find MIT, then we're happy!
    req.license.id() == spdx::license_id("MIT")
}));

pub fn evaluate_with_failures<AF: FnMut(&LicenseReq) -> bool>(
    &self,
    allow_func: AF
) -> Result<(), Vec<&ExpressionReq>>

Just as with evaluate, the license expression is evaluated to see if enough license requirements in the expresssion are met for the evaluation to succeed, except this method also keeps track of each failed requirement and returns them, allowing for more detailed error reporting about precisely what terms in the expression caused the overall failure

Trait Implementations

impl AsRef<str> for Expression

fn as_ref(&self) -> &str

Performs the conversion.

impl Clone for Expression

fn clone(&self) -> Expression

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expression

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Expression

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<Expression> for Expression

fn eq(&self, o: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.