Luce packages
LuceLuce BaseLuciaOS

dymokomi/luc

Source of release 0.24.3

0.24.3 / src / project_file.lucb

## package.prisma is the one project file; the compilers read it directly.
import c
from luce_std import files
from luce_std import paths
import strings
from luce_pkg import pkg
from luce_prism import prism

pub let file_name = "package.prisma"
pub let generated_name = "luce.toml"
pub let invalid = pkg.invalid

pub func exists_in(directory: str) -> bool!:
    let path = try paths.join(directory, file_name)
    defer path.release()
    return files.exists((c.str)path.value)

## Decoded package.prisma of `directory`; the caller closes it.
pub func read(directory: str) -> pkg.Definition!:
    let path = try paths.join(directory, file_name)
    defer path.release()
    let bytes = try files.read((c.str)path.value)
    defer bytes.release()
    return try pkg.decode_package(bytes.value)

## The compilers read package.prisma themselves. A luce.toml left behind by an earlier luc
## is removed so nothing stale sits beside the real definition.
pub func generate(directory: str, root: str, registry: bool = false, depth: usize = 0) -> !:
    _ = root
    _ = registry
    _ = depth
    let target = try paths.join(directory, generated_name)
    defer target.release()
    if files.exists((c.str)target.value): try files.remove_file((c.str)target.value)

func save(document: prism.Document*, directory: str) -> !:
    let encoded = try document.encode(prism.Encoding.text)
    defer encoded.release()
    _ = try pkg.decode_package(encoded.value().bytes())
    let path = try paths.join(directory, file_name)
    defer path.release()
    try files.write((c.str)path.value, encoded.value().bytes())

func set_text(document: prism.Document*, path: str, name: str, text: str) -> !:
    let value = try prism.Value.text(text)
    defer value.release()
    try document.set(path, name, value)

func element(root: str, name: str, output: u8[]) -> str!:
    return try strings.format(output, f"/{root}/{name}")

## Add or replace a dependency on the package checked out at `location`.
pub func add_dependency(directory: str, location: str) -> str!:
    let source = try paths.join(directory, location)
    defer source.release()
    if not try exists_in(source.value): error(invalid, "no package.prisma at that path")
    var dependency = try read(source.value)
    defer dependency.close()
    var current = try read(directory)
    defer current.close()
    let file = try paths.join(directory, file_name)
    defer file.release()
    let reference = try prism.Document.load(file.value)
    defer reference.release()
    let document = reference.value()
    var buffer: u8[256]
    let path = try element(current.name, dependency.name, buffer)
    if document.contains(path): try document.remove(path)
    try document.add(path, "dependency")
    try set_text(document, path, "owner", dependency.owner)
    try set_text(document, path, "path", location)
    try save(document, directory)
    return try strings.copy(dependency.name)

## Add or replace a dependency on a released registry package: `requirement` is a caret
## requirement or a version, or empty for the newest release.
pub func add_registry_dependency(directory: str, owner: str, name: str, requirement: str) -> !:
    var current = try read(directory)
    defer current.close()
    let file = try paths.join(directory, file_name)
    defer file.release()
    let reference = try prism.Document.load(file.value)
    defer reference.release()
    let document = reference.value()
    var buffer: u8[256]
    let path = try element(current.name, name, buffer)
    if document.contains(path): try document.remove(path)
    try document.add(path, "dependency")
    try set_text(document, path, "owner", owner)
    if requirement.length > 0: try set_text(document, path, "version", requirement)
    try save(document, directory)

pub func remove_dependency(directory: str, name: str) -> bool!:
    var current = try read(directory)
    defer current.close()
    let file = try paths.join(directory, file_name)
    defer file.release()
    let reference = try prism.Document.load(file.value)
    defer reference.release()
    let document = reference.value()
    var buffer: u8[256]
    let path = try element(current.name, name, buffer)
    if not document.contains(path) or try document.type_at(path) != "dependency": return false
    try document.remove(path)
    try save(document, directory)
    return true

## Where `luc sync` unpacks a locked registry package inside the project at `root`: under
## `.luc/deps/`, by identifier, which is where the compilers look for a dependency that
## declares no checkout path.
pub func dependency_directory(root: str, name: str) -> str!:
    let hidden = try paths.join(root, ".luc")
    defer hidden.release()
    let parent = try paths.join(hidden.value, "deps")
    defer parent.release()
    let identifier = try module_name(name)
    defer strings.release(identifier)
    let directory = try paths.join(parent.value, identifier)
    defer directory.release()
    return try strings.copy(directory.value)

## Module identifier for a package name: hyphens become underscores.
pub func module_name(name: str) -> str!:
    let copy = try strings.copy(name)
    let bytes = (u8[])copy.bytes
    for i in 0..<bytes.length:
        if bytes[i] == '-': bytes[i] = '_'
    return copy

## The starter module of a new library: the last word of its name, `json` for luce-json
## and `lib` for my-lib, so a consumer writes `from luce_json import json` rather than
## repeating the package's name (base.md ยง16.3).
pub func library_module(name: str) -> str!:
    var start: usize = 0
    for i in 0..<name.length:
        if (name.bytes[i] == '-' or name.bytes[i] == '_') and i + 1 < name.length:
            start = i + 1
    return try strings.copy((str)name.bytes[start..])

## Text of a new package.prisma for `luc init` and `luc new`. `kind` is package,
## application or tool; an application is a luce-ui window with its desktop bundle. Its
## luce-ui dependency names no version: the newest release, which luc.lock records.
pub func scaffold(name: str, owner: str, language: str, kind: str, output: u8[]) -> str!:
    let suffix = ".luc" if language == "luce" else ".lucb"
    let module = try library_module(name)
    defer strings.release(module)
    if kind == "package":
        return try strings.format(output, f"#prisma 4.0\ndef package \"{name}\" {{\n    str owner = \"{owner}\"\n    str version = \"0.1.0\"\n    str kind = \"package\"\n    str language = \"{language}\"\n    str[] public = [\"{module}\"]\n}}\n")
    if kind == "tool":
        return try strings.format(output, f"#prisma 4.0\ndef package \"{name}\" {{\n    str owner = \"{owner}\"\n    str version = \"0.1.0\"\n    str kind = \"tool\"\n    str language = \"{language}\"\n    str entry = \"src/main{suffix}\"\n}}\n")
    # The display name is the package name in words: my-editor -> "My Editor".
    var display: u8[64]
    var length: usize
    var word_start = true
    for byte in name.bytes:
        if length >= display.length: break
        if byte == '-' or byte == '_':
            display[length] = ' '
            word_start = true
        else:
            display[length] = byte - 32 if word_start and byte >= 'a' and byte <= 'z' else byte
            word_start = false
        length += 1
    var label: u8[64]
    var label_length: usize
    for byte in name.bytes:
        if label_length >= label.length: break
        if byte == '_': continue
        label[label_length] = byte
        label_length += 1
    return try strings.format(output, f"#prisma 4.0\ndef package \"{name}\" {{\n    str owner = \"{owner}\"\n    str version = \"0.1.0\"\n    str kind = \"application\"\n    str language = \"luce\"\n    str entry = \"src/main.luc\"\n    def application \"bundle\" {{\n        str name = \"{(str)display[..<length]}\"\n        str identifier = \"com.{owner}.{(str)label[..<label_length]}\"\n    }}\n    def dependency \"luce-ui\" {{\n        str owner = \"dymokomi\"\n    }}\n}}\n")