@@ -5,3 +5,6 @@

 ^README\.Rmd$

 ^\.github$

 ^LICENSE\.md$

+^_pkgdown\.yml$

+^docs$

+^pkgdown$

new file mode 100644

@@ -0,0 +1,46 @@

+on:

+  push:

+    branches: master

+

+name: pkgdown

+

+jobs:

+  pkgdown:

+    runs-on: macOS-latest

+    env:

+      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}

+    steps:

+      - uses: actions/checkout@v2

+

+      - uses: r-lib/actions/setup-r@master

+

+      - uses: r-lib/actions/setup-pandoc@master

+

+      - name: Query dependencies

+        run: |

+          install.packages('remotes')

+          saveRDS(remotes::dev_package_deps(dependencies = TRUE), ".github/depends.Rds", version = 2)

+          writeLines(sprintf("R-%i.%i", getRversion()$major, getRversion()$minor), ".github/R-version")

+        shell: Rscript {0}

+

+      - name: Cache R packages

+        uses: actions/cache@v2

+        with:

+          path: ${{ env.R_LIBS_USER }}

+          key: ${{ runner.os }}-${{ hashFiles('.github/R-version') }}-1-${{ hashFiles('.github/depends.Rds') }}

+          restore-keys: ${{ runner.os }}-${{ hashFiles('.github/R-version') }}-1-

+

+      - name: Install dependencies

+        run: |

+          remotes::install_deps(dependencies = TRUE)

+          install.packages("pkgdown")

+        shell: Rscript {0}

+

+      - name: Install package

+        run: R CMD INSTALL .

+

+      - name: Deploy package

+        run: |

+          git config --local user.email "actions@github.com"

+          git config --local user.name "GitHub Actions"

+          Rscript -e 'pkgdown::deploy_to_branch(new_process = FALSE)'

@@ -33,4 +33,5 @@ unsrturl.bst

 .tm_properties

 /Design

 inst/doc

-ISAnalytics.Rproj

\ No newline at end of file

+ISAnalytics.Rproj

+docs

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

 Package: ISAnalytics

 Title: Analyze gene therapy vector insertion sites data identified from genomics next generation sequencing reads for clonal tracking studies

-Version: 0.99.10

