less-rs 0.0.0

A Rust implementation of the Less CSS preprocessor.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::{
  fmt::Write,
  ops::{Deref, DerefMut},
};

use less_allocator::{Box, Vec};
use variable::Variable;

use crate::{
  parser::DeclarationList,
  printer::{Printer, PrinterError},
  selector::SelectorList,
  traits::ToCss,
};

pub mod variable;

#[derive(Debug)]
pub struct CssRuleList<'i>(pub(crate) Vec<'i, CssRule<'i>>);

impl<'i> ToCss<'i> for CssRuleList<'i> {
  fn to_css<W: std::fmt::Write>(
    &self,
    dest: &mut Printer<'_, 'i, W>,
  ) -> Result<(), PrinterError<'i>> {
    let variables = Vec::from_iter_in(
      self.0.iter().filter_map(|rule| {
        if let CssRule::LessVariable(variable) = rule {
          Some(&*variable.0)
        } else {
          None
        }
      }),
      dest.allocator,
    );

    dest.with_context(variables, |dest| {
      self.0.iter().try_for_each(|rule| rule.to_css(dest))
    })?;

    Ok(())
  }
}

#[derive(Debug)]
pub struct StyleRule<'i> {
  pub selector: SelectorList<'i>,
  pub declarations: DeclarationList<'i>,
  pub rules: CssRuleList<'i>,
}

impl<'i> ToCss<'i> for StyleRule<'i> {
  fn to_css<W: std::fmt::Write>(
    &self,
    dest: &mut Printer<'_, 'i, W>,
  ) -> Result<(), PrinterError<'i>> {
    // TODO: remove this as both `CssRules` and `StyleRule` have their own variables,
    // which is basically the same.
    let variables = Vec::from_iter_in(
      self.rules.iter().filter_map(|rule| {
        if let CssRule::LessVariable(variable) = rule {
          Some(&*variable.0)
        } else {
          None
        }
      }),
      dest.allocator,
    );

    dest.write_str(".class {")?;
    dest.write_newline()?;
    dest.with_context(variables, |dest| self.declarations.to_css(dest))?;
    self.rules.to_css(dest)?;
    dest.write_char('}')?;
    Ok(())
  }
}

#[derive(Debug)]
pub enum CssRule<'i> {
  /// A Style rule
  /// https://drafts.csswg.org/cssom-1/#the-cssstylerule-interface
  Style(Box<'i, StyleRule<'i>>),
  LessVariable(Box<'i, Variable<'i>>),
}

impl<'i> ToCss<'i> for CssRule<'i> {
  fn to_css<W: std::fmt::Write>(
    &self,
    dest: &mut Printer<'_, 'i, W>,
  ) -> Result<(), PrinterError<'i>> {
    match self {
      CssRule::Style(rule) => {
        rule.to_css(dest)?;
      }
      CssRule::LessVariable(_) => {}
    }
    Ok(())
  }
}

impl<'i> Deref for CssRuleList<'i> {
  type Target = Vec<'i, CssRule<'i>>;

  fn deref(&self) -> &Self::Target {
    &self.0
  }
}

impl DerefMut for CssRuleList<'_> {
  fn deref_mut(&mut self) -> &mut Self::Target {
    &mut self.0
  }
}