X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/2b11ab27a8508a49bb5e2c87babbbae9e95f4e3d..c856e47c2a25dc6979ea07f2c3942687687c833a:/sdk/R/R/autoGenAPI.R

diff --git a/sdk/R/R/autoGenAPI.R b/sdk/R/R/autoGenAPI.R
index 7dedfa50ed..3e8c2fa0cf 100644
--- a/sdk/R/R/autoGenAPI.R
+++ b/sdk/R/R/autoGenAPI.R
@@ -1,5 +1,6 @@
-#TODO: Some methods do the same thing like collecion.index and collection.list.
-#      Make one implementation of the method and make other reference to it.
+# Copyright (C) The Arvados Authors. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
 
 getAPIDocument <- function(){
     url <- "https://4xphq.arvadosapi.com/discovery/v1/apis/arvados/v1/rest"
@@ -11,68 +12,181 @@ getAPIDocument <- function(){
 #' @export
 generateAPI <- function()
 {
-    JSONDocument <- getAPIDocument()
+    #TODO: Consider passing discovery document URL as parameter.
+    #TODO: Consider passing location where to create new files.
+    discoveryDocument <- getAPIDocument()
+
+    methodResources <- discoveryDocument$resources
+    resourceNames   <- names(methodResources)
+
+    methodDoc <- genMethodsDoc(methodResources, resourceNames)
+    classDoc <- genAPIClassDoc(methodResources, resourceNames)
+    arvadosAPIHeader <- genAPIClassHeader()
+    arvadosProjectMethods <- genProjectMethods()
+    arvadosClassMethods <- genClassContent(methodResources, resourceNames)
+    arvadosAPIFooter <- genAPIClassFooter()
+
+    arvadosClass <- c(methodDoc,
+                      classDoc,
+                      arvadosAPIHeader,
+                      arvadosProjectMethods,
+                      arvadosClassMethods,
+                      arvadosAPIFooter)
 
-    generateArvadosClasses(JSONDocument)
-    generateArvadosAPIClass(JSONDocument)
+    fileConn <- file("./R/Arvados.R", "w")
+    writeLines(unlist(arvadosClass), fileConn)
+    close(fileConn)
+    NULL
 }
 
-generateArvadosAPIClass <- function(discoveryDocument)
+genAPIClassHeader <- function()
 {
-    classMetaData     <- discoveryDocument$schemas
-    functionResources <- discoveryDocument$resources
-    resourceNames     <- names(functionResources)
+    c("Arvados <- R6::R6Class(",
+      "",
+      "\t\"Arvados\",",
+      "",
+      "\tpublic = list(",
+      "",
+      "\t\tinitialize = function(authToken = NULL, hostName = NULL, numRetries = 0)",
+      "\t\t{",
+      "\t\t\tif(!is.null(hostName))",
+      "\t\t\t\tSys.setenv(ARVADOS_API_HOST = hostName)",
+      "",
+      "\t\t\tif(!is.null(authToken))",
+      "\t\t\t\tSys.setenv(ARVADOS_API_TOKEN = authToken)",
+      "",
+      "\t\t\thostName <- Sys.getenv(\"ARVADOS_API_HOST\")",
+      "\t\t\ttoken    <- Sys.getenv(\"ARVADOS_API_TOKEN\")",
+      "",
+      "\t\t\tif(hostName == \"\" | token == \"\")",
+      "\t\t\t\tstop(paste(\"Please provide host name and authentification token\",",
+      "\t\t\t\t\t\t   \"or set ARVADOS_API_HOST and ARVADOS_API_TOKEN\",",
+      "\t\t\t\t\t\t   \"environment variables.\"))",
+      "",
+      "\t\t\tprivate$token <- token",
+      "\t\t\tprivate$host  <- paste0(\"https://\", hostName, \"/arvados/v1/\")",
+      "\t\t\tprivate$numRetries <- numRetries",
+      "\t\t\tprivate$REST <- RESTService$new(token, hostName,",
+      "\t\t\t                                HttpRequest$new(), HttpParser$new(),",
+      "\t\t\t                                numRetries)",
+      "",
+      "\t\t},\n")
+}
 
-    arvadosAPIHeader <- generateAPIClassHeader()
-    arvadosAPIFooter <- generateAPIClassFooter()
+genProjectMethods <- function()
+{
+    c("\t\tprojects.get = function(uuid)",
+      "\t\t{",
+      "\t\t\tself$groups.get(uuid)",
+      "\t\t},",
+      "",
+      "\t\tprojects.create = function(group, ensure_unique_name = \"false\")",
+      "\t\t{",
+      "\t\t\tgroup <- c(\"group_class\" = \"project\", group)",
+      "\t\t\tself$groups.create(group, ensure_unique_name)",
+      "\t\t},",
+      "",
+      "\t\tprojects.update = function(group, uuid)",
+      "\t\t{",
+      "\t\t\tgroup <- c(\"group_class\" = \"project\", group)",
+      "\t\t\tself$groups.update(group, uuid)",
+      "\t\t},",
+      "",
+      "\t\tprojects.list = function(filters = NULL, where = NULL,",
+      "\t\t\torder = NULL, select = NULL, distinct = NULL,",
+      "\t\t\tlimit = \"100\", offset = \"0\", count = \"exact\",",
+      "\t\t\tinclude_trash = NULL)",
+      "\t\t{",
+      "\t\t\tfilters[[length(filters) + 1]] <- list(\"group_class\", \"=\", \"project\")",
+      "\t\t\tself$groups.list(filters, where, order, select, distinct,",
+      "\t\t\t                 limit, offset, count, include_trash)",
+      "\t\t},",
+      "",
+      "\t\tprojects.delete = function(uuid)",
+      "\t\t{",
+      "\t\t\tself$groups.delete(uuid)",
+      "\t\t},",
+      "")
+}
 
+genClassContent <- function(methodResources, resourceNames)
+{
     arvadosMethods <- Map(function(resource, resourceName)
     {
         methodNames <- names(resource$methods)
 
         functions <- Map(function(methodMetaData, methodName)
         {
+            #NOTE: Index, show and destroy are aliases for the preferred names
+            # "list", "get" and "delete". Until they are removed from discovery
+            # document we will filter them here.
+            if(methodName %in% c("index", "show", "destroy"))
+               return(NULL)
+
             methodName <- paste0(resourceName, ".", methodName)
-            createFunction(methodName, methodMetaData, classMetaData)
+            createMethod(methodName, methodMetaData)
 
         }, resource$methods, methodNames)
 
         unlist(unname(functions))
 
-    }, functionResources, resourceNames)
+    }, methodResources, resourceNames)
 
-    arvadosClass <- c(arvadosAPIHeader, arvadosMethods, arvadosAPIFooter)
+    arvadosMethods
+}
 
