@@ -1,8 +1,8 @@

 Package: RNAmodR

 Type: Package

 Title: Detection of post-transcriptional modifications in high throughput sequencing data

-Version: 1.3.3

-Date: 2020-06-08

+Version: 1.3.4

+Date: 2020-07-18

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

                     "Ernst", 

                     email = "felix.gm.ernst@outlook.com", 

@@ -28,14 +28,12 @@ Depends:

     S4Vectors (>= 0.27.12),

     IRanges (>= 2.23.9),

     GenomicRanges,

-    Modstrings,

-    GenomeInfoDbData

+    Modstrings

 Imports:

     methods,

     stats,

     grDevices, 

     matrixStats,

-    assertive,

     BiocGenerics,

     Biostrings (>= 2.57.2),

     BiocParallel,

@@ -137,7 +137,6 @@ import(BiocGenerics)

 import(GenomicRanges)

 import(Gviz)

 import(S4Vectors)

-import(assertive)

 import(methods)

 importClassesFrom(IRanges,CharacterList)

 importClassesFrom(IRanges,IRanges)

@@ -302,10 +302,10 @@ setClass("Modifier",

   if(is(seqdata,"SequenceData")){

     seqdata <- list(seqdata)

   }

-  if(!assertive::is_a_bool(x@aggregateValidForCurrentArguments)){

+  if(!.is_a_bool(x@aggregateValidForCurrentArguments)){

     return("Invalid slot: 'aggregateValidForCurrentArguments'")

   }

-  if(!assertive::is_a_bool(x@aggregateValidForCurrentArguments)){

+  if(!.is_a_bool(x@aggregateValidForCurrentArguments)){

     return("Invalid slot: 'modificationsValidForCurrentArguments'")

   }

   if(hasAggregateData(x)){

@@ -448,8 +448,9 @@ setMethod(f = "modifications",

           signature = signature(x = "Modifier"),

           definition =

             function(x, perTranscript = FALSE){

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

-                stop("'perTranscript' has to be a single logical value.")

+              if(!.is_a_bool(perTranscript)){

+                stop("'perTranscript' has to be a single logical value.",

+                     call. = FALSE)

               }

               valid <- c(validAggregate(x), validModification(x))

               if(!all(valid)){

@@ -554,7 +555,7 @@ setMethod(f = "sequences",

           signature = signature(x = "Modifier"),

           definition =

             function(x, modified = FALSE){

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

+              if(!.is_a_bool(modified)){

                 stop("'modified' has to be a single logical value.",

                      call. = FALSE)

               }

@@ -648,8 +649,9 @@ setMethod(f = "settings",

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

               return(x@settings)

             }

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

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

+            if(!.is_a_string(name)){

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

+                   call. = FALSE)

             }

             x@settings[[name]]

           }

@@ -975,7 +977,10 @@ setMethod(f = "aggregate",

           signature = signature(x = "Modifier"),

           definition =

             function(x, force = FALSE){

-              assertive::assert_is_a_bool(force)

+              if(!.is_a_bool(force)){

+                stop("'force' has to be TRUE or FALSE.",

+                     call. = FALSE)

+              }

               if(!hasAggregateData(x) || force){

                 x@aggregate <- .check_aggregate_modifier(aggregateData(x), x)

                 x@aggregateValidForCurrentArguments <- TRUE

@@ -1065,7 +1070,10 @@ setMethod(f = "modify",

           signature = signature(x = "Modifier"),

           definition =

             function(x, force = FALSE){

-              assertive::assert_is_a_bool(force)

+              if(!.is_a_bool(force)){

+                stop("'force' has to be TRUE or FALSE.",

+                     call. = FALSE)

+              }

               if(!validAggregate(x) | force){

                 x <- aggregate(x, force = TRUE)

               }

@@ -10,10 +10,21 @@ setMethod(f = "constructModRanges",

             if(nrow(data) == 0L) {

               return(GenomicRanges::GRanges()) 

             }

-            assertive::assert_is_a_non_empty_string(modType)

-            assertive::assert_is_closure_function(scoreFun)

-            assertive::assert_is_a_non_empty_string(source)

-            assertive::assert_is_a_non_empty_string(type)

+            if(!.is_non_empty_string(modType)){

+              stop("'modType' must be single non empty character value.",

+                   call. = FALSE)

+            }

+            if(!.is_function(scoreFun)){

+              stop("'scoreFun' must be a function.", call. = FALSE)

+            }

+            if(!.is_non_empty_string(source)){

+              stop("'source' must be single non empty character value.",

+                   call. = FALSE)

+            }

+            if(!.is_non_empty_string(type)){

+              stop("'type' must be single non empty character value.",

+                   call. = FALSE)

+            }

             if(!.is_valid_modType(modType)){

               stop("Modification '",modType,"' not found in the short name ",

                    "alphabet from the Modstrings package. ",

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

 NULL

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

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

+  if(missing(show_arg) || !.is_a_bool(show_arg)){

     show_arg <- default

   }

   show_arg

@@ -133,7 +133,7 @@ setMethod(f = "relistToClass",

 .ModifierSet_settings <- data.frame(

   variable = c("internalBP"),

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

+  testFUN = c(".is_a_bool"),

   errorValue = c(FALSE),

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

   stringsAsFactors = FALSE)

@@ -480,7 +480,7 @@ setMethod(f = "sequences",

           signature = signature(x = "ModifierSet"),

           definition = 

             function(x, modified = FALSE){

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

+              if(!.is_a_bool(modified)){

                 stop("'modified' has to be a single logical value.",

                      call. = FALSE)

               }

@@ -97,7 +97,7 @@ NULL

                "allTypes",

                "perTranscript",

                "sequenceData"),

-  testFUN = c(".is_a_non_empty_string",

+  testFUN = c(".is_non_empty_string",

               ".is_a_bool",

               ".is_a_bool",

               ".is_a_bool"),

@@ -263,7 +263,10 @@ setMethod("compareByCoord",

     colnames <- colnames(data)

     colnames <- colnames[!(colnames %in% c("positions","names","mod","Activity"))]

     if(is.character(normalize)){

-      assertive::assert_is_a_string(normalize)

+      if(!.is_non_empty_string(normalize)){

+        stop("'normalize' must be single non empty character value.",

+             call. = FALSE)

+      }

       if(!(normalize %in% colnames)){

         stop("Data column '",normalize,"' not found in data. Available columns",

              " are '",paste(colnames, collapse = "','"),"'.",

@@ -272,7 +275,10 @@ setMethod("compareByCoord",

       data[,colnames] <- as.data.frame(data[,colnames,drop = FALSE]) - 

         data[,normalize]

     } else if(is.logical(normalize)){

-      assertive::assert_is_a_bool(normalize)

+      if(!.is_a_bool(normalize)){

+        stop("'normalize' has to be TRUE or FALSE.",

+             call. = FALSE)

+      }

       if(normalize){

         data[,colnames] <- as.data.frame(data[,colnames,drop = FALSE]) - 

           apply(data[,colnames],1,max)

@@ -128,7 +128,7 @@ setMethod(

                         showSequence = TRUE, showAnnotation = FALSE, ...) {

     # get plotting arguments

     args <- .norm_viz_args_ModifierSet(list(...), x)

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

+    if(!.is_a_string(name)){

       stop("'Name' must be a character.", call. = FALSE)

     }

     chromosome <- .norm_viz_chromosome(ranges(x), name)

@@ -64,7 +64,6 @@

 NULL

 #' @import methods

-#' @import assertive

 #' @import S4Vectors

 #' @import GenomicRanges

 #' @import BiocGenerics

@@ -110,7 +110,7 @@ setMethod(

   f = "initialize",

   signature = signature(.Object = "SequenceData"),

   definition = function(.Object, ...){

-    if(!assertive::is_a_non_empty_string(.Object@dataDescription)){

+    if(!.is_non_empty_string(.Object@dataDescription)){

       stop("'dataDescription' must be a single non empty character value.")

     }

     callNextMethod(.Object, ...)

@@ -467,7 +467,7 @@ setMethod("unlist", "SequenceData",

   proto@minQuality <- .norm_min_quality(args, proto@minQuality)

   condition <- factor(names(bamfiles))

   replicate <- .get_replicate_number(condition)

-  if(!assertive::is_a_non_empty_string(proto@dataDescription)){

+  if(!.is_non_empty_string(proto@dataDescription)){

     stop("'dataDescription' must be a single non empty character value.")

   }

   if(is.null(proto@minQuality)){

@@ -266,11 +266,11 @@ NULL

 }

 .construct_coord_from_name_from_to <- function(x, name, pos){

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

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

+  if(!.is_a_string(name)){

+    stop("'name' must be a single character value.", call. = FALSE)

   }

   if(!is.integer(pos)){

-    stop("'from' and 'to' must be integer and have the same length.")

+    stop("'from' and 'to' must be integer and have the same length.", call. = FALSE)

   }

   coord <- GenomicRanges::GRanges(seqnames = seq_len(pos),

                                   ranges = IRanges::IRanges(pos, pos),

@@ -4,7 +4,7 @@ NULL

 # Annotation -------------------------------------------------------------------

 #' @importFrom rtracklayer GFF3File

-.norm_gff <- function(x, className, .xname = assertive::get_name_in_parent(x)){

+.norm_gff <- function(x, className, .xname = .get_name_in_parent(x)){

   if(!is(x,"GFF3File")){

     x <- try(rtracklayer::GFF3File(x), silent = TRUE)

     if (is(x, "try-error")){

@@ -23,14 +23,19 @@ NULL

 #' @importFrom GenomicFeatures makeTxDbFromGFF

 # Returns a TxDb or a GRangesList object

 .norm_annotation <- function(annotation, className, 

-                  .annotationname = assertive::get_name_in_parent(annotation)){

+                  .annotationname = .get_name_in_parent(annotation)){

   if(!is(annotation,"GRangesList")){

     if(!is(annotation,"GFFFile") && !is(annotation,"TxDb")){

       annotation <- .norm_gff(annotation, className, .annotationname)

     } else if(is(annotation,"GFFFile")) {

-      assertive::assert_all_are_existing_files(c(BiocGenerics::path(annotation)))

+      if(!.all_are_existing_files(c(BiocGenerics::path(annotation)))){

+        stop("annotation files don't exist or cannot be accessed.",

+             call. = FALSE)

+      }

     } else if(is(annotation,"TxDb")) {

-      assertive::assert_all_are_true(validObject(annotation))

+      if(!all(validObject(annotation))){

+        stop(".")

+      }

     } else {

       stop("Something went wrong. Unrecognized annotation input during ",

            "creation of class '",className,"'.",

@@ -71,11 +76,19 @@ NULL

            call. = FALSE)

     }

     seq <- tmp

-    assertive::assert_all_are_existing_files(c(BiocGenerics::path(seq)))

+    if(!.all_are_existing_files(c(BiocGenerics::path(seq)))){

+      stop("sequence files don't exist or cannot be accessed.",

+           call. = FALSE)

+    }

   } else if(is(seq,"FaFile")) {

-    assertive::assert_all_are_existing_files(c(BiocGenerics::path(seq)))

+    if(!.all_are_existing_files(c(BiocGenerics::path(seq)))){

+      stop("sequence files don't exist or cannot be accessed.",

+           call. = FALSE)

+    }

   } else if(is(seq,"BSgenome")) {

-    assertive::assert_all_are_true(validObject(seq))

+    if(!all(validObject(seq))){

+      stop(".")

+    }

   } else {

     stop("Something went wrong. Unrecognized sequence input during creation of",

          " class '",className,"'.",

@@ -90,7 +103,7 @@ SAMPLE_TYPES <- c("treated","control")

 #' @importFrom Rsamtools BamFileList

 .norm_bamfiles <- function(x, className, 

-                           .xname = assertive::get_name_in_parent(x)){

+                           .xname = .get_name_in_parent(x)){

   if(is.list(x)){

     if(!is.character(x[[1]]) && !is(x[[1]],"BamFile")){

       ans <- lapply(x, .norm_bamfiles, className, .xname)

@@ -118,17 +118,10 @@ NULL

 }

-# 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

-.is_a_non_empty_string <- assertive::is_a_non_empty_string

-

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

 .get_name_in_parent_list <- function(...){

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

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

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

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

   xnames

@@ -206,3 +206,49 @@ NULL

   names(to) <- names(partitioning)

   .seqs_l_by(from,to)

 }

+

+################################################################################

+# testing

+

+.is_a_bool <- function(x){

+  is.logical(x) && length(x) == 1L && !is.na(x)

+}

+

+.is_non_empty_character <- function(x){

+  is.character(x) && all(nzchar(x))

+}

+

+.is_non_empty_string <- function(x){

+  .is_non_empty_character(x) && length(x) == 1L

+}

+

+.is_a_string <- function(x){

+  is.character(x) && length(x) == 1L

+}

+

+.are_whole_numbers <- function(x){

+  tol <- 100 * .Machine$double.eps

+  abs(x - round(x)) <= tol && !is.infinite(x)

+}

+

+.is_numeric_string <- function(x){

+  x <- as.character(x)

+  suppressWarnings({x <- as.numeric(x)})

+  !is.na(x)

+}

+

+.is_function <- function(x){

+  typeof(x) == "closure" && is(x, "function")

+}

+

+.all_are_existing_files <- function(x){

+  all(file.exists(x))

+}

+

+.get_name_in_parent <- function(x) {

+  .safe_deparse(do.call(substitute, list(substitute(x), parent.frame())))

+}

+

+.safe_deparse <- function (expr, ...) {

+  paste0(deparse(expr, width.cutoff = 500L, ...), collapse = "")

+}