Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / src / schema.lucb

## Optional per-type constraints with exact, scalar uniqueness.
import interop
import memory
import query.scalars
from collections.index import Index
from document import Document, assemble_element, walk_document
from model import Element
from animation import resolve_property
from storage import List, Buffer, Pair, text_copy, close_names
from types import DType, invalid

struct Rule:
    var type_name: Buffer
    var field: Buffer
    var dtype: DType
    var required: bool
    var unique: bool

    func close():
        self.type_name.close()
        self.field.close()

pub struct Violations:
    var entries: List[Pair]

    pub func init():
        return

    pub func count() -> usize:
        return self.entries.count

    pub func path_at(index: usize) -> str!:
        if index >= self.entries.count:
            error(invalid, "violation index is out of bounds")
        return self.entries.items[index].key.view()

    pub func message_at(index: usize) -> str!:
        if index >= self.entries.count:
            error(invalid, "violation index is out of bounds")
        return self.entries.items[index].value.view()

    func append(path: str, parts: const str[]) -> !:
        var entry: Pair
        errdefer entry.close()
        entry.key = try text_copy(path)
        for part in parts:
            try entry.value.text(part)
        try self.entries.push(entry)

    pub func close():
        for i in 0..<self.entries.count:
            self.entries.items[i].close()
        self.entries.close()

pub let violations_type = interop.Type[Violations]("Prism schema violations", Violations.close, closeable = true)

func dtype_name(dtype: DType) -> str:
    let names = ["bool", "char", "i8", "i16", "i32", "i64", "u8", "u16", "u32", "u64", "f32", "f64", "str", "f16"]
    return names[(usize)dtype]

pub struct Schema:
    var rules: List[Rule]

    pub func init():
        return

    pub func add_field(type_name: str, field: str, dtype: DType, required: bool = false, unique: bool = false) -> !:
        var rule = Rule(dtype = dtype, required = required, unique = unique)
        errdefer rule.close()
        rule.type_name = try text_copy(type_name)
        rule.field = try text_copy(field)
        for i in 0..<self.rules.count:
            if self.rules.items[i].type_name.view() == type_name and self.rules.items[i].field.view() == field:
                self.rules.items[i].close()
                self.rules.items[i] = rule
                return
        try self.rules.push(rule)

    func check_row(element: const Element*, by_type: const Index*, seen: List[Index]*, paths: List[Buffer]*, result: Violations*) -> !:
        let type_index = by_type.find(element.kind.view()) else return
        for index in by_type.buckets.items[type_index].rows.span():
            let rule = &self.rules.items[index]
            let name = rule.field.view()
            let position = element.property(name)
            if position == none:
                if rule.required:
                    try result.append(element.path.view(), ["missing required property '", name, "'"])
                continue
            var value = try resolve_property(&element.properties.items[position else 0], 0.0)
            defer value.close()
            if value.kind != rule.dtype:
                let actual = dtype_name(value.kind)
                let expected = dtype_name(rule.dtype)
                try result.append(element.path.view(), ["property '", name, "' is ", actual, ", expected ", expected])
            if rule.unique:
                if let found = try scalars.key(&value):
                    var key = found
                    defer key.close()
                    if let previous = seen.items[index].find(key.view()):
                        let first = seen.items[index].buckets.items[previous].rows.items[0]
                        let path = paths.items[first].view()
                        try result.append(element.path.view(), ["duplicate value for unique property '", name, "' (also at ", path, ")"])
                    else:
                        var copied = try text_copy(element.path.view())
                        errdefer copied.close()
                        _ = try seen.items[index].add(key.view(), paths.count)
                        try paths.push(copied)
                        copied = Buffer()

    pub func validate(doc: interop.Reference[Document]) -> interop.Reference[Violations]!:
        var by_type: Index
        defer by_type.close()
        var seen: List[Index]
        defer close_indexes(&seen)
        var paths: List[Buffer]
        defer close_names(&paths)
        for i in 0..<self.rules.count:
            _ = try by_type.add(self.rules.items[i].type_name.view(), i)
            try seen.push(Index())
        var result = Violations()
        errdefer result.close()
        let view = try doc.get()
        if view.is_layered():
            var walk = try walk_document(view)
            defer walk.close()
            for path in walk.span():
                var element = try assemble_element(view, path)
                defer element.close()
                try self.check_row(&element, &by_type, &seen, &paths, &result)
        else:
            for element in view.view_data().elements.span():
                try self.check_row(&element, &by_type, &seen, &paths, &result)
        let owned = result
        result = Violations()
        return try own_violations(owned)

    pub func close():
        for i in 0..<self.rules.count:
            self.rules.items[i].close()
        self.rules.close()

pub let schema_type = interop.Type[Schema]("Prism schema", Schema.close, closeable = true)

func close_indexes(indexes: List[Index]*):
    for i in 0..<indexes.count:
        indexes.items[i].close()
    indexes.close()

func own_violations(result: Violations) -> interop.Reference[Violations]!:
    var owned = result
    let native = new Violations() in memory.heap catch failure:
        owned.close()
        error(failure.code, failure.message)
    native[0] = owned
    return try interop.Reference[Violations].adopt(native, violations_type, memory.heap)