-    #TODO: Save to a file or load in memory?
-    fileConn <- file("./R/Arvados.R", "w")
-    writeLines(unlist(arvadosClass), fileConn)
-    close(fileConn)
-    NULL
+genAPIClassFooter <- function()
+{
+    c("\t\tgetHostName = function() private$host,",
+      "\t\tgetToken = function() private$token,",
+      "\t\tsetRESTService = function(newREST) private$REST <- newREST,",
+      "\t\tgetRESTService = function() private$REST",
+      "\t),",
+      "",
+      "\tprivate = list(",
+      "",
+      "\t\ttoken = NULL,",
+      "\t\thost = NULL,",
+      "\t\tREST = NULL,",
+      "\t\tnumRetries = NULL",
+      "\t),",
+      "",
+      "\tcloneable = FALSE",
+      ")")
 }
 
-getFunctionName <- function(functionMetaData)
+createMethod <- function(name, methodMetaData)
 {
-    stringr::str_replace(functionMetaData$id, "arvados.", "")
+    args      <- getMethodArguments(methodMetaData)
+    signature <- getMethodSignature(name, args)
+    body      <- getMethodBody(methodMetaData)
+
+    c(signature,
+      "\t\t{",
+          body,
+      "\t\t},\n")
 }
 
-#TODO: Make sure that arguments that are required always go first.
-#      This is not the case if request$required is false.
-getFunctionArguments <- function(functionMetaData)
+getMethodArguments <- function(methodMetaData)
 {
-    request <- functionMetaData$request
-    requestArgument <- NULL
+    request <- methodMetaData$request
+    requestArgs <- NULL
 
     if(!is.null(request))
+    {
+        resourceName <- tolower(request$properties[[1]][[1]])
+
         if(request$required)
-            requestArgument <- names(request$properties)
+            requestArgs <- resourceName
         else
-            requestArgument <- paste(names(request$properties), "=", "NULL")
+            requestArgs <- paste(resourceName, "=", "NULL")
+    }
 
-    argNames <- names(functionMetaData$parameters)
+    argNames <- names(methodMetaData$parameters)
 
     args <- sapply(argNames, function(argName)
     {
-        arg <- functionMetaData$parameters[[argName]]
+        arg <- methodMetaData$parameters[[argName]]
 
         if(!arg$required)
         {
@@ -85,45 +199,55 @@ getFunctionArguments <- function(functionMetaData)
         argName
     })
 
-    paste0(c(requestArgument, args))
+    c(requestArgs, args)
 }
 
-getFunctionBody <- function(functionMetaData, classMetaData)
+getMethodSignature <- function(methodName, args)
 {
-    url  <- getRequestURL(functionMetaData)
-    headers <- getRequestHeaders()
-    requestQueryList <- getRequestQueryList(functionMetaData)
-    requestBody <- getRequestBody(functionMetaData)
-    request <- getRequest(functionMetaData)
-    response <- getResponse(functionMetaData)
-    errorCheck <- getErrorCheckingCode()
-    returnObject <- getReturnObject(functionMetaData, classMetaData)
+    collapsedArgs <- paste0(args, collapse = ", ")
+    lineLengthLimit <- 40
+
+    if(nchar(collapsedArgs) > lineLengthLimit)
+    {
+        return(paste0("\t\t",
+                      formatArgs(paste(methodName, "= function("),
+                                 "\t", args, ")", lineLengthLimit)))
+    }
+    else
+    {
+        return(paste0("\t\t", methodName, " = function(", collapsedArgs, ")"))
+    }
+}
+
+getMethodBody <- function(methodMetaData)
+{
+    url              <- getRequestURL(methodMetaData)
+    headers          <- getRequestHeaders()
+    requestQueryList <- getRequestQueryList(methodMetaData)
+    requestBody      <- getRequestBody(methodMetaData)
+    request          <- getRequest(methodMetaData)
+    response         <- getResponse(methodMetaData)
+    errorCheck       <- getErrorCheckingCode()
+    returnStatement  <- getReturnObject()
 
     body <- c(url,
               headers,
-              requestQueryList,
+              requestQueryList, "",
               requestBody, "",
               request, response, "",
               errorCheck, "",
-              returnObject)
+              returnStatement)
 
     paste0("\t\t\t", body)
 }
 
