dymokomi/luce-prism
Source of release 0.6.0
## 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)