@@ -443,12 +443,18 @@ filter_and_extract <- function(

         g <- GenomicRanges::makeGRangesFromDataFrame(

             complete_df,

             keep.extra.columns = TRUE,

+            seqnames.field = c("seqnames", "seqname",

+                               "chromosome", "chrom",

+                               "chr", "chromosome_name"),

             start.field = "left",

             end.field = "right")

     } else {

         g <- GenomicRanges::makeGRangesFromDataFrame(

             df,

             keep.extra.columns = TRUE,

+            seqnames.field = c("seqnames", "seqname",

+                               "chromosome", "chrom",

+                               "chr", "chromosome_name"),

             start.field = "left",

             end.field = "right")

     }

@@ -232,10 +232,6 @@ filter_and_extract <- function(

         else

             all_values[!all_values %in% except_values]

         names(regions) <- NULL

-        # since import convert this value from GMQL schema to GTF format

-        # we need to convert it back

-        regions <- replace(regions, regions == "feature", "type")

-        regions <- replace(regions, regions == "frame", "phase")

     }

     elementMetadata(g1) <- NULL

@@ -318,7 +314,7 @@ filter_and_extract <- function(

         })

         ## we would like that manage more index from grep

         found <- as.logical(length(unlist(a)))

-        # if found retrieve samples that has at least one choosen metadata

+        # if found retrieve samples that has at least one chosen metadata

         if (found) {

             x

         }

