Use jaspSyntax (#167)

* Use jaspSyntax

* Update R/common.R

Co-authored-by: Don van den Bergh <donvdbergh@hotmail.com>

---------

Co-authored-by: Don van den Bergh <donvdbergh@hotmail.com>

Author: boutinb

NAMESPACE

@@ -135,6 +135,7 @@ export(rowVariance)
 export(rowVarianceNaRm)
 export(runJaspResults)
 export(runWrappedAnalysis)
+export(storeDataSet)
 export(startProgressbar)
 export(tDist)
 export(unifDist)

R/common.R

@@ -1145,29 +1145,34 @@ editImage <- function(name, optionsJson) {
   return(toJSON(response))
 }
 
-registerData <- function(data) {
-   #TODO
-}
-
-checkAnalysisOptions <- function(analysisName, options, version) {
-  # TODO when QMLComponents can be linked to jaspBase
-  return(options)
+#' @export
+storeDataSet <- function(dataset) {
+  jaspSyntax::loadDataSet(dataset)
 }
 
 #' @export
-runWrappedAnalysis <- function(analysisName, data, options, version) {
+runWrappedAnalysis <- function(moduleName, analysisName, qmlFileName, options, version, preloadData) {
   if (jaspResultsCalledFromJasp()) {
-
-    result <- list("options" = options, "analysis" = analysisName, "version" = version)
-    result <- jsonlite::toJSON(result, auto_unbox = TRUE, digits = NA, null="null", force = TRUE)
-    return(as.character(result))
+    # In this case, it is JASP Desktop that called the wrapper. This was done to parse the R code, and to get the arguments
+    # in a structured way. In this way the Desktop can then set the options to the QML controls of the form, and this will run the analysis.
+    # So here, just give back the parsed options.
+    return(toJSON(list("options" = options, "module" = moduleName, "analysis" = analysisName, "version" = version)))
 
   } else {
+    # The wrapper is called inside an R environment (R Studio probably).
+    # The options must be parsed and checked by the QML form, and then the real analysis can be called.
+    qmlFile <- file.path(find.package(moduleName), "qml", qmlFileName)
+    # Load the qml form, and set the right options (formula should be parsed and all logics set in QML should be checked), and run the analysis
+    options <- jaspSyntax::loadQmlAndParseOptions(moduleName, analysisName, qmlFile, as.character(toJSON(options)), version, preloadData)
 
-    options <- checkAnalysisOptions(analysisName, options, version)
-    # fool renv so it does not try to install jaspTools
-    jaspToolsRunAnalysis <- utils::getFromNamespace("runAnalysis", asNamespace("jaspTools"))
-    return(jaspToolsRunAnalysis(analysisName, data, options))
+    if (options == "")
+      stop("Error when parsing the options")
+
+     internalAnalysisName <- paste0(moduleName, "::", analysisName, "Internal")
 
+     return(runJaspResults(name=internalAnalysisName, title=analysisName, dataKey="{}", options=options, stateKey="{}", functionCall=internalAnalysisName, preloadData=preloadData))
   }
 }
+
+
+

R/formula.R

@@ -45,8 +45,9 @@
 #' @export
 jaspFormula <- function(formula, data) {
   formulaEncoded <- formulaEncode(formula)
-  data    <- formulaCheckOrReadData(data)
-  formulaCheckRequirements(formulaEncoded, data)
+
+  colNames    <- formulaCheckOrReadData(data)
+  formulaCheckRequirements(formulaEncoded, colNames)
 
   # TODO: We should use the encoded formula hier, but if a column has a type ('col.scale'), then it is decoded by 'col'
   result <- list(
@@ -63,7 +64,6 @@ jaspFormula <- function(formula, data) {
 #' @rdname jaspFormula
 #' @export
 makeJaspFormula <- function(..., response=NULL, data) {
-  data <- formulaCheckOrReadData(data)
 
   if(!is.null(response) && !is.character(response)) {
     stop("`response` must be a character.", domain = NA)
@@ -78,7 +78,7 @@ makeJaspFormula <- function(..., response=NULL, data) {
   }
 
 
-  rhs <- vapply(dots, makeJaspFormulaRhs, character(1), data = data)
+  rhs <- vapply(dots, makeJaspFormulaRhs, character(1))
 
   formula <- stats::reformulate(rhs, response)
   return(jaspFormula(formula, data))
@@ -94,8 +94,7 @@ jaspFormulaRhs <- function(terms = NULL, group = NULL, intercept = TRUE, correla
   return(result)
 }
 
-makeJaspFormulaRhs <- function(rhs, data) {
-  allVarNames <- colnames(data)
+makeJaspFormulaRhs <- function(rhs) {
 
   result <- paste(rhs[["terms"]], collapse = "+")
   if (is.null(rhs[["terms"]])) {
@@ -133,27 +132,26 @@ formulaEncode <- function(formula) {
 
 formulaCheckOrReadData <- function(data) {
   # If we are in JASP and no data are supplied explicitly, we simply read the dataset from JASP.
-  if(jaspBase::jaspResultsCalledFromJasp()) # && (missing(data) || is.null(data)))
+  if(jaspBase::jaspResultsCalledFromJasp()) {
     data <- jaspBase::readDataSetToEnd(all.columns = TRUE)
+	colNames = decodeColNames(colnames(data))
+  } else {
+	colNames = jaspSyntax::getVariableNames()
+  }
 
-  if(missing(data) || is.null(data) || !is.data.frame(data))
-    stop("`data` must be a data frame.", domain = NA)
-
-  return(data)
+  return(colNames)
 }
 
-formulaCheckRequirements <- function(formula, data) {
+formulaCheckRequirements <- function(formula, columnNames) {
   if (!inherits(formula, "formula")) {
     stop("`formula` argument must be object of class `formula`.", domain = NA)
   }
-
   attr <- attributes(stats::terms(formula))
 
   if (!is.null(attr[["offset"]])) {
     stop("JASP formulas do not understand `offset` terms. Analyses that allow the `offset` terms have a special `offset` argument.", domain = NA)
   }
 
-  columnNames <- decodeColNames(colnames(data))
   lhs <- decodeColNames(all.names(formulaExtractLhs(formula)))
   anyLhsTransformed <- !all(lhs %in% c(columnNames, "cbind", "(", ")"))