-getErrorCheckingCode <- function()
-{
-    c("if(!is.null(resource$errors))", "\tstop(resource$errors)")
-}
-
-getRequestBody <- function(functionMetaData)
+getRequestURL <- function(methodMetaData)
 {
-    request <- functionMetaData$request
-
-    if(is.null(request) || !request$required)
-        return("body <- NULL")
-
-    requestParameterName <- names(request$properties)[1]
-    paste0("body <- ", requestParameterName, "$toJSON()")
+    endPoint <- methodMetaData$path
+    endPoint <- stringr::str_replace_all(endPoint, "\\{", "${")
+    url <- c(paste0("endPoint <- stringr::str_interp(\"", endPoint, "\")"),
+             paste0("url <- paste0(private$host, endPoint)"))
+    url
 }
 
 getRequestHeaders <- function()
@@ -132,231 +256,295 @@ getRequestHeaders <- function()
       "                \"Content-Type\" = \"application/json\")")
 }
 
-getReturnObject <- function(functionMetaData, classMetaData)
+getRequestQueryList <- function(methodMetaData)
 {
-    returnClass <- functionMetaData$response[["$ref"]]
-    classArguments <- getReturnClassArguments(returnClass, classMetaData)
+    queryArgs <- names(Filter(function(arg) arg$location == "query",
+                        methodMetaData$parameters))
 
+    if(length(queryArgs) == 0)
+        return("queryArgs <- NULL")
+
+    queryArgs <- sapply(queryArgs, function(arg) paste0(arg, " = ", arg))
+    collapsedArgs <- paste0(queryArgs, collapse = ", ")
 
-    if(returnClass == "Collection")
-        return(c("collection <- Collection$new(",
-                 paste0("\t", splitArgs(classArguments, 40, ")")),
-                 "",
-                 "collection$setRESTService(private$REST)",
-                 "collection"))
+    lineLengthLimit <- 40
 
-    c(paste0(returnClass, "$new("),
-      paste0("\t", splitArgs(classArguments, 40, ")")))
+    if(nchar(collapsedArgs) > lineLengthLimit)
+        return(formatArgs("queryArgs <- list(", "\t\t\t\t  ", queryArgs, ")",
+                          lineLengthLimit))
+    else
+        return(paste0("queryArgs <- list(", collapsedArgs, ")"))
 }
 
