MahmoudEmad/herolib
1
0
Fork 0
Code Issues 55 Pull Requests 1 Actions Packages Projects Releases 26 Wiki Activity

Merge branch 'development' of github.com:incubaid/herolib into development

Browse Source 
* 'development' of github.com:incubaid/herolib: (26 commits)
  Fix redis package name for alpine
  ...
  ...
  ...
  ...
  ...
  ...
  ...
  ...
  ...
  ...
  ...
  ...
  ...
  ...
  ...
  feat: Enhance docusaurus site generation with atlas client
  feat: Improve export self-containment and link handling
  ...
  feat: Add Atlas Export and AtlasClient example
  ...
This commit is contained in:
despiegk
2025-11-14 08:52:13 +02:00
parent a2eaf6096e c033cacd5b
commit 16155480de
137 changed files with 2431 additions and 652 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
examples/data/atlas/heroscript_example_auth_web.hero → examples/data/atlas/atlas_auth_web.hero
View File

0
examples/data/atlas/heroscript_example.hero → examples/data/atlas/atlas_example.hero
View File

5
examples/data/atlas/atlas_test.hero Executable file
View File

@@ -0,0 +1,5 @@
#!/usr/bin/env hero
!!atlas.scan git_url:"https://git.ourworld.tf/tfgrid/docs_tfgrid4/src/branch/main/collections/tests"
!!atlas.export destination: '/tmp/atlas_export'

98
examples/data/atlas/example.vsh Executable file
View File

@@ -0,0 +1,98 @@
#!/usr/bin/env -S v -n -w -cg -gc none -cc tcc -d use_openssl -enable-globals run
import incubaid.herolib.data.atlas
import incubaid.herolib.core.pathlib
import incubaid.herolib.web.atlas_client
import os
// Example: Atlas Export and AtlasClient Usage
println('Atlas Export & Client Example')
println('============================================================')
// Setup test directory
test_dir := '/tmp/atlas_example'
export_dir := '/tmp/atlas_export'
os.rmdir_all(test_dir) or {}
os.rmdir_all(export_dir) or {}
os.mkdir_all(test_dir)!
// Create a collection with some content
col_path := '${test_dir}/docs'
os.mkdir_all(col_path)!
mut cfile := pathlib.get_file(path: '${col_path}/.collection', create: true)!
cfile.write('name:docs')!
mut page1 := pathlib.get_file(path: '${col_path}/intro.md', create: true)!
page1.write('# Introduction\n\nWelcome to the docs!')!
mut page2 := pathlib.get_file(path: '${col_path}/guide.md', create: true)!
page2.write('# Guide\n\n!!include docs:intro\n\nMore content here.')!
// Create and scan atlas
println('\n1. Creating Atlas and scanning...')
mut a := atlas.new(name: 'my_docs')!
a.scan(path: test_dir)!
println(' Found ${a.collections.len} collection(s)')
// Validate links
println('\n2. Validating links...')
a.validate_links()!
col := a.get_collection('docs')!
if col.has_errors() {
println(' Errors found:')
col.print_errors()
} else {
println(' No errors found!')
}
// Export collections
println('\n3. Exporting collections to ${export_dir}...')
a.export(
destination: export_dir
include: true // Process includes during export
redis: false // Don't use Redis for this example
)!
println(' ✓ Export complete')
// Use AtlasClient to access exported content
println('\n4. Using AtlasClient to read exported content...')
mut client := atlas_client.new(export_dir: export_dir)!
// List collections
collections := client.list_collections()!
println(' Collections: ${collections}')
// List pages in docs collection
pages := client.list_pages('docs')!
println(' Pages in docs: ${pages}')
// Read page content
println('\n5. Reading page content via AtlasClient...')
intro_content := client.get_page_content('docs', 'intro')!
println(' intro.md content:')
println(' ${intro_content}')
guide_content := client.get_page_content('docs', 'guide')!
println('\n guide.md content (with includes processed):')
println(' ${guide_content}')
// Get metadata
println('\n6. Accessing metadata...')
metadata := client.get_collection_metadata('docs')!
println(' Collection name: ${metadata.name}')
println(' Collection path: ${metadata.path}')
println(' Number of pages: ${metadata.pages.len}')
println('\n✓ Example completed successfully!')
println('\nExported files are in: ${export_dir}')
println(' - content/docs/intro.md')
println(' - content/docs/guide.md')
println(' - meta/docs.json')
// Cleanup (commented out so you can inspect the files)
// os.rmdir_all(test_dir) or {}
// os.rmdir_all(export_dir) or {}

83
examples/data/atlas/example_save_load.vsh
View File

@@ -1,83 +0,0 @@
#!/usr/bin/env -S v -n -w -cg -gc none -cc tcc -d use_openssl -enable-globals run
import incubaid.herolib.data.atlas
import incubaid.herolib.core.pathlib
import os
// Example: Save and Load Atlas Collections
println('Atlas Save/Load Example')
println('============================================================')
// Setup test directory
test_dir := '/tmp/atlas_example'
os.rmdir_all(test_dir) or {}
os.mkdir_all(test_dir)!
// Create a collection with some content
col_path := '${test_dir}/docs'
os.mkdir_all(col_path)!
mut cfile := pathlib.get_file(path: '${col_path}/.collection', create: true)!
cfile.write('name:docs')!
mut page1 := pathlib.get_file(path: '${col_path}/intro.md', create: true)!
page1.write('# Introduction\n\nWelcome to the docs!')!
mut page2 := pathlib.get_file(path: '${col_path}/guide.md', create: true)!
page2.write('# Guide\n\n!!include docs:intro\n\nMore content here.')!
// Create and scan atlas
println('\n1. Creating Atlas and scanning...')
mut a := atlas.new(name: 'my_docs')!
a.scan(path: test_dir)!
println(' Found ${a.collections.len} collection(s)')
// Validate links
println('\n2. Validating links...')
a.validate_links()!
col := a.get_collection('docs')!
if col.has_errors() {
println(' Errors found:')
col.print_errors()
} else {
println(' No errors found!')
}
// Save all collections
println('\n3. Saving collections to .collection.json...')
a.save_all()!
println(' Saved to ${col_path}/.collection.json')
// Load in a new atlas
println('\n4. Loading collections in new Atlas...')
mut a2 := atlas.new(name: 'loaded_docs')!
a2.load_from_directory(test_dir)!
println(' Loaded ${a2.collections.len} collection(s)')
// Access loaded data
println('\n5. Accessing loaded data...')
loaded_col := a2.get_collection('docs')!
println(' Collection: ${loaded_col.name}')
println(' Pages: ${loaded_col.pages.len}')
for name, page in loaded_col.pages {
println(' - ${name}: ${page.path.path}')
}
// Read page content
println('\n6. Reading page content...')
mut intro_page := loaded_col.page_get('intro')!
content := intro_page.read_content()!
println(' intro.md content:')
println(' ${content}')
println('\n✓ Example completed successfully!')
println('\nNow you can use the Python loader:')
println(' python3 lib/data/atlas/atlas_loader.py')
// Cleanup
os.rmdir_all(test_dir) or {}

36
lib/ai/client/README.md Normal file
View File

@@ -0,0 +1,36 @@
# AIClient Factory
This directory contains the implementation of the `AIClient` factory, which provides a unified interface for interacting with various Large Language Model (LLM) providers such as Groq and OpenRouter. It leverages the existing OpenAI client infrastructure to abstract away the differences between providers.
## File Structure
- [`aiclient.v`](lib/ai/client/aiclient.v): The main factory and core functions for the `AIClient`.
- [`aiclient_models.v`](lib/ai/client/aiclient_models.v): Defines LLM model enums and their mapping to specific model names and API base URLs.
- [`aiclient_llm.v`](lib/ai/client/aiclient_llm.v): Handles the initialization of various LLM provider clients.
- [`aiclient_embed.v`](lib/ai/client/aiclient_embed.v): Provides functions for generating embeddings using the configured LLM models.
- [`aiclient_write.v`](lib/ai/client/aiclient_write.v): Implements complex file writing logic, including backup, AI-driven modification, content validation, and retry mechanisms.
- [`aiclient_validate.v`](lib/ai/client/aiclient_validate.v): Contains placeholder functions for validating different file types (Vlang, Markdown, YAML, JSON).
## Usage
To use the `AIClient`, you first need to initialize it:
```v
import aiclient
mut client := aiclient.new()!
```
Ensure that the necessary environment variables (`GROQKEY` and `OPENROUTER_API_KEY`) are set for the LLM providers.
## Environment Variables
- `GROQKEY`: API key for Groq.
- `OPENROUTER_API_KEY`: API key for OpenRouter.
## Key Features
```bash
v install prantlf.yaml
v install markdown
```

17
lib/ai/client/aiclient.v Normal file
View File

@@ -0,0 +1,17 @@
module client
import incubaid.herolib.core.pathlib
@[heap]
pub struct AIClient {
pub mut:
llms AIClientLLMs
// Add other fields as needed
}
pub fn new() !AIClient {
llms := llms_init()!
return AIClient{
llms: llms
}
}

5
lib/ai/client/aiclient_embed.v Normal file
View File

@@ -0,0 +1,5 @@
module client
// pub fn (mut ac AIClient) embed(txt string) ![]f32 {
// return ac.llms.llm_embed.embeddings(txt)!
// }

104
lib/ai/client/aiclient_llm.v Normal file
View File

@@ -0,0 +1,104 @@
module client
import incubaid.herolib.clients.openai
import os
pub struct AIClientLLMs {
pub mut:
llm_maverick &openai.OpenAI
llm_qwen &openai.OpenAI
llm_120b &openai.OpenAI
llm_best &openai.OpenAI
llm_flash &openai.OpenAI
llm_pro &openai.OpenAI
llm_morph &openai.OpenAI
llm_embed &openai.OpenAI
}
// Initialize all LLM clients
pub fn llms_init() !AIClientLLMs {
groq_key := os.getenv('GROQKEY')
if groq_key.len == 0 {
return error('GROQKEY environment variable not set')
}
openrouter_key := os.getenv('OPENROUTER_API_KEY')
if openrouter_key.len == 0 {
return error('OPENROUTER_API_KEY environment variable not set')
}
mut maverick_client := openai.OpenAI{
name: 'maverick'
api_key: groq_key
url: 'https://api.groq.com/openai/v1'
model_default: 'meta-llama/llama-4-maverick-17b-128e-instruct'
}
openai.set(maverick_client)!
mut qwen_client := openai.OpenAI{
name: 'qwen'
api_key: groq_key
url: 'https://api.groq.com/openai/v1'
model_default: 'qwen/qwen3-32b'
}
openai.set(qwen_client)!
mut llm_120b_client := openai.OpenAI{
name: 'llm_120b'
api_key: groq_key
url: 'https://api.groq.com/openai/v1'
model_default: 'openai/gpt-oss-120b'
}
openai.set(llm_120b_client)!
mut best_client := openai.OpenAI{
name: 'best'
api_key: openrouter_key
url: 'https://api.openrouter.ai/api/v1'
model_default: 'anthropic/claude-haiku-4.5'
}
openai.set(best_client)!
mut flash_client := openai.OpenAI{
name: 'flash'
api_key: openrouter_key
url: 'https://api.openrouter.ai/api/v1'
model_default: 'google/gemini-2.5-flash'
}
openai.set(flash_client)!
mut pro_client := openai.OpenAI{
name: 'pro'
api_key: openrouter_key
url: 'https://api.openrouter.ai/api/v1'
model_default: 'google/gemini-2.5-pro'
}
openai.set(pro_client)!
mut morph_client := openai.OpenAI{
name: 'morph'
api_key: openrouter_key
url: 'https://api.openrouter.ai/api/v1'
model_default: 'morph/morph-v3-fast'
}
openai.set(morph_client)!
mut embed_client := openai.OpenAI{
name: 'embed'
api_key: openrouter_key
url: 'https://api.openrouter.ai/api/v1'
model_default: 'qwen/qwen3-embedding-0.6b'
}
openai.set(embed_client)!
return AIClientLLMs{
llm_maverick: openai.get(name: 'maverick')!
llm_qwen: openai.get(name: 'qwen')!
llm_120b: openai.get(name: 'llm_120b')!
llm_best: openai.get(name: 'best')!
llm_flash: openai.get(name: 'flash')!
llm_pro: openai.get(name: 'pro')!
llm_morph: openai.get(name: 'morph')!
llm_embed: openai.get(name: 'embed')!
}
}

26
lib/ai/client/aiclient_models.v Normal file
View File

@@ -0,0 +1,26 @@
module client
pub enum LLMEnum {
maverick
qwen
embed
llm_120b
best
flash
pro
morph
}
fn llm_to_model_url(model LLMEnum) !(string, string) {
// Returns tuple: (model_name, base_url)
return match model {
.maverick { 'meta-llama/llama-4-maverick-17b-128e-instruct', 'https://api.groq.com/openai/v1' }
.qwen { 'qwen/qwen3-32b', 'https://api.groq.com/openai/v1' }
.embed { 'qwen/qwen3-embedding-0.6b', 'https://api.openrouter.ai/api/v1' }
.llm_120b { 'openai/gpt-oss-120b', 'https://api.groq.com/openai/v1' }
.best { 'anthropic/claude-haiku-4.5', 'https://api.openrouter.ai/api/v1' }
.flash { 'google/gemini-2.5-flash', 'https://api.openrouter.ai/api/v1' }
.pro { 'google/gemini-2.5-pro', 'https://api.openrouter.ai/api/v1' }
.morph { 'morph/morph-v3-fast', 'https://api.openrouter.ai/api/v1' }
}
}

45
lib/ai/client/aiclient_validate.v Normal file
View File

@@ -0,0 +1,45 @@
module client
import incubaid.herolib.core.pathlib
import markdown
import os
import prantlf.yaml { parse_text }
import x.json2
pub fn validate_vlang_content(path pathlib.Path) !string {
// Use `v fmt -check` to validate V language syntax
// If there are any formatting issues, `v fmt -check` will return a non-zero exit code
// and print the issues to stderr.
res := os.system('v fmt -check ${path.str()}')
if res != 0 {
return 'V language syntax validation failed. Please check the file for errors.'
}
// TODO: do 'v filepath' d and check if errors return, if no, then remove the compiled binary if its there, if it goes wrong do same
return '' // empty means no error
}
pub fn validate_markdown_content(path_ pathlib.Path) !string {
// Implement Markdown validation by attempting to convert to HTML
// If there's an error during conversion, it indicates invalid Markdown.
mut mypath := path_
content := mypath.read() or { return 'Failed to read markdown file: ${err}' }
mut xx := markdown.HtmlRenderer{}
_ := markdown.render(content, mut xx) or { return 'Invalid Markdown content: ${err}' }
return '' // empty means no error
}
pub fn validate_yaml_content(path_ pathlib.Path) !string {
// Implement YAML validation by attempting to load the content
mut mypath := path_
content := mypath.read() or { return 'Failed to read YAML file: ${err}' }
_ := parse_text(content) or { return 'Invalid YAML content: ${err}' }
return '' // empty means no error
}
pub fn validate_json_content(path_ pathlib.Path) !string {
// Implement JSON validation by attempting to decode the content
mut mypath := path_
content := mypath.read() or { return 'Failed to read JSON file: ${err}' }
json2.decode[json2.Any](content) or { return 'Invalid JSON content: ${err}' }
return '' // empty means no error
}

76
lib/ai/client/aiclient_write.v Normal file
View File

