Struct spdx::expression::Expression [−][src]
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
[src]
pub fn parse(original: &str) -> Result<Self, ParseError<'_>>
[src]
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<'_>>
[src]
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
[src]
pub fn requirements(&self) -> impl Iterator<Item = &ExpressionReq>
[src]
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>
[src]
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
[src]
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>>
[src]
&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
[src]
impl Clone for Expression
[src]
fn clone(&self) -> Expression
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for Expression
[src]
impl Display for Expression
[src]
impl PartialEq<Expression> for Expression
[src]
Auto Trait Implementations
impl RefUnwindSafe for Expression
impl Send for Expression
impl Sync for Expression
impl Unpin for Expression
impl UnwindSafe for Expression
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,