-getReturnClassArguments <- function(className, classMetaData)
+getRequestBody <- function(methodMetaData)
 {
-    classArguments <- unique(names(classMetaData[[className]]$properties))
+    request <- methodMetaData$request
 
-    arguments <- sapply(classArguments, function(arg)
-    {
-        paste0(arg, " = resource$", arg)
-    })
+    if(is.null(request) || !request$required)
+        return("body <- NULL")
+
+    resourceName <- tolower(request$properties[[1]][[1]])
 
-    arguments
+    requestParameterName <- names(request$properties)[1]
+
+    c(paste0("if(length(", resourceName, ") > 0)"),
+      paste0("\tbody <- jsonlite::toJSON(list(", resourceName, " = ", resourceName, "), "),
+             "\t                         auto_unbox = TRUE)",
+      "else",
+      "\tbody <- NULL")
 }
 
-getRequest <- function(functionMetaData)
+getRequest <- function(methodMetaData)
 {
-    method <- functionMetaData$httpMethod
+    method <- methodMetaData$httpMethod
     c(paste0("response <- private$REST$http$exec(\"", method, "\", url, headers, body,"),
       "                                   queryArgs, private$numRetries)")
 }
 
-getResponse <- function(functionMetaData)
+getResponse <- function(methodMetaData)
 {
     "resource <- private$REST$httpParser$parseJSONResponse(response)"
 }
 
-getRequestURL <- function(functionMetaData)
+getErrorCheckingCode <- function()
 {
-    endPoint <- functionMetaData$path
-    endPoint <- stringr::str_replace_all(endPoint, "\\{", "${")
-    url <- c(paste0("endPoint <- stringr::str_interp(\"", endPoint, "\")"),
-             paste0("url <- paste0(private$host, endPoint)"))
-    url
+    c("if(!is.null(resource$errors))",
+      "\tstop(resource$errors)")
 }
 
-getRequestQueryList <- function(functionMetaData)
+getReturnObject <- function()
 {
-    args <- names(functionMetaData$parameters)
-
-    if(length(args) == 0)
-        return("queryArgs <- NULL")
+    "resource"
+}
 
-    args <- sapply(args, function(arg) paste0(arg, " = ", arg))
-    collapsedArgs <- paste0(args, collapse = ", ")
+#NOTE: Arvados class documentation:
 
-    if(nchar(collapsedArgs) > 40)
-    {
-        formatedArgs <- splitArgs(args, 40, ")")
-        return(c(paste0("queryArgs <- list("),
-                 paste0("\t\t", formatedArgs)))
-    }
-    else
+genMethodsDoc <- function(methodResources, resourceNames)
+{
+    methodsDoc <- unlist(unname(Map(function(resource, resourceName)
     {
-        return(paste0("queryArgs <- list(", collapsedArgs, ")"))
-    }
-}
+        methodNames <- names(resource$methods)
 
-createFunction <- function(functionName, functionMetaData, classMetaData)
-{
-    args <- getFunctionArguments(functionMetaData)
-    body <- getFunctionBody(functionMetaData, classMetaData)
-    funSignature <- getFunSignature(functionName, args)
+        methodDoc <- Map(function(methodMetaData, methodName)
+        {
+            #NOTE: Index, show and destroy are aliases for the preferred names
+            # "list", "get" and "delete". Until they are removed from discovery
+            # document we will filter them here.
+            if(methodName %in% c("index", "show", "destroy"))
+               return(NULL)
+
+            methodName <- paste0(resourceName, ".", methodName)
+            getMethodDoc(methodName, methodMetaData)
+
+        }, resource$methods, methodNames)
+
+        unlist(unname(methodDoc))
 
-    functionString <- c(funSignature,
-                        "\t\t{",
-                            body,
-                        "\t\t},\n")
+    }, methodResources, resourceNames)))
 
-    functionString
+    projectDoc <- genProjectMethodsDoc()
+    
+    c(methodsDoc, projectDoc)
 }
 