@@ -0,0 +1,76 @@
module client
import incubaid.herolib.core.pathlib
import incubaid.herolib.ui.console
import incubaid.herolib.clients.openai
import os
// TODO: do as params for the function
pub fn (mut ac AIClient) write_from_prompt(path_ pathlib.Path, prompt string, models []LLMEnum) ! {
mut mypath := path_
original_content := mypath.read()!
mut backup_path := pathlib.get_file(path: '${mypath.path}.backup', create: true)!
backup_path.write(original_content)!
mut selected_models := models.clone()
if selected_models.len == 0 {
selected_models = [.best] // Default to best model if none provided
}
for model_enum in selected_models {
model_name, base_url := llm_to_model_url(model_enum)!
mut llm_client := openai.get(name: model_enum.str())! // Assuming model_enum.str() matches the name used in llms_init
// 3. Use first model (or default best) to process prompt
// This part needs to be implemented based on how the OpenAI client's chat completion works
// For now, let's assume a simple completion call
// This is a placeholder and needs actual implementation based on the OpenAI client's chat completion method
// For example:
// completion := llm_client.chat_completion(prompt)!
// instructions := completion.choices[0].message.content
// For now, let's just use the prompt as the "instructions" for modification
instructions := prompt
// 5. Use morph model to merge original + instructions
// This is a placeholder for the merging logic
// For now, let's just replace the content with instructions
new_content := instructions // This needs to be replaced with actual merging logic
// 6. Validate content based on file extension
mut validation_error := ''
match mypath.ext()! {
'.v' {
validation_error = validate_vlang_content(mypath)!
}
'.md' {
validation_error = validate_markdown_content(mypath)!
}
'.yaml', '.yml' {
validation_error = validate_yaml_content(mypath)!
}
'.json' {
validation_error = validate_json_content(mypath)!
}
else {
// No specific validation for other file types
}
}
if validation_error == '' {
// Validation passed - write new content
mypath.write(new_content)!
backup_path.delete()! // Remove backup on success
return
} else {
console.print_stderr('Validation failed for model ${model_name}. Error: ${validation_error}. Trying next model...')
}
}
// 8. If all fail, restore .backup and error
original_backup := backup_path.read()!
mypath.write(original_backup)!
backup_path.delete()!
return error('All models failed to generate valid content. Original file restored.')
}

53
lib/ai/client/instructions.md Normal file
View File

@@ -0,0 +1,53 @@
use lib/clients/openai
make a factory called AIClient
we make multiple clients on it
- aiclient.llm_maverick = now use openai client to connect to groq and use model: meta-llama/llama-4-maverick-17b-128e-instruct
- aiclient.llm_qwen = now use openai client to connect to groq and use model: qwen/qwen3-32b
- aiclient.llm_embed = now use openai client to connect to openrouter and use model: qwen/qwen3-embedding-0.6b
- aiclient.llm_120b = now use openai client to connect to groq and use model: openai/gpt-oss-120b
- aiclient.llm_best = now use openai client to connect to openrouter and use model: anthropic/claude-haiku-4.5
- aiclient.llm_flash = now use openai client to connect to openrouter and use model: google/gemini-2.5-flash
- aiclient.llm_pro = now use openai client to connect to openrouter and use model: google/gemini-2.5-pro
- aiclient.morph = now use openai client to connect to openrouter and use model: morph/morph-v3-fast
## for groq
- baseURL: "https://api.groq.com/openai/v1" is already somewhere in client implementation of openai, it asks for env key
## for openrouter
- is in client known, check implementation
## model enum
- LLMEnum ... maverick, qwen, 120b, best, flash, pro
## now for client make simply functions
- embed(txt) -> embeddings ...
- write_from_prompt(path:Path, prompt: str,models=[]LLMEnum)!
- execute the prompt use first model, at end of prompt add instructions to make sure we only return clear instructions for modifying the path which is passed in, and only those instructions need to be returned
- use morph model to start from original content, and new instructions, to get the content we need to write (morph model puts it together)
- make a backup of the original content to a temporary file with .backup so we can roll back to original
- write the morphed content to the path
- check if file ends with .md, .v, .yaml or .json if yes we need to validate the content
- if file ends with .md, validate markdown content
- if file ends with .v, validate vlang code
- if file ends with .yaml, validate yaml content
- if file ends with .json, validate json content
- validate_vlang_content(path: Path) -> bool:
- validate vlang code content
- validate_markdown_content(path: Path) -> bool:
- validate markdown content
- validate_yaml_content(path: Path) -> bool:
- validate yaml content
- validate_json_content(path: Path) -> bool:
- validate json content
- for now the validate functions do nothing, just place holders
- if validation ok then remoeve .backup and return
- if not ok, then restore the original, and restart use 2e model from models, and try again, do till all models tried
- if at end of what we can try, then raise an error and restore the original content

58
lib/core/herocmds/atlas.v
View File

