133 lines
3.9 KiB
Rust
133 lines
3.9 KiB
Rust
use std::collections::HashMap;
|
|
|
|
use codemap::Spanned;
|
|
|
|
use crate::{
|
|
atrule::{Function, Mixin},
|
|
builtin::GLOBAL_FUNCTIONS,
|
|
common::Identifier,
|
|
error::SassResult,
|
|
value::Value,
|
|
};
|
|
|
|
#[derive(Debug, Clone, Default)]
|
|
pub(crate) struct Scope {
|
|
vars: HashMap<Identifier, Spanned<Value>>,
|
|
mixins: HashMap<Identifier, Mixin>,
|
|
functions: HashMap<Identifier, Function>,
|
|
}
|
|
|
|
// todo: separate struct for global scope?
|
|
impl Scope {
|
|
#[must_use]
|
|
pub fn new() -> Self {
|
|
Self {
|
|
vars: HashMap::new(),
|
|
mixins: HashMap::new(),
|
|
functions: HashMap::new(),
|
|
}
|
|
}
|
|
|
|
fn get_var_no_global(&self, name: &Spanned<Identifier>) -> SassResult<Spanned<Value>> {
|
|
match self.vars.get(&name.node) {
|
|
Some(v) => Ok(v.clone()),
|
|
None => Err(("Undefined variable.", name.span).into()),
|
|
}
|
|
}
|
|
|
|
pub fn get_var<T: Into<Identifier>>(
|
|
&self,
|
|
name: Spanned<T>,
|
|
global_scope: &Scope,
|
|
) -> SassResult<Spanned<Value>> {
|
|
let name = name.map_node(Into::into);
|
|
match self.vars.get(&name.node) {
|
|
Some(v) => Ok(v.clone()),
|
|
None => global_scope.get_var_no_global(&name),
|
|
}
|
|
}
|
|
|
|
pub fn insert_var<T: Into<Identifier>>(
|
|
&mut self,
|
|
s: T,
|
|
v: Spanned<Value>,
|
|
) -> Option<Spanned<Value>> {
|
|
self.vars.insert(s.into(), v)
|
|
}
|
|
|
|
pub fn var_exists_no_global(&self, name: &Identifier) -> bool {
|
|
self.vars.contains_key(name)
|
|
}
|
|
|
|
pub fn var_exists<'a, T: Into<&'a Identifier>>(&self, v: T, global_scope: &Scope) -> bool {
|
|
let name = v.into();
|
|
self.vars.contains_key(name) || global_scope.var_exists_no_global(name)
|
|
}
|
|
|
|
fn get_mixin_no_global(&self, name: &Spanned<Identifier>) -> SassResult<Mixin> {
|
|
match self.mixins.get(&name.node) {
|
|
Some(v) => Ok(v.clone()),
|
|
None => Err(("Undefined mixin.", name.span).into()),
|
|
}
|
|
}
|
|
|
|
pub fn get_mixin<T: Into<Identifier>>(
|
|
&self,
|
|
name: Spanned<T>,
|
|
global_scope: &Scope,
|
|
) -> SassResult<Mixin> {
|
|
let name = name.map_node(Into::into);
|
|
match self.mixins.get(&name.node) {
|
|
Some(v) => Ok(v.clone()),
|
|
None => global_scope.get_mixin_no_global(&name),
|
|
}
|
|
}
|
|
|
|
pub fn insert_mixin<T: Into<Identifier>>(&mut self, s: T, v: Mixin) -> Option<Mixin> {
|
|
self.mixins.insert(s.into(), v)
|
|
}
|
|
|
|
fn mixin_exists_no_global(&self, name: &Identifier) -> bool {
|
|
self.mixins.contains_key(name)
|
|
}
|
|
|
|
pub fn mixin_exists<T: Into<Identifier>>(&self, v: T, global_scope: &Scope) -> bool {
|
|
let name = v.into();
|
|
self.mixins.contains_key(&name) || global_scope.mixin_exists_no_global(&name)
|
|
}
|
|
|
|
fn get_fn_no_global(&self, name: &Spanned<Identifier>) -> SassResult<Function> {
|
|
match self.functions.get(&name.node) {
|
|
Some(v) => Ok(v.clone()),
|
|
None => Err(("Undefined function.", name.span).into()),
|
|
}
|
|
}
|
|
|
|
pub fn get_fn<T: Into<Identifier>>(
|
|
&self,
|
|
name: Spanned<T>,
|
|
global_scope: &Scope,
|
|
) -> SassResult<Function> {
|
|
let name = name.map_node(Into::into);
|
|
match self.functions.get(&name.node) {
|
|
Some(v) => Ok(v.clone()),
|
|
None => global_scope.get_fn_no_global(&name),
|
|
}
|
|
}
|
|
|
|
pub fn insert_fn<T: Into<Identifier>>(&mut self, s: T, v: Function) -> Option<Function> {
|
|
self.functions.insert(s.into(), v)
|
|
}
|
|
|
|
fn fn_exists_no_global(&self, name: &Identifier) -> bool {
|
|
self.functions.contains_key(name)
|
|
}
|
|
|
|
pub fn fn_exists<T: Into<Identifier>>(&self, v: T, global_scope: &Scope) -> bool {
|
|
let name = v.into();
|
|
self.functions.contains_key(&name)
|
|
|| global_scope.fn_exists_no_global(&name)
|
|
|| GLOBAL_FUNCTIONS.contains_key(name.clone().into_inner().as_str())
|
|
}
|
|
}
|