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")