a7dab091503d997490434372c8fc3eabd9c8eb09
22
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Brad Arant
|
a7dab09150 |
Add DEFINED TAGS listing to <dump> output
Custom <tag name=...> definitions have no scope levels the way variables do - __tag.cpp always registers into the single global.tags map regardless of where in the script the definition sits, so this is one flat list, not broken out by global/local/parent like the existing variable/keyword sections. Verified end-to-end via a real jet-2.0 run: two tags defined before <dump> both appear correctly in the DEFINED TAGS section. |
||
|
Brad Arant
|
76ea89e79c |
Add <try>/<catch> tag, fix a real infinite-loop bug it exposed in Tag's
split-container mechanism
<try>...container...<catch>...container2...</catch-less, matching <else>'s
own convention> intercepts any error that would otherwise propagate up and
halt the whole script - a coreutils::Exception (what every other tag
actually throws), any other std::exception (e.g. the
std::filesystem::filesystem_error <whiledir> can raise), or anything else.
Optional name=/scope= keywords bind the caught error's message to a
variable for the catch block to reference, matching <for>'s own
name=/scope= convention. New class named __trytag rather than __try: <ios>
transitively defines a preprocessor macro "#define __try try" (an SEH-
compatibility shim pulled in on this toolchain) that silently rewrites the
identifier __try to the keyword try wherever it appears, breaking
compilation - confirmed via `g++ -E -dM` before picking this name. The JET
tag name itself is still plain <try>.
Reuses the same container/container2 split mechanism <if>/<else> already
has (Tag's constructor takes an optional splitTagName), which surfaced a
real, previously-latent bug: the code that consumes the split tag's own
opening delimiter after a match was hardcoded to the literal string
"<else>" instead of being built from splitTagName. This happened to work
for every existing split-tag user (<if>, <while>, <until> all use "else"),
but for <try>'s "catch" the hardcoded ifNext("<else>") never matched, so
the cursor never advanced past <catch> and the outer scan loop matched the
same unconsumed <catch> forever - a genuine infinite loop, not just wrong
output, confirmed via a real hung jet-2.0 run before diagnosis. Fixed by
building the actual expected delimiter ("<" + splitTagName + ">")
dynamically instead.
Verified via real jet-2.0 script execution (not just compilation): a
caught <read> failure correctly binds its error text to a name= variable
and skips straight to the catch block, discarding whatever partial output
the failed attempt had already written; an untriggered <try> runs its own
content normally and skips <catch> entirely; a <try> with no <catch> at
all silently swallows the error and the script continues past it. Also
regression-tested <if>/<else> and <while> (both depend on the exact same
fixed code path) to confirm nothing broke for the existing "else" case.
|
||
|
Brad Arant
|
bc3c50f045 |
Convert davidarant.page - deliberately errors at runtime, matching the DB pages
Its source uses <whiledir dir=... name=...>, but the tags real keyword is path= (confirmed in __whiledir.cpp) - dir/name are not recognized, so this throws whiledir tag must specify a path. at runtime, same as barant.com own mismatched source would. Converted through the normal pipeline rather than omitted, same treatment as vst/modular1/modular1_patches: verified it fails with a clean HTTP 500 via APIServers existing exception-catching path, and the server stays alive and responsive throughout. |
||
|
Brad Arant
|
942d2641ab |
Wire up live <mysql> for vst/modular1/modular1_patches, without <database>
<database> was SESSIONCTL.tag's own JET-1.4-only concept - the new JetCore port never implemented it. The real, dispatched tag for opening a MySQL connection is <mysql> (confirmed in Tag.cpp's dispatch chain), so these 3 product pages - the ones deferred in the previous conversion pass because they pull live rows via <sql> - now wrap their content in a real <mysql host="localhost" database="barant" user="barant" password="..."> matching barant.com's own config.cfg, with <retain> (a SESSIONCTL-only form-echo helper with no analog here) stripped. host="localhost" is correct per config.cfg but only reachable from barant.com itself - a locally-run .jtc genuinely cannot connect from here. That's intentional: the connection fails at runtime exactly as if the database were down, and APIServer's existing catch(coreutils::Exception) path (ApiSession.cpp) already turns that into a clean 500 rather than a crash - verified live: all 3 pages return HTTP 500 with mysql's own "database and host parameters are not valid." message, and the server process stays up and responsive throughout. The real DB password is deliberately not a literal in this file - it's read from BARANT_DB_PASSWORD at conversion time, and the resulting .jet output for these 3 pages is gitignored rather than committed, so the credential never enters git history even though it does end up baked into the locally-generated, locally-deployed .jtc. |
||
|
Brad Arant
|
fde94acad6 |
Convert barant.com JET 1.4 marketing pages to jetc/.jtc (local, non-production)
Pulls .page files and shared template infrastructure (mainpagetemplate.temp, menu.bar, barant.tag, opensource.menu, cart.menu, login.menu) read-only from barant.com via SFTP into jetc/barant-site/src, then convert.py mechanically flattens them into self-contained .jet files: linkbutton becomes a plain anchor link (the old SESSIONCTL PAGE/PROCESS form-postback model has no equivalent here - each page is its own real #api route now, not a shared single-form state machine), sectionframe is expanded per its barant.tag definition, /images/* references are fetched and inlined as data URIs (APIServer has no static-file serving), and session-gated chrome (cart, account/admin, login.menu) is resolved to its anonymous-visitor default state, since no session/DB backend is wired into this conversion. 17 pages convert and serve cleanly end-to-end (verified via a local apiserver-barant-site.json instance on :8081, kept separate from the existing demo server on :8080 to avoid a /main route collision with the earlier hand-cloned barant.jet). Two pages deliberately out of scope for this pass: davidarant.page (whiledir filesystem iteration) and the per-topic sub-pages of jet.page (dispatches on an ARGS query param this conversion does not populate - only the default overview state converts). vst.page/modular1.page/modular1_patches.page also deferred - they pull live product rows via sql, a real backend dependency beyond "pages and their template" scope. Nothing was written back to barant.com - SFTP access was read-only throughout, per explicit instruction to convert locally without touching the original site. |
||
|
Brad Arant
|
b143b821de | Change barant.jet route from /barant to /main | ||
|
Brad Arant
|
80a939d1ef |
Inline barant.com images and fonts into barant.jet as data URIs
The two <img> tags used relative /images/... paths, which 404 through APIServer (no static-file serving) exactly like the stylesheets did. The three @font-face src urls were absolute https://barant.com/fonts/... references - technically reachable, but barant.com does not send an Access-Control-Allow-Origin header for them, so browsers block loading them cross-origin from a different serving host. Fetched all five and embedded as base64 data: URIs so the served page is fully self-contained. |
||
|
Brad Arant
|
7b4a25f305 |
Inline barant.com stylesheets into barant.jet head
APIServer has no static-file serving, only #api-declared routes, so the original relative /css/main.css and /css/control.css <link> tags 404d. Fetched both stylesheets from barant.com and embedded them directly in a <style> block instead. |
||
|
Brad ArantandClaude Sonnet 5
|
b1c275182a |
jetc: add barant.jet, a real-world DOM-equal reproduction of barant.com
Fetched the live raw HTML from https://barant.com/ (rendered by the user's own separate JET-1.4 C interpreter, unrelated to this JetCore/ jetc project - see the barant.com project memory) and embedded it as literal content in a jetc template (#api GET /barant), as a real-world stress test of the --shared compiler against markup nobody wrote with jetc in mind. Needed several fixes to compile, all discovered by reading jetc's own JetParser.cpp rather than guessing, and each one either genuinely DOM-neutral or an actual bug fix in barant.com's own markup: - Void elements (<meta>/<link>/<input>/<img>/<br>) had to be self-closed. jetc's parser treats any unrecognized <tag ...> as a generic custom tag needing a matching </tag> (mirroring the interpreter's own extensible custom-tag model) - it has no built-in notion of HTML's void-element list. Self-closing is standard HTML5 syntax with zero effect on the parsed DOM either way. - <!DOCTYPE html> and HTML comments (<!--...-->) aren't understood at all - confirmed via a minimal repro that even a bare <!-- comment --> breaks tag tokenization (the "<!" prefix isn't special-cased). Routed the doctype through a <set name="x" value="<!DOCTYPE html>"/> + $[x] pair instead - a <set> attribute value is a plain quoted string, never re-parsed as nested markup, verified via host_test to render byte-identical to the literal text. The one HTML comment (a Google Analytics label) was just removed outright - comments have no rendered/DOM effect, so this is neither a workaround nor a meaningful change, and the actual <script> tags it was labeling are untouched and verified still present. - A genuine real bug in barant.com's own live markup: `<table class="menubar" cellspacing="0" cellpadding="0" width: 100%">` (line 28) - a stray unpaired `"` with no matching partner (missing `=` and opening quote before `100%`). jetc's attribute scanner toggles into "inside a quoted value" mode on any `"` and treats everything (including the real closing `>`) as opaque until the next `"` - a single unpaired quote anywhere derails tokenization for the rest of the file, which is exactly what "unterminated tag near end of input" turned out to mean here. Browsers silently tolerate this malformed attribute (hence it looking fine live); jetc's simpler tokenizer doesn't. Fixed to width="100%", the obvious intent. - Two stray trailing </if></if> lines (a leftover artifact from barant.com's own JET-1.4 template engine, unrelated to anything here) were dropped - dead, invisible in any browser, and incompatible with jetc's tag-matching (no corresponding <if> anywhere). Verified: diffed the actual rendered output (via host_test) against the original fetched HTML - every difference maps exactly to one of the changes above, nothing else moved. Deployed live into the running APIServer test instance (GET /barant) and confirmed Content-Length matches the diffed render exactly (13944 bytes). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> |
||
|
Brad ArantandClaude Sonnet 5
|
9bbb95cc57 |
jetc: rename --shared build output convention from .so to .jtc
Purely a naming-convention change per user request, not a format
change - the output is still a real ELF shared object (-shared -fPIC),
still dlopen()-able exactly as before. .jtc ("jet compiled") marks it as
an APIServer-loadable content module rather than a generic library.
build-shared.sh: usage text and STEM derivation
(basename "$OUTPUT" .so -> .jtc) both updated - the STEM change is the
one functional piece here, everything else in this commit is comments/
usage strings. Doc comments in jetc.cpp/JetCodegen.h/host_test.cpp/
api_test.cpp updated to match.
Verified live: rebuilt jetc and all five demo*.jtc modules, reran
api_test/host_test against demo3.jtc (still resolves jetc_api_demo3/
jetc_render_demo3 and renders correctly) - the extension is purely
cosmetic to dlopen(), as expected.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
|
||
|
Brad ArantandClaude Sonnet 5
|
3f273b0a95 |
jetc: add demo4-7.jet as worked #api examples (Stage 4 verification)
Used to live-verify APIServer end to end - one small template per
distinct code path, matching demo.jet/demo2.jet's existing role as
worked examples rather than throwaway scratch files:
- demo4.jet: "#api GET /users/{id}" + $[id] - path param capture.
- demo5.jet: "#api POST /echo" + $[:message] - urlencoded form body via
CGIFormData, reached through the same $[:name] CGI convention the
interpreter already uses.
- demo6.jet: "#api GET /crash" + $[:message] with no body present -
deliberately throws (Tag::getVariable's cgiData-is-null error),
verifying a render-time exception turns into a clean response instead
of taking the server down.
- demo7.jet: "#api GET /search" + $[q] - query string parsing.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
|
||
|
Brad ArantandClaude Sonnet 5
|
634eb7a9a9 |
jetc: add #api directive + jetc_api_<name> route metadata export
Stage 1 of the APIServer plan: a compiled --shared .so currently exports
only a bare jetc_render_<name>(Global&, MString&) with no way for a host
to discover what HTTP method+path it wants to serve. Adds a leading
"#api METHOD /path" directive (one or more, parsed the same way jetc
already strips a leading "#!" shebang line - not modeled as a new
AST/tag-attribute concept, since jetc's parser has no existing notion of
the enclosing <jet> tag's attributes to hang this off of).
In --shared mode, JetCodegen now also emits a second exported function
alongside the render entry point:
struct JetApiRoute { const char *method; const char *path; };
extern "C" const JetApiRoute *jetc_api_<name>(int *count) { ... }
<name> is derived the same way for both symbols (sanitizeIdent(
baseNameNoExt(inputPath))), so a future host loader can find both by
convention from just the .so's filename - no name needs to be embedded
in the metadata itself, and the routes a module declares can never drift
out of sync with the render function that implements them (the failure
mode a sidecar manifest file would have).
Malformed directives (missing method/path, path without a leading '/')
are a hard compile error; #api directives present without --shared print
a non-fatal warning (the metadata has nowhere to go without a host to
load a .so, but the render-only executable/CGI path still works fine).
Verified live, not just compiled: rebuilt jetc, compiled demo3.jet (a new
worked example with two #api lines sharing one handler) via
build-shared.sh into a real demo3.so, and added api_test.cpp (mirrors
host_test.cpp's dlopen()/dlsym() pattern) confirming jetc_api_demo3
returns the expected two routes at runtime. Re-ran host_test against the
same .so to confirm the render path is unaffected. Confirmed demo.jet/
demo2.jet (no #api lines) emit no JetApiRoute code at all - no regression
for templates that don't declare routes.
Also fixed a gitignore gap surfaced while committing this: an earlier
"jetc/*.cpp" ignore rule (meant for generated *.compiled.cpp output) was
a blanket pattern that silently hid this commit's own api_test.cpp from
git status. Narrowed to "jetc/*.compiled.cpp" (the actual generated-file
naming, per build-compiled.sh/build-shared.sh) and added explicit ignores
for the host_test/api_test/demo3 binaries plus two known stale generated
leftovers (demo.cpp/demo2.cpp) that predate this session.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
|
||
|
Brad ArantandClaude Sonnet 5
|
a32444acc2 |
Clean up TODO.txt/testjet.jet, gitignore jetc build byproducts
TODO.txt: drop the stale "Fix the variable retriever..." bug-list entry -
long since fixed. tests/testjet.jet: cgi="true" -> cgi="yes", matching the
deliberate "yes" convention already used elsewhere (__jet.cpp checks
resolveKeyword("cgi") == "yes", not "true"). tests/dump.txt: regenerated
output from re-running the test after the above.
.gitignore: jetc/ was accumulating untracked build output (compiled .cpp,
binaries, .pic.o, .so, libCoreUtils_pic.a) alongside its real tracked
source - ignore the generated artifacts, keep the two worked-example
.jet templates explicitly un-ignored since *.cpp/no-extension patterns
would otherwise also catch demo.jet/demo2.jet's own extension-less
compiled binaries without excluding the .jet sources themselves.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
|
||
|
Brad ArantandClaude Sonnet 5
|
6ac33601a0 |
Fix $[...] variable parsing to consume the entire bracket contents
renderVariableName() built the variable name by whitelisting an
identifier charset (letters/digits/._-) via getTokenInclude(), then
threw "invalid variable name." on the first character outside that set
- including a plain space. Real-world CGI form field names aren't
restricted to identifier characters (an HTML <input name="first name">
is completely valid), so $[:first name] failed outright instead of
looking up the field as sent.
Rewrote to exclude only the genuinely structural characters (']', ';',
and the start of a nested $[.../#[...substitution) via getTokenExclude,
so everything else between the brackets - spaces included - is consumed
as part of the name before any lookup happens, rather than stopping
early and erroring. This also let the separate ':' handling branch be
dropped entirely: since ':' is no longer excluded, it now flows through
the same sweep naturally (needed for both the CGI sigil name itself and
the "$[:name:2]" explicit-index suffix).
Verified live: $[:first name] against a real multipart CGI body with a
field literally named "first name" now resolves correctly (previously
threw before ever reaching the lookup). A stray, non-nested '$' or '#'
in a name is kept as literal text rather than erroring. Re-verified
existing sigils are unaffected - plain $[x], $[!x] (forced-global), and
tests/posttest.sh's ^session/:.name3 lookups all still resolve exactly
as before.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
|
||
|
Brad ArantandClaude Sonnet 5
|
aaed4cb4da |
Fix Operand treating a "false"-valued variable as boolean true
When resolving a bare $[var]/#[var] reference, Operand set .boolean = true whenever the value's text was EITHER "true" OR "false" - effectively "boolean = looks-boolean-ish" rather than reflecting which of the two it actually was. <if expr="..">/<while expr="..">check exactly this .boolean field (see __if.cpp/__while.cpp), so <if expr="$[flag]"> took the true branch even when flag held the literal text "false". Fixed to boolean = (string == "true"). Verified live: a variable set to value="false" now correctly takes an <if expr="$[var]">'s false branch, and value="true" still correctly takes the true branch. Re-ran tests/posttest.sh - unaffected, no regression. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> |
||
|
Brad ArantandClaude Sonnet 5
|
f33c041ae5 |
Fix posttest.sh: missing boundary= made CGIFormData silently parse zero fields
CONTENT_TYPE was "multipart/form-data" with no boundary= parameter - a
real browser/curl request always includes one. Without it,
__jet.cpp's contentType.find("boundary=") returns -1, so boundary stays
a default-constructed empty ZString. CGIFormData's opening-marker search
then becomes just "--" (boundary appended to it), which matches
trivially at the very start of the body text, so the parser immediately
reports Status::COMPLETE having consumed only those two bytes and parsed
zero fields - no error, no exception, just silently empty. Every
$[:name] lookup returned blank as a result, not just $[:name3] (verified
- all six of post.example.formdata's fields were affected identically).
Fixed CONTENT_TYPE to carry the real boundary value used in
post.example.formdata ("----WebKitFormBoundaryA1LWIjMAIsdFW9XA", matching
each part's "--" + boundary delimiter line), and corrected
CONTENT_LENGTH (619 -> 623, the fixture's real current byte count - it
had grown since 619 was set, from prior edits giving each form field a
distinct name instead of several duplicate "name" fields).
Also includes the already-in-progress edits to post.example.formdata
(distinct field names name/name2.../name6, replacing several duplicate
"name" entries), post.example.urlencoded (matching field names), and
testpost.jet (added a $[:name3] line) that were sitting uncommitted -
these are what surfaced the bug in the first place, not a new change
made alongside this fix.
Verified live: all six $[:name]..$[:name6] now resolve to their exact
raw multipart values (1 test / 2&test / 3+test / 4 test / 5 / 6 - no
CGI-decoding applied, correct for multipart bodies, unlike the
urlencoded-body path which does decode).
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
|
||
|
Brad ArantandClaude Sonnet 5
|
a94fc5e8fb |
jetc: add --shared mode to compile templates to a dlopen()-able .so
For the server you're about to build: `jetc --shared template.jet out.cpp`
now emits no main() at all - instead the render logic is exported as
`extern "C" void jetc_render_<template>(jet::Global &global,
coreutils::MString &out)`, one call per request, meant to be dlsym()'d
by a long-running host process instead of spawning a jet-2.0 process (or
even a separate compiled executable) per request. extern "C" here only
fixes the symbol's name mangling for a stable dlsym() target - the
parameter types are still real C++ classes, safe to pass across the
dlopen() boundary since the host and the .so share the same
CoreUtils/JetCore headers and toolchain (a same-ABI plugin boundary, not
a foreign C one). coreutils::Exception propagates out of the call
uncaught, so the host decides how to handle a render failure rather than
the module unilaterally deciding (the executable mode's try/catch prints
to stdout and exits, which is CGI-appropriate but wrong for a persistent
server). The exported symbol name is derived from the input filename
(jetc.cpp's baseNameNoExt+sanitizeIdent) so multiple compiled templates'
.so's stay collision-free even under dlopen(..., RTLD_GLOBAL).
jetc/build-shared.sh builds the .so: JetCore's 22 tag classes are still
force-linked directly (Tag::interpretSpan's fallback path can dispatch
to any of them at runtime, regardless of what a given template
statically references), but CoreUtils objects are compiled -fPIC and
archived into a throwaway libCoreUtils_pic.a instead of being linked
directly - libCoreUtils.a itself isn't position-independent, so linking
it into a .so fails outright ("relocation ... can not be used when
making a shared object"), and force-linking every CoreUtils .cpp
directly (rather than archiving, so the linker only pulls in what's
actually referenced) surfaced an unrelated, pre-existing incomplete
class - IMFMessage's vtable is never emitted anywhere, presumably a
partially-migrated class (see project memory on IMFMultipart/IMFText
still being fd-based) - as an unresolved dlopen()-time symbol, even
though nothing here uses it. A normal archive-based link (like the
existing libCoreUtils.a already does for jet-2.0) never pulls IMFMessage
in at all, so building libCoreUtils_pic.a the same way sidesteps it
without touching the unrelated bug itself.
jetc/host_test.cpp is a minimal stand-in for the real server: dlopen()s
a compiled .so, dlsym()s its entry point, and calls it twice with fresh
jet::Global objects (simulating two separate requests against one loaded
module) to prove the .so is genuinely reusable, not single-use. Verified
both demo templates (demo.jet, demo2.jet - the latter covering nested
if/for, a stateful while loop, and the interpretSpan fallback path) build
as .so's and produce the same byte-identical output as the executable
and interpreter paths, across two calls each. Also re-verified the
existing (non-shared) executable build path still matches jet-2.0's
output after the Codegen::generate() signature change.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
|
||
|
Brad ArantandClaude Sonnet 5
|
d52ca61250 |
Add jetc: a prototype JET-to-C++ compiler, plus the Tag API it needed
jetc (JetCore/jetc/) compiles a subset of JET template syntax - literal text, $[...]/#[...] variable output, <set>, <if>/<else>, <for>, <while> - into a standalone C++ program that links against CoreUtils and the same JetCore tag-class library jet-2.0 itself uses. The static tag/text structure becomes real C++ control flow (if/for/while), resolved once at build time instead of being re-scanned character-by-character from raw source on every request and, for loop bodies, on every single iteration (confirmed by reading Tag::parseContainer - it re-tokenizes its container text from scratch every time it runs, since a tag's parse and its execution are the same pass in this codebase). Anything genuinely dynamic - variable values, expr/value comparisons, loop bounds - still calls into the existing runtime (Tag::getVariable/resolveKeyword, jet::Operand) exactly as the interpreter does; compiling doesn't try to eliminate that; only the repeated re-parsing of the template's own shape. A <if type="..."> or <while type="..."> comparison type is resolved to its C++ operator once at compile time (type is a literal attribute value in practice, not runtime data) instead of being re-checked against six string constants on every evaluation. Any tag jetc doesn't have a codegen rule for (mysql, sql, call, include, a <set> with a container body, etc.) is captured as its exact raw source span and handed to the existing interpreter at compiled-program runtime via the new Tag::interpretSpan(), so an unsupported construct degrades gracefully instead of failing to compile - a real, if narrower, program rather than requiring full tag coverage up front. Tag.h/.cpp: made assignVariable public (parallel to the already-public getVariable - generated code needs a write path without being a Tag subclass) and added interpretSpan() as the fallback's entry point into parseContainer. Verified live: two representative templates (jetc/demo.jet, an if/for/set walkthrough; jetc/demo2.jet, a nested <if> inside a <for>, a <while> that mutates and rereads its own condition variable across iterations, and a fallback-interpreted <comment> tag) both compile, link, run standalone, and produce byte-identical output to jet-2.0 running the same source. Building and running jetc/demo2.jet's <while> loop surfaced a real, previously-unknown MString bug (fixed separately, see CoreUtils commit 6e4e463) along with a separate, already-existing bug in __while.cpp's value1/value2/type form (unrelated to this compiler, not fixed here - see project memory). jetc/build-compiled.sh builds the compiler and a given .jet file's compiled binary in one step; jetc/demo.jet and demo2.jet are kept as worked examples. Known limitations: <set> with a container body isn't modeled (falls back to interpretation); a fallback-interpreted tag nested inside compiled control flow uses the template's single top-level scope for parent/local context rather than a faithful per-level chain, which only matters for legacy tags that rely on nested "local" scoping. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> |
||
|
Brad ArantandClaude Sonnet 5
|
fc849c44a4 |
Back $[@name] session variables with a JSON file via JFile, reusing the @ sigil
The @ sigil previously read through global.getSession(global.sessionId), a MySQL-session binding that was already confirmed dead this session - Global::sessionId is never assigned anywhere in the codebase, so any $[@name] read would always throw. The design goal: persist session state as a JSON file at sessiondir/<sessionId>.json, using CoreUtils's existing JFile (an MFile+JString combination with load-on-construct/save-on- destruct RAII semantics), reusing @ rather than introducing a new sigil since the old @ usage was unreachable in practice anyway. Global.h/.cpp: added Global::sessionFile (a JFile*, NULL unless a request is in cgi mode with sessiondir set). Its destructor now explicitly deletes sessionFile - JFile's actual disk write happens in MFile's destructor via update(), so this has to run for persistence to happen at all (a raw `new`'d pointer that's never deleted, as cgiData still is, would never save anything back to disk). __jet.cpp: the sessiondir block now builds the session file path from the sessiondir keyword and the active session id (existing cookie or newly issued) and constructs global.sessionFile there, for both branches. The "pull sessionfile from sessiondir" comment is now implemented - JFile's own constructor already handles "file doesn't exist yet" by loading as empty, so one construction point serves both a resumed and a brand-new session. Tag.cpp: getVariable's "@" branch now reads via (*global.sessionFile)[name] with a clear error if no session is active, instead of the dead MySQL lookup. Added Tag::assignVariable (declared in Tag.h), a single write path both storeVariable overloads now funnel through, so a "@name"- prefixed target (e.g. <set name="@x" value="y"/>) is routed to the session file instead of the normal global/local/parent variables maps - without this, the read side would have been read-only, which isn't a very useful session mechanism. This surfaced two real, pre-existing CoreUtils bugs, both fixed separately (see CoreUtils commit 3e6e410): JFile's virtual-base diamond skipping JString's own empty-object seed, and MString's ZString-source copy paths pairing an absolute data pointer with a cursor-relative length - both were silently corrupting any cursor-advanced ZString (exactly what assignVariable produces when it strips the "@" prefix via ifNext() before storing). Verified live: two genuinely separate jet-2.0 process invocations sharing one session cookie, where the first writes two session variables and the second - a fresh process with no shared memory - reads both back correctly from the JSON file on disk. Also re-ran tests/posttest.sh (unchanged output, no regression) and the full CoreUtils test suite (no regressions). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> |
||
|
Brad ArantandClaude Sonnet 5
|
6f2f3d7339 |
Fix testpost.jet: cgi="true" doesn't match __jet.cpp's cgi=="yes" check
$[^session] (a cookie lookup, global.cookies.data[name]) was always empty because __jet.cpp's cgi keyword check compares against "yes" (a deliberate choice from an earlier session, not the codebase-wide true/false convention used by filterblanklines/trimlines/eval etc.) - testpost.jet had cgi="true", a stale mismatch that predates that decision, so the entire cgi block (including reading HTTP_COOKIE into global.cookies) never ran at all. Fixed the test fixture to say cgi="yes" to match. Verified live via tests/posttest.sh against the current build: $[^session] now correctly prints 18fd56a83f (posttest.sh's simulated HTTP_COOKIE session id), and dump.txt's *** COOKIES *** section shows session=[18fd56a83f] instead of empty. dump.txt committed with this fresh, correct output. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> |
||
|
Brad ArantandClaude Sonnet 5
|
51133e0c76 |
Wire CGI form data through the new Parser-based CGIFormData
Global now owns a long-lived StreamReader (cgiReader) that CGIFormData
(a Parser) holds a reference to - declared before cgiData so it's
constructed first and destroyed last. __jet.cpp's POST handling
constructs CGIFormData against it and feeds the request body off stdin
in 4KB chunks, driving doParse() after each feed rather than blocking to
read the whole body up front - the same feed()/doParse() pattern a
socket-fed StreamReader would use, keeping memory bounded for large
multipart uploads.
Also fixes two real, pre-existing bugs surfaced while getting an actual
end-to-end CGI request working through jet-2.0 (not just compiling):
- Tag::Tag's opening-tag parser was gated on "parent && in.ifNext(\"<\")",
but jet-2.0.cpp's main() constructs the top-level __jet with
parent=NULL - meaning the outer <jet ...> tag's own attributes
(cgi="yes" and everything else) were never actually parsed at all, just
echoed as literal passthrough content. parent=NULL is used at exactly
one call site in the whole codebase, so dropping the "parent &&"
requirement only changes behavior for that one top-level case - every
nested tag construction already passes a real parent.
- __jet.cpp's boundary-extraction code calls contentType.find("boundary=")
to locate the multipart boundary parameter, but find() repositions
contentType's own cursor to the match as a side effect. That same
cursor-shifted contentType then got passed into CGIFormData's
constructor, whose startsWith("multipart/form-data")/
startsWith("application/x-www-form-urlencoded") checks are
cursor-relative and so silently matched neither, falling through to an
unrecognized content type that parsed nothing (reported COMPLETE
immediately, no error, just empty results). Fixed with
contentType.reset() before the CGIFormData construction.
Verified with a real end-to-end run: jet-2.0 invoked with simulated CGI
environment variables (REQUEST_METHOD=POST, CONTENT_TYPE with a
boundary=, CONTENT_LENGTH) and a genuine multipart/form-data body
(including a file-upload part) piped over stdin, using $[:name] in a
.jet script - correctly returns each field's value and correctly leaves
the skipped upload field empty.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
|
||
|
Brad ArantandClaude Sonnet 5
|
2d9505cd33 |
Fix jet cgi=yes CGI variable loading and related bugs
- __jet.cpp: the cgi keyword check compared against "true" but the
documented/intended value is "yes", so <jet cgi="yes" ...> never
actually turned CGI mode on; fixed. Also replaced the hardcoded
fake multipart boundary ("xxxx") with real extraction from the
Content-Type header's boundary= parameter.
- Global.h: default-initialize cgiData to NULL (a GET request with
cgi="yes" never allocates it, so it was previously left
dangling); Global.cpp now sets the cookie jar's delimiter to ";"
to match RFC 6265, since it defaulted to CGIFormattedData's
&-based form-data delimiter.
- Global.cpp: fix addSession()'s missing throw that let it silently
continue past a duplicate session id.
- Tag.cpp: fix the CGI-variable lookup branch, which failed to
compile (cgiData is a pointer; needed to dereference it before
indexing) and added a null check so a CGI request that never
populated cgiData (bad Content-Type, or the null-safety gap
above) throws a clear error instead of crashing; implemented the
previously-empty session-variable lookup branch; left the
unreachable duplicate environment-variable branch as-is with a
comment, since fixing its sigil is a user-facing template-syntax
decision, not a bug fix.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
|