-getFunSignature <- function(funName, args)
+genAPIClassDoc <- function(methodResources, resourceNames)
 {
-    collapsedArgs <- paste0(args, collapse = ", ")
+    c("#' Arvados",
+      "#'",
+      "#' Arvados class gives users ability to access Arvados REST API.",
+      "#'" ,
+      "#' @section Usage:",
+      "#' \\preformatted{arv = Arvados$new(authToken = NULL, hostName = NULL, numRetries = 0)}",
+      "#'",
+      "#' @section Arguments:",
+      "#' \\describe{",
+      "#' \t\\item{authToken}{Authentification token. If not specified ARVADOS_API_TOKEN environment variable will be used.}",
+      "#' \t\\item{hostName}{Host name. If not specified ARVADOS_API_HOST environment variable will be used.}",
+      "#' \t\\item{numRetries}{Number which specifies how many times to retry failed service requests.}",
+      "#' }",
+      "#'",
+      "#' @section Methods:",
+      "#' \\describe{",
+      getAPIClassMethodList(methodResources, resourceNames),
+      "#' }",
+      "#'",
+      "#' @name Arvados",
+      "#' @examples",
+      "#' \\dontrun{",
+      "#' arv <- Arvados$new(\"your Arvados token\", \"example.arvadosapi.com\")",
+      "#'",
+      "#' collection <- arv$collections.get(\"uuid\")",
+      "#'",
+      "#' collectionList <- arv$collections.list(list(list(\"name\", \"like\", \"Test%\")))",
+      "#' collectionList <- listAll(arv$collections.list, list(list(\"name\", \"like\", \"Test%\")))",
+      "#'",
+      "#' deletedCollection <- arv$collections.delete(\"uuid\")",
+      "#'",
+      "#' updatedCollection <- arv$collections.update(list(name = \"New name\", description = \"New description\"),",
+      "#'                                             \"uuid\")",
+      "#'",
+      "#' createdCollection <- arv$collections.create(list(name = \"Example\",",
+      "#'                                                  description = \"This is a test collection\"))",
+      "#' }",
+      "NULL",
+      "",
+      "#' @export")
+}
 
-    if(nchar(collapsedArgs) > 40)
-    {
-        formatedArgs <- splitArgs(args, 40, ")")
-        return(c(paste0("\t\t", funName, " = function("),
-                 paste0("\t\t\t\t", formatedArgs)))
-    }
-    else
+getAPIClassMethodList <- function(methodResources, resourceNames)
+{
+    methodList <- unlist(unname(Map(function(resource, resourceName)
     {
-        return(paste0("\t\t", funName, " = function(", collapsedArgs, ")"))
-    }
+        methodNames <- names(resource$methods)
+        paste0(resourceName,
+               ".",
+               methodNames[!(methodNames %in% c("index", "show", "destroy"))])
+
+    }, methodResources, resourceNames)))
+    
+    hardcodedMethods <- c("projects.create", "projects.get",
+                          "projects.list", "projects.update", "projects.delete")
+    paste0("#' \t\\item{}{\\code{\\link{", sort(c(methodList, hardcodedMethods)), "}}}") 
 }
 
-generateAPIClassHeader <- function()
+getMethodDoc <- function(methodName, methodMetaData)
 {
-    c("#' @export",
-      "Arvados <- R6::R6Class(",
-      "",
-      "\t\"Arvados\",",
-      "",
-      "\tpublic = list(",
-      "",
-      "\t\tinitialize = function(authToken = NULL, hostName = NULL, numRetries = 0)",
-      "\t\t{",
-      "\t\t\tif(!is.null(hostName))",
-      "\t\t\t\tSys.setenv(ARVADOS_API_HOST = hostName)",
-      "",
-      "\t\t\tif(!is.null(authToken))",
-      "\t\t\t\tSys.setenv(ARVADOS_API_TOKEN = authToken)",
-      "",
-      "\t\t\thostName <- Sys.getenv(\"ARVADOS_API_HOST\")",
-      "\t\t\ttoken    <- Sys.getenv(\"ARVADOS_API_TOKEN\")",
-      "",
-      "\t\t\tif(hostName == \"\" | token == \"\")",
-      "\t\t\t\tstop(paste(\"Please provide host name and authentification token\",",
-      "\t\t\t\t\t\t   \"or set ARVADOS_API_HOST and ARVADOS_API_TOKEN\",",
-      "\t\t\t\t\t\t   \"environment variables.\"))",
-      "",
-      "\t\t\tprivate$token <- token",
-      "\t\t\tprivate$host  <- paste0(\"https://\", hostName, \"/arvados/v1/\")",
-      "\t\t\tprivate$numRetries <- numRetries",
-      "\t\t\tprivate$REST <- RESTService$new(token, hostName,",
-      "\t\t\t                                HttpRequest$new(), HttpParser$new(),",
-      "\t\t\t                                numRetries)",
-      "",
-      "\t\t},\n")
+    name        <- paste("#' @name", methodName)
+    usage       <- getMethodUsage(methodName, methodMetaData)
+    description <- paste("#'", methodName, "is a method defined in Arvados class.")
+    params      <- getMethodDescription(methodMetaData)
+    returnValue <- paste("#' @return", methodMetaData$response[["$ref"]], "object.")
+
+    c(paste("#'", methodName),
+      "#' ",
+      description,
+      "#' ",
+      usage,
+      params,
+      returnValue,
+      name,
+      "NULL",
+      "")
 }
 
