31d6660d56
* feat: add script module mode with folder model for Bun and Python Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix: add missing modules field to RawCode in bun_executor Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * sqlx * feat: enrich WAC templates with checkpoint and replay semantics Add prominent comments explaining that all computation must happen inside task/step/taskScript or it will be replayed on resume/retry. Clarify that waitForApproval does not hold a worker and that approve/reject URLs are available in the timeline step details. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(cli): script module sync idempotency, per-module hash tracking, and preview support - Fix pull→push idempotency: use `??` instead of `||` for module lock field so empty strings are preserved (matches API's `lock: ""`) - Add per-module hash tracking in wmill-lock.yaml following the flow inline script pattern (SCRIPT_TOP_HASH + per-module subpath hashes) - Selective module lock regeneration: only regenerate locks for modules whose content actually changed, not all modules - Use unfiltered rawWorkspaceDependencies for module hashes to match what updateModuleLocks passes to fetchScriptLock - Show changed module names in stale script output for clarity - Add module support to `script preview` command: read modules from __mod/ folder and pass them in the preview API request - Add preview tests for taskScript pattern (flat and folder layout) - Update test assertion for module stale detection output Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat(frontend): WAC UI improvements — reorder templates, module tab rename, import consolidation - Reorder WAC template buttons: TypeScript before Python in ScriptBuilder, CreateActionsScript, and CreateActionsFlow - Remove dropdown items from +Script button (simplify to direct link) - Move "Import Workflow-as-Code" to +Flow dropdown with dedicated drawer - Add module tab rename: pencil icon on hover opens popover with validation, fixed-width icon container prevents layout shift Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat: remaining module-mode changes from working branch - Backend parser updates for WAC detection - CLI sync/types updates for raw app path and module support - Frontend UI polish (Dev.svelte, ScriptRow, script hash page) - Test fixture updates Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * test(cli): add test for module modification detection in generate-metadata Verifies that modifying a single module file re-triggers stale detection and only the changed module is listed, not all modules. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(backend): critical fixes from PR review - Fix hardcoded dev path in bun_executor.rs WAC v2 wrapper — use "windmill-client" import instead of absolute filesystem path - Fix missed no_main_func → auto_kind rename in parser TS test - Add modules column to clone_script SQL (windmill-common and windmill-api-workspaces) so cloned scripts retain their modules - Add modules: None to RawCode structs in worker tests - Restore complete sqlx cache (merge main's cache + our new queries) Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(backend): fix clone warning treated as error in CI Change `.clone()` on double reference to `*k` dereference in scripts.rs hash implementation. Update sqlx cache with new query hashes from modified clone_script SQL. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(frontend): use published parser wasm versions for CI build The local file:// paths for windmill-parser-wasm-py and windmill-parser-wasm-ts don't exist in the Cloudflare Pages build environment. Revert to published npm versions (1.655.0). Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(frontend): update parser wasm packages to 1.657.2 Use newly published windmill-parser-wasm-ts and windmill-parser-wasm-py v1.657.2 which include auto_kind/WAC detection changes. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(frontend): regenerate package-lock.json for npm ci compatibility Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(frontend): use main's lockfile as base, update only parser wasm packages Regenerating package-lock.json from scratch pulled different dependency versions causing svelte-check type errors. Instead, start from main's lockfile and only update the two changed packages. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(backend): add modules column to fetch_script_for_update query The Script<SR> struct has a modules field (FromRow), but fetch_script_for_update didn't SELECT modules, causing a runtime error "no column found for name: modules" when the worker processed dependency jobs. This was the root cause of the relock_skip test timeout. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(backend): fix script module execution for Python and Bun - Fix modules not passed through job queue: inject _MODULES into PushArgs.extra when pushing Code jobs so worker can extract them - Fix Python module imports: use relative imports (from .helper) and add sys.path.insert for module directory in wrapper - Fix Python tests: use relative imports and empty lock to prevent pip from resolving module names as packages - Add local file check in Bun loader for module resolution - Ignore Bun module test (bundle mode loader integration tracked separately) - Add missing modules column to fetch_script_for_update query Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(backend): remove unnecessary empty lock in Python module tests Relative imports (from .helper) are not parsed as pip packages, so the empty lock workaround is not needed. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(backend): fix module execution for Python and Bun — all tests pass Python modules: - Use relative imports (from .helper import greet) since scripts run as packages - Add sys.path.insert for module directory in wrapper to ensure local modules take precedence over pip packages with same name Bun modules: - Use bundled output (./out/main.js) as wrapper import when modules are present — the bundled output has module content inlined by Bun.build, avoiding runtime loader resolution issues - Add local file check in loader.bun.js onResolve to short-circuit API URL resolution for module files on disk Job queue: - Inject _MODULES into PushArgs.extra when pushing Code jobs so the worker can extract them at execution time Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * refactor: address PR review — simplify, fix correctness, remove dead code Critical fixes: - Replace all CLI `no_main_func` references with `auto_kind` (string) to match the backend migration and API changes - Remove duplicated `compute_python_module_dir` in worker.rs, use the canonical version from python_executor.rs High priority: - Auto-create `__init__.py` in intermediate directories for nested Python modules so imports like `from .utils.math import add` work without users manually creating __init__.py files - Remove redundant `sys_path_insert` — relative imports use Python's package system, not sys.path Medium: - Fix lock file base name extraction: use regex to strip only the final extension (`.replace(/\.[^.]+$/, '')`) instead of `indexOf(".")` which breaks for files like `helper.test.ts` Simplification: - Remove dead `{#if false}` Popover block in ScriptEditor.svelte - Guard loader.bun.js local file check to only run for relative paths (matching the Windows loader pattern) - Add clarifying comment on Bun dual mechanism (build + run phases) - Add maintenance comment on manual Hash impl for NewScript Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: final review fixes — stale cleanup, baseName, auto_kind export - Fix sync.ts baseName extraction using indexOf(".") → regex (same fix as script.ts/metadata.ts, missed this instance) - Add stale module file cleanup in writeModulesToDisk: removes files from __mod/ that are no longer in the modules map before writing, fixing the pull→push cycle that couldn't delete modules - Log warning when _MODULES serialization fails in job push instead of silently dropping modules - Use strict equality (===) for auto_kind comparison - Exclude auto_kind from workspace export — it is auto-detected by the parser at deploy time from script content Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(cli): remove auto_kind from push, comparison, and metadata auto_kind is auto-detected by the parser at deploy time, so the CLI should not send it, compare it, or write it to script.yaml. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: remove erroneously added backend/backend/.sqlx directory Duplicate .sqlx cache was committed at the wrong nested path. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: address PR review feedback + fix CI dead_code warning Frontend (ScriptEditor.svelte): - Fix switchToMain() missing lastSyncedCode update — prevents stale code sync on external changes while editing a module tab - Fix formatAction saving module code to main script's localStorage draft — now saves main code when on a module tab - Fix non-null assertion on inferModuleLang in renameModule — fall back to original language instead of force unwrap - Remove redundant activeModuleTab truthy check in runTest CLI (script.ts): - Clean up empty directories after removing stale module files in writeModulesToDisk Backend: - Add path traversal guard in write_module_files — reject module paths containing ".." - Fix dead_code warning on auto_kind field in workspace export struct Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat(frontend): improve auto_kind UX + address review findings - Rename "Include without main function" toggle to "Include library scripts" in script list (ItemsList.svelte) - Update NoMainFuncBadge: "No main" → "Library" with clearer tooltip - Filter module file extensions by main script language — Python scripts only allow .py modules, TypeScript only .ts, etc. - Split flushModuleState into flushModuleContent (no UI side-effect) and flushModuleState (flush + reset tab), reducing duplication - Dynamic placeholder and hint text in add module popover based on main script language Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
691 lines
21 KiB
Rust
691 lines
21 KiB
Rust
#[cfg(test)]
|
|
mod test {
|
|
use serde_json::json;
|
|
use windmill_parser::{Arg, MainArgSignature, ObjectType, Typ};
|
|
use windmill_parser_nu::parse_nu_signature;
|
|
|
|
#[test]
|
|
fn test_nu_no_main_sig() {
|
|
assert!(parse_nu_signature("").is_err());
|
|
}
|
|
#[test]
|
|
fn test_nu_any_sig() {
|
|
let sig = parse_nu_signature(
|
|
r#"
|
|
def main [ a, b , c, d] {}
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
MainArgSignature {
|
|
star_args: false,
|
|
star_kwargs: false,
|
|
args: vec![
|
|
Arg {
|
|
name: "a".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "b".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "c".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "d".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
}
|
|
],
|
|
auto_kind: None,
|
|
has_preprocessor: None,
|
|
},
|
|
sig
|
|
);
|
|
}
|
|
#[test]
|
|
fn test_nu_optional_sig() {
|
|
let sig = parse_nu_signature(
|
|
r#"
|
|
def main [foo?] {}
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
MainArgSignature {
|
|
star_args: false,
|
|
star_kwargs: false,
|
|
args: vec![Arg {
|
|
name: "foo".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: Some(serde_json::Value::Null),
|
|
has_default: true,
|
|
oidx: None
|
|
},],
|
|
auto_kind: None,
|
|
has_preprocessor: None,
|
|
},
|
|
sig
|
|
);
|
|
}
|
|
#[test]
|
|
fn test_nu_simple_typed_sig() {
|
|
let sig = parse_nu_signature(
|
|
r#"
|
|
def main [ foo: string, bar: int] {}
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
MainArgSignature {
|
|
star_args: false,
|
|
star_kwargs: false,
|
|
args: vec![
|
|
Arg {
|
|
name: "foo".into(),
|
|
otyp: None,
|
|
typ: Typ::Str(None),
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "bar".into(),
|
|
otyp: None,
|
|
typ: Typ::Int,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
],
|
|
auto_kind: None,
|
|
has_preprocessor: None,
|
|
},
|
|
sig
|
|
);
|
|
}
|
|
#[test]
|
|
fn test_nu_complete_typed_sig() {
|
|
let sig = parse_nu_signature(
|
|
r#"
|
|
def main [
|
|
a1: any,
|
|
a2: bool,
|
|
a3: int,
|
|
a4: float,
|
|
a5: datetime,
|
|
a6: string,
|
|
a7: record,
|
|
a8: list,
|
|
a9: table,
|
|
a10: nothing,
|
|
] {}
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
MainArgSignature {
|
|
star_args: false,
|
|
star_kwargs: false,
|
|
args: vec![
|
|
Arg {
|
|
name: "a1".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "a2".into(),
|
|
otyp: None,
|
|
typ: Typ::Bool,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "a3".into(),
|
|
otyp: None,
|
|
typ: Typ::Int,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "a4".into(),
|
|
otyp: None,
|
|
typ: Typ::Float,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "a5".into(),
|
|
otyp: None,
|
|
typ: Typ::Datetime,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "a6".into(),
|
|
otyp: None,
|
|
typ: Typ::Str(None),
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "a7".into(),
|
|
otyp: None,
|
|
typ: Typ::Object(ObjectType::new(None, Some(vec![]))),
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "a8".into(),
|
|
otyp: None,
|
|
typ: Typ::List(Box::new(Typ::Unknown)),
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "a9".into(),
|
|
otyp: None,
|
|
typ: Typ::List(Box::new(Typ::Object(ObjectType::new(None, Some(vec![]))))),
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "a10".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
],
|
|
auto_kind: None,
|
|
has_preprocessor: None,
|
|
},
|
|
sig
|
|
);
|
|
}
|
|
#[test]
|
|
fn test_nu_default_sig() {
|
|
let sig = parse_nu_signature(
|
|
r#"
|
|
def main [ foo = "Foo", bar: string = "Bar", bazz = 3 ] {}
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
|
|
println!("{}", serde_json::to_string_pretty(&sig).unwrap());
|
|
|
|
assert_eq!(
|
|
MainArgSignature {
|
|
star_args: false,
|
|
star_kwargs: false,
|
|
args: vec![
|
|
Arg {
|
|
name: "foo".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: Some(json!("Foo")),
|
|
has_default: true,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "bar".into(),
|
|
otyp: None,
|
|
typ: Typ::Str(None),
|
|
default: Some(json!("Bar")),
|
|
has_default: true,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "bazz".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: Some(json!(3)),
|
|
has_default: true,
|
|
oidx: None
|
|
},
|
|
],
|
|
auto_kind: None,
|
|
has_preprocessor: None,
|
|
},
|
|
sig
|
|
);
|
|
}
|
|
#[test]
|
|
fn test_nu_preprocessor_sig() {}
|
|
|
|
#[test]
|
|
fn test_nu_flags_sig() {
|
|
assert!(parse_nu_signature(
|
|
r#"
|
|
def main [--flag] {}
|
|
"#,
|
|
)
|
|
.is_err());
|
|
}
|
|
#[test]
|
|
fn test_nu_rest_sig() {
|
|
assert!(parse_nu_signature(
|
|
r#"
|
|
def main [...foo: string] {}
|
|
"#,
|
|
)
|
|
.is_err())
|
|
}
|
|
|
|
// #[test]
|
|
// fn test_nu_dynamically_sized_sig() {
|
|
// parse_nu_signature(
|
|
// r#"
|
|
// def main [] {
|
|
|
|
// }
|
|
// "#,
|
|
// );
|
|
// }
|
|
// #[test]
|
|
// fn test_nu_record_sig() {
|
|
// let sig = parse_nu_signature(
|
|
// r#"
|
|
// def main [ foo: record<a: string, b, c: number, d> ] { }
|
|
// "#,
|
|
// )
|
|
// .unwrap();
|
|
|
|
// assert_eq!(
|
|
// MainArgSignature {
|
|
// star_args: false,
|
|
// star_kwargs: false,
|
|
// args: vec![Arg {
|
|
// name: "foo".into(),
|
|
// otyp: None,
|
|
// typ: Typ::Object(vec![
|
|
// ObjectProperty { key: "a".into(), typ: Box::new(Typ::Str(None)) },
|
|
// ObjectProperty { key: "b".into(), typ: Box::new(Typ::Unknown) },
|
|
// ObjectProperty { key: "c".into(), typ: Box::new(Typ::Float) },
|
|
// ObjectProperty { key: "d".into(), typ: Box::new(Typ::Unknown) },
|
|
// ]),
|
|
// default: None,
|
|
// has_default: false,
|
|
// oidx: None
|
|
// },],
|
|
// auto_kind: None,
|
|
// has_preprocessor: None,
|
|
// },
|
|
// sig
|
|
// );
|
|
// }
|
|
|
|
#[test]
|
|
fn test_nu_list_sig() {
|
|
let sig = parse_nu_signature(
|
|
r#"
|
|
def main [ foo: list<number> ] { }
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
|
|
println!("{}", serde_json::to_string_pretty(&sig).unwrap());
|
|
|
|
assert_eq!(
|
|
MainArgSignature {
|
|
star_args: false,
|
|
star_kwargs: false,
|
|
args: vec![Arg {
|
|
name: "foo".into(),
|
|
otyp: None,
|
|
typ: Typ::List(Box::new(Typ::Float)),
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},],
|
|
auto_kind: None,
|
|
has_preprocessor: None,
|
|
},
|
|
sig
|
|
);
|
|
}
|
|
#[test]
|
|
fn test_nu_list_full_sig() {
|
|
let sig = parse_nu_signature(
|
|
r#"
|
|
def main [ a, foo: list<number> = [ 2, 3, 4 ], b ] { }
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
|
|
println!("{}", serde_json::to_string_pretty(&sig).unwrap());
|
|
|
|
assert_eq!(
|
|
MainArgSignature {
|
|
star_args: false,
|
|
star_kwargs: false,
|
|
args: vec![
|
|
Arg {
|
|
name: "a".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "foo".into(),
|
|
otyp: None,
|
|
typ: Typ::List(Box::new(Typ::Float)),
|
|
default: Some(json!([2, 3, 4])),
|
|
has_default: true,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "b".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
],
|
|
auto_kind: None,
|
|
has_preprocessor: None,
|
|
},
|
|
sig
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_nu_datetime_sig() {
|
|
let sig = parse_nu_signature(
|
|
r#"
|
|
def main [ foo: datetime ] { }
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
MainArgSignature {
|
|
star_args: false,
|
|
star_kwargs: false,
|
|
args: vec![Arg {
|
|
name: "foo".into(),
|
|
otyp: None,
|
|
typ: Typ::Datetime,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},],
|
|
auto_kind: None,
|
|
has_preprocessor: None,
|
|
},
|
|
sig
|
|
);
|
|
}
|
|
// TODO: Re-enable for V1
|
|
// #[test]
|
|
// fn test_nu_table_sig() {
|
|
// let sig = parse_nu_signature(
|
|
// r#"
|
|
// def main [ foo: table<a, b: number, c: string>] { }
|
|
// "#,
|
|
// )
|
|
// .unwrap();
|
|
|
|
// assert_eq!(
|
|
// MainArgSignature {
|
|
// star_args: false,
|
|
// star_kwargs: false,
|
|
// args: vec![Arg {
|
|
// name: "foo".into(),
|
|
// otyp: None,
|
|
// typ: Typ::List(Box::new(Typ::Object(vec![
|
|
// ObjectProperty { key: "a".into(), typ: Box::new(Typ::Unknown) },
|
|
// ObjectProperty { key: "b".into(), typ: Box::new(Typ::Float) },
|
|
// ObjectProperty { key: "c".into(), typ: Box::new(Typ::Str(None)) },
|
|
// ]))),
|
|
// default: None,
|
|
// has_default: false,
|
|
// oidx: None
|
|
// },],
|
|
// auto_kind: None,
|
|
// has_preprocessor: None,
|
|
// },
|
|
// sig
|
|
// );
|
|
// }
|
|
|
|
#[test]
|
|
fn test_nu_wrapup_sig() {
|
|
let sig = parse_nu_signature(
|
|
r#"
|
|
def main [a ,b :int,c? , d: string = "foo", bi?: any] {}
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
MainArgSignature {
|
|
star_args: false,
|
|
star_kwargs: false,
|
|
args: vec![
|
|
Arg {
|
|
name: "a".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "b".into(),
|
|
otyp: None,
|
|
typ: Typ::Int,
|
|
default: None,
|
|
has_default: false,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "c".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: Some(serde_json::Value::Null),
|
|
has_default: true,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "d".into(),
|
|
otyp: None,
|
|
typ: Typ::Str(None),
|
|
default: Some(json!("foo")),
|
|
has_default: true,
|
|
oidx: None
|
|
},
|
|
Arg {
|
|
name: "bi".into(),
|
|
otyp: None,
|
|
typ: Typ::Unknown,
|
|
default: Some(serde_json::Value::Null),
|
|
has_default: true,
|
|
oidx: None
|
|
}
|
|
],
|
|
auto_kind: None,
|
|
has_preprocessor: None,
|
|
},
|
|
sig
|
|
);
|
|
}
|
|
// #[test]
|
|
// fn test_nu_wrapup_nested_sig() {
|
|
// let sig = parse_nu_signature(
|
|
// r#"
|
|
// def main [
|
|
// baz: string,
|
|
// foo: record<a: string,
|
|
// b,
|
|
// c: list<number>,
|
|
// d: record<a1, b1, c1>>
|
|
// =
|
|
// {
|
|
// a: "a",
|
|
// b: 3,
|
|
// c: [ 2, 3, 4 ],
|
|
// d: {
|
|
// a: true,
|
|
// b: false,
|
|
// c: true
|
|
// }
|
|
// }
|
|
// ] { }
|
|
// "#,
|
|
// )
|
|
// .unwrap();
|
|
|
|
// println!("{}", serde_json::to_string_pretty(&sig).unwrap());
|
|
|
|
// assert_eq!(
|
|
// MainArgSignature {
|
|
// star_args: false,
|
|
// star_kwargs: false,
|
|
// args: vec![
|
|
// Arg {
|
|
// name: "baz".into(),
|
|
// otyp: None,
|
|
// typ: Typ::Str(None),
|
|
// default: None,
|
|
// has_default: false,
|
|
// oidx: None
|
|
// },
|
|
// Arg {
|
|
// name: "foo".into(),
|
|
// otyp: None,
|
|
// typ: Typ::Object(vec![
|
|
// ObjectProperty { key: "a".into(), typ: Box::new(Typ::Str(None)) },
|
|
// ObjectProperty { key: "b".into(), typ: Box::new(Typ::Unknown) },
|
|
// ObjectProperty {
|
|
// key: "c".into(),
|
|
// typ: Box::new(Typ::List(Box::new(Typ::Float)))
|
|
// },
|
|
// ObjectProperty {
|
|
// key: "d".into(),
|
|
// typ: Box::new(Typ::Object(vec![
|
|
// ObjectProperty {
|
|
// key: "a1".into(),
|
|
// typ: Box::new(Typ::Unknown)
|
|
// },
|
|
// ObjectProperty {
|
|
// key: "b1".into(),
|
|
// typ: Box::new(Typ::Unknown)
|
|
// },
|
|
// ObjectProperty {
|
|
// key: "c1".into(),
|
|
// typ: Box::new(Typ::Unknown)
|
|
// }
|
|
// ]))
|
|
// },
|
|
// ]),
|
|
// default: Some(json!({
|
|
// "a": "a",
|
|
// "b": 3,
|
|
// "c": [
|
|
// 2,
|
|
// 3,
|
|
// 4
|
|
// ],
|
|
// "d": {
|
|
// "a": true,
|
|
// "b": false,
|
|
// "c": true
|
|
// }
|
|
// })),
|
|
// has_default: true,
|
|
// oidx: None
|
|
// },
|
|
// ],
|
|
// auto_kind: None,
|
|
// has_preprocessor: None,
|
|
// },
|
|
// sig
|
|
// );
|
|
// }
|
|
#[test]
|
|
fn test_nu_nested_extra_types() {
|
|
assert_eq!(
|
|
parse_nu_signature(
|
|
r#"
|
|
def main [a: list<int>] {}
|
|
"#,
|
|
)
|
|
.is_err(),
|
|
true
|
|
);
|
|
assert_eq!(
|
|
parse_nu_signature(
|
|
r#"
|
|
def main [a: list<float>] {}
|
|
"#,
|
|
)
|
|
.is_err(),
|
|
true
|
|
);
|
|
assert_eq!(
|
|
parse_nu_signature(
|
|
r#"
|
|
def main [a: list<datetime>] {}
|
|
"#,
|
|
)
|
|
.is_err(),
|
|
true
|
|
);
|
|
assert_eq!(
|
|
parse_nu_signature(
|
|
r#"
|
|
def main [a: list<binary>] {}
|
|
"#,
|
|
)
|
|
.is_err(),
|
|
true
|
|
);
|
|
assert_eq!(
|
|
parse_nu_signature(
|
|
r#"
|
|
def main [a: list<list<int>>] {}
|
|
"#,
|
|
)
|
|
.is_err(),
|
|
true
|
|
);
|
|
}
|
|
}
|