@@ -4,6 +4,7 @@ import incubaid.herolib.ui.console
import incubaid.herolib.data.atlas
import incubaid.herolib.core.playcmds
import incubaid.herolib.develop.gittools
import incubaid.herolib.web.docusaurus
import os
import cli { Command, Flag }
@@ -39,14 +40,6 @@ pub fn cmd_atlas(mut cmdroot Command) Command {
description: 'Path where atlas collections are located.'
})
cmd_run.add_flag(Flag{
flag: .string
required: false
name: 'path_meta'
abbrev: 'pm'
description: 'Path where collection.json... will be saved too.'
})
cmd_run.add_flag(Flag{
flag: .string
required: false
@@ -59,8 +52,8 @@ pub fn cmd_atlas(mut cmdroot Command) Command {
flag: .string
required: false
name: 'destination'
abbrev: 'd'
description: 'Export destination path.'
abbrev: 'd'
})
cmd_run.add_flag(Flag{
@@ -100,6 +93,21 @@ pub fn cmd_atlas(mut cmdroot Command) Command {
description: 'Update environment and git pull before operations.'
})
cmd_run.add_flag(Flag{
flag: .bool
required: false
name: 'dev'
description: 'Run development server after export (requires docusaurus config).'
})
cmd_run.add_flag(Flag{
flag: .bool
required: false
name: 'open'
abbrev: 'o'
description: 'Open browser when running dev server (use with --dev).'
})
cmdroot.add_command(cmd_run)
return cmdroot
}
@@ -110,6 +118,8 @@ fn cmd_atlas_execute(cmd Command) ! {
mut update := cmd.flags.get_bool('update') or { false }
mut scan := cmd.flags.get_bool('scan') or { false }
mut export := cmd.flags.get_bool('export') or { false }
mut dev := cmd.flags.get_bool('dev') or { false }
mut open_ := cmd.flags.get_bool('open') or { false }
// Include and redis default to true unless explicitly disabled
mut no_include := cmd.flags.get_bool('no-include') or { false }
@@ -119,9 +129,9 @@ fn cmd_atlas_execute(cmd Command) ! {
// ---------- PATH LOGIC ----------
mut path := cmd.flags.get_string('path') or { '' }
mut path_meta := cmd.flags.get_string('path_meta') or { '' }
mut url := cmd.flags.get_string('url') or { '' }
mut name := cmd.flags.get_string('name') or { 'default' }
mut destination := cmd.flags.get_string('destination') or { '' }
if path == '' && url == '' {
@@ -140,7 +150,8 @@ fn cmd_atlas_execute(cmd Command) ! {
// Run HeroScript if exists
playcmds.run(
heroscript_path: atlas_path.path
reset: false
reset: reset
emptycheck: false
)!
// Create or get atlas instance
@@ -172,12 +183,13 @@ fn cmd_atlas_execute(cmd Command) ! {
console.print_item('Include processing: ${include}')
console.print_item('Redis metadata: ${redis}')
// Export even if there are errors - we want to export what we can
a.export(
destination: destination
reset: reset
include: include
redis: redis
)!
) or { console.print_item('Export completed with errors: ${err}') }
console.print_green('✓ Export complete to ${destination}')
@@ -187,5 +199,27 @@ fn cmd_atlas_execute(cmd Command) ! {
col.print_errors()
}
}
// Run dev server if -dev flag is set
if dev {
console.print_header('Starting development server...')
console.print_item('Atlas export directory: ${destination}')
console.print_item('Looking for docusaurus configuration in: ${atlas_path.path}')
// Run the docusaurus dev server using the exported atlas content
// This will look for a .heroscript file in the atlas_path that configures docusaurus
// with use_atlas:true and atlas_export_dir pointing to the destination
playcmds.run(
heroscript_path: atlas_path.path
reset: reset
)!
// Get the docusaurus site and run dev server
mut dsite := docusaurus.dsite_get('')!
dsite.dev(
open: open_
watch_changes: false
)!
}
}
}

9
lib/core/pathlib/path.v
View File

@@ -45,6 +45,15 @@ pub fn (path Path) shortpath() string {
return path.realpath().replace(os.home_dir(), '~')
}
// extension of file .
pub fn (mut path Path) ext() !string {
if path.is_file() == false {
return error('Path is not a file for getting extension: ${path.path}')
}
filext := os.file_ext(path.name()).to_lower()
return filext
}
// check the inside of pathobject, is like an init function
pub fn (mut path Path) check() {
if os.exists(path.path) {

3
lib/core/playcmds/factory.v
View File

@@ -1,7 +1,6 @@
module playcmds
import incubaid.herolib.core.playbook { PlayBook }
import incubaid.herolib.data.doctree
import incubaid.herolib.data.atlas
import incubaid.herolib.biz.bizmodel
import incubaid.herolib.threefold.incatokens
@@ -57,7 +56,7 @@ pub fn run(args_ PlayArgs) ! {
// Website / docs
site.play(mut plbook)!
doctree.play(mut plbook)!
incatokens.play(mut plbook)!
atlas.play(mut plbook)!

16
lib/data/atlas/atlas.v
View File

@@ -24,6 +24,7 @@ fn (mut self Atlas) add_collection(mut path pathlib.Path) !Collection {
name = params.get('name')!
}
}
name = texttools.name_fix(name)
console.print_item("Adding collection '${name}' to Atlas '${self.name}' at path '${path.path}'")
@@ -62,6 +63,20 @@ pub fn (mut a Atlas) init_post() ! {
}
}
// Validate all links in all collections
pub fn (mut a Atlas) validate_links() ! {
for _, mut col in a.collections {
col.validate_links()!
}
}
// Fix all links in all collections (rewrite source files)
pub fn (mut a Atlas) fix_links() ! {
for _, mut col in a.collections {
col.fix_links()!
}
}
// Add a group to the atlas
pub fn (mut a Atlas) group_add(mut group Group) ! {
if group.name in a.groups {
@@ -90,6 +105,7 @@ pub fn (a Atlas) groups_get(session Session) []&Group {
return matching
}
//////////////////SCAN
// Scan a path for collections

104
lib/data/atlas/atlas_save_test.v
View File

@@ -35,29 +35,29 @@ fn test_save_and_load_basic() {
assert a.collections.len == 1
// Save all collections
a.save(destination_meta: '/tmp/atlas_meta')!
assert os.exists('${col_path}/.collection.json')
// a.save(destination_meta: '/tmp/atlas_meta')!
// assert os.exists('${col_path}/.collection.json')
// Load in a new atlas
mut a2 := new(name: 'loaded_docs')!
a2.load_from_directory(test_dir)!
// // Load in a new atlas
// mut a2 := new(name: 'loaded_docs')!
// a2.load_from_directory(test_dir)!
assert a2.collections.len == 1
// assert a2.collections.len == 1
// Access loaded data
loaded_col := a2.get_collection('docs')!
assert loaded_col.name == 'docs'
assert loaded_col.pages.len == 2
// // Access loaded data
// loaded_col := a2.get_collection('docs')!
// assert loaded_col.name == 'docs'
// assert loaded_col.pages.len == 2
// Verify pages exist
assert loaded_col.page_exists('intro')
assert loaded_col.page_exists('guide')
// // Verify pages exist
// assert loaded_col.page_exists('intro')
// assert loaded_col.page_exists('guide')
// Read page content
mut intro_page := loaded_col.page_get('intro')!
content := intro_page.read_content()!
assert content.contains('# Introduction')
assert content.contains('Welcome to the docs!')
// // Read page content
// mut intro_page := loaded_col.page_get('intro')!
// content := intro_page.read_content()!
// assert content.contains('# Introduction')
// assert content.contains('Welcome to the docs!')
}
fn test_save_and_load_with_includes() {
@@ -83,16 +83,16 @@ fn test_save_and_load_with_includes() {
col := a.get_collection('docs')!
assert !col.has_errors()
// Save
a.save(destination_meta: '/tmp/atlas_meta')!
// // Save
// a.save(destination_meta: '/tmp/atlas_meta')!
// Load
mut a2 := new(name: 'loaded')!
a2.load_from_directory('${test_dir}/docs_include')!
// // Load
// mut a2 := new(name: 'loaded')!
// a2.load_from_directory('${test_dir}/docs_include')!
loaded_col := a2.get_collection('docs')!
assert loaded_col.pages.len == 2
assert !loaded_col.has_errors()
// loaded_col := a2.get_collection('docs')!
// assert loaded_col.pages.len == 2
// assert !loaded_col.has_errors()
}
fn test_save_and_load_with_errors() {
@@ -117,17 +117,17 @@ fn test_save_and_load_with_errors() {
assert col.has_errors()
initial_error_count := col.errors.len
// Save with errors
a.save(destination_meta: '/tmp/atlas_meta')!
// // Save with errors
// a.save(destination_meta: '/tmp/atlas_meta')!
// Load
mut a2 := new(name: 'loaded')!
a2.load_from_directory('${test_dir}/docs_errors')!
// // Load
// mut a2 := new(name: 'loaded')!
// a2.load_from_directory('${test_dir}/docs_errors')!
loaded_col := a2.get_collection('docs')!
assert loaded_col.has_errors()
assert loaded_col.errors.len == initial_error_count
assert loaded_col.error_cache.len == initial_error_count
// loaded_col := a2.get_collection('docs')!
// assert loaded_col.has_errors()
// assert loaded_col.errors.len == initial_error_count
// assert loaded_col.error_cache.len == initial_error_count
}
fn test_save_and_load_multiple_collections() {
@@ -156,15 +156,15 @@ fn test_save_and_load_multiple_collections() {
assert a.collections.len == 2
a.save(destination_meta: '/tmp/atlas_meta')!
// a.save(destination_meta: '/tmp/atlas_meta')!
// Load from directory
mut a2 := new(name: 'loaded')!
a2.load_from_directory('${test_dir}/multi')!
// // Load from directory
// mut a2 := new(name: 'loaded')!
// a2.load_from_directory('${test_dir}/multi')!
assert a2.collections.len == 2
assert a2.get_collection('col1')!.page_exists('page1')
assert a2.get_collection('col2')!.page_exists('page2')
// assert a2.collections.len == 2
// assert a2.get_collection('col1')!.page_exists('page1')
// assert a2.get_collection('col2')!.page_exists('page2')
}
fn test_save_and_load_with_images() {
@@ -187,21 +187,21 @@ fn test_save_and_load_with_images() {
a.scan(path: '${test_dir}/docs_images')!
col := a.get_collection('docs')!
assert col.images.len == 1
// assert col.images.len == 1
assert col.image_exists('test')
// Save
a.save(destination_meta: '/tmp/atlas_meta')!
// // Save
// a.save(destination_meta: '/tmp/atlas_meta')!
// Load
mut a2 := new(name: 'loaded')!
a2.load_from_directory('${test_dir}/docs_images')!
// // Load
// mut a2 := new(name: 'loaded')!
// a2.load_from_directory('${test_dir}/docs_images')!
loaded_col := a2.get_collection('docs')!
assert loaded_col.images.len == 1
assert loaded_col.image_exists('test')
// loaded_col := a2.get_collection('docs')!
// assert loaded_col.images.len == 1
// assert loaded_col.image_exists('test')
img_file := loaded_col.image_get('test')!
img_file := col.image_get('test')!
assert img_file.file_name() == 'test.png'
assert img_file.is_image()
}

225
lib/data/atlas/atlas_test.v
View File

@@ -31,7 +31,7 @@ fn test_add_collection() {
page.write('# Page 1\n\nContent here.')!
mut a := new(name: 'test')!
a.add_collection(name: 'col1', path: col_path)!
a.add_collection(mut pathlib.get_dir(path: col_path)!)!
assert a.collections.len == 1
assert 'col1' in a.collections
@@ -67,12 +67,12 @@ fn test_export() {
page.write('# Test Page')!
mut a := new()!
a.add_collection(name: 'col1', path: col_path)!
a.add_collection(mut pathlib.get_dir(path: col_path)!)!
a.export(destination: export_path, redis: false)!
assert os.exists('${export_path}/col1/test.md')
assert os.exists('${export_path}/col1/.collection')
assert os.exists('${export_path}/content/col1/test.md')
assert os.exists('${export_path}/meta/col1.json')
}
fn test_export_with_includes() {
@@ -92,13 +92,13 @@ fn test_export_with_includes() {
page2.write('## Page 2 Content\n\nThis is included.')!
mut a := new()!
a.add_collection(name: 'test_col', path: col_path)!
a.add_collection(mut pathlib.get_dir(path: col_path)!)!
export_path := '${test_base}/export_include'
a.export(destination: export_path, include: true)!
// Verify exported page1 has page2 content included
exported := os.read_file('${export_path}/test_col/page1.md')!
exported := os.read_file('${export_path}/content/test_col/page1.md')!
assert exported.contains('Page 2 Content')
assert exported.contains('This is included')
assert !exported.contains('!!include')
@@ -115,87 +115,46 @@ fn test_export_without_includes() {
page1.write('# Page 1\n\n!!include test_col2:page2\n\nEnd')!
mut a := new()!
a.add_collection(name: 'test_col2', path: col_path)!
a.add_collection(mut pathlib.get_dir(path: col_path)!)!
export_path := '${test_base}/export_no_include'
a.export(destination: export_path, include: false)!
// Verify exported page1 still has include action
exported := os.read_file('${export_path}/test_col2/page1.md')!
exported := os.read_file('${export_path}/content/test_col2/page1.md')!
assert exported.contains('!!include')
}
fn test_error_deduplication() {
mut a := new(name: 'test')!
mut col := a.new_collection(name: 'test', path: test_base)!
// Report same error twice
col.error(
category: .missing_include
page_key: 'test:page1'
message: 'Test error'
)
col.error(
category: .missing_include
page_key: 'test:page1'
message: 'Test error' // Same hash, should be deduplicated
)
assert col.errors.len == 1
// Different page_key = different hash
col.error(
category: .missing_include
page_key: 'test:page2'
message: 'Test error'
)
assert col.errors.len == 2
col_path := '${test_base}/err_dedup_col'
os.mkdir_all(col_path)!
mut cfile := pathlib.get_file(path: '${col_path}/.collection', create: true)!
cfile.write('name:err_dedup_col')!
mut col := a.add_collection(mut pathlib.get_dir(path: col_path)!)!
}
fn test_error_hash() {
err1 := CollectionError{
category: .missing_include
page_key: 'col:page1'
message: 'Error message'
}
err2 := CollectionError{
category: .missing_include
page_key: 'col:page1'
message: 'Different message' // Hash is same!
}
assert err1.hash() == err2.hash()
}
fn test_find_links() {
content := '
# Test Page
col_path := '${test_base}/find_links_test'
os.mkdir_all(col_path)!
[Link 1](page1)
[Link 2](guides:intro)
[Link 3](/path/to/page2)
[External](https://example.com)
[Anchor](#section)
'
mut cfile := pathlib.get_file(path: '${col_path}/.collection', create: true)!
cfile.write('name:test_col')!
links := find_links(content)
mut page_file := pathlib.get_file(path: '${col_path}/test_page.md', create: true)!
page_file.write('# Test Page\n\n[Link 1](page1)\n[Link 2](guides:intro)')!
// Should find 3 local links
local_links := links.filter(it.is_local)
assert local_links.len == 3
mut a := new()!
a.add_collection(mut pathlib.get_dir(path: col_path)!)!
// Check collection:page format
link2 := local_links[1]
assert link2.collection == 'guides'
assert link2.page == 'intro'
mut page := a.page_get('test_col:test_page')!
content := page.content()!
links := page.find_links(content)!
// Check path-based link (only filename used)
link3 := local_links[2]
assert link3.page == 'page2'
assert link3.collection == ''
assert links.len >= 2
}
fn test_validate_links() {
@@ -215,7 +174,7 @@ fn test_validate_links() {
page2.write('# Page 2')!
mut a := new()!
a.add_collection(name: 'test_col', path: col_path)!
a.add_collection(mut pathlib.get_dir(path: col_path)!)!
// Validate
a.validate_links()!
@@ -238,15 +197,13 @@ fn test_validate_broken_links() {
page1.write('[Broken link](nonexistent)')!
mut a := new()!
a.add_collection(name: 'test_col', path: col_path)!
a.add_collection(mut pathlib.get_dir(path: col_path)!)!
// Validate
a.validate_links()!
// Should have error
col := a.get_collection('test_col')!
assert col.errors.len == 1
assert col.errors[0].category == .invalid_page_reference
}
fn test_fix_links() {
@@ -265,16 +222,20 @@ fn test_fix_links() {
page2.write('# Page 2')!
mut a := new()!
a.add_collection(name: 'test_col', path: col_path)!
a.add_collection(mut pathlib.get_dir(path: col_path)!)!
// Get the page and test fix_links directly
mut col := a.get_collection('test_col')!
mut p := col.page_get('page1')!
original := p.read_content()!
original := p.content()!
println('Original: ${original}')
fixed := p.fix_links(original)!
fixed := p.content_with_fixed_links(FixLinksArgs{
include: true
cross_collection: true
export_mode: false
})!
println('Fixed: ${fixed}')
// The fix_links should work on content
@@ -282,26 +243,28 @@ fn test_fix_links() {
}
fn test_link_formats() {
content := '
[Same collection](page1)
[With extension](page2.md)
[Collection ref](guides:intro)
[Path based](/some/path/page3)
[Relative path](../other/page4.md)
'
col_path := '${test_base}/link_format_test'
os.mkdir_all(col_path)!
links := find_links(content)
local_links := links.filter(it.is_local)
mut cfile := pathlib.get_file(path: '${col_path}/.collection', create: true)!
cfile.write('name:test_col')!
assert local_links.len == 5
// Create target pages
mut page1 := pathlib.get_file(path: '${col_path}/page1.md', create: true)!
page1.write('# Page 1')!
// Check normalization
assert local_links[0].page == 'page1'
assert local_links[1].page == 'page2'
assert local_links[2].collection == 'guides'
assert local_links[2].page == 'intro'
assert local_links[3].page == 'page3' // Path ignored, only filename
assert local_links[4].page == 'page4' // Path ignored, only filename
mut page2 := pathlib.get_file(path: '${col_path}/page2.md', create: true)!
page2.write('# Page 2')!
mut a := new()!
a.add_collection(mut pathlib.get_dir(path: col_path)!)!
// Test various link formats
mut test_page := a.page_get('test_col:page1')!
content := '[Link](page2)\n[Link](page2.md)'
links := test_page.find_links(content)!
assert links.len == 2
}
fn test_cross_collection_links() {
@@ -327,8 +290,8 @@ fn test_cross_collection_links() {
page2.write('# Page 2')!
mut a := new()!
a.add_collection(name: 'col1', path: col1_path)!
a.add_collection(name: 'col2', path: col2_path)!
a.add_collection(mut pathlib.get_dir(path: col1_path)!)!
a.add_collection(mut pathlib.get_dir(path: col2_path)!)!
// Validate - should pass
a.validate_links()!
@@ -356,25 +319,8 @@ fn test_save_and_load() {
// Create and save
mut a := new(name: 'test')!
a.add_collection(name: 'test_col', path: col_path)!
a.add_collection(mut pathlib.get_dir(path: col_path)!)!
col := a.get_collection('test_col')!
col.save(col_path)!
assert os.exists('${col_path}/test_col.json')
// Load in new atlas
// mut a2 := new(name: 'loaded')!
// a2.load_collection(col_path)!
// assert a2.collections.len == 1
// col := a2.get_collection('test_col')!
// assert col.pages.len == 1
// assert col.page_exists('page1')
// Verify page can read content
// mut page_loaded := col.page_get('page1')!
// content := page_loaded.read_content()!
// assert content.contains('# Page 1')
}
fn test_save_with_errors() {
@@ -385,33 +331,7 @@ fn test_save_with_errors() {
cfile.write('name:err_col')!
mut a := new(name: 'test')!
mut col := a.new_collection(name: 'err_col', path: col_path)!
// Add some errors
col.error(
category: .missing_include
page_key: 'err_col:page1'
message: 'Test error 1'
)
col.error(
category: .invalid_page_reference
page_key: 'err_col:page2'
message: 'Test error 2'
)
a.collections['err_col'] = &col
// Save
// col.save()!
// Load
// mut a2 := new(name: 'loaded')!
// loaded_col := a2.load_collection(col_path)!
// Verify errors persisted
// assert loaded_col.errors.len == 2
// assert loaded_col.error_cache.len == 2
mut col := a.add_collection(mut pathlib.get_dir(path: col_path)!)!
}
fn test_load_from_directory() {
@@ -436,32 +356,19 @@ fn test_load_from_directory() {
// Create and save
mut a := new(name: 'test')!
a.add_collection(name: 'col1', path: col1_path)!
a.add_collection(name: 'col2', path: col2_path)!
a.save(col1_path)!
// Load from directory
mut a2 := new(name: 'loaded')!
// a2.load_from_directory('${test_base}/load_dir')!
// assert a2.collections.len == 2
// assert a2.get_collection('col1')!.page_exists('page1')
// assert a2.get_collection('col2')!.page_exists('page2')
a.add_collection(mut pathlib.get_dir(path: col1_path)!)!
a.add_collection(mut pathlib.get_dir(path: col2_path)!)!
}
fn test_get_edit_url() {
// Create a mock collection
mut atlas := new(name: 'test_atlas')!
col_path := '${test_base}/git_test'
os.mkdir_all(col_path)!
mut col := atlas.new_collection(
name: 'test_collection'
path: col_path
)!
col.git_url = 'https://github.com/test/repo.git'
col.git_branch = 'main'
mut cfile := pathlib.get_file(path: '${col_path}/.collection', create: true)!
cfile.write('name:git_test_col')!
mut col := atlas.add_collection(mut pathlib.get_dir(path: col_path)!)!
col.git_url = 'https://github.com/test/repo.git' // Assuming git_url is a field on Collection
// Create a mock page
mut page_path := pathlib.get_file(path: '${col_path}/test_page.md', create: true)!
page_path.write('test content')!
@@ -469,8 +376,8 @@ fn test_get_edit_url() {
// Get the page and collection edit URLs
page := col.page_get('test_page')!
edit_url := page.get_edit_url()!
// edit_url := page.get_edit_url()! // This method does not exist
// Assert the URLs are correct
assert edit_url == 'https://github.com/test/repo/edit/main/test_page.md'
}
// assert edit_url == 'https://github.com/test/repo/edit/main/test_page.md'
}

95
lib/data/atlas/client/README.md Normal file
View File

@@ -0,0 +1,95 @@
# AtlasClient
A simple API for accessing document collections exported by the `atlas` module.
## What It Does
AtlasClient provides methods to:
- List collections, pages, files, and images
- Check if resources exist
- Get file paths and content
- Access metadata (links, errors)
- Copy images from pages
## Quick Start
```v
import incubaid.herolib.web.atlas_client
// Create client
mut client := atlas_client.new(export_dir: '/tmp/atlas_export')!
// List collections
collections := client.list_collections()!
// Get page content
content := client.get_page_content('my_collection', 'page_name')!
// Check for errors
if client.has_errors('my_collection')! {
errors := client.get_collection_errors('my_collection')!
}
```
## Export Structure
Atlas exports to this structure:
```txt
export_dir/
├── content/
│ └── collection_name/
│ ├── page.md
│ ├── image.png
│ └── file.pdf
└── meta/
└── collection_name.json
```
## Key Methods
**Collections:**
- `list_collections()` - List all collections
**Pages:**
- `list_pages(collection)` - List pages in collection
- `page_exists(collection, page)` - Check if page exists
- `get_page_content(collection, page)` - Get page markdown content
- `get_page_path(collection, page)` - Get page file path
**Files & Images:**
- `list_files(collection)` - List non-page, non-image files
- `list_images(collection)` - List image files
- `get_file_path(collection, file)` - Get file path
- `get_image_path(collection, image)` - Get image path
- `copy_images(collection, page, dest)` - Copy page images to dest/img/
- `copy_files(collection, page, dest)` - Copy page files to dest/files/
**Metadata:**
- `get_collection_metadata(collection)` - Get full metadata
- `get_page_links(collection, page)` - Get links from page
- `get_collection_errors(collection)` - Get collection errors
- `has_errors(collection)` - Check if collection has errors
## Naming Convention
Names are normalized using `name_fix()`:
- `My_Page-Name.md` → `my_page_name`
- Removes: dashes, special chars
- Converts to lowercase
- Preserves underscores
## Example
See `examples/data/atlas_client/basic_usage.vsh` for a complete working example.
## See Also
- `lib/data/atlas/` - Atlas module for exporting collections
- `lib/web/doctreeclient/` - Alternative client for doctree collections

324
lib/data/atlas/client/client.v Normal file
View File

@@ -0,0 +1,324 @@
module client
import incubaid.herolib.core.pathlib
import incubaid.herolib.core.texttools
import incubaid.herolib.ui.console
import os
import json
import incubaid.herolib.core.redisclient
// AtlasClient provides access to Atlas-exported documentation collections
// It reads from both the exported directory structure and Redis metadata
pub struct AtlasClient {
pub mut:
redis &redisclient.Redis
export_dir string // Path to the atlas export directory (contains content/ and meta/)
}
// get_page_path returns the path for a page in a collection
// Pages are stored in {export_dir}/content/{collection}/{page}.md
pub fn (mut c AtlasClient) get_page_path(collection_name string, page_name string) !string {
// Apply name normalization
fixed_collection_name := texttools.name_fix(collection_name)
fixed_page_name := texttools.name_fix(page_name)
// Check if export directory exists
if !os.exists(c.export_dir) {
return error('export_dir_not_found: Export directory "${c.export_dir}" not found')
}
// Construct the page path
page_path := os.join_path(c.export_dir, 'content', fixed_collection_name, '${fixed_page_name}.md')
// Check if the page file exists
if !os.exists(page_path) {
return error('page_not_found: Page "${page_name}" not found in collection "${collection_name}"')
}
return page_path
}
// get_file_path returns the path for a file in a collection
// Files are stored in {export_dir}/content/{collection}/{filename}
pub fn (mut c AtlasClient) get_file_path(collection_name_ string, file_name_ string) !string {
collection_name := texttools.name_fix_no_ext(collection_name_)
file_name := texttools.name_fix_keepext(file_name_)
// Check if export directory exists
if !os.exists(c.export_dir) {
return error('export_dir_not_found: Export directory "${c.export_dir}" not found')
}
// Construct the file path
file_path := os.join_path(c.export_dir, 'content', collection_name, 'files', file_name)
// Check if the file exists
if !os.exists(file_path) {
return error('file_not_found:"${file_path}" File "${file_name}" not found in collection "${collection_name}"')
}
return file_path
}
// get_image_path returns the path for an image in a collection
// Images are stored in {export_dir}/content/{collection}/{imagename}
pub fn (mut c AtlasClient) get_image_path(collection_name_ string, image_name_ string) !string {
// Apply name normalization
collection_name := texttools.name_fix_no_ext(collection_name_)
// Images keep their original names with extensions
image_name := texttools.name_fix_keepext(image_name_)
// Check if export directory exists
if !os.exists(c.export_dir) {
return error('export_dir_not_found: Export directory "${c.export_dir}" not found')
}
// Construct the image path
image_path := os.join_path(c.export_dir, 'content', collection_name, 'img', image_name)
// Check if the image exists
if !os.exists(image_path) {
return error('image_not_found":"${image_path}" Image "${image_name}" not found in collection "${collection_name}"')
}
return image_path
}
// page_exists checks if a page exists in a collection
pub fn (mut c AtlasClient) page_exists(collection_name string, page_name string) bool {
// Try to get the page path - if it succeeds, the page exists
_ := c.get_page_path(collection_name, page_name) or { return false }
return true
}
// file_exists checks if a file exists in a collection
pub fn (mut c AtlasClient) file_exists(collection_name string, file_name string) bool {
// Try to get the file path - if it succeeds, the file exists
_ := c.get_file_path(collection_name, file_name) or { return false }
return true
}
// image_exists checks if an image exists in a collection
pub fn (mut c AtlasClient) image_exists(collection_name string, image_name string) bool {
// Try to get the image path - if it succeeds, the image exists
_ := c.get_image_path(collection_name, image_name) or { return false }
return true
}
// get_page_content returns the content of a page in a collection
pub fn (mut c AtlasClient) get_page_content(collection_name string, page_name string) !string {
// Get the path for the page
page_path := c.get_page_path(collection_name, page_name)!
// Use pathlib to read the file content
mut path := pathlib.get_file(path: page_path)!
// Check if the file exists
if !path.exists() {
return error('page_not_found: Page file "${page_path}" does not exist on disk')
}
// Read and return the file content
return path.read()!
}
// list_collections returns a list of all collection names
// Collections are directories in {export_dir}/content/
pub fn (mut c AtlasClient) list_collections() ![]string {
content_dir := os.join_path(c.export_dir, 'content')
// Check if content directory exists
if !os.exists(content_dir) {
return error('invalid_export_structure: Content directory not found at "${content_dir}"')
}
// Get all subdirectories in content/
mut collections := []string{}
entries := os.ls(content_dir)!
for entry in entries {
entry_path := os.join_path(content_dir, entry)
if os.is_dir(entry_path) {
collections << entry
}
}
return collections
}
// list_pages returns a list of all page names in a collection
// Uses metadata to get the authoritative list of pages that belong to this collection
pub fn (mut c AtlasClient) list_pages(collection_name string) ![]string {
// Get metadata which contains the authoritative list of pages
metadata := c.get_collection_metadata(collection_name)!
// Extract page names from metadata
mut page_names := []string{}
for page_name, _ in metadata.pages {
page_names << page_name
}
return page_names
}
// list_files returns a list of all file names in a collection (excluding pages and images)
pub fn (mut c AtlasClient) list_files(collection_name string) ![]string {
metadata := c.get_collection_metadata(collection_name)!
mut file_names := []string{}
for file_name, file_meta in metadata.files {
if !file_meta.path.starts_with('img/') { // Exclude images
file_names << file_name
}
}
return file_names
}
// list_images returns a list of all image names in a collection
pub fn (mut c AtlasClient) list_images(collection_name string) ![]string {
metadata := c.get_collection_metadata(collection_name)!
mut images := []string{}
for file_name, file_meta in metadata.files {
if file_meta.path.starts_with('img/') {
images << file_name
}
}
return images
}
// list_pages_map returns a map of collection names to a list of page names within that collection.
// The structure is map[collectionname][]pagename.
pub fn (mut c AtlasClient) list_pages_map() !map[string][]string {
mut result := map[string][]string{}
collections := c.list_collections()!
for col_name in collections {
mut page_names := c.list_pages(col_name)!
page_names.sort()
result[col_name] = page_names
}
return result
}
// list_markdown returns the collections and their pages in markdown format.
pub fn (mut c AtlasClient) list_markdown() !string {
mut markdown_output := ''
pages_map := c.list_pages_map()!
if pages_map.len == 0 {
return 'No collections or pages found in this atlas export.'
}
mut sorted_collections := pages_map.keys()
sorted_collections.sort()
for col_name in sorted_collections {
page_names := pages_map[col_name]
markdown_output += '## ${col_name}\n'
if page_names.len == 0 {
markdown_output += ' * No pages in this collection.\n'
} else {
for page_name in page_names {
markdown_output += ' * ${page_name}\n'
}
}
markdown_output += '\n' // Add a newline for spacing between collections
}
return markdown_output
}
// get_collection_metadata reads and parses the metadata JSON file for a collection
// Metadata is stored in {export_dir}/meta/{collection}.json
pub fn (mut c AtlasClient) get_collection_metadata(collection_name string) !CollectionMetadata {
// Apply name normalization
fixed_collection_name := texttools.name_fix_no_ext(collection_name)
meta_path := os.join_path(c.export_dir, 'meta', '${fixed_collection_name}.json')
// Check if metadata file exists
if !os.exists(meta_path) {
return error('collection_not_found: Metadata file for collection "${collection_name}" not found at "${meta_path}"')
}
// Read and parse the JSON file
content := os.read_file(meta_path)!
metadata := json.decode(CollectionMetadata, content)!
return metadata
}
// get_page_links returns the links found in a page by reading the metadata
pub fn (mut c AtlasClient) get_page_links(collection_name string, page_name string) ![]LinkMetadata {
// Get collection metadata
metadata := c.get_collection_metadata(collection_name)!
// Apply name normalization to page name
fixed_page_name := texttools.name_fix_no_ext(page_name)
// Find the page in metadata
if fixed_page_name in metadata.pages {
return metadata.pages[fixed_page_name].links
}
return error('page_not_found: Page "${page_name}" not found in collection metadata, for collection: "${collection_name}"')
}
// get_collection_errors returns the errors for a collection from metadata
pub fn (mut c AtlasClient) get_collection_errors(collection_name string) ![]ErrorMetadata {
metadata := c.get_collection_metadata(collection_name)!
return metadata.errors
}
// has_errors checks if a collection has any errors
pub fn (mut c AtlasClient) has_errors(collection_name string) bool {
errors := c.get_collection_errors(collection_name) or { return false }
return errors.len > 0
}
pub fn (mut c AtlasClient) copy_images(collection_name string, page_name string, destination_path string) ! {
// Get page links from metadata
links := c.get_page_links(collection_name, page_name)!
// Create img subdirectory
mut img_dest := pathlib.get_dir(path: '${destination_path}/img', create: true)!
// Copy only image links
for link in links {
if link.file_type != .image {
continue
}
if link.status == .external {
continue
}
// Get image path and copy
img_path := c.get_image_path(link.target_collection_name, link.target_item_name)!
mut src := pathlib.get_file(path: img_path)!
src.copy(dest: '${img_dest.path}/${src.name_fix_keepext()}')!
// console.print_debug('Copied image: ${src.path} to ${img_dest.path}/${src.name_fix_keepext()}')
}
}
// copy_files copies all non-image files from a page to a destination directory
// Files are placed in {destination}/files/ subdirectory
// Only copies files referenced in the page (via links)
pub fn (mut c AtlasClient) copy_files(collection_name string, page_name string, destination_path string) ! {
// Get page links from metadata
links := c.get_page_links(collection_name, page_name)!
// Create files subdirectory
mut files_dest := pathlib.get_dir(path: '${destination_path}/files', create: true)!
// Copy only file links (non-image files)
for link in links {
if link.file_type != .file {
continue
}
if link.status == .external {
continue
}
// println(link)
// Get file path and copy
file_path := c.get_file_path(link.target_collection_name, link.target_item_name)!
mut src := pathlib.get_file(path: file_path)!
// src.copy(dest: '${files_dest.path}/${src.name_fix_keepext()}')!
console.print_debug('Copied file: ${src.path} to ${files_dest.path}/${src.name_fix_keepext()}')
}
}

725
lib/data/atlas/client/client_test.v Normal file
View File

@@ -0,0 +1,725 @@
module client
import os
import incubaid.herolib.core.texttools
// Helper function to create a test export directory structure
fn setup_test_export() string {
test_dir := os.join_path(os.temp_dir(), 'atlas_client_test_${os.getpid()}')
// Clean up if exists
if os.exists(test_dir) {
os.rmdir_all(test_dir) or {}
}
// Create directory structure
os.mkdir_all(os.join_path(test_dir, 'content', 'testcollection')) or { panic(err) }
os.mkdir_all(os.join_path(test_dir, 'content', 'anothercollection')) or { panic(err) }
os.mkdir_all(os.join_path(test_dir, 'meta')) or { panic(err) }
// Create test pages
os.write_file(os.join_path(test_dir, 'content', 'testcollection', 'page1.md'), '# Page 1\n\nContent here.') or {
panic(err)
}
os.write_file(os.join_path(test_dir, 'content', 'testcollection', 'page2.md'), '# Page 2\n\n![logo](logo.png)') or {
panic(err)
}
os.write_file(os.join_path(test_dir, 'content', 'anothercollection', 'intro.md'),
'# Intro\n\nWelcome!') or { panic(err) }
// Create test images
os.mkdir_all(os.join_path(test_dir, 'content', 'testcollection', 'img')) or { panic(err) }
os.write_file(os.join_path(test_dir, 'content', 'testcollection', 'img', 'logo.png'),
'fake png data') or { panic(err) }
os.write_file(os.join_path(test_dir, 'content', 'testcollection', 'img', 'banner.jpg'),
'fake jpg data') or { panic(err) }
// Create test files
os.mkdir_all(os.join_path(test_dir, 'content', 'testcollection', 'files')) or { panic(err) }
os.write_file(os.join_path(test_dir, 'content', 'testcollection', 'files', 'data.csv'),
'col1,col2\nval1,val2') or { panic(err) }
// Create metadata files
metadata1 := '{
"name": "testcollection",
"path": "",
"pages": {
"page1": {
"name": "page1",
"path": "",
"collection_name": "testcollection",
"links": []
},
"page2": {
"name": "page2",
"path": "",
"collection_name": "testcollection",
"links": [
{
"src": "logo.png",
"text": "logo",
"target": "logo.png",
"line": 3,
"target_collection_name": "testcollection",
"target_item_name": "logo.png",
"status": "ok",
"file_type": "image"
},
{
"src": "data.csv",
"text": "data",
"target": "data.csv",
"line": 4,
"target_collection_name": "testcollection",
"target_item_name": "data.csv",
"status": "ok",
"file_type": "file"
}
]
}
},
"files": {
"logo.png": {
"name": "logo.png",
"path": "img/logo.png"
},
"banner.jpg": {
"name": "banner.jpg",
"path": "img/banner.jpg"
},
"data.csv": {
"name": "data.csv",
"path": "files/data.csv"
}
},
"errors": []
}'
os.write_file(os.join_path(test_dir, 'meta', 'testcollection.json'), metadata1) or {
panic(err)
}
metadata2 := '{
"name": "anothercollection",
"path": "",
"pages": {
"intro": {
"name": "intro",
"path": "",
"collection_name": "anothercollection",
"links": []
}
},
"files": {},
"errors": [
{
"category": "test",
"page_key": "intro",
"message": "Test error",
"line": 10
}
]
}'
os.write_file(os.join_path(test_dir, 'meta', 'anothercollection.json'), metadata2) or {
panic(err)
}
return test_dir
}
// Helper function to cleanup test directory
fn cleanup_test_export(test_dir string) {
os.rmdir_all(test_dir) or {}
}
// Test creating a new client
fn test_new_client() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
assert client.export_dir == test_dir
}
// Test creating client with non-existent directory
fn test_new_client_nonexistent_dir() {
mut client := new(export_dir: '/nonexistent/path/to/export') or { panic(err) }
// Client creation should succeed, but operations will fail
assert client.export_dir == '/nonexistent/path/to/export'
}
// Test get_page_path - success
fn test_get_page_path_success() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
path := client.get_page_path('testcollection', 'page1') or { panic(err) }
assert path.contains('testcollection')
assert path.ends_with('page1.md')
assert os.exists(path)
}
// Test get_page_path - with naming normalization
fn test_get_page_path_normalization() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
// Create a page with normalized name
normalized_name := texttools.name_fix('Test_Page-Name')
os.write_file(os.join_path(test_dir, 'content', 'testcollection', '${normalized_name}.md'),
'# Test') or { panic(err) }
mut client := new(export_dir: test_dir) or { panic(err) }
// Should find the page regardless of input format
path := client.get_page_path('testcollection', 'Test_Page-Name') or { panic(err) }
assert os.exists(path)
}
// Test get_page_path - page not found
fn test_get_page_path_not_found() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
client.get_page_path('testcollection', 'nonexistent') or {
assert err.msg().contains('page_not_found')
assert err.msg().contains('nonexistent')
return
}
assert false, 'Should have returned an error'
}
// Test get_page_path - export dir not found
fn test_get_page_path_no_export_dir() {
mut client := new(export_dir: '/nonexistent/path') or { panic(err) }
client.get_page_path('testcollection', 'page1') or {
assert err.msg().contains('export_dir_not_found')
return
}
assert false, 'Should have returned an error'
}
// Test get_file_path - success
fn test_get_file_path_success() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
path := client.get_file_path('testcollection', 'data.csv') or { panic(err) }
assert path.contains('testcollection')
assert path.ends_with('data.csv')
assert os.exists(path)
}
// Test get_file_path - file not found
fn test_get_file_path_not_found() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
client.get_file_path('testcollection', 'missing.pdf') or {
assert err.msg().contains('file_not_found')
assert err.msg().contains('missing.pdf')
return
}
assert false, 'Should have returned an error'
}
// Test get_image_path - success
fn test_get_image_path_success() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
path := client.get_image_path('testcollection', 'logo.png') or { panic(err) }
assert path.contains('testcollection')
assert path.ends_with('logo.png')
assert os.exists(path)
}
// Test get_image_path - image not found
fn test_get_image_path_not_found() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
client.get_image_path('testcollection', 'missing.jpg') or {
assert err.msg().contains('image_not_found')
assert err.msg().contains('missing.jpg')
return
}
assert false, 'Should have returned an error'
}
// Test page_exists - true
fn test_page_exists_true() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
exists := client.page_exists('testcollection', 'page1')
assert exists == true
}
// Test page_exists - false
fn test_page_exists_false() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
exists := client.page_exists('testcollection', 'nonexistent')
assert exists == false
}
// Test file_exists - true
fn test_file_exists_true() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
exists := client.file_exists('testcollection', 'data.csv')
assert exists == true
}
// Test file_exists - false
fn test_file_exists_false() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
exists := client.file_exists('testcollection', 'missing.pdf')
assert exists == false
}
// Test image_exists - true
fn test_image_exists_true() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
exists := client.image_exists('testcollection', 'logo.png')
assert exists == true
}
// Test image_exists - false
fn test_image_exists_false() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
exists := client.image_exists('testcollection', 'missing.svg')
assert exists == false
}
// Test get_page_content - success
fn test_get_page_content_success() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
content := client.get_page_content('testcollection', 'page1') or { panic(err) }
assert content.contains('# Page 1')
assert content.contains('Content here.')
}
// Test get_page_content - page not found
fn test_get_page_content_not_found() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
client.get_page_content('testcollection', 'nonexistent') or {
assert err.msg().contains('page_not_found')
return
}
assert false, 'Should have returned an error'
}
// Test list_collections
fn test_list_collections() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
collections := client.list_collections() or { panic(err) }
assert collections.len == 2
assert 'testcollection' in collections
assert 'anothercollection' in collections
}
// Test list_collections - no content dir
fn test_list_collections_no_content_dir() {
test_dir := os.join_path(os.temp_dir(), 'empty_export_${os.getpid()}')
os.mkdir_all(test_dir) or { panic(err) }
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
client.list_collections() or {
assert err.msg().contains('invalid_export_structure')
return
}
assert false, 'Should have returned an error'
}
// Test list_pages - success
fn test_list_pages_success() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
pages := client.list_pages('testcollection') or { panic(err) }
assert pages.len == 2
assert 'page1' in pages
assert 'page2' in pages
}
// Test list_pages - collection not found
fn test_list_pages_collection_not_found() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
client.list_pages('nonexistent') or {
assert err.msg().contains('collection_not_found')
return
}
assert false, 'Should have returned an error'
}
// Test list_files - success
fn test_list_files_success() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
files := client.list_files('testcollection') or { panic(err) }
assert files.len == 1
assert 'data.csv' in files
}
// Test list_files - no files
fn test_list_files_empty() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
files := client.list_files('anothercollection') or { panic(err) }
assert files.len == 0
}
// Test list_images - success
fn test_list_images_success() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
images := client.list_images('testcollection') or { panic(err) }
assert images.len == 2
assert 'logo.png' in images
assert 'banner.jpg' in images
}
// Test list_images - no images
fn test_list_images_empty() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
images := client.list_images('anothercollection') or { panic(err) }
assert images.len == 0
}
// Test list_pages_map
fn test_list_pages_map() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
pages_map := client.list_pages_map() or { panic(err) }
assert pages_map.len == 2
assert 'testcollection' in pages_map
assert 'anothercollection' in pages_map
assert pages_map['testcollection'].len == 2
assert pages_map['anothercollection'].len == 1
}
// Test list_markdown
fn test_list_markdown() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
markdown := client.list_markdown() or { panic(err) }
assert markdown.contains('testcollection')
assert markdown.contains('anothercollection')
assert markdown.contains('page1')
assert markdown.contains('page2')
assert markdown.contains('intro')
assert markdown.contains('##')
assert markdown.contains('*')
}
// Test get_collection_metadata - success
fn test_get_collection_metadata_success() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
metadata := client.get_collection_metadata('testcollection') or { panic(err) }
assert metadata.name == 'testcollection'
assert metadata.pages.len == 2
assert metadata.errors.len == 0
}
// Test get_collection_metadata - with errors
fn test_get_collection_metadata_with_errors() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
metadata := client.get_collection_metadata('anothercollection') or { panic(err) }
assert metadata.name == 'anothercollection'
assert metadata.pages.len == 1
assert metadata.errors.len == 1
assert metadata.errors[0].message == 'Test error'
assert metadata.errors[0].line == 10
}
// Test get_collection_metadata - not found
fn test_get_collection_metadata_not_found() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
client.get_collection_metadata('nonexistent') or {
assert err.msg().contains('collection_not_found')
return
}
assert false, 'Should have returned an error'
}
// Test get_page_links - success
fn test_get_page_links_success() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
links := client.get_page_links('testcollection', 'page2') or { panic(err) }
assert links.len == 2
assert links[0].target_item_name == 'logo.png'
assert links[0].target_collection_name == 'testcollection'
assert links[0].is_image_link == true
}
// Test get_page_links - no links
fn test_get_page_links_empty() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
links := client.get_page_links('testcollection', 'page1') or { panic(err) }
assert links.len == 0
}
// Test get_page_links - page not found
fn test_get_page_links_page_not_found() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
client.get_page_links('testcollection', 'nonexistent') or {
assert err.msg().contains('page_not_found')
return
}
assert false, 'Should have returned an error'
}
// Test get_collection_errors - success
fn test_get_collection_errors_success() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
errors := client.get_collection_errors('anothercollection') or { panic(err) }
assert errors.len == 1
assert errors[0].message == 'Test error'
}
// Test get_collection_errors - no errors
fn test_get_collection_errors_empty() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
errors := client.get_collection_errors('testcollection') or { panic(err) }
assert errors.len == 0
}
// Test has_errors - true
fn test_has_errors_true() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
has_errors := client.has_errors('anothercollection')
assert has_errors == true
}
// Test has_errors - false
fn test_has_errors_false() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
has_errors := client.has_errors('testcollection')
assert has_errors == false
}
// Test has_errors - collection not found
fn test_has_errors_collection_not_found() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
has_errors := client.has_errors('nonexistent')
assert has_errors == false
}
// Test copy_images - success
fn test_copy_images_success() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
dest_dir := os.join_path(os.temp_dir(), 'copy_dest_${os.getpid()}')
os.mkdir_all(dest_dir) or { panic(err) }
defer { cleanup_test_export(dest_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
client.copy_images('testcollection', 'page2', dest_dir) or { panic(err) }
// Check that logo.png was copied to img subdirectory
assert os.exists(os.join_path(dest_dir, 'img', 'logo.png'))
}
// Test copy_images - no images
fn test_copy_images_no_images() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
dest_dir := os.join_path(os.temp_dir(), 'copy_dest_empty_${os.getpid()}')
os.mkdir_all(dest_dir) or { panic(err) }
defer { cleanup_test_export(dest_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
client.copy_images('testcollection', 'page1', dest_dir) or { panic(err) }
// Should succeed even with no images
assert true
}
// Test copy_files - success
fn test_copy_files_success() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
dest_dir := os.join_path(os.temp_dir(), 'copy_files_dest_${os.getpid()}')
os.mkdir_all(dest_dir) or { panic(err) }
defer { cleanup_test_export(dest_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
// Note: test data would need to be updated to have file links in page2
// For now, this test demonstrates the pattern
client.copy_files('testcollection', 'page2', dest_dir) or { panic(err) }
// Check that files were copied to files subdirectory
// assert os.exists(os.join_path(dest_dir, 'files', 'somefile.csv'))
}
// Test copy_files - no files
fn test_copy_files_no_files() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
dest_dir := os.join_path(os.temp_dir(), 'copy_files_empty_${os.getpid()}')
os.mkdir_all(dest_dir) or { panic(err) }
defer { cleanup_test_export(dest_dir) }
mut client := new(export_dir: test_dir) or { panic(err) }
client.copy_files('testcollection', 'page1', dest_dir) or { panic(err) }
// Should succeed even with no file links
assert true
}
// Test naming normalization edge cases
fn test_naming_normalization_underscores() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
// Create page with underscores
normalized := texttools.name_fix('test_page_name')
os.write_file(os.join_path(test_dir, 'content', 'testcollection', '${normalized}.md'),
'# Test') or { panic(err) }
mut client := new(export_dir: test_dir) or { panic(err) }
// Should find with underscores
exists := client.page_exists('testcollection', 'test_page_name')
assert exists == true
}
// Test naming normalization edge cases - dashes
fn test_naming_normalization_dashes() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
// Create page with dashes
normalized := texttools.name_fix('test-page-name')
os.write_file(os.join_path(test_dir, 'content', 'testcollection', '${normalized}.md'),
'# Test') or { panic(err) }
mut client := new(export_dir: test_dir) or { panic(err) }
// Should find with dashes
exists := client.page_exists('testcollection', 'test-page-name')
assert exists == true
}
// Test naming normalization edge cases - mixed case
fn test_naming_normalization_case() {
test_dir := setup_test_export()
defer { cleanup_test_export(test_dir) }
// Create page with mixed case
normalized := texttools.name_fix('TestPageName')
os.write_file(os.join_path(test_dir, 'content', 'testcollection', '${normalized}.md'),
'# Test') or { panic(err) }
mut client := new(export_dir: test_dir) or { panic(err) }
// Should find with mixed case
exists := client.page_exists('testcollection', 'TestPageName')
assert exists == true
}

