#[derive(Clone, Debug, PartialEq)]
pub enum ConditionalFormatType {
CellIs,
Expression,
ColorScale,
DataBar,
IconSet,
Top10,
AboveAverage,
DuplicateValues,
UniqueValues,
ContainsText,
NotContainsText,
BeginsWith,
EndsWith,
ContainsBlanks,
NotContainsBlanks,
ContainsErrors,
NotContainsErrors,
TimePeriod,
}
impl ConditionalFormatType {
pub fn xml_value(&self) -> &'static str {
match self {
ConditionalFormatType::CellIs => "cellIs",
ConditionalFormatType::Expression => "expression",
ConditionalFormatType::ColorScale => "colorScale",
ConditionalFormatType::DataBar => "dataBar",
ConditionalFormatType::IconSet => "iconSet",
ConditionalFormatType::Top10 => "top10",
ConditionalFormatType::AboveAverage => "aboveAverage",
ConditionalFormatType::DuplicateValues => "duplicateValues",
ConditionalFormatType::UniqueValues => "uniqueValues",
ConditionalFormatType::ContainsText => "containsText",
ConditionalFormatType::NotContainsText => "notContainsText",
ConditionalFormatType::BeginsWith => "beginsWith",
ConditionalFormatType::EndsWith => "endsWith",
ConditionalFormatType::ContainsBlanks => "containsBlanks",
ConditionalFormatType::NotContainsBlanks => "notContainsBlanks",
ConditionalFormatType::ContainsErrors => "containsErrors",
ConditionalFormatType::NotContainsErrors => "notContainsErrors",
ConditionalFormatType::TimePeriod => "timePeriod",
}
}
pub fn from_xml(value: &str) -> Option<Self> {
Some(match value {
"cellIs" => ConditionalFormatType::CellIs,
"expression" => ConditionalFormatType::Expression,
"colorScale" => ConditionalFormatType::ColorScale,
"dataBar" => ConditionalFormatType::DataBar,
"iconSet" => ConditionalFormatType::IconSet,
"top10" => ConditionalFormatType::Top10,
"aboveAverage" => ConditionalFormatType::AboveAverage,
"duplicateValues" => ConditionalFormatType::DuplicateValues,
"uniqueValues" => ConditionalFormatType::UniqueValues,
"containsText" => ConditionalFormatType::ContainsText,
"notContainsText" => ConditionalFormatType::NotContainsText,
"beginsWith" => ConditionalFormatType::BeginsWith,
"endsWith" => ConditionalFormatType::EndsWith,
"containsBlanks" => ConditionalFormatType::ContainsBlanks,
"notContainsBlanks" => ConditionalFormatType::NotContainsBlanks,
"containsErrors" => ConditionalFormatType::ContainsErrors,
"notContainsErrors" => ConditionalFormatType::NotContainsErrors,
"timePeriod" => ConditionalFormatType::TimePeriod,
_ => return None,
})
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum ConditionalOperator {
LessThan,
LessThanOrEqual,
Equal,
NotEqual,
GreaterThanOrEqual,
GreaterThan,
Between,
NotBetween,
}
impl ConditionalOperator {
pub fn from_xml(value: &str) -> Option<Self> {
Some(match value {
"lessThan" => ConditionalOperator::LessThan,
"lessThanOrEqual" => ConditionalOperator::LessThanOrEqual,
"equal" => ConditionalOperator::Equal,
"notEqual" => ConditionalOperator::NotEqual,
"greaterThanOrEqual" => ConditionalOperator::GreaterThanOrEqual,
"greaterThan" => ConditionalOperator::GreaterThan,
"between" => ConditionalOperator::Between,
"notBetween" => ConditionalOperator::NotBetween,
_ => return None,
})
}
pub fn xml_value(&self) -> &'static str {
match self {
ConditionalOperator::LessThan => "lessThan",
ConditionalOperator::LessThanOrEqual => "lessThanOrEqual",
ConditionalOperator::Equal => "equal",
ConditionalOperator::NotEqual => "notEqual",
ConditionalOperator::GreaterThanOrEqual => "greaterThanOrEqual",
ConditionalOperator::GreaterThan => "greaterThan",
ConditionalOperator::Between => "between",
ConditionalOperator::NotBetween => "notBetween",
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct ConditionalColor {
pub rgb: Option<String>,
pub theme: Option<u32>,
pub tint: Option<f64>,
}
impl ConditionalColor {
pub fn rgb<S: Into<String>>(color: S) -> Self {
ConditionalColor {
rgb: Some(color.into()),
theme: None,
tint: None,
}
}
pub fn theme(index: u32) -> Self {
ConditionalColor {
rgb: None,
theme: Some(index),
tint: None,
}
}
pub fn red() -> Self {
Self::rgb("FFFF0000")
}
pub fn green() -> Self {
Self::rgb("FF00FF00")
}
pub fn yellow() -> Self {
Self::rgb("FFFFFF00")
}
pub fn blue() -> Self {
Self::rgb("FF0000FF")
}
pub fn white() -> Self {
Self::rgb("FFFFFFFF")
}
}
#[derive(Clone, Debug)]
pub struct ColorScale {
pub min_color: ConditionalColor,
pub mid_color: Option<ConditionalColor>,
pub max_color: ConditionalColor,
pub min_type: String,
pub min_value: Option<String>,
pub mid_type: Option<String>,
pub mid_value: Option<String>,
pub max_type: String,
pub max_value: Option<String>,
}
impl ColorScale {
pub fn two_color(min_color: ConditionalColor, max_color: ConditionalColor) -> Self {
ColorScale {
min_color,
mid_color: None,
max_color,
min_type: "min".to_string(),
min_value: None,
mid_type: None,
mid_value: None,
max_type: "max".to_string(),
max_value: None,
}
}
pub fn three_color(
min_color: ConditionalColor,
mid_color: ConditionalColor,
max_color: ConditionalColor,
) -> Self {
ColorScale {
min_color,
mid_color: Some(mid_color),
max_color,
min_type: "min".to_string(),
min_value: None,
mid_type: Some("percentile".to_string()),
mid_value: Some("50".to_string()),
max_type: "max".to_string(),
max_value: None,
}
}
pub fn red_yellow_green() -> Self {
Self::three_color(
ConditionalColor::rgb("FFF8696B"),
ConditionalColor::rgb("FFFFEB84"),
ConditionalColor::rgb("FF63BE7B"),
)
}
pub fn green_yellow_red() -> Self {
Self::three_color(
ConditionalColor::rgb("FF63BE7B"),
ConditionalColor::rgb("FFFFEB84"),
ConditionalColor::rgb("FFF8696B"),
)
}
}
#[derive(Clone, Debug)]
pub struct DataBar {
pub fill_color: ConditionalColor,
pub border_color: Option<ConditionalColor>,
pub min_type: String,
pub min_value: Option<String>,
pub max_type: String,
pub max_value: Option<String>,
pub show_value: bool,
pub gradient: bool,
pub negative_color: Option<ConditionalColor>,
}
impl DataBar {
pub fn new() -> Self {
DataBar {
fill_color: ConditionalColor::rgb("FF638EC6"),
border_color: None,
min_type: "min".to_string(),
min_value: None,
max_type: "max".to_string(),
max_value: None,
show_value: true,
gradient: true,
negative_color: None,
}
}
pub fn with_color(mut self, color: ConditionalColor) -> Self {
self.fill_color = color;
self
}
pub fn hide_value(mut self) -> Self {
self.show_value = false;
self
}
pub fn solid_fill(mut self) -> Self {
self.gradient = false;
self
}
}
impl Default for DataBar {
fn default() -> Self {
Self::new()
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum IconSetStyle {
ThreeArrows,
ThreeArrowsGray,
ThreeFlags,
ThreeTrafficLights,
ThreeSigns,
ThreeSymbols,
ThreeSymbols2,
FourArrows,
FourArrowsGray,
FourRating,
FourTrafficLights,
FiveArrows,
FiveArrowsGray,
FiveRating,
FiveQuarters,
}
impl IconSetStyle {
pub fn from_xml(value: &str) -> Option<Self> {
Some(match value {
"3Arrows" => IconSetStyle::ThreeArrows,
"3ArrowsGray" => IconSetStyle::ThreeArrowsGray,
"3Flags" => IconSetStyle::ThreeFlags,
"3TrafficLights1" | "3TrafficLights2" => IconSetStyle::ThreeTrafficLights,
"3Signs" => IconSetStyle::ThreeSigns,
"3Symbols" => IconSetStyle::ThreeSymbols,
"3Symbols2" => IconSetStyle::ThreeSymbols2,
"4Arrows" => IconSetStyle::FourArrows,
"4ArrowsGray" => IconSetStyle::FourArrowsGray,
"4Rating" => IconSetStyle::FourRating,
"4TrafficLights" => IconSetStyle::FourTrafficLights,
"5Arrows" => IconSetStyle::FiveArrows,
"5ArrowsGray" => IconSetStyle::FiveArrowsGray,
"5Rating" => IconSetStyle::FiveRating,
"5Quarters" => IconSetStyle::FiveQuarters,
_ => return None,
})
}
pub fn xml_type(&self) -> &'static str {
match self {
IconSetStyle::ThreeArrows => "3Arrows",
IconSetStyle::ThreeArrowsGray => "3ArrowsGray",
IconSetStyle::ThreeFlags => "3Flags",
IconSetStyle::ThreeTrafficLights => "3TrafficLights1",
IconSetStyle::ThreeSigns => "3Signs",
IconSetStyle::ThreeSymbols => "3Symbols",
IconSetStyle::ThreeSymbols2 => "3Symbols2",
IconSetStyle::FourArrows => "4Arrows",
IconSetStyle::FourArrowsGray => "4ArrowsGray",
IconSetStyle::FourRating => "4Rating",
IconSetStyle::FourTrafficLights => "4TrafficLights",
IconSetStyle::FiveArrows => "5Arrows",
IconSetStyle::FiveArrowsGray => "5ArrowsGray",
IconSetStyle::FiveRating => "5Rating",
IconSetStyle::FiveQuarters => "5Quarters",
}
}
}
#[derive(Clone, Debug)]
pub struct IconSet {
pub style: IconSetStyle,
pub show_value: bool,
pub reverse: bool,
pub thresholds: Vec<(String, String)>, }
impl IconSet {
pub fn new(style: IconSetStyle) -> Self {
IconSet {
style,
show_value: true,
reverse: false,
thresholds: Vec::new(),
}
}
pub fn icon_only(mut self) -> Self {
self.show_value = false;
self
}
pub fn reversed(mut self) -> Self {
self.reverse = true;
self
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ConditionalFormat {
pub font_color: Option<ConditionalColor>,
pub bold: Option<bool>,
pub italic: Option<bool>,
pub underline: Option<bool>,
pub strikethrough: Option<bool>,
pub fill_color: Option<ConditionalColor>,
pub border_color: Option<ConditionalColor>,
pub number_format: Option<String>,
}
impl ConditionalFormat {
pub fn new() -> Self {
Self::default()
}
pub fn with_font_color(mut self, color: ConditionalColor) -> Self {
self.font_color = Some(color);
self
}
pub fn with_bold(mut self, bold: bool) -> Self {
self.bold = Some(bold);
self
}
pub fn with_fill(mut self, color: ConditionalColor) -> Self {
self.fill_color = Some(color);
self
}
}
#[derive(Clone, Debug)]
pub struct ConditionalRule {
pub rule_type: ConditionalFormatType,
pub priority: u32,
pub operator: Option<ConditionalOperator>,
pub formula1: Option<String>,
pub formula2: Option<String>,
pub text: Option<String>,
pub format: Option<ConditionalFormat>,
pub color_scale: Option<ColorScale>,
pub data_bar: Option<DataBar>,
pub icon_set: Option<IconSet>,
pub stop_if_true: bool,
pub bottom: bool,
pub percent: bool,
pub rank: Option<u32>,
pub above_average: bool,
pub equal_average: bool,
pub std_dev: Option<u32>,
pub time_period: Option<String>,
}
impl Default for ConditionalRule {
fn default() -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::Expression,
priority: 1,
operator: None,
formula1: None,
formula2: None,
text: None,
format: None,
color_scale: None,
data_bar: None,
icon_set: None,
stop_if_true: false,
bottom: false,
percent: false,
rank: None,
above_average: true,
equal_average: false,
std_dev: None,
time_period: None,
}
}
}
impl ConditionalRule {
pub fn of_type(rule_type: ConditionalFormatType) -> Self {
ConditionalRule {
rule_type,
..Default::default()
}
}
pub fn cell_is(operator: ConditionalOperator, value: &str) -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::CellIs,
operator: Some(operator),
formula1: Some(value.to_string()),
..Default::default()
}
}
pub fn formula(formula: &str) -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::Expression,
formula1: Some(formula.to_string()),
..Default::default()
}
}
pub fn with_color_scale(scale: ColorScale) -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::ColorScale,
color_scale: Some(scale),
..Default::default()
}
}
pub fn with_data_bar(bar: DataBar) -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::DataBar,
data_bar: Some(bar),
..Default::default()
}
}
pub fn with_icon_set(icons: IconSet) -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::IconSet,
icon_set: Some(icons),
..Default::default()
}
}
pub fn top(n: u32) -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::Top10,
rank: Some(n),
..Default::default()
}
}
pub fn contains_text(text: &str) -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::ContainsText,
text: Some(text.to_string()),
..Default::default()
}
}
pub fn not_contains_text(text: &str) -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::NotContainsText,
text: Some(text.to_string()),
..Default::default()
}
}
pub fn begins_with(text: &str) -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::BeginsWith,
text: Some(text.to_string()),
..Default::default()
}
}
pub fn ends_with(text: &str) -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::EndsWith,
text: Some(text.to_string()),
..Default::default()
}
}
pub fn time_period(period: &str) -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::TimePeriod,
time_period: Some(period.to_string()),
..Default::default()
}
}
pub fn above_average() -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::AboveAverage,
..Default::default()
}
}
pub fn below_average() -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::AboveAverage,
above_average: false,
..Default::default()
}
}
pub fn duplicate_values() -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::DuplicateValues,
..Default::default()
}
}
pub fn unique_values() -> Self {
ConditionalRule {
rule_type: ConditionalFormatType::UniqueValues,
..Default::default()
}
}
pub fn bottom(n: u32) -> Self {
let mut rule = Self::top(n);
rule.bottom = true;
rule
}
pub fn with_format(mut self, format: ConditionalFormat) -> Self {
self.format = Some(format);
self
}
pub fn with_priority(mut self, priority: u32) -> Self {
self.priority = priority;
self
}
}
#[derive(Clone, Debug)]
pub struct ConditionalFormatting {
pub range: String,
pub rules: Vec<ConditionalRule>,
}
impl ConditionalFormatting {
pub fn new<S: Into<String>>(range: S) -> Self {
ConditionalFormatting {
range: range.into(),
rules: Vec::new(),
}
}
pub fn add_rule(&mut self, rule: ConditionalRule) {
self.rules.push(rule);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_cell_is_rule() {
let rule = ConditionalRule::cell_is(ConditionalOperator::GreaterThan, "100")
.with_format(ConditionalFormat::new().with_fill(ConditionalColor::green()));
assert_eq!(rule.rule_type, ConditionalFormatType::CellIs);
assert_eq!(rule.operator, Some(ConditionalOperator::GreaterThan));
assert_eq!(rule.formula1, Some("100".to_string()));
}
#[test]
fn test_color_scale() {
let scale = ColorScale::red_yellow_green();
let rule = ConditionalRule::with_color_scale(scale);
assert_eq!(rule.rule_type, ConditionalFormatType::ColorScale);
assert!(rule.color_scale.is_some());
}
#[test]
fn test_data_bar() {
let bar = DataBar::new()
.with_color(ConditionalColor::blue())
.hide_value();
let rule = ConditionalRule::with_data_bar(bar);
assert_eq!(rule.rule_type, ConditionalFormatType::DataBar);
assert!(rule.data_bar.is_some());
assert!(!rule.data_bar.unwrap().show_value);
}
#[test]
fn test_icon_set() {
let icons = IconSet::new(IconSetStyle::ThreeArrows).icon_only();
let rule = ConditionalRule::with_icon_set(icons);
assert_eq!(rule.rule_type, ConditionalFormatType::IconSet);
assert!(rule.icon_set.is_some());
}
#[test]
fn test_conditional_formatting() {
let mut cf = ConditionalFormatting::new("A1:A100");
cf.add_rule(
ConditionalRule::top(10).with_format(
ConditionalFormat::new()
.with_bold(true)
.with_fill(ConditionalColor::yellow()),
),
);
assert_eq!(cf.range, "A1:A100");
assert_eq!(cf.rules.len(), 1);
}
}
#[cfg(test)]
mod coverage_tests {
use super::*;
#[test]
fn type_and_operator_xml_roundtrip() {
for t in [
ConditionalFormatType::CellIs,
ConditionalFormatType::Expression,
ConditionalFormatType::ColorScale,
ConditionalFormatType::DataBar,
ConditionalFormatType::IconSet,
ConditionalFormatType::Top10,
ConditionalFormatType::ContainsText,
] {
let x = t.xml_value();
assert_eq!(ConditionalFormatType::from_xml(x), Some(t));
}
assert_eq!(ConditionalFormatType::from_xml("nonsense"), None);
for op in [
ConditionalOperator::GreaterThan,
ConditionalOperator::LessThan,
ConditionalOperator::Between,
ConditionalOperator::Equal,
] {
assert_eq!(ConditionalOperator::from_xml(op.xml_value()), Some(op));
}
}
#[test]
fn conditional_colors() {
assert!(ConditionalColor::rgb("FF0000").rgb.is_some());
assert!(ConditionalColor::theme(3).theme.is_some());
let _ = (
ConditionalColor::red(),
ConditionalColor::green(),
ConditionalColor::yellow(),
ConditionalColor::blue(),
ConditionalColor::white(),
);
}
#[test]
fn color_scales() {
let two = ColorScale::two_color(ConditionalColor::red(), ConditionalColor::green());
assert!(two.mid_color.is_none());
let three = ColorScale::three_color(
ConditionalColor::red(),
ConditionalColor::yellow(),
ConditionalColor::green(),
);
assert!(three.mid_color.is_some());
assert!(ColorScale::red_yellow_green().mid_color.is_some());
assert!(ColorScale::green_yellow_red().mid_color.is_some());
}
#[test]
fn data_bars_and_icon_sets() {
let bar = DataBar::new()
.with_color(ConditionalColor::blue())
.hide_value()
.solid_fill();
assert!(!bar.show_value, "hide_value clears show_value");
assert!(!bar.gradient, "solid_fill clears gradient");
let icons = IconSet::new(IconSetStyle::ThreeTrafficLights)
.icon_only()
.reversed();
assert!(icons.reverse && !icons.show_value);
assert_eq!(
IconSetStyle::from_xml(IconSetStyle::ThreeTrafficLights.xml_type()),
Some(IconSetStyle::ThreeTrafficLights)
);
}
#[test]
fn rule_constructors_and_formatting() {
let fmt = ConditionalFormat::new()
.with_font_color(ConditionalColor::red())
.with_bold(true)
.with_fill(ConditionalColor::yellow());
let _ = ConditionalRule::of_type(ConditionalFormatType::Expression);
let _ = ConditionalRule::cell_is(ConditionalOperator::GreaterThan, "10")
.with_format(fmt)
.with_priority(1);
let _ = ConditionalRule::formula("$A$1>0");
let _ = ConditionalRule::with_color_scale(ColorScale::red_yellow_green());
let _ = ConditionalRule::with_data_bar(DataBar::new());
let _ = ConditionalRule::with_icon_set(IconSet::new(IconSetStyle::ThreeArrows));
let _ = ConditionalRule::top(10);
let _ = ConditionalRule::bottom(5);
let _ = ConditionalRule::contains_text("x");
let _ = ConditionalRule::not_contains_text("y");
let _ = ConditionalRule::begins_with("a");
let _ = ConditionalRule::ends_with("z");
let _ = ConditionalRule::time_period("today");
let _ = ConditionalRule::above_average();
let _ = ConditionalRule::below_average();
let _ = ConditionalRule::duplicate_values();
let _ = ConditionalRule::unique_values();
let mut cf = ConditionalFormatting::new("A1:A10");
cf.add_rule(ConditionalRule::top(3));
cf.add_rule(ConditionalRule::formula("$A1>5"));
assert_eq!(cf.rules.len(), 2);
}
}