@@ -1,7 +1,7 @@

 Package: RNAmodR

 Type: Package

 Title: Detection of post-transcriptional modifications

-Version: 0.99.12

+Version: 0.99.13

 Date: 2019-05-21

 Authors@R: c(person("Felix G.M.", 

                     "Ernst", 

@@ -66,6 +66,7 @@ Collate:

     'AllGenerics.R'

     'Gviz-ModifiedSequenceTrack-class.R'

     'Gviz-functions.R'

+    'settings.R'

     'Modifier-utils.R'

     'SequenceDataFrame-class.R'

     'normalization.R'

@@ -160,18 +160,16 @@ ModInosine <- function(x, annotation, sequences, seqinfo, ...){

 # settings ---------------------------------------------------------------------

-.norm_inosine_args <- function(input){

+.ModInosine_settings <- data.frame(

+  variable = c("minScore"),

+  testFUN = c(".not_numeric_between_0_100"),

+  errorValue = c(TRUE),

+  errorMessage = c("'minScore' must be numeric with a value between 0 and 100."),

+  stringsAsFactors = FALSE)

+

+.norm_ModInosine_settings <- function(input){

   minScore <- 0.4

-  if(!is.null(input[["minScore"]])){

-    minScore <- input[["minScore"]]

-    if(!is.numeric(minScore) | minScore < 0 | minScore > 100){

-      stop("'minScore' must be numeric with a value between 0 and 100.",

-           call. = FALSE)

-    }

-  }

-  args <- .norm_args(input)

-  args <- c(args,

-            list(minScore = minScore))

+  args <- .norm_settings(input, .ModInosine_settings, minScore)

   args

 }

@@ -181,8 +179,8 @@ setReplaceMethod(f = "settings",

                  signature = signature(x = "ModInosine"),

                  definition = function(x, value){

                    x <- callNextMethod()

-                   value <- .norm_inosine_args(value)

-                   x@arguments[names(value)] <- unname(value)

+                   value <- .norm_ModInosine_settings(value)

+                   x@settings[names(value)] <- unname(value)

                    x

                  })

@@ -3,6 +3,7 @@

 #' @include SequenceDataSet-class.R

 #' @include SequenceDataList-class.R

 #' @include Modifier-utils.R

+#' @include settings.R

 NULL

 invalidMessage <- paste0("Settings were changed after data aggregation or ",

@@ -120,7 +121,7 @@ invalidMessage <- paste0("Settings were changed after data aggregation or ",

 #' \code{dataType} is used.

 #' @slot aggregate the aggregated data as a \code{SplitDataFrameList}

 #' @slot modifications the found modifications as a \code{GRanges} object

-#' @slot arguments arguments used for the analysis as a \code{list}

+#' @slot settings arguments used for the analysis as a \code{list}

 #' @slot aggregateValidForCurrentArguments \code{TRUE} or \code{FALSE} whether

 #' the aggregate data was constructed with the current arguments

 #' @slot modificationsValidForCurrentArguments \code{TRUE} or \code{FALSE}

@@ -206,7 +207,7 @@ setClass("Modifier",

                    data = "SD_or_SDS_or_SDL",

                    aggregate = "CompressedSplitDataFrameList",

                    modifications = "GRanges",

-                   arguments = "list",

+                   settings = "list",

                    aggregateValidForCurrentArguments = "logical",

                    modificationsValidForCurrentArguments = "logical"),

          prototype = list(aggregateValidForCurrentArguments = FALSE,

@@ -495,40 +496,8 @@ setMethod(f = "sequences",

 #' @export

 setMethod(f = "seqinfo",

           signature = signature(x = "Modifier"),

-          definition = function(x){seqinfo(sequenceData(x))})

-

-.norm_args <- function(input){

-  minCoverage <- 10L

-  minReplicate <- 1L

-  find.mod <- TRUE

-  if(!is.null(input[["minCoverage"]])){

-    minCoverage <- input[["minCoverage"]]

-    if(!is.integer(minCoverage) ||

-       minCoverage < 0L ||

-       length(minCoverage) != 1){

-      stop("'minCoverage' must be a single positive integer value.")

-    }

-  }

-  if(!is.null(input[["minReplicate"]])){

-    minReplicate <- input[["minReplicate"]]

-    if(!is.integer(minReplicate) ||

-       minReplicate < 0L ||

-       length(minReplicate) != 1){

-      stop("'minReplicate' must be a single positive integer value.")

-    }

-  }

-  if(!is.null(input[["find.mod"]])){

-    find.mod <- input[["find.mod"]]

-    if(!assertive::is_a_bool(find.mod)){

-      stop("'find.mod' must be a single logical value.")

-    }

-  }

-  args <- list(minCoverage = minCoverage,

-               minReplicate = minReplicate,

-               find.mod = find.mod)

-  args

-}

-

+          definition = function(x){seqinfo(sequenceData(x))}

+)

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "validAggregate",

@@ -582,18 +551,42 @@ setMethod(f = "validModification",

 #' settings(mi) <- list(minCoverage = 11L)

 NULL

+.Modifier_settings <- data.frame(

+  variable = c("minCoverage",

+               "minReplicate",

+               "find.mod"),

+  testFUN = c(".not_integer_bigger_than_zero",

+              ".not_integer_bigger_than_zero",

+              ".is_a_bool"),

+  errorValue = c(TRUE,

+                 TRUE,

+                 FALSE),

+  errorMessage = c("'minCoverage' must be a single positive integer value.",

+                   "'minReplicate' must be a single positive integer value.",

+                   "'find.mod' must be a single logical value."),

+  stringsAsFactors = FALSE)

+

+.norm_Modifier_settings <- function(input){

+  minCoverage <- 10L

+  minReplicate <- 1L

+  find.mod <- TRUE

+  args <- .norm_settings(input, .Modifier_settings, minCoverage, minReplicate,

+                         find.mod)

+  args

+}

+

 #' @rdname settings

 #' @export

 setMethod(f = "settings",

           signature = signature(x = "Modifier"),

           definition = function(x, name){

             if(missing(name) || is.null(name)){

-              return(x@arguments)

+              return(x@settings)

             }

             if(!assertive::is_a_string(name)){

               stop("'name' must be a single character value.")

             }

-            x@arguments[[name]]

+            x@settings[[name]]

           }

 )

@@ -608,8 +601,8 @@ setReplaceMethod(f = "settings",

                    if(!is.list(value)){

                      value <- as.list(value)

                    }

-                   value <- .norm_args(value)

-                   x@arguments[names(value)] <- unname(value)

+                   value <- .norm_Modifier_settings(value)

+                   x@settings[names(value)] <- unname(value)

                    x@aggregateValidForCurrentArguments <- FALSE

                    x@modificationsValidForCurrentArguments <- FALSE

                    x

@@ -75,6 +75,20 @@ NULL

 }

 .rocr_exclusive_functions <- c("rch","auc","prbe","mxe","rmse","ecost")

+.rocr_performance_settings <- data.frame(

+  variable = c("measure",

+               "x.measure",

+               "score"),

+  testFUN = c(".is_a_string",

+              ".is_a_string",

+              ".is_a_string"),

+  errorValue = c(FALSE,

+                 FALSE,

+                 FALSE),

+  errorMessage = c("'measure' must a single character compatible with ?ROCR::performance.",

+                   "'x.measure' must a single character compatible with ?ROCR::performance.",

+                   "'score' must a single character and a valid column name in getAggregateData()."),

+  stringsAsFactors = FALSE)

 .norm_performance_args <- function(input, x){

   if(!is.list(input)){

     stop("'performance.args' must be a list.")

@@ -87,45 +101,48 @@ NULL

   measure <- "tpr"

   x.measure <- "fpr"

   score <- mainScore(x)

-  if(!is.null(input[["measure"]])){

-    measure <- input[["measure"]]

-    if(!assertive::is_a_string(measure)){

-      stop("'measure' must a single character compatible with ",

-           "?ROCR::performance.",

-           call. = FALSE)

-    }

+  args <- .norm_settings(input, .rocr_performance_settings, measure, x.measure,

+                         score)

+  if(args[["measure"]] %in% .rocr_exclusive_functions){

+    args[["x.measure"]] <- "cutoff"

   }

-  if(!is.null(input[["x.measure"]])){

-    if(length(input[["x.measure"]]) == 0L || is.na(input[["x.measure"]]) || 

-       input[["x.measure"]] == ""){

-      x.measure <- "cutoff"

-    } else {

-      x.measure <- input[["x.measure"]]

-      if(!assertive::is_a_string(x.measure)){

-        stop("'x.measure' must a single character compatible with ",

-             "?ROCR::performance.",

-             call. = FALSE)

-      }

-    }

-  } else if(measure %in% .rocr_exclusive_functions){

-    x.measure <- "cutoff"

+  if(is(x,"Modifier")){

+    cn <- colnames(getAggregateData(x)[[1]])

+  } else if(is(x,"ModifierSet")) {

+    cn <- colnames(getAggregateData(x[[1]])[[1]])

+  } else {

+    stop("")

   }

-  if(!is.null(input[["score"]])){

-    score <- input[["score"]]

-    if(!assertive::is_a_string(score) ||

-       !(score %in% colnames(getAggregateData(x)[[1]]))){

-      stop("'score' must a single character and a valid column name in ",

-           "getAggregateData().",

-           call. = FALSE)

-    }

+  if(!(args[["score"]] %in% cn)){

+    stop(.rocr_performance_settings[.rocr_performance_settings$variable == "score","errorMessage"],

+         call. = FALSE)

   }

-  args <- list(measure = measure,

-               x.measure = x.measure,

-               score = score)

   args <- c(args, input[!(names(input) %in% names(args))])

   args

 }

+.rocr_plot_settings <- data.frame(

+  variable = c("colorize",

+               "lwd",

+               "colorize.palette",

+               "abline",

+               "AUC"),

+  testFUN = c(".is_a_bool",

+              ".is_numeric_string",

+              ".is_a_string",

+              ".is_a_bool",

+              ".is_a_bool"),

+  errorValue = c(FALSE,

+                 FALSE,

+                 FALSE,

+                 FALSE,

+                 FALSE),

+  errorMessage = c("'colorize' must a single logical value.",

+                   "'lwd' must be a single numeric value.",

+                   "'colorize.palette' must a single character compatible with ?ROCR::plot.performance.",

+                   "'abline' must a single logical value.",

+                   "'AUC' must a single logical value."),

+  stringsAsFactors = FALSE)

 .norm_plot_args <- function(input){

   if(!is.list(input)){

     stop("'plot.args' must be a list.")

@@ -140,47 +157,8 @@ NULL

   colorize.palette <- NULL

   abline <- FALSE

   AUC <- FALSE

-  if(!is.null(input[["colorize.palette"]])){

-    colorize.palette <- input[["colorize.palette"]]

-    if(!assertive::is_a_string(colorize.palette)){

-      stop("'colorize.palette' must a single character compatible with ",

-           "?ROCR::plot.performance.",

-           call. = FALSE)

-    }

-  }

-  if(!is.null(input[["abline"]])){

-    abline <- input[["abline"]]

-    if(!assertive::is_a_bool(abline)){

-      stop("'abline' must a single logical value.",

-           call. = FALSE)

-    }

-  }

-  if(!is.null(input[["AUC"]])){

-    AUC <- input[["AUC"]]

-    if(!assertive::is_a_bool(AUC)){

-      stop("'AUC' must a single logical value.",

-           call. = FALSE)

-    }

-  }

-  if(!is.null(input[["colorize"]])){

-    colorize <- input[["colorize"]]

-    if(!assertive::is_a_bool(colorize)){

-      stop("'colorize' must a single logical value.",

-           call. = FALSE)

-    }

-  }

-  if(!is.null(input[["lwd"]])){

-    lwd <- input[["lwd"]]

-    if(!assertive::is_numeric_string(lwd)){

-      stop("'lwd' must be a single numeric value.",

-           call. = FALSE)

-    }

-  }

-  args <- list(colorize = colorize,

-               lwd = lwd,

-               colorize.palette = colorize.palette,

-               abline = abline,

-               AUC = AUC)

+  args <- .norm_settings(input, .rocr_plot_settings, colorize, lwd,

+                         colorize.palette, abline, AUC)

   args <- c(args, input[!(names(input) %in% names(args))])

   args

 }

@@ -1,5 +1,6 @@

 #' @include RNAmodR.R

 #' @include Modifier-class.R

+#' @include settings.R

 NULL

 #' @name subsetByCoord

@@ -67,7 +67,7 @@ NULL

 NULL

 .norm_show_argument <- function(show_arg, default = FALSE){

-  if(!assertive::is_a_bool(show_arg)){

+  if(missing(show_arg) || !assertive::is_a_bool(show_arg)){

     show_arg <- default

   }

   show_arg

@@ -94,27 +94,23 @@ NULL

   type

 }

+.viz_Modifier_settings <- data.frame(

+  variable = c("modified.seq",

+               "additional.mod"),

+  testFUN = c(".is_a_bool",

+              ".is_not_GRanges_or_GRangesList"),

+  errorValue = c(FALSE,

+                 TRUE),

+  errorMessage = c("'modified.seq' must be a single logical value.",

+                   "'additional.mod' must be a GRanges or GRangesList object, which is compatible with combineIntoModstrings()."),

+  stringsAsFactors = FALSE)

 .norm_viz_args_Modifier <- function(input, x){

   modified.seq <- FALSE

   additional.mod <- GRanges()

-  if(!is.null(input[["modified.seq"]])){

-    modified.seq <- input[["modified.seq"]]

-    if(!assertive::is_a_bool(modified.seq)){

-      stop("'modified.seq' must be a single logical value.",

-           call. = FALSE)

-    }

-  }

-  if(!is.null(input[["additional.mod"]])){

-    additional.mod <- input[["additional.mod"]]

-    if(!is(additional.mod,"GRanges") && !is(additional.mod,"GRangesList")){

-      stop("'additional.mod' must be a GRanges or GRangesList object, which is",

-           " compatible with combineIntoModstrings().",

-           call. = FALSE)

-    }

-  }

+  args <- .norm_settings(input, .viz_Modifier_settings, modified.seq,

+                         additional.mod)

   args <- c(.norm_viz_args_SequenceData(input, x),

-            list(modified.seq = modified.seq,

-                 additional.mod = additional.mod))

+            args)

   args

 }

@@ -131,16 +131,16 @@ setMethod(f = "relistToClass",

        listData = x)

 }

+

+.ModifierSet_settings <- data.frame(

+  variable = c("internalBP"),

+  testFUN = c("assertive::is_a_bool"),

+  errorValue = c(FALSE),

+  errorMessage = c("'internalBP' must be TRUE or FALSE."),

+  stringsAsFactors = FALSE)

 .norm_ModifierSet_args <- function(input){

   internalBP <- FALSE

-  if(!is.null(input[["internalBP"]])){

-    internalBP <- input[["internalBP"]]

-    if(!assertive::is_a_bool(internalBP)){

-      stop("'internalBP' must be TRUE or FALSE.",

-           call. = FALSE)

-    }

-  }

-  args <- list(internalBP = internalBP)

+  args <- .norm_settings(input, .ModifierSet_settings, internalBP)

   args

 }

@@ -99,6 +99,7 @@ NULL

   } else {

     compareType <- NA

   }

+  # browser()

   allTypes <- FALSE

   perTranscript <- FALSE

   sequenceData <- FALSE

@@ -2,18 +2,17 @@

 #' @include Modifier-viz.R

 NULL

+.viz_ModifierSet_settings <- data.frame(

+  variable = c("colours"),

+  testFUN = c(".not_colours"),

+  errorValue = c(TRUE),

+  errorMessage = c("'colours' must be valid colour representation, which can be interpreted by col2rgb()."),

+  stringsAsFactors = FALSE)

 .norm_viz_args_ModifierSet <- function(input, x){

   colours <- NA

-  if(!is.null(input[["colours"]])){

-    colours <- input[["colours"]]

-    if(!is.character(colours) || any(!.are_colours(colours))){

-      stop("'colours' must be valid colour representation, which can be ",

-           "interpreted by col2rgb().",

-           call. = FALSE)

-    }

-  }

+  args <- .norm_settings(input, .viz_ModifierSet_settings, colours)

   args <- c(.norm_viz_args_Modifier(input, x),

-            list(colours = colours))

+            args)

   args

 }

@@ -1,6 +1,7 @@

 #' @include RNAmodR.R

 #' @include normalization.R

 #' @include SequenceDataFrame-class.R

+#' @include settings.R

 NULL

 #' @name SequenceData-class

@@ -105,9 +106,9 @@ setClass("SequenceData",

                    unlistType = "character",

                    dataDescription = "character"),

          prototype = list(ranges = GRangesList(),

-                 sequencesType = "RNAStringSet",

-                 sequences = RNAStringSet(),

-                 unlistType = "SequenceDataFrame"))

+                          sequencesType = "RNAStringSet",

+                          sequences = RNAStringSet(),

+                          unlistType = "SequenceDataFrame"))

 setMethod(

   f = "initialize",

@@ -397,17 +398,15 @@ setMethod("rownames", "SequenceData",

 # constructor ------------------------------------------------------------------

+.quality_settings <- data.frame(

+  variable = c("minQuality"),

+  testFUN = c(".not_integer_bigger_equal_than_one"),

+  errorValue = c(TRUE),

+  errorMessage = c("'minQuality' must be integer with a value higher than 1L."),

+  stringsAsFactors = FALSE)

+

 .norm_min_quality <- function(input, minQuality){

-  if(!is.null(input[["minQuality"]])){

-    minQuality <- input[["minQuality"]]

-    if(!is.integer(minQuality) | minQuality <= 1L){

-      if(!is.na(minQuality)){

-        stop("'minQuality' must be integer with a value higher than 1L.",

-             call. = FALSE)

-      }

-    }

-  }

-  minQuality

+  .norm_settings(input, .quality_settings, minQuality)[["minQuality"]]

 }

 .get_replicate_number <- function(bamfiles, conditions){

@@ -2,10 +2,42 @@

 #' @include SequenceData-class.R

 #' @include SequenceDataSet-class.R

 #' @include Modifier-subset.R

+#' @include settings.R

 NULL

 # common utility function for subsetting ---------------------------------------

+.subset_settings <- data.frame(

+  variable = c("name",

+               "type",

+               "merge",

+               "flanking",

+               "rawData",

+               "perTranscript",

+               "sequenceData"),

+  testFUN = c(".empty_character",

+              ".empty_character",

+              ".is_a_bool",

+              ".not_integer_bigger_equal_than_zero",

+              ".is_a_bool",

+              ".is_a_bool",

+              ".is_a_bool"),

+  errorValue = c(TRUE,

+                 TRUE,

+                 FALSE,

+                 TRUE,

+                 FALSE,

+                 FALSE,

+                 FALSE),

+  errorMessage = c("'name' must be a character with a width > 0L.",

+                   "'type' must be a character with a width > 0L.",

+                   "'merge' must be a single logical value.",

+                   "'flanking' must be a single integer value equal or higher than 0L.",

+                   "'rawData' must be a single logical value.",

+                   "'perTranscript' must be a single logical value.",

+                   "'sequenceData' must be a single logical value."),

+  stringsAsFactors = FALSE)

+

 .norm_subset_args <- function(input,x){

   name <- NA_character_

   if(is(x,"Modifier") || is(x,"ModifierSet")){

@@ -18,62 +50,14 @@ NULL

   perTranscript <- FALSE

   sequenceData <- FALSE

   rawData <- FALSE # only used for subsetting SequenceData

-  if(!is.null(input[["name"]])){

-    name <- input[["name"]]

-    if(!is.character(name) || width(name) == 0L){

-      stop("'name' must be a character with a width > 0L.",

-           call. = FALSE)

-    }

-  }

-  if(!is.null(input[["type"]])){

-    type <- input[["type"]]

-    if(!is.na(type)){

-      if(!is.character(type) || width(type) == 0L){

-        stop("'type' must be a character with a width > 0L.",

-             call. = FALSE)

-      }

-      if(!(type %in% Modstrings::shortName(Modstrings::ModRNAString()))){

-        stop("'type' must be one or more elements of shortName(ModRNAString()).",

-             call. = FALSE)

-      }

-    }

-  }

-  if(!is.null(input[["merge"]])){

-    merge <- input[["merge"]]

-    if(!assertive::is_a_bool(merge)){

-      stop("'merge' must be a single logical value.", call. = FALSE)

-    }

-  }

-  if(!is.null(input[["flanking"]])){

-    flanking <- input[["flanking"]]

-    if(!is.integer(flanking) || flanking < 0L){

-      stop("'flanking' must be a single integer value equal or higher than 0L.",

-           call. = FALSE)

-    }

-  }

-  if(!is.null(input[["rawData"]])){ # only used for subsetting SequenceData

-    rawData <- input[["rawData"]]

-    if(!assertive::is_a_bool(rawData)){

-      stop("'rawData' must be a single logical value.",

+  args <- .norm_settings(input, .subset_settings, name, type, merge, flanking,

+                         perTranscript, sequenceData, rawData)

+  if(!is.na(args[["type"]])){

+    if(!(args[["type"]] %in% Modstrings::shortName(Modstrings::ModRNAString()))){

+      stop("'type' must be one or more elements of shortName(ModRNAString()).",

            call. = FALSE)

     }

   }

-  if(!is.null(input[["perTranscript"]])){

-    perTranscript <- input[["perTranscript"]]

-    if(!assertive::is_a_bool(perTranscript)){

-      stop("'perTranscript' must be a single logical value.",

-           call. = FALSE)

-    }

-  }

-  if(!is.null(input[["sequenceData"]])){

-    sequenceData <- input[["sequenceData"]]

-    if(!assertive::is_a_bool(sequenceData)){

-      stop("'sequenceData' must be a single logical value.")

-    }

-  }

-  args <- list(name = name, type = type, merge = merge, flanking = flanking,

-               rawData = rawData, perTranscript = perTranscript,

-               sequenceData = sequenceData)

   args

 }

@@ -65,17 +65,6 @@ NULL

        to = end)

 }

-

-#' @importFrom grDevices col2rgb

-.are_colours <- function(x) {

-  vapply(x,

-         function(z) {

-           tryCatch(is.matrix(grDevices::col2rgb(z)),

-                    error = function(e) FALSE)

-         },

-         logical(1))

-}

-

 .norm_viz_colour <- function(colour, type = NA){

   if(!is.character(colour) || any(!.are_colours(colour))){

     stop("'colour' must be a character vector and contain valid colours, which",

new file mode 100644

@@ -0,0 +1,118 @@

+#' @include RNAmodR.R

+NULL

+

+# testthat

+

+.test_test_TRUE <- function(x){TRUE}

+.test_test_FALSE <- function(x){FALSE}

+

+# tests ------------------------------------------------------------------------

+

+.not_logical_operator <- function(x){

+  .empty_character(x) | !(x %in% c("|","&"))

+}

+

+.not_single_numeric <- function(x){

+  !is.numeric(x) | length(x) != 1 | is.na(x)

+}

+.not_numeric_between_0_100 <- function(x){

+  .not_single_numeric(x) | x < 0 | x > 100

+}

+.not_numeric_between_0_1 <- function(x){

+  .not_single_numeric(x) | x < 0 | x > 1

+}

+.not_numeric_bigger_zero <- function(x){

+  .not_single_numeric(x) | x < 0

+}

+

+.not_single_integer <- function(x){

+  !is.integer(x) | length(x) != 1 | is.na(x)

+}

+.not_integer_bigger_than_10 <- function(x){

+  .not_single_integer(x) | x <= 10L

+}

+.not_integer_bigger_than_zero <- function(x){

+  .not_single_integer(x) | x <= 0L

+}

+.not_integer_bigger_equal_than_zero <- function(x){

+  .not_single_integer(x) | x < 0L

+}

+.not_integer_bigger_equal_than_one <- function(x){

+  .not_single_integer(x) | x <= 1L

+}

+

+.is_not_GRanges_or_GRangesList <- function(x){

+  !is(x,"GRanges") && !is(x,"GRangesList")

+}

+

+#' @importFrom grDevices col2rgb

+.are_colours <- function(x) {

+  vapply(x,

+         function(z) {

+           tryCatch(is.matrix(grDevices::col2rgb(z)),

+                    error = function(e) FALSE)

+         },

+         logical(1))

+}

+.not_colours <- function(x){

+  !is.character(x) | any(!.are_colours(x))

+}

+

+.empty_character <- function(x){

+  if(!is.character(x) | is.na(x)){

+    return(TRUE)

+  }

+  width(x) == 0L

+}

+

+# test import from assertive ---------------------------------------------------

+

+.is_a_bool <- assertive::is_a_bool

+.is_numeric_string <- assertive::is_numeric_string

+.is_a_string <- assertive::is_a_string

+

+# testing settings -------------------------------------------------------------

+

+.get_name_in_parent_list <- function(...){

+  xnames <- assertive::get_name_in_parent(list(...))

+  xnames <- gsub("list\\(","",gsub("\\)","",xnames))

+  xnames <- strsplit(xnames,", ")[[1]]

+  xnames

+}

+

+.test_setting <- function(xname, settings, defaults, input){

+  test <- settings$variable == xname

+  FUN <- as.character(settings[test,"testFUN"])

+  default <- defaults[[xname]]

+  input <- input[[xname]]

+  if(is.null(input)){

+    return(default)

+  }

+  FUN <- get(FUN)

+  if(FUN(input) == settings[test,"errorValue"]){

+    stop(as.character(settings[test,"errorMessage"]), call. = FALSE)

+  }

+  input

+}

+

+.norm_settings <- function(input, settings, ...){

+  if(!all(c("variable","testFUN","errorValue","errorMessage") %in% colnames(settings))){

+    stop("Invalid columns in settings test definition.", call. = FALSE)

+  }

+  if(any(duplicated(settings$variable))){

+    stop("Duplicated variable names in settings test definition.",

+         call. = FALSE)

+  }

+  xnames <- .get_name_in_parent_list(...)

+  defaults <- list(...)

+  names(defaults) <- xnames

+  f <- xnames %in% settings$variable

+  if(!all(f)){

+    stop("Test for variables '",

+         paste(xnames[!f],collapse = "', '"),

+         "' not found.", call. = FALSE)

+  }

+  args <- lapply(xnames, .test_setting, settings, defaults, input)

+  names(args) <- xnames

+  args

+}

Binary files a/data/msi.rda and b/data/msi.rda differ

@@ -123,7 +123,7 @@ condition types.}

 \item{\code{modifications}}{the found modifications as a \code{GRanges} object}

-\item{\code{arguments}}{arguments used for the analysis as a \code{list}}

+\item{\code{settings}}{arguments used for the analysis as a \code{list}}

 \item{\code{aggregateValidForCurrentArguments}}{\code{TRUE} or \code{FALSE} whether

 the aggregate data was constructed with the current arguments}

new file mode 100644

@@ -0,0 +1,65 @@

+

+context("Settings")

+test_that("Settings:",{

+  variable1 <- 1

+  variable2 <- 2

+  variable3 <- 3

+  expect_equal(RNAmodR:::.get_name_in_parent_list(),character(0))

+  expect_equal(RNAmodR:::.get_name_in_parent_list(variable1),c("variable1"))

+  expect_equal(RNAmodR:::.get_name_in_parent_list(variable1,variable2),

+               c("variable1","variable2"))

+  .test_settings_df <- data.frame(

+    variable = c("variable1","variable2"),

+    stringsAsFactors = FALSE)

+  expect_error(RNAmodR:::.test_setting("variable1",.test_settings_df,list(variable1 = 2),

+                                        list(variable1 = 3)),

+               "invalid first argument")

+  expect_error(RNAmodR:::.norm_settings(list(variable2 = 4),.test_settings_df,

+                                        variable1),

+               "Invalid columns in settings test definition")

+  .test_settings_df <- data.frame(

+    variable = c("variable1","variable1"),

+    testFUN = c(".test_test_TRUE",".test_test_FALSE"),

+    errorValue = c(FALSE,TRUE),

+    errorMessage = c("1","2"),

+    stringsAsFactors = FALSE)

+  expect_error(RNAmodR:::.norm_settings(list(variable2 = 4),.test_settings_df,

+                                        variable1),

+               "Duplicated variable names in settings test definition")

+  .test_settings_df <- data.frame(

+    variable = c("variable1","variable2"),

+    testFUN = c(".test_test_TRUE",".test_test_FALSE"),

+    errorValue = c(FALSE,TRUE),

+    errorMessage = c("1","2"),

+    stringsAsFactors = FALSE)

+  expect_equal(RNAmodR:::.test_setting("variable1",.test_settings_df,list(variable1 = 2),

+                                       list(variable1 = 3)),

+               3)

+  expect_equal(RNAmodR:::.test_setting("variable1",.test_settings_df,list(variable1 = 2),

+                                       list()),

+               2)

+  .test_settings_df <- data.frame(

+    variable = c("variable1","variable2"),

+    testFUN = c(".test_test_TRUE",".test_test_FALSE"),

+    errorValue = c(TRUE,TRUE),

+    errorMessage = c("1","2"),

+    stringsAsFactors = FALSE)

+  expect_error(RNAmodR:::.test_setting("variable1",.test_settings_df,list(variable1 = 2),

+                                       list(variable1 = 3)),

+               "1")

+  expect_equal(RNAmodR:::.test_setting("variable2",.test_settings_df,list(variable2 = 2),

+                                       list(variable2 = 3)),

+               3)

+  expect_equal(RNAmodR:::.norm_settings(list(variable2 = 4),.test_settings_df,

+                                        variable1),

+               list(variable1 = 1))

+  expect_equal(RNAmodR:::.norm_settings(list(variable2 = 4),.test_settings_df,

+                                        variable2),

+               list(variable2 = 4))

+  expect_error(RNAmodR:::.norm_settings(list(variable1 = 4),.test_settings_df,

+                                        variable1),

+               "1")

+  expect_error(RNAmodR:::.norm_settings(list(variable3 = 4),.test_settings_df,

+                                        variable3),

+               "Test for variables 'variable3' not found.")

+})

@@ -70,22 +70,22 @@ test_that("SequenceDataList:",{

   expect_equal(ranges(sdl),ranges(sdl[[1]]))

   expect_equal(sequences(sdl),sequences(sdl[[1]]))

   ##############################################################################

-  # actual <- aggregate(sdl)

-  # expect_s4_class(actual,"SimpleList")

-  # expect_equal(actual,

-  #              SimpleList(End5SequenceData_PileupSequenceData = aggregate(sdl[[1]]),

-  #                         End5SequenceData = aggregate(sdl[[2]]),

-  #                         PileupSequenceData = aggregate(sdl[[3]])))

-  # actual <- as.list(sdl)

-  # expect_type(actual,"list")

-  # expect_named(actual,names)

-  # expect_equal(actual[[2]],e5sd)

-  # expect_equal(actual[[3]],psd)

-  # actual <- as.list(sdl, use.names = FALSE)

-  # expect_null(names(actual))

-  # expect_true(validObject(actual))

-  # # error

-  # expect_error(SequenceDataSet(e5sd,c(1,2,3)),

-  #              "All elements in 'x' must be SequenceData objects")

-  # expect_error(as.list(sdl, use.names = 1))

+  actual <- aggregate(sdl)

+  expect_s4_class(actual,"SimpleList")

+  expect_equal(actual,

+               SimpleList(End5SequenceData_PileupSequenceData = aggregate(sdl[[1]]),

+                          End5SequenceData = aggregate(sdl[[2]]),

+                          PileupSequenceData = aggregate(sdl[[3]])))

+  actual <- as.list(sdl)

+  expect_type(actual,"list")

+  expect_named(actual,names)

+  expect_equal(actual[[2]],e5sd)

+  expect_equal(actual[[3]],psd)

+  actual <- as.list(sdl, use.names = FALSE)

+  expect_null(names(actual))

+  expect_true(validObject(actual))

+  # error

+  expect_error(SequenceDataSet(e5sd,c(1,2,3)),

+               "All elements in 'x' must be SequenceData objects")

+  expect_error(as.list(sdl, use.names = 1))

 })

@@ -5,18 +5,18 @@ test_that("Modifier/ModifierSet:",{