feat: Added 'repeats' and 'extends' properties for Parameter

py/stencila/schema/types.py

@@ -1504,14 +1504,18 @@ class Parameter(Variable):
     """A parameter that can be set and used in evaluated code."""
 
     default: Optional["Node"] = None
+    extends: Optional[bool] = None
+    repeats: Optional[bool] = None
     required: Optional[bool] = None
 
     def __init__(
         self,
         name: str,
         default: Optional["Node"] = None,
+        extends: Optional[bool] = None,
         id: Optional[str] = None,
         meta: Optional[Dict[str, Any]] = None,
+        repeats: Optional[bool] = None,
         required: Optional[bool] = None,
         schema: Optional["SchemaTypes"] = None
     ) -> None:
@@ -1523,6 +1527,10 @@ def __init__(
         )
         if default is not None:
             self.default = default
+        if extends is not None:
+            self.extends = extends
+        if repeats is not None:
+            self.repeats = repeats
         if required is not None:
             self.required = required
 

r/R/types.R

@@ -1778,17 +1778,21 @@ Variable <- function(
 #' @name Parameter
 #' @param name The name the parameter is referred to in code. \bold{Required}.
 #' @param default The default value of the parameter.
+#' @param extends Indicates that this parameter is variadic and can accept multiple named arguments.
 #' @param id The identifier for this item.
 #' @param meta Metadata associated with this item.
+#' @param repeats Indicates that this parameter is variadic and can accept multiple arguments.
 #' @param required Is this parameter required, if not it should have a default or default is assumed to be null.
 #' @param schema The schema that the value of the parameter will be validated against.
 #' @seealso \code{\link{Variable}}
 #' @export
 Parameter <- function(
   name,
   default,
+  extends,
   id,
   meta,
+  repeats,
   required,
   schema
 ){
@@ -1800,6 +1804,8 @@ Parameter <- function(
   )
   self$type <- as_scalar("Parameter")
   self[["default"]] <- check_property("Parameter", "default", FALSE, missing(default), "Node", default)
+  self[["extends"]] <- check_property("Parameter", "extends", FALSE, missing(extends), "logical", extends)
+  self[["repeats"]] <- check_property("Parameter", "repeats", FALSE, missing(repeats), "logical", repeats)
   self[["required"]] <- check_property("Parameter", "required", FALSE, missing(required), "logical", required)
   class(self) <- c("list", "Entity")
   self

schema/Parameter.schema.yaml

@@ -15,3 +15,11 @@ properties:
     '@id': stencila:required
     description: Is this parameter required, if not it should have a default or default is assumed to be null.
     type: boolean
+  repeats:
+    '@id': stencila:repeats
+    description: Indicates that this parameter is variadic and can accept multiple arguments.
+    type: boolean
+  extends:
+    '@id': stencila:extends
+    description: Indicates that this parameter is variadic and can accept multiple named arguments.
+    type: boolean

ts/executor.ts

@@ -112,10 +112,13 @@ function parseItem(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   item: any,
   parameters: Parameter[],
-  code: (CodeChunkExecution | CodeExpression)[]
+  code: (CodeChunkExecution | CodeExpression)[],
+  functionDepth: number = 0
 ): void {
   if (isA('Entity', item) || item instanceof Object) {
-    if (isA('Parameter', item)) {
+    if (isA('Function', item)) {
+      ++functionDepth
+    } else if (isA('Parameter', item) && functionDepth === 0) {
       parameters.push(item)
     } else if (
       (isA('CodeChunk', item) || isA('CodeExpression', item)) &&
@@ -139,10 +142,14 @@ function parseItem(
     }
 
     Object.entries(item).forEach(([, i]) => {
-      parseItem(i, parameters, code)
+      parseItem(i, parameters, code, functionDepth)
     })
+
+    if (isA('Function', item)) {
+      --functionDepth
+    }
   } else if (Array.isArray(item)) {
-    item.forEach(i => parseItem(i, parameters, code))
+    item.forEach(i => parseItem(i, parameters, code, functionDepth))
   }
 }
 
@@ -234,6 +241,8 @@ function parseFunctionDeclaration(
   if (fn.params !== undefined) {
     fn.params.forEach(p => {
       if (p.type === 'Identifier') parameters.push(parameter(p.name))
+      else if (p.type === 'RestElement' && p.argument.type === 'Identifier')
+        parameters.push(parameter(p.argument.name, { repeats: true }))
     })
   }