@@ -331,24 +327,15 @@ filter_and_extract <- function(

     suffixes,

     vector_field

 ) {

-    g1 <- tryCatch(

-        expr = {

-            rtracklayer::import(con = gtf_region_files[1], format = "gtf")

-        },

-        error = function(e){ 

-            rtracklayer::import(

-                gtf_region_files[1], 

-                format = "gff",

-                version = "3")

-        },

-        warning = function(w){

-            rtracklayer::import(

-                gtf_region_files[1], 

-                format = "gff", 

-                version = "3")

-        }

+    attr_col_names <- vector_field[

+      !vector_field %in% c("seqname", "seqid", "start", "end", "strand")]

+    

+    g1 <- rtracklayer::import(

+        con = gtf_region_files[1], 

+        format = "gtf",

+        colnames = attr_col_names

     )

-  

+    

     elementMetadata(g1) <- NULL

     if (is.null(suffixes)) {

         suffixes <- ""

@@ -377,16 +364,10 @@ filter_and_extract <- function(

     if (!is.null(regions)) {

         DF_list <- mapply(function(x, header) {

-            g_x <- tryCatch(

-                expr = {

-                    rtracklayer::import(x, format = "gtf")

-                },

-                error = function(e){ 

-                    rtracklayer::import(x, format = "gff", version = "3")

-                },

-                warning = function(w){

-                    rtracklayer::import(x, format = "gff", version = "3")

-                }

+            g_x <- rtracklayer::import(

+                x, 

+                format = "gtf", 

+                colnames = attr_col_names

             )

             meta <- elementMetadata(g_x)[regions]

             if (header != "") {

@@ -331,7 +331,24 @@ filter_and_extract <- function(

     suffixes,

     vector_field

 ) {

-    g1 <- rtracklayer::import(con = gtf_region_files[1], format = "gtf")

+    g1 <- tryCatch(

+        expr = {

+            rtracklayer::import(con = gtf_region_files[1], format = "gtf")

+        },

+        error = function(e){ 

+            rtracklayer::import(

+                gtf_region_files[1], 

+                format = "gff",

+                version = "3")

+        },

+        warning = function(w){

+            rtracklayer::import(

+                gtf_region_files[1], 

+                format = "gff", 

+                version = "3")

+        }

+    )

+  

     elementMetadata(g1) <- NULL

     if (is.null(suffixes)) {

         suffixes <- ""

@@ -360,7 +377,17 @@ filter_and_extract <- function(

     if (!is.null(regions)) {

         DF_list <- mapply(function(x, header) {

-            g_x <- rtracklayer::import(con = x, format = "gtf")

+            g_x <- tryCatch(

+                expr = {

+                    rtracklayer::import(x, format = "gtf")

+                },

+                error = function(e){ 

+                    rtracklayer::import(x, format = "gff", version = "3")

+                },

+                warning = function(w){

+                    rtracklayer::import(x, format = "gff", version = "3")

+                }

+            )

             meta <- elementMetadata(g_x)[regions]

             if (header != "") {

                 names(meta) <- paste(regions, header, sep = ".")

@@ -72,12 +72,12 @@

 #' filter_and_extract(sorted_grl_full, region_attributes = FULL())

 #' 

 #' ## This statement imports a GMQL dataset as GRangesList and filters it

-#' ## including all the region attributes except "jaccard" and "score"

+#' ## including all the region attributes except "jaccard"

 #' 

 #' sorted_grl_full_except <- sort(grl)

 #' filter_and_extract(

 #'  sorted_grl_full_except, 

-#'  region_attributes = FULL("jaccard", "score")

+#'  region_attributes = FULL("jaccard")

 #' )

 #' 

 #' @export

@@ -83,376 +83,365 @@

 #' @export

 #'

 filter_and_extract <- function(

-  data,

-  metadata = NULL,

-  metadata_prefix = NULL,

-  region_attributes = NULL,

-  suffix = "antibody_target"

+    data,

+    metadata = NULL,

+    metadata_prefix = NULL,

+    region_attributes = NULL,

+    suffix = "antibody_target"

 ) {

-  

-  if (is(data, "GRangesList")) {

-    .extract_from_GRangesList(

-      data,

-      metadata,

-      metadata_prefix,

-      region_attributes,

-      suffix

-    )

-  } else {

-    .extract_from_dataset(

-      data,

-      metadata,

-      metadata_prefix,

-      region_attributes, suffix

-    )

-  }

+    if (is(data, "GRangesList")) {

+        .extract_from_GRangesList(

+            data,

+            metadata,

+            metadata_prefix,

+            region_attributes,

+            suffix)

+    } else {

+        .extract_from_dataset(

+            data,

+            metadata,

+            metadata_prefix,

+            region_attributes, suffix)

+    }

 }

 .extract_from_dataset <- function(

-  datasetName,

-  metadata,

-  metadata_prefix,

-  regions,

-  suffix

-) {

-  datasetName <- sub("/*[/]$", "", datasetName)

-  if (basename(datasetName) != "files") {

-    datasetName <- file.path(datasetName, "files")

-  }

-  

-  if (!dir.exists(datasetName)) {

-    stop("Directory does not exists")

-  }

-  

-  gdm_meta_files <- list.files(

-    datasetName,

-    pattern = "*.gdm.meta$",

-    full.names = TRUE

-  )

-  

-  gtf_meta_files <- list.files(

     datasetName,

-    pattern = "*.gtf.meta$",

-    full.names = TRUE

-  )

-  

-  if (!length(gdm_meta_files) && !length(gtf_meta_files)) {

-    stop("no samples present or no files format supported")

-  }

-  

-  if (length(gdm_meta_files) && length(gtf_meta_files)) {

-    stop("GMQL dataset cannot be mixed dataset: no GTF and GDM together")

-  }

-  

-  vector_field <- .schema_header(datasetName)

-  

-  if (length(gdm_meta_files)) {

-    samples_file <- .check_metadata_files(

-      metadata, metadata_prefix,

-      gdm_meta_files

-    )

-    

-    samples_meta_to_read <- unlist(samples_file)

+    metadata,

+    metadata_prefix,

+    regions,

+    suffix

+) {

+    datasetName <- sub("/*[/]$", "", datasetName)

+    if (basename(datasetName) != "files") {

+        datasetName <- file.path(datasetName, "files")

+    }

-    if (length(samples_meta_to_read)) {

-      samples_to_read <- gsub(".meta$", "", samples_meta_to_read)

-    } else {

-      samples_to_read <- gsub(".meta$", "", gdm_meta_files)

-      samples_meta_to_read <- gtf_meta_files

+    if (!dir.exists(datasetName)) {

+        stop("Directory does not exists")

     }

-    suffix_vec <- .get_suffix(suffix, FALSE, samples_meta_to_read)

-    granges <- .parse_gdm_files(

-      vector_field, 

-      samples_to_read, 

-      regions,

-      suffix_vec

+    gdm_meta_files <- list.files(

+        datasetName,

+        pattern = "*.gdm.meta$",

+        full.names = TRUE

     )

-  } else {

-    samples_file <- .check_metadata_files(

-      metadata, 

-      metadata_prefix,

-      gtf_meta_files

+    gtf_meta_files <- list.files(

+        datasetName,

+        pattern = "*.gtf.meta$",

+        full.names = TRUE

     )

-    samples_meta_to_read <- unlist(samples_file)

-    if (length(samples_meta_to_read)) {

-      samples_to_read <- gsub(".meta$", "", samples_meta_to_read)

-    } else {

-      samples_to_read <- gsub(".meta$", "", gtf_meta_files)

-      samples_meta_to_read <- gtf_meta_files

+    if (!length(gdm_meta_files) && !length(gtf_meta_files)) {

+        stop("no samples present or no files format supported")

     }

-    suffix_vec <- .get_suffix(suffix, FALSE, samples_meta_to_read)

-    granges <- .parse_gtf_files(

-      samples_to_read, 

-      regions, 

-      suffix_vec, 

-      vector_field

-    )

-  }

+    if (length(gdm_meta_files) && length(gtf_meta_files)) {

+        stop("GMQL dataset cannot be mixed dataset: no GTF and GDM together")

+    }

+    

+    vector_field <- .schema_header(datasetName)

+    

+    if (length(gdm_meta_files)) {

+        samples_file <- .check_metadata_files(

+            metadata, metadata_prefix,

+            gdm_meta_files

+        )

+        

+        samples_meta_to_read <- unlist(samples_file)

+        

+        if (length(samples_meta_to_read)) {

+            samples_to_read <- gsub(".meta$", "", samples_meta_to_read)

+        } else {

+            samples_to_read <- gsub(".meta$", "", gdm_meta_files)

+            samples_meta_to_read <- gtf_meta_files

+        }

+        

+        suffix_vec <- .get_suffix(suffix, FALSE, samples_meta_to_read)

+        granges <- .parse_gdm_files(

+            vector_field, 

+            samples_to_read, 

+            regions,

+            suffix_vec)

+    } else {

+        samples_file <- .check_metadata_files(

+            metadata, 

+            metadata_prefix,

+            gtf_meta_files

+        )

+        samples_meta_to_read <- unlist(samples_file)

+        

+        if (length(samples_meta_to_read)) {

+            samples_to_read <- gsub(".meta$", "", samples_meta_to_read)

+        } else {

+            samples_to_read <- gsub(".meta$", "", gtf_meta_files)

+            samples_meta_to_read <- gtf_meta_files

+        }

+        

+        suffix_vec <- .get_suffix(suffix, FALSE, samples_meta_to_read)

+        granges <- .parse_gtf_files(

+            samples_to_read, 

+            regions, 

+            suffix_vec, 

+            vector_field

+        )

+    }

 }

 .extract_from_GRangesList <- function(

-  rangesList,

-  metadata,

-  metadata_prefix,

-  regions,

-  suffix

+    rangesList,

+    metadata,

+    metadata_prefix,

+    regions,

+    suffix

 ) {

-  if (!is(rangesList, "GRangesList")) {

-    stop("only GrangesList admitted")

-  }

-  

-  if (!length(rangesList)) {

-    stop("rangesList empty")

-  }

-  

-  meta_list <- metadata(rangesList)

-  samples <- .check_metadata_list(metadata, metadata_prefix, meta_list)

-  if (!length(unlist(samples))) {

-    samples <- rangesList

-  } else {

-    index <- unlist(samples)

-    samples <- rangesList[c(index)]

-  }

-  new_meta_list <- metadata(samples)

-  suffix_vec <- .get_suffix(suffix, TRUE, new_meta_list)

-  granges <- .parse_Granges(samples, regions, suffix_vec)

+    if (!is(rangesList, "GRangesList")) {

+        stop("only GrangesList admitted")

+    }

+    

+    if (!length(rangesList)) {

+        stop("rangesList empty")

+    }

+    

+    meta_list <- metadata(rangesList)

+    samples <- .check_metadata_list(metadata, metadata_prefix, meta_list)

+    if (!length(unlist(samples))) {

+        samples <- rangesList

+    } else {

+        index <- unlist(samples)

+        samples <- rangesList[c(index)]

+    }

+    new_meta_list <- metadata(samples)

+    suffix_vec <- .get_suffix(suffix, TRUE, new_meta_list)

+    granges <- .parse_Granges(samples, regions, suffix_vec)

 }

 .parse_Granges <- function(region_list, regions, suffixes) {

-  if (is.null(suffixes)) {

-    suffixes <- ""

-  }

-  

-  g1 <- region_list[[1]]

-

-  if(is.object(regions) && ("FULL" %in% class(regions))) {

-    all_values <- names(elementMetadata(g1))

-    except_values <- regions$values

-    regions <- if (is.null(except_values))

-      all_values

-    else

-      all_values[!all_values %in% except_values]

-    names(regions) <- NULL

-    # since import convert this value from GMQL schema to GTF format

-    # we need to convert it back

-    regions <- replace(regions, regions == "feature", "type")

-    regions <- replace(regions, regions == "frame", "phase")

-  }

-  

-  elementMetadata(g1) <- NULL

-  if (!is.null(regions)) {

-    DF_list <- mapply(function(g_x, h) {

-      meta <- elementMetadata(g_x)[regions]

-      if (h != "") {

-        names(meta) <- paste(regions, h, sep = ".")

-      }

-      data.frame(meta)

-    }, region_list, suffixes, SIMPLIFY = FALSE)

-    DF_only_regions <- dplyr::bind_cols(DF_list)

-    elementMetadata(g1) <- DF_only_regions

-  }

-  g1

+    if (is.null(suffixes)) {

+        suffixes <- ""

+    }

+    

+    g1 <- region_list[[1]]

+    

+    if(is.object(regions) && ("FULL" %in% class(regions))) {

+        all_values <- names(elementMetadata(g1))

+        except_values <- regions$values

+        regions <- if (is.null(except_values))

+            all_values

+        else

+            all_values[!all_values %in% except_values]

+        names(regions) <- NULL

+        # since import convert this value from GMQL schema to GTF format

+        # we need to convert it back

+        regions <- replace(regions, regions == "feature", "type")

+        regions <- replace(regions, regions == "frame", "phase")

+    }

+    

+    elementMetadata(g1) <- NULL

+    if (!is.null(regions)) {

+        DF_list <- mapply(function(g_x, h) {

+            meta <- elementMetadata(g_x)[regions]

+            if (h != "") {

+                names(meta) <- paste(regions, h, sep = ".")

+            }

+            data.frame(meta)

+        }, region_list, suffixes, SIMPLIFY = FALSE)

+        DF_only_regions <- dplyr::bind_cols(DF_list)

+        elementMetadata(g1) <- DF_only_regions

+    }

+    g1

 }

 .get_suffix <- function(col_name, from_list, meta_fl) {

-  suffix <- paste0(col_name, "$")

-  

-  if (from_list) {

-    meta_list <- mapply(function(x, index) {

-      vec_names <- names(x)

-      s_index <- grep(suffix, vec_names)

-      first_index <- s_index[1]

-      suffix <- unlist(x[first_index]) # ne prendo solo uno

-      names(suffix) <- NULL

-      

-      # if found retrieve samples that has at least one choosen metadata

-      if (first_index && !is.na(first_index)) {

-        suffix

-      } else {

-        ""

-      }

-    }, meta_fl, seq_along(meta_fl))

-  }

-  else {

-    meta_list <- vapply(meta_fl, function(x) {

-      list <- .add_metadata(x)

-      vec_names <- names(list)

-      index <- grep(suffix, vec_names)

-      first_index <- index[1]

-      suffix <- unlist(list[first_index]) # ne prendo solo uno

-      names(suffix) <- NULL

-      # if found retrieve samples that has at least one choosen metadata

-      if (first_index && !is.na(first_index)) {

-        suffix

-      } else {

-        ""

-      }

-    }, character(1))

-  }

-  names(meta_list) <- NULL

-  meta_list

+    suffix <- paste0(col_name, "$")

+    

+    if (from_list) {

+        meta_list <- mapply(function(x, index) {

+            vec_names <- names(x)

+            s_index <- grep(suffix, vec_names)

+            first_index <- s_index[1]

+            suffix <- unlist(x[first_index]) # ne prendo solo uno

+            names(suffix) <- NULL

+            

+            # if found retrieve samples that has at least one choosen metadata

+            if (first_index && !is.na(first_index)) {

+                suffix

+            } else {

+                ""

+            }

+        }, meta_fl, seq_along(meta_fl))

+    }

+    else {

+        meta_list <- vapply(meta_fl, function(x) {

+            list <- .add_metadata(x)

+            vec_names <- names(list)

+            index <- grep(suffix, vec_names)

+            first_index <- index[1]

+            suffix <- unlist(list[first_index]) # ne prendo solo uno

+            names(suffix) <- NULL

+            # if found retrieve samples that has at least one choosen metadata

+            if (first_index && !is.na(first_index)) {

+                suffix

+            } else {

+                ""

+            }

+        }, character(1))

+    }

+    names(meta_list) <- NULL

+    meta_list

 }

 .check_metadata_list <- function(metadata, metadata_prefix, meta_list) {

-  vec_meta <- paste0(metadata_prefix, metadata)

-  list <- mapply(function(x, index) {

-    vec_names <- names(x)

-    a <- lapply(vec_meta, function(y) {

-      which(y == vec_names)

-    })

-    ## we would like that manage more index from grep

-    found <- as.logical(length(unlist(a)))

-    # if found retrieve samples that has at least one choosen metadata

-    if (found) {

-      index

-    }

-  }, meta_list, seq_along(meta_list))

+    vec_meta <- paste0(metadata_prefix, metadata)

+    list <- mapply(function(x, index) {

+        vec_names <- names(x)

+        a <- lapply(vec_meta, function(y) {

+            which(y == vec_names)

+        })

+        ## we would like that manage more index from grep

+        found <- as.logical(length(unlist(a)))

+        # if found retrieve samples that has at least one choosen metadata

+        if (found) {

+            index

+        }

+    }, meta_list, seq_along(meta_list))

 }

 .check_metadata_files <- function(metadata, metadata_prefix, meta_files) {

-  vec_meta <- paste0(metadata_prefix, metadata)

-  meta_list <- lapply(meta_files, function(x) {

-    list <- .add_metadata(x)

-    vec_names <- names(list)

-    a <- lapply(vec_meta, function(y) {

-      grep(y, vec_names)

+    vec_meta <- paste0(metadata_prefix, metadata)

+    meta_list <- lapply(meta_files, function(x) {

+        list <- .add_metadata(x)

+        vec_names <- names(list)

+        a <- lapply(vec_meta, function(y) {

+            grep(y, vec_names)

+        })

+        ## we would like that manage more index from grep

+        found <- as.logical(length(unlist(a)))

+        # if found retrieve samples that has at least one choosen metadata

+        if (found) {

+            x

+        }

     })

-    ## we would like that manage more index from grep

-    found <- as.logical(length(unlist(a)))

-    # if found retrieve samples that has at least one choosen metadata

-    if (found) {

-      x

-    }

-  })

 }

 .parse_gtf_files <- function(

-  gtf_region_files, 

-  regions, 

-  suffixes,

-  vector_field

+    gtf_region_files, 

+    regions, 

+    suffixes,

+    vector_field

 ) {

-  g1 <- rtracklayer::import(con = gtf_region_files[1], format = "gtf")

-  elementMetadata(g1) <- NULL

-  if (is.null(suffixes)) {

-    suffixes <- ""

-  }

-  

-  # check if we used a FULL parameter instead of char array containing

-  # the region parameters

-  if(is.object(regions) && ("FULL" %in% class(regions))) {

-    all_values <- vector_field[!vector_field %in% c(

-      "seqname", 

-      "strand", 

-      "start",

-      "end"

-      )

-    ]

-    except_values <- regions$values

-    regions <- if (is.null(except_values))

-      all_values

-    else

-      all_values[!all_values %in% except_values]

-    names(regions) <- NULL

-    # since import convert this value from GMQL schema to GTF format

-    # we need to convert it back

-    regions <- replace(regions, regions == "feature", "type")

-    regions <- replace(regions, regions == "frame", "phase")

-  }

-  

-  if (!is.null(regions)) {

-    DF_list <- mapply(function(x, header) {

-      g_x <- rtracklayer::import(con = x, format = "gtf")

-      meta <- elementMetadata(g_x)[regions]

-      if (header != "") {

-        names(meta) <- paste(regions, header, sep = ".")

-      }

-      data.frame(meta)

-    }, gtf_region_files, suffixes, SIMPLIFY = FALSE)

-    DF_only_regions <- dplyr::bind_cols(DF_list)

-    elementMetadata(g1) <- DF_only_regions

-  }

-  g1

+    g1 <- rtracklayer::import(con = gtf_region_files[1], format = "gtf")

+    elementMetadata(g1) <- NULL

+    if (is.null(suffixes)) {

+        suffixes <- ""

+    }

+    

+    # check if we used a FULL parameter instead of char array containing

+    # the region parameters

+    if(is.object(regions) && ("FULL" %in% class(regions))) {

+        all_values <- vector_field[!vector_field %in% c(

+            "seqname", 

+            "strand", 

+            "start",

+            "end")

+        ]

+        except_values <- regions$values

+        regions <- if (is.null(except_values))

+            all_values

+        else

+            all_values[!all_values %in% except_values]

+        names(regions) <- NULL

+        # since import convert this value from GMQL schema to GTF format

+        # we need to convert it back

+        regions <- replace(regions, regions == "feature", "type")

+        regions <- replace(regions, regions == "frame", "phase")

+    }

+    

+    if (!is.null(regions)) {

+        DF_list <- mapply(function(x, header) {

+            g_x <- rtracklayer::import(con = x, format = "gtf")

+            meta <- elementMetadata(g_x)[regions]

+            if (header != "") {

+                names(meta) <- paste(regions, header, sep = ".")

+            }

+            data.frame(meta)

+        }, gtf_region_files, suffixes, SIMPLIFY = FALSE)

+        DF_only_regions <- dplyr::bind_cols(DF_list)

+        elementMetadata(g1) <- DF_only_regions

+    }

+    g1

 }

 .parse_gdm_files <- function(

-  vector_field,

-  gdm_region_files,

-  regions,

-  suffixes

+    vector_field,

+    gdm_region_files,

+    regions,

+    suffixes

 ) {

-  # read first sample cause chromosome regions are the same for all samples

-  df <- data.table::fread(

-    gdm_region_files[1],

-    col.names = vector_field,

-    header = FALSE,

-    sep = "\t"

-  )

-  col_names <- names(df)

-  df <- subset(df, TRUE, c("chr", "left", "right", "strand"))

-  

-  # check if we used a FULL parameter instead of char array containing

-  # the region parameters

-  if(is.object(regions) && ("FULL" %in% class(regions))) {

-    all_values <- vector_field[!vector_field %in% c(

-      "chr", 

-      "left", 

-      "right",

-      "strand"

-      )

-    ]

-    except_values <- regions$values

-    regions <- if (is.null(except_values))

-      all_values

-    else

-      all_values[!all_values %in% except_values]

-    names(regions) <- NULL

-  }

-  

-  if (!is.null(regions)) {

-    df_list <- lapply(gdm_region_files, function(x, regions, vector_field) {

-      region_frame <- data.table::fread(

-        x,

+    # read first sample cause chromosome regions are the same for all samples

+    df <- data.table::fread(

+        gdm_region_files[1],

         col.names = vector_field,

         header = FALSE,

         sep = "\t"

-      )

-      col_names <- names(region_frame)

-      # delete column not choosen by input

-      if (!is.null(regions)) {

-        col_names <- col_names[col_names %in% regions]

-      }

-      

-      if (length(col_names)) {

-        r <- subset(region_frame, TRUE, col_names)

-      }

-    }, regions, vector_field)

+    )

+    col_names <- names(df)

+    df <- subset(df, TRUE, c("chr", "left", "right", "strand"))

-    df_only_regions <- dplyr::bind_cols(df_list)

-    complete_df <- dplyr::bind_cols(df, df_only_regions)

+    # check if we used a FULL parameter instead of char array containing

+    # the region parameters

+    if(is.object(regions) && ("FULL" %in% class(regions))) {

+        all_values <- vector_field[!vector_field %in% c(

+            "chr", 

+            "left", 

+            "right",

+            "strand")

+        ]

+        except_values <- regions$values

+        regions <- if (is.null(except_values))

+            all_values

+        else

+            all_values[!all_values %in% except_values]

+        names(regions) <- NULL

+    }

-    region_names <- names(complete_df)[-(seq_len(4))]

-    region_names <- gsub("[0-9]+", "", region_names)

-    region_names <- paste(region_names, suffixes, sep = ".")

-    region_names <- c(names(complete_df)[(seq_len(4))], region_names)

-    names(complete_df) <- region_names

-    g <- GenomicRanges::makeGRangesFromDataFrame(

-      complete_df,

-      keep.extra.columns = TRUE,

-      start.field = "left",

-      end.field = "right"

-    )

-  }

-  else {

-    g <- GenomicRanges::makeGRangesFromDataFrame(

-      df,

-      keep.extra.columns = TRUE,

-      start.field = "left",

-      end.field = "right"

-    )

-  }

+    if (!is.null(regions)) {

+        df_list <- lapply(gdm_region_files, function(x, regions, vector_field) {

+            region_frame <- data.table::fread(

+                x,

+                col.names = vector_field,

+                header = FALSE,

+                sep = "\t")

+            col_names <- names(region_frame)

+            # delete column not choosen by input

+            if (!is.null(regions)) {

+                col_names <- col_names[col_names %in% regions]

+            }

+            

+            if (length(col_names)) {

+                r <- subset(region_frame, TRUE, col_names)

+            }

+        }, regions, vector_field)

+        

+        df_only_regions <- dplyr::bind_cols(df_list)

+        complete_df <- dplyr::bind_cols(df, df_only_regions)

+        

+        region_names <- names(complete_df)[-(seq_len(4))]

+        region_names <- gsub("[0-9]+", "", region_names)

+        region_names <- paste(region_names, suffixes, sep = ".")

+        region_names <- c(names(complete_df)[(seq_len(4))], region_names)

+        names(complete_df) <- region_names

+        g <- GenomicRanges::makeGRangesFromDataFrame(

+            complete_df,

+            keep.extra.columns = TRUE,

+            start.field = "left",

+            end.field = "right")

+    } else {

+        g <- GenomicRanges::makeGRangesFromDataFrame(

+            df,

+            keep.extra.columns = TRUE,

+            start.field = "left",

+            end.field = "right")

+    }

 }

@@ -26,7 +26,11 @@

 #' @param region_attributes vector of strings that extracts only region

 #' attributes  specified; if NULL no regions attribute is taken and the output

 #' is only GRanges made up by the region coordinate attributes

-#' (seqnames, start, end, strand)

+#' (seqnames, start, end, strand);

+#' It is also possible to assign the \code{\link{FULL}} with or without 

+#' its input parameter; in case was without the `except` parameter, 

+#' all the region attributes are taken, otherwise all the region attributes 

+#' are taken except the input attribute defined by except.

 #' @param suffix name for each metadata column of GRanges. By default it is the

 #' value of the metadata attribute named "antibody_target". This string is

 #' taken from sample metadata file or from metadata() associated.

@@ -61,19 +65,14 @@

 #' sorted_grl <- sort(grl)

 #' filter_and_extract(sorted_grl, region_attributes = c("pvalue", "peak"))

 #' 

-#' ## It is also possible to define the region attributes, using the FULL() 

-#' ## function parameter, in order to includes every region 

-#' ## attributes present into the schema file

+#' ## This statement imports a GMQL dataset as GRangesList and filters it

+#' ## including all the region attributes

 #' 

 #' sorted_grl_full <- sort(grl)

-#' filter_and_extract(sorted_grl, region_attributes = FULL())

+#' filter_and_extract(sorted_grl_full, region_attributes = FULL())

 #'