+Version: 0.99.11

 Date: 2020-07-03

 Authors@R: c(

   person(given = "Andrea",

@@ -53,7 +53,8 @@ Suggests:

     sessioninfo,

     rmarkdown,

     roxygen2,

-    psych

+    psych,

+    vegan

 VignetteBuilder: knitr

 RdMacros: 

     lifecycle

@@ -23,6 +23,8 @@ export(realign_after_collisions)

 export(reduced_AF_columns)

 export(remove_collisions)

 export(separate_quant_matrices)

+export(threshold_filter)

+export(top_integrations)

 export(unzip_file_system)

 import(BiocParallel)

 import(dplyr)

@@ -40,6 +42,7 @@ importFrom(dplyr,arrange)

 importFrom(dplyr,bind_cols)

 importFrom(dplyr,bind_rows)

 importFrom(dplyr,contains)

+importFrom(dplyr,desc)

 importFrom(dplyr,distinct)

 importFrom(dplyr,filter)

 importFrom(dplyr,full_join)

@@ -47,13 +50,12 @@ importFrom(dplyr,group_by)

 importFrom(dplyr,group_split)

 importFrom(dplyr,inner_join)

 importFrom(dplyr,intersect)

-importFrom(dplyr,left_join)

 importFrom(dplyr,mutate)

 importFrom(dplyr,rename)

 importFrom(dplyr,select)

 importFrom(dplyr,semi_join)

 importFrom(dplyr,slice)

-importFrom(dplyr,summarise)

+importFrom(dplyr,slice_head)

 importFrom(forcats,as_factor)

 importFrom(forcats,fct_inseq)

 importFrom(fs,as_fs_path)

@@ -82,6 +84,7 @@ importFrom(purrr,map_dbl)

 importFrom(purrr,map_dfr)

 importFrom(purrr,map_lgl)

 importFrom(purrr,pmap)

+importFrom(purrr,pmap_chr)

 importFrom(purrr,pmap_df)

 importFrom(purrr,pmap_dfr)

 importFrom(purrr,reduce)

@@ -100,10 +103,12 @@ importFrom(rlang,eval_tidy)

 importFrom(rlang,expr)

 importFrom(rlang,is_function)

 importFrom(rlang,is_installed)

+importFrom(rlang,parse_expr)

 importFrom(stringr,str_detect)

 importFrom(stringr,str_extract)

 importFrom(stringr,str_extract_all)

 importFrom(stringr,str_pad)

+importFrom(stringr,str_replace)

 importFrom(stringr,str_replace_all)

 importFrom(stringr,str_split)

 importFrom(tibble,add_column)

@@ -1,5 +1,17 @@

 # ISAnalytics News

+## Changes in version 0.99.11 (2020-09-21)

+

+#### NEW FEATURES

+

+* Added analysis functions `threshold_filter`, `top_integrations`

+* Added support for multi-quantification matrices in `compute_abundance`

+

+#### MINOR FIXES

+

+* Fixed bug in `comparison_matrix` that ignored custom column names

+* Fixed issues in some documentation pages

+

 ## Changes in version 0.99.10 (2020-09-14)

 ISanalytics is officially on bioconductor!

@@ -40,6 +40,8 @@

 #'   * \code{\link{compute_abundance}}

 #'   * \code{\link{comparison_matrix}}

 #'   * \code{\link{separate_quant_matrices}}

+#'   * \code{\link{threshold_filter}}

+#'   * \code{\link{top_integrations}}

 #' * Utility functions:

 #'   * \code{\link{generate_blank_association_file}}

 #'   * \code{\link{generate_Vispa2_launch_AF}}

@@ -7,14 +7,24 @@

 #' Abundance is obtained for every row by calculating the ratio

 #' between the single value and the total value for the sample.

 #'

-#' @param x An integration matrix

+#' @details Abundance will be computed upon the user selected columns

+#' in the `columns` parameter. For each column a corresponding

+#' relative abundance column (and optionally a percentage abundance

+#' column) will be produced.

+#'

+#' @param x An integration matrix - aka a data frame that includes

+#' the `mandatory_IS_vars()` as columns

+#' @param columns A character vector of column names to process,

+#' must be numeric or integer columns

 #' @param percentage Add abundance as percentage?

+#'

 #' @family Analysis functions

 #'

 #' @importFrom magrittr `%>%`

 #' @importFrom tibble is_tibble

-#' @importFrom dplyr group_by summarise left_join mutate select

-#' @importFrom rlang .data

+#' @import dplyr

+#' @importFrom rlang .data eval_tidy parse_expr

+#' @importFrom stringr str_replace

 #' @return An integration matrix

 #' @export

 #'

@@ -24,33 +34,63 @@

 #' )

 #' matrix <- import_single_Vispa2Matrix(path)

 #' abundance <- compute_abundance(matrix)

-compute_abundance <- function(x, percentage = TRUE) {

+compute_abundance <- function(x, columns = "Value", percentage = TRUE) {

     ## Check parameters

     stopifnot(tibble::is_tibble(x))

+    stopifnot(is.character(columns))

     if (.check_mandatory_vars(x) == FALSE) {

         stop(.non_ISM_error())

     }

     if (.check_complAmpID(x) == FALSE) {

         stop(.missing_complAmpID_error())

     }

-    if (.check_value_col(x) == FALSE) {

-        stop(.missing_value_col_error())

-    }

     stopifnot(is.logical(percentage) & length(percentage) == 1)

+    if (!all(columns %in% colnames(x))) {

+        stop(.missing_user_cols_error())

+    }

+    purrr::walk(columns, function(col) {

+        expr <- rlang::expr(`$`(x, !!col))

+        if (!is.numeric(rlang::eval_tidy(expr)) &

+            !is.numeric(rlang::eval_tidy(expr))) {

+            stop(.non_num_user_cols_error())

+        }

+    })

     ## Computation

     totals <- x %>%

         dplyr::group_by(.data$CompleteAmplificationID) %>%

         dplyr::summarise(

-            QuantificationSum = sum(.data$Value)

+            dplyr::across(dplyr::all_of(columns),

+                sum,

+                .names = "{.col}_sum"

+            ),

+            .groups = "drop"

         )

     abundance_df <- x %>%

         dplyr::left_join(totals, by = "CompleteAmplificationID") %>%

-        dplyr::mutate(AbsAbundance = .data$Value / .data$QuantificationSum) %>%

-        dplyr::select(-c(.data$QuantificationSum))

+        dplyr::mutate(dplyr::across(dplyr::all_of(columns),

+            list(ab = ~ .x / rlang::eval_tidy(

+                rlang::parse_expr(

+                    paste(

+                        dplyr::cur_column(),

+                        "sum",

+                        sep = "_"

+                    )

+                )

+            )),

+            .names = "{.col}_RelAbundance"

+        )) %>%

+        dplyr::select(-c(dplyr::all_of(paste(columns, "sum", sep = "_")))) %>%

+        dplyr::distinct()

     if (percentage == TRUE) {

         abundance_df <- abundance_df %>%

             dplyr::mutate(

-                PercAbundance = .data$AbsAbundance * 100

+                dplyr::across(dplyr::contains("RelAbundance"), ~ .x * 100,

+                    .names = "{.col}_PercAbundance"

+                )

+            ) %>%

+            dplyr::rename_with(

+                ~ stringr::str_replace(.x, "_RelAbundance", ""),

+                dplyr::contains("PercAbundance")

             )

     }

     abundance_df

@@ -125,8 +165,14 @@ comparison_matrix <- function(x,

     stopifnot(is.character(barcodeCount) & length(barcodeCount) == 1)

     stopifnot(is.character(cellCount) & length(cellCount) == 1)

     stopifnot(is.character(ShsCount) & length(ShsCount) == 1)

+    param_names <- c(

+        fragmentEstimate = fragmentEstimate,

+        seqCount = seqCount, barcodeCount = barcodeCount,

+        cellCount = cellCount, ShsCount = ShsCount

+    )

     x <- purrr::map2(x, names(x), function(matrix, quant_type) {

-        matrix %>% dplyr::rename({{ quant_type }} := .data$Value)

+        quant_name <- param_names[names(param_names) %in% quant_type]

+        matrix %>% dplyr::rename(!!quant_name := .data$Value)

     })

     result <- purrr::reduce(x, function(matrix1, matrix2) {

         commoncols <- dplyr::intersect(colnames(matrix1), colnames(matrix2))

@@ -207,8 +253,10 @@ separate_quant_matrices <- function(x, fragmentEstimate = "fragmentEstimate",

     stopifnot(is.character(cellCount) & length(cellCount) == 1)

     stopifnot(is.character(ShsCount) & length(ShsCount) == 1)

     param_col <- c(

-        fragmentEstimate, seqCount, barcodeCount, cellCount,

-        ShsCount

+        fragmentEstimate = fragmentEstimate,

+        seqCount = seqCount, barcodeCount = barcodeCount,

+        cellCount = cellCount,

+        ShsCount = ShsCount

     )

     to_copy <- if (any(!num_cols %in% param_col)) {

         if (all(!num_cols %in% param_col)) {

@@ -216,7 +264,7 @@ separate_quant_matrices <- function(x, fragmentEstimate = "fragmentEstimate",

         }

         num_cols[!num_cols %in% param_col]

     }

-    num_cols <- num_cols[num_cols %in% param_col]

+    num_cols <- param_col[param_col %in% num_cols]

     annot <- if (.is_annotated(x)) {

         annotation_IS_vars()

     } else {

@@ -230,6 +278,247 @@ separate_quant_matrices <- function(x, fragmentEstimate = "fragmentEstimate",

             mandatory_IS_vars(), annot, "CompleteAmplificationID",

             to_copy, quant

         )] %>% dplyr::rename(Value = quant)

-    }) %>% purrr::set_names(num_cols)

+    }) %>% purrr::set_names(names(num_cols))

     separated

 }

+

+

+#' Filter data frames with custom predicates

+#'

+#' @description

+#' \lifecycle{experimental}

+#' Filter a single data frame or a list of data frames with custom

+#' predicates assembled from the function parameters.

+#'

+#' @details

+#' ## A single data frame as input

+#'

+#' If the user chooses to operate on a single data frame, the other parameters

+#' should only be vectors: numeric vector for `threshold` and character

+#' vectors for both `cols_to_compare` and `comparators`.

+#' A filtering condition is obtained by combining element by element

+#' `cols_to_compare` + `comparators` + `threshold` (similarly to the

+#' `paste` function). For example:

+#'

+#' \verb{

+#' threshold = c(20, 35, 50)

+#' cols_to_compare = c("a", "b", "c")

+#' comparators = "<"

+#' }

+#'

+#' given these vectors, the input data frame

+#' will be filtered by checking which values in column "a" are less

+#' than 20 **AND** which values in column "b" are less than 35 **AND**

+#' which values in column "c" are less than 50.

+#' Things the user should keep in mind are:

+#' * The vectors of length 1 are going to be recycled if one or

+#' more parameters are longer (in the example, the `comparators` value)

+#' * If vectors are not of length 1 they must have the same length

+#' * Columns to compare, of course, need to be included in the

+#' input data frame and need to be numeric/integer

+#' * The filtering will perform a logical "AND" on all the conditions,

+#' only rows that satisfy ALL the conditions are preserved

+#'

+#' ## A list of data frames as input

+#'

+#' The input for the function may also be a list of data frames,

+#' either named or unnamed.

+#'

+#' ### Unnamed list

+#' If the input is a simple unnamed list, the other parameters should

+#' be simple vectors (as for data frames). All the predicates will

+#' simply be applied to every data frame in the list: this is useful

+#' if it's desirable to filter for the same conditions different data frames

+#' that have the same structure but different data.

+#'

+#' ### Named list

+#' It is also possible to filter different data frames with different

+#' sets of conditions. Besides having the possibility of defining the

+#' other parameters as simple vector, which has the same results as

+#' operating on an unnamed list, the user can define the parameters as

+#' named lists containing vectors. For example:

+#'

+#' ```{r}

+#'

+#' example_df <- tibble::tibble(a = c(20, 30, 40),

+#'                              b = c(40, 50, 60),

+#'                              c = c("a", "b", "c"),

+#'                              d = c(3L, 4L, 5L))

+#' example_list <- list(first = example_df,

+#'                      second = example_df,

+#'                      third = example_df)

+#' print(example_list)

+#'

+#' filtered <- threshold_filter(example_list,

+#'                              threshold = list(first = c(20, 60),

+#'                                               third = c(25)),

+#'                              cols_to_compare = list(first = c("a", "b"),

+#'                                                     third = c("a")),

+#'                              comparators = list(first = c(">", "<"),

+#'                                                 third = c(">=")))

+#' print(filtered)

+#'

+#' ```

+#' The above signature will roughly be translated as:

+#' * Filter the element "first" in the list by checking that values in

+#' column "a" are bigger than 20 AND values in column "b" are less than

+#' 60

+#' * Don't apply any filter to the element "second" (returns the

+#' data frame as is)

+#' * Filter the element "third" by checking that values in column "a"

+#' are equal or bigger than 25.

+#'

+#' It is also possible to use some parameters as vectors and some as

+#' lists: vectors will be recycled for every element filtered.

+#'

+#' ```r

+#' filtered <- threshold_filter(example_list,

+#'                              threshold = list(first = c(20, 60),

+#'                                               third = c(25, 65)),

+#'                              cols_to_compare = c("a", "b"),

+#'                              comparators = list(first = c(">", "<"),

+#'                                                 third = c(">=", "<=")))

+#' ```

+#' In this example, different threshold and comparators will be applied

+#' to the same columns in all data frames.

+#'

+#' Things the user should keep in mind are:

+#' * Names for the list parameters must be the same names in the

+#' input list

+#' * Only elements explicited in list parameters as names will

+#' be filtered

+#' * Lengths of both vectors and lists must be consistent

+#'

+#' @param x A data frame or a list of data frames

+#' @param threshold A numeric/integer vector or a named list of

+#' numeric/integer vectors

+#' @param cols_to_compare A character vector or a named list of

+#' character vectors

+#' @param comparators A character vector or a named list of

+#' character vectors. Must be one of the allowed values between

+#' `c("<", ">", "==", "!=", ">=", "<=")`

+#'

+#' @family Analysis functions

+#'

+#' @return A data frame or a list of data frames

+#' @export

+#'

+#' @examples

+#' example_df <- tibble::tibble(

+#'     a = c(20, 30, 40),

+#'     b = c(40, 50, 60),

+#'     c = c("a", "b", "c"),

+#'     d = c(3L, 4L, 5L)

+#' )

+#' example_list <- list(

+#'     first = example_df,

+#'     second = example_df,

+#'     third = example_df

+#' )

+#'

+#' filtered <- threshold_filter(example_list,

+#'     threshold = list(

+#'         first = c(20, 60),

+#'         third = c(25)

+#'     ),

+#'     cols_to_compare = list(

+#'         first = c("a", "b"),

+#'         third = c("a")

+#'     ),

+#'     comparators = list(

+#'         first = c(">", "<"),

+#'         third = c(">=")

+#'     )

+#' )

+threshold_filter <- function(x,

+    threshold,

+    cols_to_compare = "Value",

+    comparators = ">") {

+    stopifnot(is.list(x))

+    ### ---- If x is a data frame ---- ###

+    if (is.data.frame(x)) {

+        return(.tf_data_frame(x, threshold, cols_to_compare, comparators))

+    }

+    ### ---- If x is a list ---- ###

+    return(.tf_list(x, threshold, cols_to_compare, comparators))

+}

+

+

+#' Sorts and keeps the top n integration sites in a data frame.

+#'

+#' \lifecycle{experimental}

+#' The input data frame will be sorted by the highest values in

+#' the columns specified and the top n rows will be returned as output.

+#' The user can choose to keep additional columns in the output

+#' by passing a vector of column names or passing 2 "shortcuts":

+#' * `keep` = "everything" keeps all columns in the original data frame

+#' * `keep` = "nothing" only keeps the mandatory columns

+#' (`mandatory_IS_vars()`) plus the columns in the `columns` parameter.

+#'

+#' @param x An integration matrix (data frame containing

+#' `mandatory_IS_vars()`)

+#' @param n How many rows should the output have? Must be numeric

+#' or integer and greater than 0

+#' @param columns Columns to use for the sorting. If more than a column

+#' is supplied primary ordering is done on the first column,

+#' secondary ordering on all other columns

+#' @param keep Names of the columns to keep besides `mandatory_IS_vars()`

+#' and `columns`

+#'

+#' @family Analysis functions

+#'

+#' @importFrom dplyr arrange across all_of desc slice_head select

+#' @importFrom magrittr `%>%`

+#'

+#' @return A data frame with `n` rows

+#' @export

+#'

+#' @examples

+#' smpl <- tibble::tibble(

+#'     chr = c("1", "2", "3", "4", "5", "6"),

+#'     integration_locus = c(14536, 14544, 14512, 14236, 14522, 14566),

+#'     strand = c("+", "+", "-", "+", "-", "+"),

+#'     CompleteAmplificationID = c("ID1", "ID2", "ID1", "ID1", "ID3", "ID2"),

+#'     Value = c(3, 10, 40, 2, 15, 150),

+#'     Value2 = c(456, 87, 87, 9, 64, 96),

+#'     Value3 = c("a", "b", "c", "d", "e", "f")

+#' )

+#' top <- top_integrations(smpl,

+#'     n = 3,

+#'     columns = c("Value", "Value2"),

+#'     keep = "nothing"

+#' )

+top_integrations <- function(x, n = 50, columns = "RelAbundance",

+    keep = "everything") {

+    stopifnot(is.data.frame(x))

+    stopifnot(is.numeric(n) & length(n) == 1 & n > 0)

+    stopifnot(is.character(keep))

+    stopifnot(is.character(columns))

+    if (!.check_mandatory_vars(x)) {

+        stop(.non_ISM_error())

+    }

+    if (!all(columns %in% colnames(x))) {

+        stop(.missing_user_cols_error())

+    }

+    if (!(all(keep == "everything") || all(keep == "nothing"))) {

+        if (any(!keep %in% colnames(x))) {

+            stop(.missing_user_cols_error())

+        }

+    }

+    essential_cols <- c(mandatory_IS_vars(), columns)

+    to_keep <- if (all(keep == "everything")) {

+        colnames(x)[!colnames(x) %in% essential_cols]

+    } else if (all(keep == "nothing")) {

+        character(0)

+    } else {

+        keep[!keep %in% essential_cols]

+    }

+    result <- x %>%

+        dplyr::arrange(dplyr::across(

+            dplyr::all_of(columns),

+            dplyr::desc

+        )) %>%

+        dplyr::slice_head(n = n) %>%

+        dplyr::select(dplyr::all_of(c(essential_cols, to_keep)))

+    return(result)

+}

@@ -3,113 +3,17 @@

 #------------------------------------------------------------------------------#

 ## All functions in this file are NOT exported, to be used internally only.

-### Convenience functions for errors and warnings ###

-#' @keywords internal

-.malformed_ISmatrix_warning <- function() {

-    paste(c(

-        "Mandatory integration matrix variables, ", mandatory_IS_vars(),

-        ", were not detected"

-    ), collapse = " ")

-}

-#' @keywords internal

-.non_ISM_error <- function() {

-    paste(

-        "One or more elements in x are not integration matrices.",

-        "Aborting."

-    )

-}

-

-#' @keywords internal

-.missing_value_col_error <- function() {

-    paste(

-        "The `Value` column is missing or it contains non-numeric data.",

-        "The column is needed for this operation.",

-        "Aborting."

-    )

-}

-

-#' @keywords internal

-.missing_complAmpID_error <- function() {

-    paste(

-        "The `CompleteAmplificationID` column is missing.",

-        "The column is needed for this operation.",

-        "Aborting."

-    )

-}

-

-#' @keywords internal

-.quant_types_error <- function() {

-    paste(

-        "The list names must be quantification types",

-        ", see quantification_types() for reference"

-    )

-}

-

-#' @keywords internal

-.missing_num_cols_error <- function() {

-    paste("No numeric columns found")

-}

-

-#' @keywords internal

-.non_quant_cols_msg <- function(x) {

-    paste(c(

-        "Found numeric columns that are not quantification values:",

-        "these columns will be copied in all resulting matrices.",

-        "Found: ", x

-    ), collapse = "\n")

-}

-

-#' @keywords internal

-.non_quant_cols_error <- function() {

-    paste(

-        "No quantification values columns found. Did you set the function",

-        "parameters correctly?"

-    )

-}

-

-#' @keywords internal

-.max_val_col_warning <- function(x) {

-    paste0("Column for max value `", x, "` not found in numeric columns.")

-}

-

-#' @keywords internal

-.using_val_col_warning <- function(x) {

-    paste(c(

-        .max_val_col_warning(x),

-        "Using `Value` column as reference instead."

-    ), collapse = "\n")

-}

-

-#' @keywords internal

-.max_val_stop_error <- function(x) {

-    paste(c(

-        .max_val_col_warning(x),

-        "Did you set `max_value_column` parameter correctly?"

-    ),

-    collapse = "\n"

-    )

-}

-

-#' @keywords internal

-.nas_introduced_msg <- function() {

-    paste("NAs were introduced while producing the data frame.",

-        "The possible cause for this is:",

-        "some quantification matrices were not imported for all pools",

-        sep = "\n"

-    )

-}

-

 #### ---- Internals for checks on integration matrices----####

-#' Internal helper function for checking mandatory vars presence in x.

-#'

-#' Checks if the elements of `mandatory_IS_vars` are present as column names

-#' in the data frame.

-#' @param x A data.frame object (or any extending class)

-#' @keywords internal

-#'

-#' @return FALSE if all or some elements are not found in the data frame, TRUE

-#' otherwise

+# Internal helper function for checking mandatory vars presence in x.

+#

+# Checks if the elements of `mandatory_IS_vars` are present as column names

+# in the data frame.

+# @param x A data.frame object (or any extending class)

+# @keywords internal

+#

+# @return FALSE if all or some elements are not found in the data frame, TRUE

+# otherwise

 .check_mandatory_vars <- function(x) {

     stopifnot(is.data.frame(x))

     res <- if (all(mandatory_IS_vars() %in% colnames(x))) {

@@ -120,14 +24,14 @@

     return(res)

 }

-#' Internal helper function for checking `Value` column presence in x.

-#'

-#' Checks if the column `Value` is present in the data frame and also

-#' checks if the column is numeric or integer.

-#' @param x A data.frame object (or any extending class)

-#' @keywords internal

-#'

-#' @return FALSE if not found or contains non-numeric data, TRUE otherwise

+# Internal helper function for checking `Value` column presence in x.

+#

+# Checks if the column `Value` is present in the data frame and also

+# checks if the column is numeric or integer.

+# @param x A data.frame object (or any extending class)

+# @keywords internal

+#

+# @return FALSE if not found or contains non-numeric data, TRUE otherwise

 .check_value_col <- function(x) {

     stopifnot(is.data.frame(x))

     present <- if ("Value" %in% colnames(x)) {

@@ -142,15 +46,15 @@

     }

 }

-#' Internal helper function for checking `CompleteAmplifcationID`

-#' column presence in x.

-#'

-#' Checks if the column `CompleteAmplifcationID` is present in the data frame.

-#'

-#' @param x A data.frame object (or any extending class)

-#' @keywords internal

-#'

-#' @return FALSE if not found, TRUE otherwise

+# Internal helper function for checking `CompleteAmplifcationID`

+# column presence in x.

+#

+# Checks if the column `CompleteAmplifcationID` is present in the data frame.

+#

+# @param x A data.frame object (or any extending class)

+# @keywords internal

+#

+# @return FALSE if not found, TRUE otherwise

 .check_complAmpID <- function(x) {

     stopifnot(is.data.frame(x))

     if ("CompleteAmplificationID" %in% colnames(x)) {

@@ -160,17 +64,17 @@

     }

 }

-#' Finds experimental columns in an integration matrix.

-#'

-#' The function checks if there are numeric columns which are not

-#' standard integration matrix columns, if there are returns their names.

-#'

-#' @param x A data.frame

+# Finds experimental columns in an integration matrix.

+#

+# The function checks if there are numeric columns which are not

+# standard integration matrix columns, if there are returns their names.

+#

+# @param x A data.frame

 #' @importFrom purrr map_lgl

 #' @importFrom rlang expr eval_tidy

 #' @keywords internal

-#'

-#' @return A character vector of column names

+#

+# @return A character vector of column names

 .find_exp_cols <- function(x) {

     stopifnot(is.data.frame(x))

     default_cols <- c(

@@ -186,12 +90,12 @@

     remaining[remaining_numeric]

 }

-#' Checks if the integration matrix is annotated or not.

-#'

-#' @param x A data.frame

-#' @keywords internal

-#'

-#' @return A logical value

+# Checks if the integration matrix is annotated or not.

+#

+# @param x A data.frame

+# @keywords internal

+#

+# @return A logical value

 .is_annotated <- function(x) {

     stopifnot(is.data.frame(x))

     if (all(annotation_IS_vars() %in% colnames(x))) {

@@ -205,17 +109,17 @@

 #---- USED IN : import_single_Vispa2Matrix ----

-#' Internal function to convert a messy matrix to a tidy data frame

-#'

-#' @description Uses the suite of functions provided by the

-#' tidyverse to produce a more dense and ordered structure.

-#' This function is not exported and should be called in other importing

-#' functions.

-#'

-#' @param df Messy tibble to convert to tidy

-#' @keywords internal

-#'

-#' @return a tidy tibble

+# Internal function to convert a messy matrix to a tidy data frame

+#

+# @description Uses the suite of functions provided by the

+# tidyverse to produce a more dense and ordered structure.

+# This function is not exported and should be called in other importing

+# functions.

+#

+# @param df Messy tibble to convert to tidy

+# @keywords internal

+#

+# @return a tidy tibble

 #' @importFrom rlang .data

 #' @importFrom tidyr pivot_longer

 #' @importFrom dplyr arrange all_of filter

@@ -237,16 +141,16 @@

     isadf_tidy

 }

-#' Internal function to auto-detect the type of IS based on the headers.

-#'

-#' @param df the data frame to inspect

-#' @keywords internal

-#'

-#' @return one value among:

-#' * "OLD" : for old-style matrices that had only one column holding

-#' all genomic coordinates

-#' * "NEW" :  for the classic Vispa2 annotated/not annotated matrices

-#' * "MALFORMED" : in any other case

+# Internal function to auto-detect the type of IS based on the headers.

+#

+# @param df the data frame to inspect

+# @keywords internal

+#

+# @return one value among:

+# * "OLD" : for old-style matrices that had only one column holding

+# all genomic coordinates

+# * "NEW" :  for the classic Vispa2 annotated/not annotated matrices

+# * "MALFORMED" : in any other case

 .auto_detect_type <- function(df) {

     if ("IS_genomicID" %in% colnames(df) &

         all(!mandatory_IS_vars() %in% colnames(df))) {

@@ -260,12 +164,12 @@

 #---- USED IN : import_association_file ----

-#' Checks if the association file has the right format (standard headers).

-#'

-#' @param df The imported association file

-#' @keywords internal

-#'

-#' @return TRUE if the check passes, FALSE otherwise

+# Checks if the association file has the right format (standard headers).

+#

+# @param df The imported association file

+# @keywords internal

+#

+# @return TRUE if the check passes, FALSE otherwise

 .check_af_correctness <- function(df) {

     if (all(association_file_columns() %in% colnames(df))) {

         return(TRUE)

@@ -275,19 +179,19 @@

 }

-#' Reads association file and checks if it's correct or not.

-#'

-#' @param path The path to the association file on disk

-#' @param padding The padding for TimePoint field

-#' @param date_format The date format of date columns