-generateAPIClassFooter <- function()
+getMethodUsage <- function(methodName, methodMetaData)
 {
-    c("\t\tgetHostName = function() private$host,",
-      "\t\tgetToken = function() private$token,",
-      "\t\tsetRESTService = function(newREST) private$REST <- newREST",
-      "\t),",
-      "",
-      "\tprivate = list(",
-      "",
-      "\t\ttoken = NULL,",
-      "\t\thost = NULL,",
-      "\t\tREST = NULL,",
-      "\t\tnumRetries = NULL",
-      "\t),",
-      "",
-      "\tcloneable = FALSE",
-      ")")
+    lineLengthLimit <- 40
+    args <- getMethodArguments(methodMetaData)
+    c(formatArgs(paste0("#' @usage arv$", methodName,
+                        "("), "#' \t", args, ")", lineLengthLimit))
 }
 
-generateArvadosClasses <- function(resources)
+getMethodDescription <- function(methodMetaData)
 {
-    classes <- sapply(resources$schemas, function(classSchema)
+    request <- methodMetaData$request
+    requestDoc <- NULL
+
+    if(!is.null(request))
     {
-        #NOTE: Collection is implemented manually.
-        if(classSchema$id != "Collection")
-            getArvadosClass(classSchema)
+        requestDoc <- unname(unlist(sapply(request$properties, function(prop)
+                             {
+                                 className <- sapply(prop, function(ref) ref)
+                                 objectName <- paste0(tolower(substr(className, 1, 1)),
+                                                      substr(className, 2, nchar(className)))
+                                 paste("#' @param", objectName, className, "object.") 
+                             })))
+    }
 
-    }, USE.NAMES = TRUE)
+    argNames <- names(methodMetaData$parameters)
 
-    unlist(unname(classes))
+    argsDoc <- unname(unlist(sapply(argNames, function(argName)
+    {
+        arg <- methodMetaData$parameters[[argName]]
+        argDescription <- arg$description
+        paste("#' @param", argName, argDescription) 
+    })))
 
-    fileConn <- file("./R/ArvadosClasses.R", "w")
-    writeLines(unlist(classes), fileConn)
-    close(fileConn)
-    NULL
+    c(requestDoc, argsDoc)
 }
 
