nu 0.1.2

A shell for the GitHub era
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

use crate::errors::Description;
use crate::object::base::Block;
use crate::parser::{
    hir::{self, Expression, RawExpression},
    CommandRegistry, Spanned, Text,
};
use crate::prelude::*;
use derive_new::new;
use indexmap::IndexMap;

#[derive(new)]
crate struct Scope {
    it: Spanned<Value>,
    #[new(default)]
    vars: IndexMap<String, Spanned<Value>>,
}

impl Scope {
    crate fn empty() -> Scope {
        Scope {
            it: Value::nothing().spanned_unknown(),
            vars: IndexMap::new(),
        }
    }
}

crate fn evaluate_baseline_expr(
    expr: &Expression,
    registry: &dyn CommandRegistry,
    scope: &Scope,
    source: &Text,
) -> Result<Spanned<Value>, ShellError> {
    match &expr.item {
        RawExpression::Literal(literal) => Ok(evaluate_literal(expr.copy_span(*literal), source)),
        RawExpression::Variable(var) => evaluate_reference(var, scope, source),
        RawExpression::Binary(binary) => {
            let left = evaluate_baseline_expr(binary.left(), registry, scope, source)?;
            let right = evaluate_baseline_expr(binary.right(), registry, scope, source)?;

            match left.compare(binary.op(), &*right) {
                Ok(result) => Ok(Spanned::from_item(Value::boolean(result), *expr.span())),
                Err((left_type, right_type)) => Err(ShellError::coerce_error(
                    binary.left().copy_span(left_type),
                    binary.right().copy_span(right_type),
                )),
            }
        }
        RawExpression::Block(block) => Ok(Spanned::from_item(
            Value::Block(Block::new(block.clone(), source.clone(), *expr.span())),
            expr.span(),
        )),
        RawExpression::Path(path) => {
            let value = evaluate_baseline_expr(path.head(), registry, scope, source)?;
            let mut item = value;

            for name in path.tail() {
                let next = item.get_data_by_key(name);

                match next {
                    None => {
                        return Err(ShellError::missing_property(
                            Description::from(item.spanned_type_name()),
                            Description::from(name.clone()),
                        ))
                    }
                    Some(next) => {
                        item = Spanned::from_item(
                            next.clone().item,
                            (expr.span().start, name.span().end),
                        )
                    }
                };
            }

            Ok(Spanned::from_item(item.item().clone(), expr.span()))
        }
        RawExpression::Boolean(_boolean) => unimplemented!(),
    }
}

fn evaluate_literal(literal: Spanned<hir::Literal>, source: &Text) -> Spanned<Value> {
    let result = match literal.item {
        hir::Literal::Integer(int) => Value::int(int),
        hir::Literal::Size(int, unit) => unit.compute(int),
        hir::Literal::String(span) => Value::string(span.slice(source)),
        hir::Literal::Bare => Value::string(literal.span().slice(source)),
    };

    literal.map(|_| result)
}

fn evaluate_reference(
    name: &hir::Variable,
    scope: &Scope,
    source: &Text,
) -> Result<Spanned<Value>, ShellError> {
    match name {
        hir::Variable::It(span) => Ok(Spanned::from_item(scope.it.item.clone(), span)),
        hir::Variable::Other(span) => Ok(scope
            .vars
            .get(span.slice(source))
            .map(|v| v.clone())
            .unwrap_or_else(|| Value::nothing().spanned(span))),
    }
}