Repository navigation
multi-dataset aware test analysis + lotsa wrappers - #75
Draft
JorisGoosen wants to merge 44 commits into
Draft
JorisGoosen wants to merge 44 commits into
JorisGoosen wants to merge 44 commits into
Conversation
- 'Test Multi-DataSet' (multiDataSetAware+preloadData) and its non-aware counterpart, sharing R/multiDataSet.R and inst/qml/testMultiDataSet.qml: the VariablesForm dataset/filter selection, per-dataset routing of encoded option values via jaspBase's dataSetIdFromEncoded/dataSetNameFromEncoded/getDataSetColumn, a .meta provenance dump and the readDataSet() guard demo. - Tools/buildBundle.R: builds bundles_out/jaspTestModule.JASPModule with the local jasp-desktop/Engine/jaspBase checkout swapped into renv.lock as a Local record (verified inside the bundle afterwards); cellar-free, works on Arch R 4.6.1. - renv.lock refresh for R 4.6.1 in the next commit (kept separate: buildBundle.R swaps it transiently).
- renv.lock re-resolved on R 4.6.1 (jaspBase 6a6910db / jaspGraphs cdc4c9cf from GitHub). - Tools/buildBundle.R end-to-end on Arch: local-jaspBase Local record swapped into a copy of the lock during the build (tryCatch/finally restore - top-level on.exit is a no-op in Rscript), fake renv sandbox (symlink farm at the resolved RENV_PATHS_SANDBOX path) so jaspModuleTools' copy of restore-skipped recommended packages (codetools) works on binary R, --check-only to re-verify a bundle without rebuilding, and manifest/namespace verification that loads the bundled jaspBase and asserts the multiDataSetAware code is in it. - Tools/testdata: DataSetA/DataSetB.csv with deliberately overlapping column names (Score, Age) for the per-dataset routing test.
…not a type) ExplanationText is the module-local component in inst/qml/common/, so the form needs import "./common" like the other test forms do. Caught by loading the form through the native SyntaxInterface with jaspSyntax (github.com/jasp-stats/jaspSyntax) - which is why buildBundle.R now runs readModuleDescription() + readDefaultAnalysisOptions() as a build gate: a QML that does not create its Form throws there, verified with a deliberately broken copy, so this class of error can no longer ride along into a bundle.
…ed datasets wrapper - Analysis body renamed to multiDataSetFuncInternal; the aware Description entry gets hasWrapper: true, so JASP calls ...Internal and the generated wrapper (R/multiDataSetFuncWrapper.R, via jaspSyntax) exposes multiDataSetFunc(datasets=, ...) for R syntax use - datasets instead of data, stored via jaspBase::storeDataSets. - The non-aware twin now points at multiDataSetFuncInternal directly (it cannot use the wrapper name: JASP would call the wrapper as the analysis). - NAMESPACE: import(jaspBase) - without it, wrapper calls from a plain R session could not resolve createJaspHtml etc. (JASP attaches jaspBase, R does not). - Tools/testMultiDataSet.R: full headless test over three paths - engine-style queued slices (jaspTools datasets=), the wrapper in a clean subprocess, and a legacy non-aware run as controls; 21 checks, all passing against the local jaspBase.
…ternal + 38 generated wrappers - hasWrappers: true in Description.qml; every analysis body renamed <func> -> <func>Internal (engine appends Internal per entry), with generated R/<func>Wrapper.R exposing the R-syntax entry points (jaspSyntax::generateAnalysisWrapper, one fresh process per analysis - filteredDataEntry segfaults the bridge and would take the batch down otherwise). - Cross references updated: testContainer calls testFootnotesTableFuncInternal, testEncodingPreloadDataFuncInternal <- testEncodingFuncInternal alias. - The non-aware multi-dataset counterpart moved to func multiDataSetNonAware (+ multiDataSetNonAwareInternal): it cannot share multiDataSetFunc (that is the wrapper) and multiDataSetFuncInternal (the generator rightly refuses to wrap an Internal name). - Known gaps left as-is: testTransposedTable/testFootnotes/testContainer point at a removed test.qml, testPlotStatus at a never-existing TestPlotStatus.qml and their R funcs were already gone (dead Description entries); filteredDataEntry hits the Filter(_data == nullptr) bridge assertion headless. - Tools/testMultiDataSet.R stays green (22/22) with the module wrapped.
…orms in the multi-dataset test - Test Transposed jaspTable / Wait for it... (footnotes) / Test jaspContainer pointed at a test.qml that no longer exists, Test Plot Status at a never-existing TestPlotStatus.qml; removed the entries plus their now-unreferenced R files (testTransposedTable.R, testFootnotesTable.R, testContainer.R) and the Timer reference to the footnotes entry. - testMultiDataSet.qml now has TWO VariablesForms (A/B), each with its own dataSetSelection: point A at one dataset and B at the other and the results show both datasets loaded with per-form routing (source column A/B). The explanation now also states that a missing Data selection plus a "Non-aware run" table means the running JASP does not know the feature (stale binary/module). - Headless tests updated for dependentA/dependentB (23 checks, all passing); wrappers regenerated with the new defaults.
The demo analysis now shows the feature as designed: option values ARE the datasets' column names (both encoded by the same per-dataset encoder; results are decoded on the way out by the engine), so getDataSetColumn(value, datasets) is the whole lookup. Dropped the decode-first logic, the redundant 'column'/'type' table fields and the legacy decodeColNames call. Path-1 test fixtures are faithful now: slices carry encoded column names exactly like rbridge delivers them, including per-slice mean checks against the source csv (catches cross-dataset mixups). Wrapper path marked SKIP pending the syntax-mode dataset-selection flow (TODO-multidataset.md).
- testMultiDataSet.qml: dataSetSelectionOption 'dataSetA'/'dataSetB' + depends, so a syntax call selects each form's dataset by name (multiDataSetFunc(datasets = list(haha = dfA, godverdomme = dfB), dataSetA = 'haha', dataSetB = 'godverdomme', dependentA = 'Score', ...) routes every column to its own dataset). - non-aware twin now has testMultiDataSetNonAware.qml (no selection options - a non-aware entry neither has nor needs them, and the bridge would demand them). - wrapper test asserts the new semantics end-to-end (bridge ids + user-name titles, encoded slices + encoded options, per-form routing of identically named columns); path 2 re-enabled in the suite (29 checks green). - buildBundle jaspBase check: markers match the current exports (dataSetColumnFromEncoded is gone) and actually print the missing names (bare %in% has no names). - TODO-multidataset.md tracks the remaining work.
…ection The aware form's dataSetSelectionOptions now (rightly) demand a loaded dataset to name, which broke the smoke check. The gate loads a one-column dummy via loadDataSets and parses with isolated = FALSE (the subprocess would not see it), pointing every detected dataSetSelectionOption at it; the non-aware twin is checked without selections.
…73558, 0bf83f920)
No more manual 'Add module -> From file' per iteration: the build ends with Tools/installModuleLocal.sh (JASP's own jaspModuleBundleManager install + manifest version normalisation + developerMode/modulesRemembered prefs). --no-install-local / SKIP_MODULE_LOCAL_INSTALL=1 to opt out; failure is a warning (bundle itself is fine, usually JASP still running). TODO records the parseModuleInfo-vs-array-version bug worth reporting upstream.
SEGV opening the multi-dataset test form was a null entry in _depends: the form's depends: "dataSetA"/"dataSetB" cannot resolve on desktop (the syntax-mode DropDown is unnamed there) and JASPControl::_addExplicitDependency inserted the null, which AnalysisForm::sortControls dereferenced. Fixed in jasp-desktop 785afe486. Tools/verifyMultiDataSetRpc.py drives the whole flow over JASP's RPC server (load both CSVs, create form, mixed-provenance runs, assert routed results).
…ce (filter id), qmls drop the removed dataSetSelection bool
…no setFilter); TODO rewritten for the FilterSelect architecture + pre-existing testDbMigration failure noted
…-row table[[..':'..]] keys poisoned the DOM ids); route through jaspBase slice API; test readers accept both layouts
…nce, no-mirroring, filter-indexed slices)
Plain names and plain dataframes everywhere: path 1 now asserts what the bridge provides (real dataset ids, per-form selection honoured, decoded output, no encoded tokens left). The old R-emulation cannot satisfy this - 11 failing checks are the red for the jaspTools reroute (plan: jaspTools-bridge-parity). Wrapper path 2 untouched and green.
wanted-cols trimmed slices are the engine truth (the emulation's raw-csv 3/3 expectation was outdated); the legacy single-dataset path is now exercised via multiDataSetNonAware since aware analyses always receive the slice queue. All 32 checks green end to end; TODO records the parity state + known issues.
multiDataSet.R indexes datasets[[selectionOptionValue]] directly and reads dataset id/title off the attrs - the reference now demonstrates the contract rather than an accessor API. The wrapper's redundant storeDataSets call goes (runWrappedAnalysis loads through the bridge itself). buildBundle.R's jaspBase check is inverted from 'carries these exports' to 'leaks none of them'.
…ssion host switch, scalars unstamped, restamp there-and-back)
…t, round-trip checks
M8: multiDataSetNonAware removed - Description entry, wrapper, testMultiDataSetNonAware.qml
and the Internal body, plus the buildBundle func/qml pair (only surviving reference
mentions explain the removal). The rlogic bridge section in jasp-desktop was retargeted
to testVariablesForm in the same change (jasp-desktop commit 'mds-plan C4: map resolver
(no ids on syntax surface), ...') - cross-repo pairing, land together.
testMultiDataSet.R: bridge-boundary section rewritten to the C4 surface contract (ids
informational, selections are titles; integer-id selections now REJECTED - M4 flip;
'title - name' fails loudly on fresh loads; {types,value} unwrap/reject), path 3
retargeted to testEncodingFunc (real .readDataSetToEnd call = non-aware guard's
negative case). multiDataSetFuncWrapper.R regenerated: selection defaults render as
surface strings ("" now, was {types,value}) per C4/RENDER.
S7: results_multidataset.json untracked + gitignored (verifier run artifact).
S9: verifyMultiDataSetRpc.py paths self-locate (script dir, overridable via
--module=<dir> or $JASP_TESTMODULE_DIR).
The two dataSetSelectionOptions move off the VariablesForms onto the AvailableVariablesLists (HostFilterSelection lives on lists now, mds-plan D2.2 in jasp-desktop): each section's assigned list inherits its available list's namespace, depends: semantics kept, option names (dataSetA/dataSetB) unchanged so the wrapper/R echo fns and the RPC verifier need nothing. D6.4 will extend this form further.
…ifier checks C8/C11 per run The Engine->R boundary now strips the transient .filterIds sidecar (C11) and the send-time .meta carries no dataSetId/filterId (C8), so the per-form stamp-window checks (meta.dependentA == 1/1 etc.) can no longer hold - R legitimately sees no stamps. metaDump echoes a PROVENANCE_AUDIT marker (filterIdsSeen + count of provenance keys in the received .meta); the verifier asserts filterIdsSeen=false and metaProvenanceKeys=0 on all four runs (incl. both mid-session host switches), keeping the value-level routing/restamp/phantom-slice proofs (12.50 vs 17.73) that actually demonstrate per-form provenance still steering the data.
added 14 commits
October 17, 2026 20:15
…cises every control family under multi-source provenance New aware analysis (qml testMultiDataSetControls.qml + R multiDataSetControls.R + wrapper): nine families each reporting exactly what they received and where it resolved - assigned list under a selecting available list (A) with its combo sibling (plain string, never provenanced), an assigned list that IS its own selection host (B), a row-bearing ComponentsList with same-name twin rows from two filters keeping their OWN row children (C, the D6.1 TermRowKey re-keying), interaction terms whose components share the term filterId (D), FactorLevelList via encodeThis/extras (E), an R-code textarea with its own host encoding through it (F), a typed bindTo copy across differently-selected hosts (G, keeps the SOURCE filterId and encodes through the source's view), and the M5 scalar contract. R side is a per-family report table + PROVENANCE_AUDIT (mean/level-list per resolved column, no statistics). Description.qml gains the analysis entry (multiDataSetAware, hasWrapper). Companion jasp-desktop commits carry the C++/QML rough edges the zoo flushed out (TermRowKey row-identity keying, containsVariables-by-declaration, textarea encodeValue, RSyntax null-model guard, typed encoder re-mint, self-rebind format); the RPC verifier zoo runs land with D6.3/D6.4.
…s, scalar M5 contract, cross-host requalification; multiDataSet.R doc fix verifyMultiDataSetRpc.py gains the component-zoo runs (8 runs against testMultiDataSetControls): run 1-2 form bring-up with the zoo defaults (twins resolved per-row through their own filters, factor-level names decoded, scalars bare); runs 3-4 the mid-session host switch and switch-back (downstream re-encode follows the host, no phantom slices, dataSetIds pins); runs 5-6 re-send assignedA with the switched host (slice 2 then back to slice 1, 17.73/12.50 means proving per-filter encodings differ) with assertions relaxed to 'slice 2 queued, nothing beyond the workspace's two datasets' (the zoo's primary slice is always queued, so an exact [2] pin is wrong); run 7 the D6.2 typed copy bound into boundG on the OTHER host (keeps the SOURCE stamp, encodes through the source's view, dataSetIds covers both); run 8 the requalification landmine: the SOURCE host switches in a delta parse that does not re-send boundG - the copy must keep its foreign stamp (fixed jasp-desktop side by the BoundControl::selfRebindFormat Storage round-trip, so the delta-parse self-rebind no longer re-mints the terms without their filterIds). Every run asserts its PROVENANCE_AUDIT (filterIdsSeen=false, metaProvenance- Keys=0) and the M5 scalar contract; no raw JaspExtraOptions_ anywhere. R/multiDataSet.R: the stale getSelectionSlice doc line replaced with the real contract (index the datasets list with the selection's filter id directly - the accessor family was retired with the zero-export datasets contract). Live: ALL CHECKS PASSED (84 PASS) against the final jasp-desktop tree.
…ection-default template; multiDataSet.R contract rewrite Both aware wrappers (multiDataSetFunc, multiDataSetControlsFunc) regenerated through the bridge (jaspSyntax::generateAnalysisWrapper) with the D8.3 template: the data <- datasets[[1]] ambiguity pin is replaced by per-slice selection defaults keyed off the SELECTION TITLE surface - selectionOptions <- c(...) in the form's host-registration order, resolved at run time from options (exact title, then the bare-title best effort for "Title - filterName" surfaces), a loud stop naming the title-keyed datasets contract when nothing matches, and the documented datasets[[1L]] fallback only for a form with no selection surface. The datasets contract is now stated on every aware wrapper (@PARAM datasets roxygen). multiDataSetControlsFuncWrapper was hand-mirrored before (D6.1) - it is a real generated file now, which also updates its option defaults/order to what the form currently generates (codeF/comboA/interactionD/rowsC shapes, optionsWithFormula over the list options). R/multiDataSet.R header rewritten as the contract document (D8.5): generated .meta carries no provenance and the .filterIds sidecar is stripped at the engine boundary (C8/C11, the PROVENANCE_AUDIT marker); provenance-in-name doctrine (C1/C8, encoded names in results are how provenance survives, decoded on the way out by the one global decode table); the datasets[[filter-id]] contract now stated correctly for BOTH engine runs and jaspTools handouts (the old header's "jaspTools handouts key it by dataset id" was stale - jaspTools passes the bridge's multiDataSetJson, filter-id keyed like the engine); qualified grammar surface (plan §5): term options are parsed C++-side into typed terms, string options receive the qualified form verbatim - the D8.4 v1 stance (pass-through, slice on it via the zoo's echo pattern if needed, never re-implement the grammar in R); both aware analyses named. getSelectionSlice reference was already fixed (D6.4) - verified, no other stale references.
…-plan (2026-10-08) FilterSelect-era status snapshot; several APIs it names (effectiveVarInfo/varInfoForItem, createMeta stamps, .sliceKeyForDataSet) were replaced by the mds-plan architecture; the Done section is a historical commit log and is kept verbatim; current contract doc is R/multiDataSet.R
…org, current package set via jaspModuleTools::updateLockfile/pkgdepends) - bundles will build against the local multiDataSetAware jaspBase/jaspSyntax/jaspTools
Per the owner brief: 'make the multidataset zoo test much more expansive, add
way more results (also show the loaded data!) and check for sensible option
flows.'
New control families (Zoo A-G existed before):
- Zoo H: scalar block - TextField (textH), IntegerField (rowsH 1-10, default
5), DoubleField (doubleH), Slider (sliderH), RadioButtonGroup (radioH
mean/sum) and a CheckBox gate (gateH) with a nested gated DoubleField
(gatedH, enabled only while the gate is open).
- Zoo I: DEPENDENT DropDown (comboI) whose option list follows Zoo A's
assigned list. Also fixes a silent QML bug found on the way: Zoo A's
combobox used `source: zooVarsA` - a bare id, a QML ReferenceError, so the
dropdown silently had NO option list; a source must be the string name
("zooVarsA"). With a working source a dropdown inherits its SOURCE's host
namespace (pinned by the verifier: comboA/comboI resolve in the source
host's slice, not the analysis level).
- Zoo J: AssignedPairsVariablesList (pairsJ) - pairs its two columns into
2-component terms; RPC must send the flat value ["Score","Age"] with flat
types, the desktop pairs them.
- Zoo K: FactorsForm (factorsK) fed by assignedK. Findings pinned in comments
+ R docs: inner panels are NOT hosts (terms encode through the ANALYSIS
level, D3.2 deferral); a factor term must be a member of the form's SOURCE
list or the model sync silently drops it; kept terms are RE-TYPED by the
form (Age arrived ordinal); and the previously-fatal nominal-term case is
fixed C++-side (mds-plan post in jasp-desktop, run 18 pins the honest row).
- Zoo L: bound SimpleTableView (tableL) whose row count follows rowsH; its
cells are USED by the cross-slice computation.
Results side (R/multiDataSetControls.R) - the loaded data is now shown:
- dataPreviewTables: one 'Loaded data' table PER SLICE with every column's
decoded name and its first rowsH values (the whole qualified-name ->
encoded-token -> correct-slice chain made visible); duplicate decoded
labels get a ' (k)' suffix so the schema never collides.
- dataSetOverview, controlsProvenance (extended with the new families),
scalarEchoTable (echo + used-in, slider documented as echo-only by design),
flowsTable (5 flow demonstrations with observed values),
crossSliceTable (interaction product, cross-host product, tableview
multipliers, real-field scaling, radio-driven statistic - value-level),
encodeDemoTable (Zoo E's levels APPLIED to a real column; matches the
factor name against DECODED column names - the slices carry encoded
tokens), gatedResultTable with dependencies="gateH" so a closed gate means
the child is ABSENT, not empty (jaspBase destroys it on the option change).
Wrapper regenerated (jaspSyntax::generateAnalysisWrapper, no datasets loaded
- clean defaults, empty host selections).
The existing checks proved option roundtrips; the expansion asserts the RESULTS side: what the loaded data looks like per slice, what each control family echoed, and that the option flows actually MOVE the numbers. New coverage (zoo runs 9-18, each a full explicit option set on the RPC): - run 9 (expanded zoo): per-slice loaded-data previews (decoded column names + real values from BOTH datasets, row count follows rowsH), the provenance echoes of all new families (dependent dropdown resolves in its SOURCE host's slice; pairsJ one pair + its correlation r=-0.457 computed from the CSVs; factorsK term resolving through the ANALYSIS-level namespace per the D3.2 hostless-panel deferral; tableview echo), all 7 scalar echoes, all 5 flow rows, cross-slice computations at value level (interaction product 461.830, cross-host product 228.990, tableview multipliers 95.000, real-field scaling 76.000, radio statistic sum 125.00), the encodeThis recode demo applying levels A/B to the Group column (n=4/3/3), the gated sub-result (Age@1 10/38.00, Score@2 8/19.45), PROVENANCE_AUDIT clean and no raw tokens. - run 10 (F1): assignedA flips to Condition -> comboI's option list and effective selection follow the source into slice 2 (levels X, Y, Z). - runs 11/12 (F2): gate closed -> the gated sub-result must be ABSENT (a gate means absence; caught the missing dependencies="gateH"); gate open with threshold 40 -> the numbers move (Age@1 n=4 mean 46.50). - runs 13/14 (F3): rowsH 3 -> 7 -> preview row counts and Zoo L's table row count follow in both directions. - run 15 (F6): radioH sum -> mean switches the statistic (125.00 -> 12.50). - run 16 (F4): reducing interactionD to a single component removes the interaction-product row. - run 17 (F5): explicit tableL cells (multipliers 2,2,2,2) are USED, not just echoed (scaled mean 95.000 -> 76.000). - run 18 (regression, pairs with the mds-plan post fix in jasp-desktop): a nominal factor term whose column the analysis-level namespace lacks used to FATAL the whole run; it must complete with an honest unresolved row. Findings encoded as checks/comments: the FactorsForm drops factor terms that are not in its SOURCE list and re-types kept terms (Age arrived ordinal -> the slice receives an R factor, so the gated "first scale column" differs per slice); jaspBase HTML-escapes string cells (assertions unescape); expected statistics are computed from the same CSVs the datasets load, so assertions are value-level. All 84 pre-existing checks unchanged and green; PROVENANCE_AUDIT clean on every meta-bearing run.
…ifier pins the per-factor provenance The per-factor sidecar (FactorsFormBase::createFilterIds, jasp-desktop facac80e6) transports each factor term's OWN filterId, so Zoo K's term Age no longer falls back to the analysis-level namespace (slice 2): it encodes through its source host's view (assignedK -> filter 1) and resolves in slice 1. Run 18's nominal Group term resolves in its own namespace too (where the column exists) - the phantom-namespace route is gone entirely; the existence guard stays pinned C++-side. - Verifier: the run-9 deferral check rewritten (slice 1, not the analysis level) + new term-granularity check (rowChild carries the per-term slice key 'Age(1)'); run-18 check rewritten (resolved row instead of the honest unresolved one) + its term-granularity twin; provenance-story and regression comments updated; dead ANALYSIS_SLICE constant removed. 177 -> 179 checks, ALL CHECKS PASSED against the rebuilt app (bundle rebuilt + reinstalled, libSyntaxInterface.so resynced). - R/QML zoo comments (Zoo K findings) rewritten for the closed deferral.
…ol, extra source on the third filter Owner rules applied: the test module contains ONLY assigned variables lists with at least one source (a bare assigned list - no pool relation at all - is a malformed configuration, not a supported one), and the per-list dataSetSelectionOption crutch is gone everywhere: selections live on POOLS. - Zoo B (bare assigned list) REMOVED. Its two real pins moved: the -1 analysis-fallback resolution lives on the default-provider pool's assigned list (assignedDefault, verifier run 19), foreign-stamp survival on the anchor runs. - Zoo C (row controls, the TermRowKey twin pin) is a form over its own default-provider pool (zooPoolC); the pin is unchanged - key -1, so the stamped twins are never swept. - Zoo G (cross-host bindTo), Zoo J (pairs) and Zoo K (factors-form source): the selection moved to a pool (zooPoolG/J/K) and every list takes its source from its form. The pins are unchanged: bindTo keeps the SOURCE filterId, pairs pair into 2-component terms, the per-factor sidecar transports each term's own filterId. - Zoo M: the EXTRA SOURCE is zooPoolThree - an AvailableVariablesList hosted by the bootstrapped third filter of the test dataset (the anchor scenario's namespace); assignedHostless renamed to assignedDefault (hosting is a pool property; assigned lists never host). - Zoo N's derived pool sources assignedA + assignedDefault (mixed provenance, stamps ride the refs). - Verifier re-pinned: the anchor Age rows assert the ordinal values listing (Age imports ORDINAL in DataSetA - data_info -; a term sent as scale is re-typed to the column's real type at intake, the established zoo finding), not a mean. ALL CHECKS PASSED against the rebuilt bundle (21 runs incl. the ds1/f1 -> ds1/f3 anchor there and back).
Same cleanup as the desktop side: the planning document's card IDs in comments, verifier labels and R/qml headers are rewritten as standing prose carrying the same information. Labels and comments only; no code paths change.
The not-found error and the header both said the setup instructions are at the bottom of the script, but they live in the header (the bottom documents bundle installation instead) - say "top" so people who hit the error find them.
The not-found error only pointed at the (misplaced) instructions; now the script checks its environment up front, before touching the filesystem: - --help prints the usage; --check-only exits cleanly after the checks instead of falling through to the bundle verification, where it died on the missing bundle. - A missing or incomplete tool library prints the full one-time setup commands with this checkout's real paths filled in (bundle manager, jaspModuleTools, jaspSyntax; clone hints when the sibling checkouts are absent) instead of a stale pointer. - The pre-flight summary states where the module, the local jaspBase (with branch), the tool library, the workdir and the output land. - Header no longer duplicates the setup block; it points at the printer. No build logic changed: lockfile swap, sandbox farm, compile, the QML smoke check, the bundle/zero-export/wrapper gates and the local install are the same steps, regrouped under section headers.
…e form The Analysis finds out by itself once its form loads and a control registers a dataset selection (dataSetSelectionOption), so the two Analysis entries no longer declare it. Comments updated to the new module-author contract.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Adds a testcase for multidataset analyses.
Also adds wrappers for all analyses.
For jasp-stats/jasp-desktop#6345