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
115
116
117

use std::cell::{Cell, RefCell};

use cssparser::{CowRcStr, Delimiter, Token};
use less_allocator::{Allocator, Vec};

use crate::{
  error::ParserError, properties::PropertyDeclaration, traits::ToCss, values::token::TokenList,
};

#[derive(Debug)]
pub enum VariableValue<'i> {
  Unparsed(&'i str),
  Parsed(TokenList<'i>),
}

impl<'i> ToCss<'i> for VariableValue<'i> {
  fn to_css<W>(
    &self,
    dest: &mut crate::printer::Printer<'_, 'i, W>,
  ) -> Result<(), crate::printer::PrinterError<'i>>
  where
    W: std::fmt::Write,
  {
    match self {
      VariableValue::Unparsed(_) => unreachable!(),
      VariableValue::Parsed(property_declaration) => todo!(),
    }
  }
}

impl<'i> VariableValue<'i> {
  fn as_unparsed(&self) -> Option<&'i str> {
    if let VariableValue::Unparsed(raw) = self {
      return Some(raw);
    }
    None
  }
}

impl<'i> crate::traits::Parse<'i> for VariableValue<'i> {
  fn parse<'t>(
    _allocator: &'i Allocator,
    input: &mut cssparser::Parser<'i, 't>,
  ) -> Result<Self, cssparser::ParseError<'i, crate::error::ParserError<'i>>> {
    let start_position = input.position();
    input.parse_until_before(Delimiter::Semicolon, |input| {
      while input.next().is_ok() {}
      Ok(())
    })?;
    Ok(Self::Unparsed(input.slice_from(start_position)))
  }
}

/// A Less variable.
///
///   @font-size: 16px;
///
#[derive(Debug)]
pub struct Variable<'i> {
  pub(crate) name: cssparser::CowRcStr<'i>,
  pub(crate) raw: &'i str,
  pub(crate) evaluating: Cell<bool>,
  pub(crate) value: RefCell<VariableValue<'i>>,
}

impl<'i> Variable<'i> {
  pub fn new(name: cssparser::CowRcStr<'i>, value: VariableValue<'i>) -> Self {
    let raw = match value.as_unparsed() {
      Some(v) => v,
      None => unreachable!("Variable value must be unparsed when creating a new variable"),
    };
    Self {
      name,
      raw,
      evaluating: Cell::new(false),
      value: RefCell::new(value),
    }
  }
}

#[derive(Clone, PartialEq, Eq, Hash)]
pub struct VariableCurly<'i> {
  name: cssparser::CowRcStr<'i>,
}

// FIXTHIS
// I believe `ToCss` is used to generate css. Shouldn't use this to print debuginfo.
// That's werid for `Selector` to use this as a way to debug.
// impl<'i> ToCss for VariableCurly<'i> {
//   fn to_css<W>(&self, dest: &mut W) -> std::fmt::Result
//   where
//     W: std::fmt::Write,
//   {
//     dest.write_str("@{")?;
//     dest.write_str(&self.name)?;
//     dest.write_str("}")
//   }
// }

impl<'i> From<CowRcStr<'i>> for VariableCurly<'i> {
  fn from(value: CowRcStr<'i>) -> Self {
    Self { name: value }
  }
}

impl<'i> crate::traits::Parse<'i> for VariableCurly<'i> {
  fn parse<'t>(
    _allocator: &'i Allocator,
    input: &mut cssparser::Parser<'i, 't>,
  ) -> Result<Self, cssparser::ParseError<'i, ParserError<'i>>> {
    let variable = input.expect_less_variable_curly()?;
    dbg!(&variable);
    Ok(VariableCurly {
      name: variable.clone(),
    })
  }
}