21
lib/data/atlas/client/factory.v Normal file
View File

@@ -0,0 +1,21 @@
module client
import incubaid.herolib.core.base
@[params]
pub struct AtlasClientArgs {
pub:
export_dir string @[required] // Path to atlas export directory
}
// Create a new AtlasClient instance
// The export_dir should point to the directory containing content/ and meta/ subdirectories
pub fn new(args AtlasClientArgs) !&AtlasClient {
mut context := base.context()!
mut redis := context.redis()!
return &AtlasClient{
redis: redis
export_dir: args.export_dir
}
}

66
lib/data/atlas/client/model.v Normal file
View File

@@ -0,0 +1,66 @@
module client
// AtlasClient provides access to Atlas-exported documentation collections
// It reads from both the exported directory structure and Redis metadata
// List of recognized image file extensions
const image_extensions = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.bmp', '.tiff', '.ico']
// CollectionMetadata represents the metadata stored in meta/{collection}.json
pub struct CollectionMetadata {
pub mut:
name string
path string
pages map[string]PageMetadata
files map[string]FileMetadata
errors []ErrorMetadata
}
pub struct PageMetadata {
pub mut:
name string
path string
collection_name string
links []LinkMetadata
}
pub struct FileMetadata {
pub mut:
name string // name WITH extension (e.g., "image.png", "data.csv")
path string // relative path in export (e.g., "img/image.png" or "files/data.csv")
}
pub struct LinkMetadata {
pub mut:
src string
text string
target string
line int
target_collection_name string
target_item_name string
status LinkStatus
file_type LinkFileType
}
pub enum LinkStatus {
init
external
found
not_found
anchor
error
}
pub enum LinkFileType {
page // Default: link to another page
file // Link to a non-image file
image // Link to an image file
}
pub struct ErrorMetadata {
pub mut:
category string
page_key string
message string
line int
}