-getArvadosClass <- function(classSchema)
+genProjectMethodsDoc <- function()
 {
-    name   <- classSchema$id
-    fields <- unique(names(classSchema$properties))
-    #fieldsList <- paste0("c(", paste0("\"", fields, "\"", collapse = ", "), ")")
-    constructorArgs <- paste(fields, "= NULL")
-
-    classString <- c("#' @export",
-              paste0(name, " <- R6::R6Class("),
-                     "",
-              paste0("\t\"", name, "\","),
-                     "",
-                     "\tpublic = list(",
-              paste0("\t\t", fields, " = NULL,"),
-                     "",
-                     "\t\tinitialize = function(",
-                     paste0("\t\t\t\t", splitArgs(constructorArgs, 40, ")")),
-                     "\t\t{", 
-              paste0("\t\t\tself$", fields, " <- ", fields),
-                     "\t\t\t",
-                     "\t\t\tprivate$classFields <- c(",
-              paste0("\t\t\t\t", splitArgs(fields, 40)),
-                     "\t\t\t)",
-                     "\t\t},",
-                     "",
-                     "\t\ttoJSON = function() {",
-                     "\t\t\tfields <- sapply(private$classFields, function(field)",
-                     "\t\t\t{",
-                     "\t\t\t\tself[[field]]",
-                     "\t\t\t}, USE.NAMES = TRUE)",
-                     "\t\t\t",
-              paste0("\t\t\tjsonlite::toJSON(list(\"", tolower(name), "\" = 
-                     Filter(Negate(is.null), fields)), auto_unbox = TRUE)"),
-                     "\t\t}",
-                     "\t),",
-                     "",
-                     "\tprivate = list(",
-                     "\t\tclassFields = NULL",
-                     "\t),",
-                     "",
-                     "\tcloneable = FALSE",
-                     ")",
-                     "")
+    #TODO: Manually update this documentation to reflect changes in discovery document.
+    c("#' project.get",
+    "#' ",
+    "#' projects.get is equivalent to groups.get method.",
+    "#' ",
+    "#' @usage arv$projects.get(uuid)",
+    "#' @param uuid The UUID of the Group in question.",
+    "#' @return Group object.",
+    "#' @name projects.get",
+    "NULL",
+    "",
+    "#' project.create",
+    "#' ",
+    "#' projects.create wrapps groups.create method by setting group_class attribute to \"project\".",
+    "#' ",
+    "#' @usage arv$projects.create(group, ensure_unique_name = \"false\")",
+    "#' @param group Group object.",
+    "#' @param ensure_unique_name Adjust name to ensure uniqueness instead of returning an error on (owner_uuid, name) collision.",
+    "#' @return Group object.",
+    "#' @name projects.create",
+    "NULL",
+    "",
+    "#' project.update",
+    "#' ",
+    "#' projects.update wrapps groups.update method by setting group_class attribute to \"project\".",
+    "#' ",
+    "#' @usage arv$projects.update(group, uuid)",
+    "#' @param group Group object.",
+    "#' @param uuid The UUID of the Group in question.",
+    "#' @return Group object.",
+    "#' @name projects.update",
+    "NULL",
+    "",
+    "#' project.delete",
+    "#' ",
+    "#' projects.delete is equivalent to groups.delete method.",
+    "#' ",
+    "#' @usage arv$project.delete(uuid)",
+    "#' @param uuid The UUID of the Group in question.",
+    "#' @return Group object.",
+    "#' @name projects.delete",
+    "NULL",
+    "",
+    "#' project.list",
+    "#' ",
+    "#' projects.list wrapps groups.list method by setting group_class attribute to \"project\".",
+    "#' ",
+    "#' @usage arv$projects.list(filters = NULL,",
+    "#' 	where = NULL, order = NULL, distinct = NULL,",
+    "#' 	limit = \"100\", offset = \"0\", count = \"exact\",",
+    "#' 	include_trash = NULL, uuid = NULL, recursive = NULL)",
+    "#' @param filters ",
+    "#' @param where ",
+    "#' @param order ",
+    "#' @param distinct ",
+    "#' @param limit ",
+    "#' @param offset ",
+    "#' @param count ",
+    "#' @param include_trash Include items whose is_trashed attribute is true.",
+    "#' @param uuid ",
+    "#' @param recursive Include contents from child groups recursively.",
+    "#' @return Group object.",
+    "#' @name projects.list",
+    "NULL",
+    "")
 }
 
-splitArgs <- function(args, lineLength, appendAtEnd = "")
+#NOTE: Utility functions:
+
+# This function is used to split very long lines of code into smaller chunks.
+# This is usually the case when we pass a lot of named argumets to a function.
+formatArgs <- function(prependAtStart, prependToEachSplit,
+                       args, appendAtEnd, lineLength)
 {
-    
     if(length(args) > 1)
+    {
         args[1:(length(args) - 1)] <- paste0(args[1:(length(args) - 1)], ",") 
+    }
 
+    args[1] <- paste0(prependAtStart, args[1])
     args[length(args)] <- paste0(args[length(args)], appendAtEnd)
 
     argsLength <- length(args)
@@ -377,5 +565,11 @@ splitArgs <- function(args, lineLength, appendAtEnd = "")
         argLines <- c(argLines, line)
     }
     
-    unlist(argLines)
+    argLines <- unlist(argLines)
+    argLinesLen <- length(argLines)
+
+    if(argLinesLen > 1)
+        argLines[2:argLinesLen] <- paste0(prependToEachSplit, argLines[2:argLinesLen]) 
+
+    argLines
 }