Struct rubric::rubric::Rubric

pub struct Rubric {
    pub name: String,
    pub desc: Option<String>,
    pub criteria: Vec<Criterion>,
    pub total: isize,
    pub deadline: Option<DateTime<Local>>,
    pub final_deadline: Option<DateTime<Local>>,
    pub allow_late: bool,
    pub late_penalty: isize,
    pub daily_penalty: isize,
}

A collection of criteria, meant to be serialized from yaml.

Example

use rubric::{Rubric, yaml};

// Relative path to the yaml file
let yaml = yaml!("../../test_data/test_rubric.yml").expect("Couldn't load yaml");
let mut rubric = Rubric::from_yaml(yaml).expect("Bad yaml!");

assert_eq!(rubric.name, "Test Rubric");
assert_eq!(rubric.len(), 2);

Fields

name: String

desc: Option<String>

criteria: Vec<Criterion>

total: isize

deadline: Option<DateTime<Local>>

final_deadline: Option<DateTime<Local>>

allow_late: bool

late_penalty: isize

daily_penalty: isize

Implementations

impl Rubric

pub fn from_yaml(yaml: &str) -> Result<Self>

Parses yaml data into a Rubric.

This is equivilent to calling parse() on a string, except this will return a rubric::Error error instead of a serde_yaml::Error.

Example

use rubric::{Rubric, yaml};
let yaml = yaml!("../../test_data/test_rubric.yml").expect("Couldn't load yaml");
// If this is an Err, it will panic with the line/col of the yaml err
let mut rubric = Rubric::from_yaml(yaml).expect("Bad yaml!");

assert_eq!(rubric.name, "Test Rubric");
assert_eq!(rubric.criteria().len(), 2);

pub fn get(&mut self, func: &str) -> Option<&mut Criterion>

Searches for a criterion with the given func, returning None if it couldn't be found

// `rubric` contains a criterion with the func 'first_crit`
let criterion = rubric.get("first_crit");
assert!(criterion.is_some());
let not_criterion = rubric.get("doesnt-exist");
assert!(not_criterion.is_none());

pub fn add(&mut self, criterion: Criterion)

Adds a criterion to the rubric.

You probably shouldn't use this, instead define all your criteria in yaml.

pub fn sorted(&mut self) -> &mut Vec<Criterion>

Returns the criteria as a &mut Vec<Criterion>, sorted by the criterion's index.

Criteria with the same index/no index will not have guaranteed order.

pub fn points(&self) -> usize

The total points earned after grading.

Each criterion stores a flag that determines if it passed or failed. This will give the total worth of all criteria that passed.

If you run this before grading, it should return 0. If it doesn't, call me lmao.

pub fn total_points(&self) -> isize

Returns the total worth of all criteria, ie. the maximum number of points possible.

pub fn criteria(&self) -> &Vec<Criterion>

Returns a reference to a Vec of the criteria. This is like sorted, but they aren't sorted.

pub fn len(&self) -> usize

Returns the amount of criteria in the rubric

pub fn past_due(&self) -> bool

pub fn past_final_deadline(&self) -> bool

Trait Implementations

impl Default for Rubric

fn default() -> Rubric

This is only used for testing and examples. You shouldn't use this to create a new Rubric, instead use from_yaml().

impl FromStr for Rubric

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.