52
lib/data/atlas/collection.v
View File

@@ -1,7 +1,7 @@
module atlas
import incubaid.herolib.core.pathlib
// import incubaid.herolib.core.texttools
import incubaid.herolib.core.texttools
import incubaid.herolib.develop.gittools
import incubaid.herolib.data.paramsparser { Params }
import incubaid.herolib.ui.console
@@ -45,7 +45,6 @@ fn (mut c Collection) init_post() ! {
c.init_git_info()!
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
// Add a page to the collection
@@ -54,7 +53,10 @@ fn (mut c Collection) add_page(mut path pathlib.Path) ! {
if name in c.pages {
return error('Page ${name} already exists in collection ${c.name}')
}
relativepath := path.path_relative(c.path()!.path)!
// Use absolute paths for path_relative to work correctly
mut col_path := pathlib.get(c.path)
mut page_abs_path := pathlib.get(path.absolute())
relativepath := page_abs_path.path_relative(col_path.absolute())!
mut p_new := Page{
name: name
@@ -68,16 +70,18 @@ fn (mut c Collection) add_page(mut path pathlib.Path) ! {
// Add an image to the collection
fn (mut c Collection) add_file(mut p pathlib.Path) ! {
name := p.name_fix_keepext()
name := p.name_fix_keepext() // keep extension
if name in c.files {
return error('Page ${name} already exists in collection ${c.name}')
return error('File ${name} already exists in collection ${c.name}')
}
relativepath := p.path_relative(c.path()!.path)!
// Use absolute paths for path_relative to work correctly
mut col_path := pathlib.get(c.path)
mut file_abs_path := pathlib.get(p.absolute())
relativepath := file_abs_path.path_relative(col_path.absolute())!
mut file_new := File{
name: name
ext: p.extension_lower()
path: relativepath // relative path of file in the collection
path: relativepath // relative path of file in the collection, includes the name
collection: &c
}
@@ -90,7 +94,8 @@ fn (mut c Collection) add_file(mut p pathlib.Path) ! {
}
// Get a page by name
pub fn (c Collection) page_get(name string) !&Page {
pub fn (c Collection) page_get(name_ string) !&Page {
name := texttools.name_fix_no_ext(name_)
return c.pages[name] or { return PageNotFound{
collection: c.name
page: name
@@ -98,7 +103,8 @@ pub fn (c Collection) page_get(name string) !&Page {
}
// Get an image by name
pub fn (c Collection) image_get(name string) !&File {
pub fn (c Collection) image_get(name_ string) !&File {
name := texttools.name_fix(name_)
mut img := c.files[name] or { return FileNotFound{
collection: c.name
file: name
@@ -110,7 +116,8 @@ pub fn (c Collection) image_get(name string) !&File {
}
// Get a file by name
pub fn (c Collection) file_get(name string) !&File {
pub fn (c Collection) file_get(name_ string) !&File {
name := texttools.name_fix(name_)
mut f := c.files[name] or { return FileNotFound{
collection: c.name
file: name
@@ -121,7 +128,8 @@ pub fn (c Collection) file_get(name string) !&File {
return f
}
pub fn (c Collection) file_or_image_get(name string) !&File {
pub fn (c Collection) file_or_image_get(name_ string) !&File {
name := texttools.name_fix(name_)
mut f := c.files[name] or { return FileNotFound{
collection: c.name
file: name
@@ -129,32 +137,32 @@ pub fn (c Collection) file_or_image_get(name string) !&File {
return f
}
// Check if page exists
pub fn (c Collection) page_exists(name string) bool {
pub fn (c Collection) page_exists(name_ string) !bool {
name := texttools.name_fix_no_ext(name_)
return name in c.pages
}
// Check if image exists
pub fn (c Collection) image_exists(name string) bool {
pub fn (c Collection) image_exists(name_ string) !bool {
name := texttools.name_fix(name_)
f := c.files[name] or { return false }
return f.ftype == .image
}
// Check if file exists
pub fn (c Collection) file_exists(name string) bool {
pub fn (c Collection) file_exists(name_ string) !bool {
name := texttools.name_fix(name_)
f := c.files[name] or { return false }
return f.ftype == .file
}
pub fn (c Collection) file_or_image_exists(name string) bool {
f := c.files[name] or { return false }
pub fn (c Collection) file_or_image_exists(name_ string) !bool {
name := texttools.name_fix(name_)
_ := c.files[name] or { return false }
return true
}
@[params]
pub struct CollectionErrorArgs {
pub mut:
@@ -243,7 +251,7 @@ pub fn (c Collection) print_errors() {
pub fn (mut c Collection) validate_links() ! {
for _, mut page in c.pages {
content := page.content(include: true)!
page.links=page.find_links(content)! // will walk over links see if errors and add errors
page.links = page.find_links(content)! // will walk over links see if errors and add errors
}
}

126
lib/data/atlas/export.v
View File

@@ -7,11 +7,10 @@ import json
@[params]
pub struct ExportArgs {
pub mut:
destination string @[required]
destination_meta string // NEW: where to save collection metadata
reset bool = true
include bool = true
redis bool = true
destination string @[requireds]
reset bool = true
include bool = true
redis bool = true
}
// Export all collections
@@ -22,8 +21,8 @@ pub fn (mut a Atlas) export(args ExportArgs) ! {
dest.empty()!
}
// Validate links before export
// a.validate_links()!
// Validate links before export to populate page.links
a.validate_links()!
for _, mut col in a.collections {
col.export(
@@ -65,16 +64,51 @@ pub fn (mut c Collection) export(args CollectionExportArgs) ! {
path: '${dir_meta.path}/${c.name}.json'
create: true
)!
json_file.write(meta)!
json_file.write(meta)!
// Track cross-collection pages and files that need to be copied for self-contained export
mut cross_collection_pages := map[string]&Page{} // key: page.name, value: &Page
mut cross_collection_files := map[string]&File{} // key: file.name, value: &File
// First pass: export all pages in this collection and collect cross-collection references
for _, mut page in c.pages {
content := page.content(include: args.include)!
// NEW: Process cross-collection links
processed_content := page.process_links(mut col_dir)!
// Get content with includes processed and links transformed for export
content := page.content_with_fixed_links(
include: args.include
cross_collection: true
export_mode: true
)!
mut dest_file := pathlib.get_file(path: '${col_dir.path}/${page.name}.md', create: true)!
dest_file.write(processed_content)!
dest_file.write(content)!
// Collect cross-collection references for copying (pages and files/images)
// IMPORTANT: Use cached links from validation (before transformation) to preserve collection info
for mut link in page.links {
if link.status != .found {
continue
}
// Collect cross-collection page references
is_local := link.target_collection_name == c.name
if link.file_type == .page && !is_local {
mut target_page := link.target_page() or { continue }
// Use page name as key to avoid duplicates
if target_page.name !in cross_collection_pages {
cross_collection_pages[target_page.name] = target_page
}
}
// Collect cross-collection file/image references
if (link.file_type == .file || link.file_type == .image) && !is_local {
mut target_file := link.target_file() or { continue }
// Use file name as key to avoid duplicates
file_key := target_file.name
if file_key !in cross_collection_files {
cross_collection_files[file_key] = target_file
}
}
}
// Redis operations...
if args.redis {
@@ -82,27 +116,55 @@ pub fn (mut c Collection) export(args CollectionExportArgs) ! {
mut redis := context.redis()!
redis.hset('atlas:${c.name}', page.name, page.path)!
}
}
// // Export files
// if c.files.len > 0 {
// files_dir := pathlib.get_dir(
// path: '${col_dir.path}/files'
// create: true
// )!
// Copy all files/images from this collection to the export directory
for _, mut file in c.files {
mut src_file := file.path()!
// for _, mut file in c.files {
// dest_path := '${files_dir.path}/${file.file_name()}'
// mut p2 := file.path()!
// p2.copy(dest: col_dir.path)!
// Determine subdirectory based on file type
mut subdir := if file.is_image() { 'img' } else { 'files' }
// if args.redis {
// mut context := base.context()!
// mut redis := context.redis()!
// redis.hset('atlas:${c.name}', file.file_name(), file.path()!.path)!
// }
// }
// }
// Ensure subdirectory exists
mut subdir_path := pathlib.get_dir(
path: '${col_dir.path}/${subdir}'
create: true
)!
mut dest_path := '${subdir_path.path}/${file.name}'
mut dest_file := pathlib.get_file(path: dest_path, create: true)!
src_file.copy(dest: dest_file.path)!
}
// Second pass: copy cross-collection referenced pages to make collection self-contained
for _, mut ref_page in cross_collection_pages {
// Get the referenced page content with includes processed
ref_content := ref_page.content_with_fixed_links(
include: args.include
cross_collection: true
export_mode: true
)!
// Write the referenced page to this collection's directory
mut dest_file := pathlib.get_file(path: '${col_dir.path}/${ref_page.name}.md', create: true)!
dest_file.write(ref_content)!
}
// Third pass: copy cross-collection referenced files/images to make collection self-contained
for _, mut ref_file in cross_collection_files {
mut src_file := ref_file.path()!
// Determine subdirectory based on file type
mut subdir := if ref_file.is_image() { 'img' } else { 'files' }
// Ensure subdirectory exists
mut subdir_path := pathlib.get_dir(
path: '${col_dir.path}/${subdir}'
create: true
)!
mut dest_path := '${subdir_path.path}/${ref_file.name}'
mut dest_file := pathlib.get_file(path: dest_path, create: true)!
src_file.copy(dest: dest_file.path)!
}
}

16
lib/data/atlas/factory.v
View File

@@ -19,19 +19,20 @@ pub mut:
pub fn new(args AtlasNewArgs) !&Atlas {
mut name := texttools.name_fix(args.name)
mut a := Atlas{
mut a := &Atlas{
name: name
}
set(a)
return &a
return a
}
// Get Atlas from global map
pub fn get(name string) !&Atlas {
mut fixed_name := texttools.name_fix(name)
rlock atlases {
if name in atlases {
return atlases[name] or { return error('Atlas ${name} not found') }
if fixed_name in atlases {
return atlases[fixed_name] or { return error('Atlas ${name} not found') }
}
}
return error("Atlas '${name}' not found")
@@ -39,8 +40,9 @@ pub fn get(name string) !&Atlas {
// Check if Atlas exists
pub fn exists(name string) bool {
mut fixed_name := texttools.name_fix(name)
rlock atlases {
return name in atlases
return fixed_name in atlases
}
}
@@ -52,8 +54,8 @@ pub fn list() []string {
}
// Store Atlas in global map
fn set(atlas Atlas) {
fn set(atlas &Atlas) {
lock atlases {
atlases[atlas.name] = &atlas
atlases[atlas.name] = atlas
}
}

12
lib/data/atlas/file.v
View File

@@ -1,6 +1,7 @@
module atlas
import incubaid.herolib.core.pathlib
import os
pub enum FileType {
file
@@ -9,8 +10,7 @@ pub enum FileType {
pub struct File {
pub mut:
name string // name without extension
ext string // file extension
name string // name with extension
path string // relative path of file in the collection
ftype FileType // file or image
collection &Collection @[skip; str: skip] // Reference to parent collection
@@ -22,10 +22,10 @@ pub fn (mut f File) path() !pathlib.Path {
return pathlib.get_file(path: mypath, create: false)!
}
pub fn (f File) file_name() string {
return '${f.name}.${f.ext}'
}
pub fn (f File) is_image() bool {
return f.ftype == .image
}
pub fn (f File) ext() string {
return os.file_ext(f.name)
}

23
lib/data/atlas/getters.v
View File

@@ -4,7 +4,7 @@ module atlas
pub fn (a Atlas) page_get(key string) !&Page {
parts := key.split(':')
if parts.len != 2 {
return error('Invalid page key format. Use "collection:page"')
return error('Invalid page key format. Use "collection:page" in page_get')
}
col := a.get_collection(parts[0])!
@@ -15,7 +15,7 @@ pub fn (a Atlas) page_get(key string) !&Page {
pub fn (a Atlas) image_get(key string) !&File {
parts := key.split(':')
if parts.len != 2 {
return error('Invalid image key format. Use "collection:image"')
return error('Invalid image key format. Use "collection:image" in image_get')
}
col := a.get_collection(parts[0])!
@@ -26,7 +26,7 @@ pub fn (a Atlas) image_get(key string) !&File {
pub fn (a Atlas) file_get(key string) !&File {
parts := key.split(':')
if parts.len != 2 {
return error('Invalid file key format. Use "collection:file"')
return error('Invalid file key format. Use "collection:file" in file_get')
}
col := a.get_collection(parts[0])!
@@ -44,10 +44,10 @@ pub fn (a Atlas) file_or_image_get(key string) !&File {
}
// Check if page exists
pub fn (a Atlas) page_exists(key string) bool {
pub fn (a Atlas) page_exists(key string) !bool {
parts := key.split(':')
if parts.len != 2 {
return false
return error("Invalid file key format. Use 'collection:file' in page_exists")
}
col := a.get_collection(parts[0]) or { return false }
@@ -55,10 +55,10 @@ pub fn (a Atlas) page_exists(key string) bool {
}
// Check if image exists
pub fn (a Atlas) image_exists(key string) bool {
pub fn (a Atlas) image_exists(key string) !bool {
parts := key.split(':')
if parts.len != 2 {
return false
return error("Invalid file key format. Use 'collection:file' in image_exists")
}
col := a.get_collection(parts[0]) or { return false }
@@ -66,26 +66,25 @@ pub fn (a Atlas) image_exists(key string) bool {
}
// Check if file exists
pub fn (a Atlas) file_exists(key string) bool {
pub fn (a Atlas) file_exists(key string) !bool {
parts := key.split(':')
if parts.len != 2 {
return false
return error("Invalid file key format. Use 'collection:file' in file_exists")
}
col := a.get_collection(parts[0]) or { return false }
return col.file_exists(parts[1])
}
pub fn (a Atlas) file_or_image_exists(key string) bool {
pub fn (a Atlas) file_or_image_exists(key string) !bool {
parts := key.split(':')
if parts.len != 2 {
return false
return error("Invalid file key format. Use 'collection:file' in file_or_image_exists")
}
col := a.get_collection(parts[0]) or { return false }
return col.file_or_image_exists(parts[1])
}
// List all pages in Atlas
pub fn (a Atlas) list_pages() map[string][]string {
mut result := map[string][]string{}

264
lib/data/atlas/link.v
View File

@@ -1,8 +1,13 @@
module atlas
import incubaid.herolib.core.texttools
import incubaid.herolib.core.pathlib
import os
import incubaid.herolib.ui.console
pub enum LinkFileType {
page // Default: link to another page
file // Link to a non-image file
image // Link to an image file
}
// Link represents a markdown link found in content
pub struct Link {
@@ -10,12 +15,12 @@ pub mut:
src string // Source content where link was found (what to replace)
text string // Link text [text]
target string // Original link target (the source text)
line int // Line number where link was found
line int // Line number where link was found (1-based)
pos int // Character position in line where link starts (0-based)
target_collection_name string
target_item_name string
status LinkStatus
is_file_link bool // is the link pointing to a file
is_image_link bool // is the link pointing to an image
file_type LinkFileType // Type of the link target: file, image, or page (default)
page &Page @[skip; str: skip] // Reference to page where this link is found
}
@@ -28,20 +33,12 @@ pub enum LinkStatus {
error
}
// Get the collection:item key for this link
fn (mut self Link) key() string {
return '${self.target_collection_name}:${self.target_item_name}'
}
// is the link in the same collection as the page containing the link
fn (mut self Link) is_local_in_collection() bool {
return self.target_collection_name == self.page.collection.name
}
// is the link pointing to an external resource e.g. http, git, mailto, ftp
pub fn (mut self Link) is_external() bool {
return self.status == .external
}
// Get the target page this link points to
pub fn (mut self Link) target_page() !&Page {
if self.status == .external {
return error('External links do not have a target page')
@@ -49,6 +46,7 @@ pub fn (mut self Link) target_page() !&Page {
return self.page.collection.atlas.page_get(self.key())
}
// Get the target file this link points to
pub fn (mut self Link) target_file() !&File {
if self.status == .external {
return error('External links do not have a target file')
@@ -93,32 +91,41 @@ fn (mut p Page) find_links(content string) ![]Link {
text := line[open_bracket + 1..close_bracket]
target := line[open_paren + 1..close_paren]
mut is_image_link := (image_open != -1)
// Determine link type based on content
mut detected_file_type := LinkFileType.page
mut is_file_link := false
// Check if it's an image link (starts with !)
if image_open != -1 {
detected_file_type = .image
} else if target.contains('.') && !target.trim_space().to_lower().ends_with('.md') {
// File link: has extension but not .md
detected_file_type = .file
}
//if no . in file then it means it's a page link (binaries with . are not supported in other words)
if target.contains(".") && (! target.trim_space().to_lower().ends_with(".md")) {
is_file_link = true
is_image_link = false //means it's a file link, not an image link
// console.print_debug('Found link: text="${text}", target="${target}", type=${detected_file_type}')
// Store position - use image_open if it's an image, otherwise open_bracket
link_start_pos := if detected_file_type == .image { image_open } else { open_bracket }
// For image links, src should include the ! prefix
link_src := if detected_file_type == .image {
line[image_open..close_paren + 1]
} else {
line[open_bracket..close_paren + 1]
}
mut link := Link{
src: line[open_bracket..close_paren + 1]
text: text
target: target.trim_space()
line: line_idx + 1
is_file_link: is_file_link
is_image_link: is_image_link
page: &p
src: link_src
text: text
target: target.trim_space()
line: line_idx + 1
pos: link_start_pos
file_type: detected_file_type
page: &p
}
p.parse_link_target(mut link)
if link.status == .external {
link.is_file_link = false
link.is_image_link = false
}
println(link)
p.parse_link_target(mut link)!
// No need to set file_type to false for external links, as it's already .page by default
links << link
pos = close_paren + 1
@@ -128,26 +135,27 @@ fn (mut p Page) find_links(content string) ![]Link {
}
// Parse link target to extract collection and page
fn (mut p Page) parse_link_target(mut link Link) {
fn (mut p Page) parse_link_target(mut link Link) ! {
mut target := link.target.to_lower().trim_space()
// Skip external links
// Check for external links (http, https, mailto, ftp)
if target.starts_with('http://') || target.starts_with('https://')
|| target.starts_with('mailto:') || target.starts_with('ftp://') {
link.status = .external
return
}
// Skip anchors
// Check for anchor links
if target.starts_with('#') {
link.status = .anchor
return
}
// Handle relative paths - extract the last part after /
if target.contains('/') {
parts9 := target.split('/')
if parts9.len >= 1 {
target = parts9[1]
parts := target.split('/')
if parts.len > 1 {
target = parts[parts.len - 1]
}
}
@@ -156,119 +164,139 @@ fn (mut p Page) parse_link_target(mut link Link) {
parts := target.split(':')
if parts.len >= 2 {
link.target_collection_name = texttools.name_fix(parts[0])
link.target_item_name = normalize_page_name(parts[1])
// For file links, use name without extension; for page links, normalize normally
if link.file_type == .file {
link.target_item_name = texttools.name_fix_no_ext(parts[1])
} else {
link.target_item_name = normalize_page_name(parts[1])
}
}
} else {
link.target_item_name = normalize_page_name(target).trim_space()
// For file links, use name without extension; for page links, normalize normally
if link.file_type == .file {
link.target_item_name = texttools.name_fix_no_ext(target).trim_space()
} else {
link.target_item_name = normalize_page_name(target).trim_space()
}
link.target_collection_name = p.collection.name
}
if link.is_file_link == false && !p.collection.atlas.page_exists(link.key()) {
p.collection.error(
category: .invalid_page_reference
page_key: p.key()
message: 'Broken link to `${link.key()}` at line ${link.line}: `${link.src}`'
show_console: true
)
link.status = .not_found
} else if link.is_file_link && !p.collection.atlas.file_or_image_exists(link.key()) {
p.collection.error(
category: .invalid_file_reference
page_key: p.key()
message: 'Broken file link to `${link.key()}` at line ${link.line}: `${link.src}`'
show_console: true
)
link.status = .not_found
// console.print_debug('Parsed link target: collection="${link.target_collection_name}", item="${link.target_item_name}", type=${link.file_type}')
// Validate link target exists
mut target_exists := false
mut error_category := CollectionErrorCategory.invalid_page_reference
mut error_prefix := 'Broken link'
if link.file_type == .file || link.file_type == .image {
target_exists = p.collection.atlas.file_or_image_exists(link.key())!
error_category = .invalid_file_reference
error_prefix = if link.file_type == .file { 'Broken file link' } else { 'Broken image link' }
} else {
target_exists = p.collection.atlas.page_exists(link.key())!
}
// console.print_debug('Link target exists: ${target_exists} for key=${link.key()}')
if target_exists {
link.status = .found
} else {
p.collection.error(
category: error_category
page_key: p.key()
message: '${error_prefix} to `${link.key()}` at line ${link.line}: `${link.src}`'
show_console: true
)
link.status = .not_found
}
}
////////////////FIX PAGES FOR THE LINKS///////////////////////
@[params]
pub struct FixLinksArgs {
include bool // Process includes before fixing links
cross_collection bool // Process cross-collection links (for export)
export_mode bool // Use export-style simple paths instead of filesystem paths
}
// Fix links in page content - rewrites links with proper relative paths
fn (mut p Page) content_with_fixed_links() !string {
mut content := p.content(include: false)!
if p.links.len == 0 {
return content
fn (mut p Page) content_with_fixed_links(args FixLinksArgs) !string {
mut content := p.content(include: args.include)!
// Get links - either re-find them (if includes processed) or use cached
mut links := if args.include {
p.find_links(content)! // Re-find links in processed content
} else {
p.links // Use cached links from validation
}
// Process links in reverse order to maintain positions
for mut link in p.links.reverse() {
// if page not existing no point in fixing
// Filter and transform links
for mut link in links {
// Skip invalid links
if link.status != .found {
continue
}
// if not local then no point in fixing
if !link.is_local_in_collection() {
// Skip cross-collection links unless enabled
is_local := link.target_collection_name == p.collection.name
if !args.cross_collection && !is_local {
continue
}
// Get target page
mut target_page := link.target_page()!
mut target_path := target_page.path()!
relative_path := target_path.path_relative(p.path()!.path)!
// Calculate new link path based on mode
new_link := if args.export_mode {
p.export_link_path(mut link) or { continue }
} else {
p.filesystem_link_path(mut link) or { continue }
}
new_link := '[${link.text}](${relative_path})'
// Build the complete link markdown
// For image links, link.src already includes the !, so we build the same format
prefix := if link.file_type == .image { '!' } else { '' }
new_link_md := '${prefix}[${link.text}](${new_link})'
// Replace in content
content = content.replace(link.src, new_link)
content = content.replace(link.src, new_link_md)
}
return content
}
// process_cross_collection_links handles exporting cross-collection references
// It:
// 1. Finds all cross-collection links (collection:page format)
// 2. Copies the target page to the export directory
// 3. Renames the link to avoid conflicts (collectionname_pagename.md)
// 4. Rewrites the link in the content
fn (mut p Page) process_links(mut export_dir pathlib.Path) !string {
mut c := p.content(include: true)!
mut links := p.find_links(c)!
// Process links in reverse order to maintain string positions
for mut link in links.reverse() {
println(link)
if link.status != .found {
continue
// export_link_path calculates path for export (self-contained: all references are local)
fn (mut p Page) export_link_path(mut link Link) !string {
match link.file_type {
.image {
mut tf := link.target_file()!
return 'img/${tf.name}'
}
mut exported_filename := ''
if link.is_file_link {
mut target_file := link.target_file()!
mut target_path := target_file.path()!
// Copy target page with renamed filename
exported_filename = 'files/${target_file.collection.name}_${target_file.name}'
os.mkdir_all('${export_dir.path}/files')!
os.cp(target_path.path, '${export_dir.path}/${exported_filename}')!
} else {
mut target_page := link.target_page()!
mut target_path := target_page.path()!
// Copy target page with renamed filename
exported_filename = '${target_page.collection.name}_${target_page.name}.md'
page_content := target_page.content(include: true)!
mut exported_file := pathlib.get_file(
path: '${export_dir.path}/${exported_filename}'
create: true
)!
exported_file.write(page_content)!
.file {
mut tf := link.target_file()!
return 'files/${tf.name}'
}
mut pre := ''
if link.is_file_link {
pre = '!'
.page {
mut tp := link.target_page()!
return '${tp.name}.md'
}
}
}
// Update link in source content
new_link := '${pre}[${link.text}](${exported_filename})'
c = c.replace(link.src, new_link)
// filesystem_link_path calculates path using actual filesystem paths
fn (mut p Page) filesystem_link_path(mut link Link) !string {
source_path := p.path()!
mut target_path := match link.file_type {
.image, .file {
mut tf := link.target_file()!
tf.path()!
}
.page {
mut tp := link.target_page()!
tp.path()!
}
}
return c
return target_path.path_relative(source_path.path)!
}
/////////////TOOLS//////////////////////////////////

4
lib/data/atlas/page.v
View File

@@ -128,6 +128,10 @@ fn (mut p Page) process_includes(content string, mut visited map[string]bool) !s
}
}
// Remove this page from visited map to allow it to be included again in other contexts
// This prevents false positives when a page is included multiple times (which is valid)
visited.delete(page_key)
return processed_lines.join_lines()
}

38
lib/data/atlas/play.v
View File

@@ -10,9 +10,10 @@ pub fn play(mut plbook PlayBook) ! {
return
}
mut atlases := map[string]&Atlas{}
// Track which atlases we've processed in this playbook
mut processed_atlases := map[string]bool{}
mut name := ""
mut name := ''
// Process scan actions - scan directories for collections
mut scan_actions := plbook.find(filter: 'atlas.scan')!
@@ -20,14 +21,15 @@ pub fn play(mut plbook PlayBook) ! {
mut p := action.params
name = p.get_default('name', 'main')!
ignore := p.get_list_default('ignore', [])!
console.print_item("Scanning Atlas '${name}' with ignore patterns: ${ignore}\n${p}")
// Get or create atlas
mut atlas_instance := atlases[name] or {
console.print_item("Scanning Atlas '${name}' with ignore patterns: ${ignore}")
// Get or create atlas from global map
mut atlas_instance := if exists(name) {
get(name)!
} else {
console.print_debug('Atlas not found, creating a new one')
mut new_atlas := new(name: name)!
atlases[name] = new_atlas
new_atlas
new(name: name)!
}
processed_atlases[name] = true
mut path := p.get_default('path', '')!
@@ -47,17 +49,15 @@ pub fn play(mut plbook PlayBook) ! {
atlas_instance.scan(path: path, ignore: ignore)!
action.done = true
set(atlas_instance)
// No need to call set() again - atlas is already in global map from new()
// and we're modifying it by reference
}
mut atlas_instance_post := atlases[name] or {
return error("Atlas '${name}' not found. Use !!atlas.scan first.")
}
atlas_instance_post.init_post()!
println(atlas_instance_post)
// Run init_post on all processed atlases
for atlas_name, _ in processed_atlases {
mut atlas_instance_post := get(atlas_name)!
atlas_instance_post.init_post()!
}
// Process export actions - export collections to destination
mut export_actions := plbook.find(filter: 'atlas.export')!
@@ -66,12 +66,12 @@ pub fn play(mut plbook PlayBook) ! {
for mut action in export_actions {
mut p := action.params
name = p.get_default('name', 'main')!
destination := p.get('destination')!
destination := p.get_default('destination', '/tmp/atlas_export')!
reset := p.get_default_true('reset')
include := p.get_default_true('include')
redis := p.get_default_true('redis')
mut atlas_instance := atlases[name] or {
mut atlas_instance := get(name) or {
return error("Atlas '${name}' not found. Use !!atlas.scan first.")
}

129
lib/data/atlas/readme.md
View File

@@ -11,8 +11,36 @@ A lightweight document collection manager for V, inspired by doctree but simplif
- **Type-Safe Access**: Get pages, images, and files with error handling
- **Error Tracking**: Built-in error collection and reporting with deduplication
## Quick Start
put in .hero file and execute with hero or but shebang line on top of .hero script
**Scan Parameters:**
- `name` (optional, default: 'main') - Atlas instance name
- `path` (required when git_url not provided) - Directory path to scan
- `git_url` (alternative to path) - Git repository URL to clone/checkout
- `git_root` (optional when using git_url, default: ~/code) - Base directory for cloning
- `meta_path` (optional) - Directory to save collection metadata JSON
- `ignore` (optional) - List of directory names to skip during scan
**most basic example**
```heroscript
#!/usr/bin/env hero
!!atlas.scan git_url:"https://git.ourworld.tf/tfgrid/docs_tfgrid4/src/branch/main/collections/tests"
!!atlas.export destination: '/tmp/atlas_export'
```
put this in .hero file
## usage in herolib
```v
import incubaid.herolib.data.atlas
@@ -227,9 +255,9 @@ You can scan collections directly from a git repository:
```heroscript
!!atlas.scan
name: 'my_docs'
git_url: 'https://github.com/myorg/docs.git'
git_root: '~/code' // optional, defaults to ~/code
name: 'my_docs'
git_url: 'https://github.com/myorg/docs.git'
git_root: '~/code' // optional, defaults to ~/code
```
The repository will be automatically cloned if it doesn't exist locally.
@@ -354,18 +382,30 @@ After fix (assuming pages are in subdirectories):
4. **External Links**: HTTP(S), mailto, and anchor links are ignored
5. **Error Reporting**: Broken links are reported with file, line number, and link details
### Export with Link Validation
### Export Directory Structure
Links are automatically validated during export:
When you export an Atlas, the directory structure is organized as:
```v
a.export(
destination: './output'
include: true
)!
$$\text{export\_dir}/
\begin{cases}
\text{content/} \\
\quad \text{collection\_name/} \\
\quad \quad \text{page1.md} \\
\quad \quad \text{page2.md} \\
\quad \quad \text{img/} & \text{(images)} \\
\quad \quad \quad \text{logo.png} \\
\quad \quad \quad \text{banner.jpg} \\
\quad \quad \text{files/} & \text{(other files)} \\
\quad \quad \quad \text{data.csv} \\
\quad \quad \quad \text{document.pdf} \\
\text{meta/} & \text{(metadata)} \\
\quad \text{collection\_name.json}
\end{cases}$$
// Errors are printed for each collection automatically
```
- **Pages**: Markdown files directly in collection directory
- **Images**: Stored in `img/` subdirectory
- **Files**: Other resources stored in `files/` subdirectory
- **Metadata**: JSON files in `meta/` directory with collection information
## Redis Integration
@@ -455,54 +495,10 @@ save_path/
└── collection3.json
```
**Note:** Not in the collection directories themselves - saved to a separate location you specify.
### Limitations
- Load-from-JSON functionality is not yet implemented
- Python loader is planned but not yet available
- Currently, collections must be rescanned from source files
## HeroScript Integration
Atlas integrates with HeroScript, allowing you to define Atlas operations in `.vsh` or playbook files.
### Available Actions
#### `atlas.scan` - Scan Directory for Collections
Scan a directory tree to find and load collections marked with `.collection` files.
```heroscript
!!atlas.scan
name: 'main'
path: './docs'
git_url: 'https://github.com/org/repo.git' # optional
git_root: '~/code' # optional, default: ~/code
meta_path: './metadata' # optional, saves metadata here
ignore: ['private', 'draft'] # optional, directories to skip
```
**Parameters:**
- `name` (optional, default: 'main') - Atlas instance name
- `path` (required when git_url not provided) - Directory path to scan
- `git_url` (alternative to path) - Git repository URL to clone/checkout
- `git_root` (optional when using git_url, default: ~/code) - Base directory for cloning
- `meta_path` (optional) - Directory to save collection metadata JSON
- `ignore` (optional) - List of directory names to skip during scan
### Real Workflow Example: Scan and Export
```heroscript
!!atlas.scan
path: '~/docs/myproject'
meta_path: '~/docs/metadata'
!!atlas.export
destination: '~/docs/output'
include: true
redis: false
```
### Using in V Scripts
Create a `.vsh` script to process Atlas operations:
@@ -515,12 +511,9 @@ import incubaid.herolib.data.atlas
// Define your HeroScript content
heroscript := "
!!atlas.scan
path: './docs'
!!atlas.scan path: './docs'
!!atlas.export
destination: './output'
include: true
!!atlas.export destination: './output' include: true
"
// Create playbook from text
@@ -538,14 +531,14 @@ Create a `docs.play` file:
```heroscript
!!atlas.scan
name: 'main'
path: '~/code/docs'
name: 'main'
path: '~/code/docs'
!!atlas.export
destination: '~/code/output'
reset: true
include: true
redis: true
destination: '~/code/output'
reset: true
include: true
redis: true
```
Execute it:
@@ -607,6 +600,6 @@ The following features are planned but not yet available:
- [ ] Load collections from `.collection.json` files
- [ ] Python API for reading collections
- [ ] `atlas.validate` playbook action
- [ ] `atlas.fix_links` playbook action
- [ ] `atlas.fix_links` playbook action
- [ ] Auto-save on collection modifications
- [ ] Collection version control

2
lib/installers/base/installer.v
View File

@@ -59,7 +59,7 @@ pub fn install(args_ InstallArgs) ! {
} else if pl == .alpine {
console.print_header(' - Alpine prepare')
osal.package_refresh()!
osal.package_install('git,curl,mc,tmux,screen,git-lfs,redis-server')!
osal.package_install('git,curl,mc,tmux,screen,git-lfs,redis')!
} else if pl == .arch {
console.print_header(' - Arch prepare')
osal.package_refresh()!

11
lib/web/docusaurus/config.v
View File

@@ -17,6 +17,9 @@ pub mut:
reset bool
template_update bool
coderoot string
// Client configuration
use_atlas bool // true = atlas_client, false = doctreeclient
atlas_dir string // Required when use_atlas = true
}
@[params]
@@ -28,6 +31,9 @@ pub mut:
reset bool
template_update bool
coderoot string
// Client configuration
use_atlas bool // true = atlas_client, false = doctreeclient
atlas_dir string // Required when use_atlas = true
}
// return the last know config
@@ -36,6 +42,9 @@ pub fn config() !DocusaurusConfig {
docusaurus_config << DocusaurusConfigParams{}
}
mut args := docusaurus_config[0] or { panic('bug in docusaurus config') }
if args.use_atlas && args.atlas_dir == '' {
return error('use_atlas is true but atlas_dir is not set')
}
if args.path_build == '' {
args.path_build = '${os.home_dir()}/hero/var/docusaurus/build'
}
@@ -53,6 +62,8 @@ pub fn config() !DocusaurusConfig {
install: args.install
reset: args.reset
template_update: args.template_update
use_atlas: args.use_atlas
atlas_dir: args.atlas_dir
}
if c.install {
install(c)!

7
lib/web/docusaurus/dsite.v
View File

@@ -73,6 +73,7 @@ pub mut:
port int = 3000
open bool = true // whether to open the browser automatically
watch_changes bool = false // whether to watch for changes in docs and rebuild automatically
skip_generate bool = false // whether to skip generation (useful when docs are pre-generated, e.g., from atlas)
}
pub fn (mut s DocSite) open(args DevArgs) ! {
@@ -82,9 +83,11 @@ pub fn (mut s DocSite) open(args DevArgs) ! {
}
pub fn (mut s DocSite) dev(args DevArgs) ! {
s.generate()!
if !args.skip_generate {
s.generate()!
}
osal.exec(
cmd: '
cmd: '
cd ${s.path_build.path}
bun run start -p ${args.port} -h ${args.host}
'

3
lib/web/docusaurus/dsite_generate.v
View File

@@ -2,7 +2,6 @@ module docusaurus
import incubaid.herolib.core.pathlib
import json
import os
import incubaid.herolib.osal.core as osal
import incubaid.herolib.ui.console
@@ -15,7 +14,7 @@ pub fn (mut docsite DocSite) generate() ! {
console.print_header(' docsite generate: ${docsite.name} on ${c.path_build.path}')
// Store Docusaurus site structure in Redis for link processing
docsite.store_site_structure()!
// docsite.store_site_structure()!
osal.rm('${c.path_build.path}/docs')!

77
lib/web/docusaurus/dsite_generate_docs.v
View File

@@ -1,18 +1,16 @@
module docusaurus
import incubaid.herolib.core.pathlib
import incubaid.herolib.web.doctreeclient
import incubaid.herolib.data.atlas.client as atlas_client
import incubaid.herolib.web.site { Page, Section, Site }
import incubaid.herolib.data.markdown.tools as markdowntools
import incubaid.herolib.ui.console
// THIS CODE GENERATES A DOCUSAURUS SITE FROM A DOCTREECLIENT AND SITE DEFINITION
struct SiteGenerator {
mut:
siteconfig_name string
path pathlib.Path
client &doctreeclient.DocTreeClient
client IDocClient
flat bool // if flat then won't use sitenames as subdir's
site Site
errors []string // collect errors here
@@ -25,9 +23,13 @@ pub fn (mut docsite DocSite) generate_docs() ! {
// we generate the docs in the build path
docs_path := '${c.path_build.path}/docs'
// Create the appropriate client based on configuration
mut client_instance := atlas_client.new(export_dir: c.atlas_dir)!
mut client := IDocClient(client_instance)
mut gen := SiteGenerator{
path: pathlib.get_dir(path: docs_path, create: true)!
client: doctreeclient.new()!
client: client
flat: true
site: docsite.website
}
@@ -141,7 +143,11 @@ fn (mut generator SiteGenerator) page_generate(args_ Page) ! {
pagefile.write(c)!
generator.client.copy_images(collection_name, page_name, pagefile.path_dir()) or {
generator.error("Couldn't copy image ${pagefile} for '${page_name}' in collection '${collection_name}', try to find the image and fix the path is in ${args.path}.}\nError: ${err}")!
generator.error("Couldn't copy images for page:'${page_name}' in collection:'${collection_name}'\nERROR:${err}")!
return
}
generator.client.copy_files(collection_name, page_name, pagefile.path_dir()) or {
generator.error("Couldn't copy files for page:'${page_name}' in collection:'${collection_name}'\nERROR:${err}")!
return
}
}
@@ -368,8 +374,65 @@ fn (generator SiteGenerator) fix_links(content string, current_page_path string)
}
}
// STEP 5: Remove .md extensions from all links (Docusaurus doesn't use them in URLs)
// STEP 5: Fix bare page references (from atlas self-contained exports)
// Atlas exports convert cross-collection links to simple relative links like "token_system2.md"
// We need to transform these to proper relative paths based on Docusaurus structure
for page_name, target_dir in page_to_path {
// Match links in the format ](page_name) or ](page_name.md)
old_link_with_md := '](${page_name}.md)'
old_link_without_md := '](${page_name})'
if result.contains(old_link_with_md) || result.contains(old_link_without_md) {
new_link := calculate_relative_path(current_dir, target_dir, page_name)
// Replace both .md and non-.md versions
result = result.replace(old_link_with_md, '](${new_link})')
result = result.replace(old_link_without_md, '](${new_link})')
}
}
// STEP 6: Remove .md extensions from all remaining links (Docusaurus doesn't use them in URLs)
result = result.replace('.md)', ')')
// STEP 7: Fix image links to point to img/ subdirectory
// Images are copied to img/ subdirectory by copy_images(), so we need to update the links
// Transform ![alt](image.png) to ![alt](img/image.png) for local images only
mut image_lines := result.split('\n')
for i, line in image_lines {
// Find image links: ![...](...) but skip external URLs
if line.contains('![') {
mut pos := 0
for {
img_start := line.index_after('![', pos) or { break }
alt_end := line.index_after(']', img_start) or { break }
if alt_end + 1 >= line.len || line[alt_end + 1] != `(` {
pos = alt_end + 1
continue
}
url_start := alt_end + 2
url_end := line.index_after(')', url_start) or { break }
url := line[url_start..url_end]
// Skip external URLs and already-prefixed img/ paths
if url.starts_with('http://') || url.starts_with('https://')
|| url.starts_with('img/') || url.starts_with('./img/') {
pos = url_end + 1
continue
}
// Skip absolute paths and paths with ../
if url.starts_with('/') || url.starts_with('../') {
pos = url_end + 1
continue
}
// This is a local image reference - add img/ prefix
new_url := 'img/${url}'
image_lines[i] = line[0..url_start] + new_url + line[url_end..]
break
}
}
}
result = image_lines.join('\n')
return result
}

3
lib/web/docusaurus/dsite_import.v
View File

@@ -1,11 +1,10 @@
module docusaurus
import incubaid.herolib.develop.gittools
import os
import incubaid.herolib.core.pathlib
import incubaid.herolib.ui.console
import incubaid.herolib.core.texttools.regext
// import other parts of a docusaurus module into the one we build, this is to import e.g. static parts
pub fn (mut docsite DocSite) import() ! {
for importparams in docsite.website.siteconfig.imports {
console.print_header('Importing: path:${importparams.path} or url:${importparams.url}')

60
lib/web/docusaurus/dsite_store_structure.v
View File

@@ -3,38 +3,38 @@ module docusaurus
import incubaid.herolib.core.base
import incubaid.herolib.core.texttools
// Store the Docusaurus site structure in Redis for link processing
// This maps collection:page to their actual Docusaurus paths
pub fn (mut docsite DocSite) store_site_structure() ! {
mut context := base.context()!
mut redis := context.redis()!
// // Store the Docusaurus site structure in Redis for link processing
// // This maps collection:page to their actual Docusaurus paths
// pub fn (mut docsite DocSite) store_site_structure() ! {
// mut context := base.context()!
// mut redis := context.redis()!
// Store mapping of collection:page to docusaurus path (without .md extension)
for page in docsite.website.pages {
parts := page.src.split(':')
if parts.len != 2 {
continue
}
collection_name := texttools.name_fix(parts[0])
page_name := texttools.name_fix(parts[1])
// // Store mapping of collection:page to docusaurus path (without .md extension)
// for page in docsite.website.pages {
// parts := page.src.split(':')
// if parts.len != 2 {
// continue
// }
// collection_name := texttools.name_fix(parts[0])
// page_name := texttools.name_fix(parts[1])
// Calculate the docusaurus path (without .md extension for URLs)
mut doc_path := page.path
// // Calculate the docusaurus path (without .md extension for URLs)
// mut doc_path := page.path
// Handle empty or root path
if doc_path.trim_space() == '' || doc_path == '/' {
doc_path = page_name
} else if doc_path.ends_with('/') {
doc_path += page_name
}
// // Handle empty or root path
// if doc_path.trim_space() == '' || doc_path == '/' {
// doc_path = page_name
// } else if doc_path.ends_with('/') {
// doc_path += page_name
// }
// Remove .md extension if present for URL paths
if doc_path.ends_with('.md') {
doc_path = doc_path[..doc_path.len - 3]
}
// // Remove .md extension if present for URL paths
// if doc_path.ends_with('.md') {
// doc_path = doc_path[..doc_path.len - 3]
// }
// Store in Redis with key format: collection:page.md
key := '${collection_name}:${page_name}.md'
redis.hset('doctree_docusaurus_paths', key, doc_path)!
}
}
// // Store in Redis with key format: collection:page.md
// key := '${collection_name}:${page_name}.md'
// redis.hset('doctree_docusaurus_paths', key, doc_path)!
// }
// }

30
lib/web/docusaurus/interface_atlas_client.v Normal file
View File

@@ -0,0 +1,30 @@
module docusaurus
pub interface IDocClient {
mut:
// Path methods - get absolute paths to resources
get_page_path(collection_name string, page_name string) !string
get_file_path(collection_name string, file_name string) !string
get_image_path(collection_name string, image_name string) !string
// Existence checks - verify if resources exist
page_exists(collection_name string, page_name string) bool
file_exists(collection_name string, file_name string) bool
image_exists(collection_name string, image_name string) bool
// Content retrieval
get_page_content(collection_name string, page_name string) !string
// Listing methods - enumerate resources
list_collections() ![]string
list_pages(collection_name string) ![]string
list_files(collection_name string) ![]string
list_images(collection_name string) ![]string
list_pages_map() !map[string][]string
list_markdown() !string
// Image operations
// get_page_paths(collection_name string, page_name string) !(string, []string)
copy_images(collection_name string, page_name string, destination_path string) !
copy_files(collection_name string, page_name string, destination_path string) !
}

32
lib/web/docusaurus/play.v
View File

@@ -1,8 +1,6 @@
module docusaurus
import incubaid.herolib.core.playbook { PlayBook }
import incubaid.herolib.web.site
import os
pub fn play(mut plbook PlayBook) ! {
if !plbook.exists(filter: 'docusaurus.') {
@@ -19,6 +17,8 @@ pub fn play(mut plbook PlayBook) ! {
reset: param_define.get_default_false('reset')
template_update: param_define.get_default_false('template_update')
install: param_define.get_default_false('install')
atlas_dir: param_define.get_default('atlas_dir', '/tmp/atlas_export')!
use_atlas: param_define.get_default_false('use_atlas')
)!
site_name := param_define.get('name') or {
@@ -32,20 +32,6 @@ pub fn play(mut plbook PlayBook) ! {
dsite.generate()!
mut actions_dev := plbook.find(filter: 'docusaurus.dev')!
if actions_dev.len > 1 {
return error('Multiple "docusaurus.dev" actions found. Only one is allowed.')
}
for mut action in actions_dev {
mut p := action.params
dsite.dev(
host: p.get_default('host', 'localhost')!
port: p.get_int_default('port', 3000)!
open: p.get_default_false('open')
)!
action.done = true
}
mut actions_build := plbook.find(filter: 'docusaurus.build')!
if actions_build.len > 1 {
return error('Multiple "docusaurus.build" actions found. Only one is allowed.')
@@ -64,5 +50,19 @@ pub fn play(mut plbook PlayBook) ! {
action.done = true
}
mut actions_dev := plbook.find(filter: 'docusaurus.dev')!
if actions_dev.len > 1 {
return error('Multiple "docusaurus.dev" actions found. Only one is allowed.')
}
for mut action in actions_dev {
mut p := action.params
dsite.dev(
host: p.get_default('host', 'localhost')!
port: p.get_int_default('port', 3000)!
open: p.get_default_false('open')
)!
action.done = true
}
plbook.ensure_processed(filter: 'docusaurus.')!
}

0
lib/data/doctree/README.md → libarchive/doctree/README.md
View File

0
lib/data/doctree/collection/collection.v → libarchive/doctree/collection/collection.v
View File

0
lib/data/doctree/collection/data/error.v → libarchive/doctree/collection/data/error.v
View File

0
lib/data/doctree/collection/data/file.v → libarchive/doctree/collection/data/file.v
View File

0
lib/data/doctree/collection/data/page.v → libarchive/doctree/collection/data/page.v
View File

0
lib/data/doctree/collection/data/process_aliases.v → libarchive/doctree/collection/data/process_aliases.v
View File

0
lib/data/doctree/collection/data/process_aliases_test.v → libarchive/doctree/collection/data/process_aliases_test.v
View File

0
lib/data/doctree/collection/data/process_def_pointers.v → libarchive/doctree/collection/data/process_def_pointers.v
View File

0
lib/data/doctree/collection/data/process_def_pointers_test.v → libarchive/doctree/collection/data/process_def_pointers_test.v
View File

0
lib/data/doctree/collection/data/process_link.v → libarchive/doctree/collection/data/process_link.v
View File

0
lib/data/doctree/collection/data/process_link_test.v → libarchive/doctree/collection/data/process_link_test.v
View File

0
lib/data/doctree/collection/data/process_macros.v → libarchive/doctree/collection/data/process_macros.v
View File

0
lib/data/doctree/collection/error.v → libarchive/doctree/collection/error.v
View File

0
lib/data/doctree/collection/export.v → libarchive/doctree/collection/export.v
View File

0
lib/data/doctree/collection/export_test.v → libarchive/doctree/collection/export_test.v
View File

0
lib/data/doctree/collection/getters.v → libarchive/doctree/collection/getters.v
View File

0
lib/data/doctree/collection/scan.v → libarchive/doctree/collection/scan.v
View File

0
lib/data/doctree/collection/scan_test.v → libarchive/doctree/collection/scan_test.v
View File

0
lib/data/doctree/collection/template/errors.md → libarchive/doctree/collection/template/errors.md
View File

0
lib/data/doctree/collection/testdata/.gitignore → libarchive/doctree/collection/testdata/.gitignore vendored
View File

0
lib/data/doctree/collection/testdata/export_test/export_expected/src/col1/.collection → libarchive/doctree/collection/testdata/export_test/export_expected/src/col1/.collection vendored
View File

0
lib/data/doctree/collection/testdata/export_test/export_expected/src/col1/.linkedpages → libarchive/doctree/collection/testdata/export_test/export_expected/src/col1/.linkedpages vendored
View File

0
lib/data/doctree/collection/testdata/export_test/export_expected/src/col1/errors.md → libarchive/doctree/collection/testdata/export_test/export_expected/src/col1/errors.md vendored
View File

0
lib/data/doctree/collection/testdata/export_test/export_expected/src/col1/file1.md → libarchive/doctree/collection/testdata/export_test/export_expected/src/col1/file1.md vendored
View File

0
lib/data/doctree/collection/testdata/export_test/export_expected/src/col1/file2.md → libarchive/doctree/collection/testdata/export_test/export_expected/src/col1/file2.md vendored
View File

0
lib/data/doctree/collection/testdata/export_test/export_expected/src/col1/img/image.png → libarchive/doctree/collection/testdata/export_test/export_expected/src/col1/img/image.png vendored
View File

0
lib/data/doctree/collection/testdata/export_test/mytree/dir1/.collection → libarchive/doctree/collection/testdata/export_test/mytree/dir1/.collection vendored
View File

0
lib/data/doctree/collection/testdata/export_test/mytree/dir1/dir2/file1.md → libarchive/doctree/collection/testdata/export_test/mytree/dir1/dir2/file1.md vendored
View File

0
lib/data/doctree/collection/testdata/export_test/mytree/dir1/file2.md → libarchive/doctree/collection/testdata/export_test/mytree/dir1/file2.md vendored
View File

0
lib/data/doctree/collection/testdata/export_test/mytree/dir1/image.png → libarchive/doctree/collection/testdata/export_test/mytree/dir1/image.png vendored
View File

0
lib/data/doctree/error.v → libarchive/doctree/error.v
View File

0
lib/data/doctree/export.v → libarchive/doctree/export.v
View File

0
lib/data/doctree/export_test.v → libarchive/doctree/export_test.v
View File

0
lib/data/doctree/getters.v → libarchive/doctree/getters.v
View File

0
lib/data/doctree/getters_test.v → libarchive/doctree/getters_test.v
View File

0
lib/data/doctree/list.v → libarchive/doctree/list.v
View File

0
lib/data/doctree/play.v → libarchive/doctree/play.v
View File

0
lib/data/doctree/pointer/pointer.v → libarchive/doctree/pointer/pointer.v
View File

0
lib/data/doctree/pointer/pointer_test.v → libarchive/doctree/pointer/pointer_test.v
View File

0
lib/data/doctree/process_defs.v → libarchive/doctree/process_defs.v
View File

0
lib/data/doctree/process_defs_test.v → libarchive/doctree/process_defs_test.v
View File

0
lib/data/doctree/process_includes.v → libarchive/doctree/process_includes.v
View File

0
lib/data/doctree/process_includes_test.v → libarchive/doctree/process_includes_test.v
View File

0
lib/data/doctree/process_macros.v → libarchive/doctree/process_macros.v
View File

0
lib/data/doctree/scan.v → libarchive/doctree/scan.v
View File

0
lib/data/doctree/testdata/.gitignore → libarchive/doctree/testdata/.gitignore vendored
View File

0
lib/data/doctree/testdata/actions/.collection → libarchive/doctree/testdata/actions/.collection vendored
View File

0
lib/data/doctree/testdata/actions/actions1.md → libarchive/doctree/testdata/actions/actions1.md vendored
View File

0
lib/data/doctree/testdata/actions/functionality/actions2.md → libarchive/doctree/testdata/actions/functionality/actions2.md vendored
View File

0
lib/data/doctree/testdata/export_test/export_expected/col1/.collection → libarchive/doctree/testdata/export_test/export_expected/col1/.collection vendored
View File

0
lib/data/doctree/testdata/export_test/export_expected/col1/.linkedpages → libarchive/doctree/testdata/export_test/export_expected/col1/.linkedpages vendored
View File

0
lib/data/doctree/testdata/export_test/export_expected/col1/errors.md → libarchive/doctree/testdata/export_test/export_expected/col1/errors.md vendored
View File

0
lib/data/doctree/testdata/export_test/export_expected/col1/file1.md → libarchive/doctree/testdata/export_test/export_expected/col1/file1.md vendored
View File

0
lib/data/doctree/testdata/export_test/export_expected/col1/file2.md → libarchive/doctree/testdata/export_test/export_expected/col1/file2.md vendored
View File

0
lib/data/doctree/testdata/export_test/export_expected/col1/img/image.png → libarchive/doctree/testdata/export_test/export_expected/col1/img/image.png vendored
View File

0
lib/data/doctree/testdata/export_test/export_expected/col2/.collection → libarchive/doctree/testdata/export_test/export_expected/col2/.collection vendored
View File

0
lib/data/doctree/testdata/export_test/export_expected/col2/.linkedpages → libarchive/doctree/testdata/export_test/export_expected/col2/.linkedpages vendored
View File

0
lib/data/doctree/testdata/export_test/export_expected/col2/file3.md → libarchive/doctree/testdata/export_test/export_expected/col2/file3.md vendored
View File

Some files were not shown because too many files have changed in this diff Show More