Merge pull request #52 from angelina-momin/feature-list-codecheckers

Feature-list-codecheckers

Author: angelina-momin

DESCRIPTION

@@ -1,6 +1,6 @@
 Package: codecheck
 Title: Helper Functions for CODECHECK Project
-Version: 0.3.0
+Version: 0.4.0
 Authors@R: 
     c(person(given = "Stephen",
             family = "Eglen",

R/register.R

@@ -1,15 +1,3 @@
-CONFIG <- new.env()
-# Registers can be further divided into filter subgroups
-# For cases where an entry does not fall into any subgroup, it's rendered files
-# are stored in a folder with its own name
-CONFIG$FILTER_SUB_GROUPS <- list(
-  venues = list("community", "journal", "conference") 
-)
-CONFIG$MD_COLUMNS_WIDTHS <- "|:-------|:--------------------------------|:------------------|:---|:--------------------------|:----------|"
-CONFIG$REGISTER_COLUMNS <- list("Certificate", "Repository", "Type", "Issue", "Report", "Check date")
-CONFIG$DICT_ORCID_ID_NAME <- list()
-CONFIG$DIR_TEMP_REGISTER_CODECHECKER <- "docs/temp_register_codechecker.csv"
-
 #' Function for rendering the register into different view
 #'
 #' NOTE: You should put a GitHub API token inth the environment variable `GITHUB_PAT` to fix rate limits. Acquire one at see https://github.com/settings/tokens.
@@ -33,9 +21,14 @@ CONFIG$DIR_TEMP_REGISTER_CODECHECKER <- "docs/temp_register_codechecker.csv"
 register_render <- function(register = read.csv("register.csv", as.is = TRUE),
                             filter_by = c("venues", "codecheckers"),
                             outputs = c("html", "md", "json")) {
-  CONFIG$MD_TEMPLATE <- system.file("extdata", "templates/template_register.md", package = "codecheck")
-  
+  # Loading config.R file
+  source(system.file("extdata", "config.R", package = "codecheck"))
+
   register_table <- preprocess_register(register, filter_by)
+  
+  # Setting number of codechecks now for later use. This is done to avoid double counting codechecks
+  # done by multiple authors.
+  CONFIG$NO_CODECHECKS <- nrow(register_table)
 
   # Creating list of of register tables with indices being the filter types
   list_register_tables <- c()
@@ -53,8 +46,20 @@ register_render <- function(register = read.csv("register.csv", as.is = TRUE),
 
   # Rendering files
   if ("md" %in% outputs) render_register_mds(list_register_tables)
-  if ("html" %in% outputs) render_register_htmls(list_register_tables)
-  if ("json" %in% outputs) render_register_jsons(list_register_tables)
+  if ("html" %in% outputs) {
+    render_register_htmls(list_register_tables)
+
+    for (filter in filter_by){
+      render_non_register_htmls(list_register_tables[[filter]], page_type = filter)
+    }
+  }
+  if ("json" %in% outputs) {
+    render_register_jsons(list_register_tables)
+    
+    for (filter in filter_by){
+      render_non_register_jsons(list_register_tables[[filter]], page_type = filter)
+    }
+  }
 
   return(register_table)
 }

R/utils_create_filtered_register_csvs.R

@@ -116,7 +116,7 @@ get_output_dir <- function(filter, column_value) {
 #' @param venue_name The venue_name obtained from the "Type" column of the register
 #' @return The venue category. If the venue does not belong to any category NULL is returned
 determine_venue_category <- function(venue_name){
-  list_venue_categories <- CONFIG$FILTER_SUB_GROUPS[["venues"]]
+  list_venue_categories <- CONFIG$FILTER_SUBCATEGORIES[["venues"]]
   for (category in list_venue_categories){
     if (grepl(category, venue_name, ignore.case=TRUE)) {
       return(category)

R/utils_render_register_mds.R

@@ -90,7 +90,7 @@ render_register_md <- function(filter, register_table, register_table_name, for_
     register_table <- add_repository_links_md(register_table)
   }
   # Fill in the content
-  md_table <- load_md_template(CONFIG$MD_TEMPLATE)
+  md_table <- load_md_template(CONFIG$TEMPLATE_DIR[["reg"]][["md_template"]])
 
   markdown_content <- capture.output(kable(register_table, format = "markdown"))
   md_table <- add_markdown_title(filter, md_table, register_table_name)

R/utils_render_reigster_html.r

@@ -32,10 +32,9 @@ add_repository_links_html <- function(register_table) {
 #' Dynamically generates a html_document.yml with the full paths to the index header, prefix 
 #' and postfix.html files. 
 #' 
-#' @param filter The filter name
-#' @param register_table_name The register table name
-generate_html_document_yml <- function(filter, register_table_name) {
-  dir <- paste0(getwd(), "/", get_output_dir(filter, register_table_name))
+#' @param output_dir The output directory where the html_document needs to be saved.
+generate_html_document_yml <- function(output_dir) {
+  output_dir <- paste0(getwd(), "/", output_dir)
 
   yaml_content <- sprintf(
     "# DO NOT EDIT THIS FILE MANUALLY
@@ -48,54 +47,63 @@ generate_html_document_yml <- function(filter, register_table_name) {
       highlight: null
       self_contained: false
       lib_dir: libs",
-    dir, dir, dir
+    output_dir, output_dir, output_dir
   )
-  writeLines(yaml_content, paste0(dir, "html_document.yml"))
+  writeLines(yaml_content, paste0(output_dir, "html_document.yml"))
 }
 
 #' Dynamically generates the index_postfix.html from a template file 
 #' 
+#' @param output_dir The output directory
 #' @param filter The filter name
-#' @param register_table_name The register table name
+#' @param register_table_name The register table name. If this is NULL we are generating list of venues/ codecheckers
 #' 
 #' @importFrom whisker whisker.render
-create_index_postfix_html <- function(filter, register_table_name){
-  hrefs <- generate_html_postfix_hrefs(filter, register_table_name)
+create_index_postfix_html <- function(output_dir, filter, register_table_name = NULL){
+
+  # When we have register table names, we are handling the case of reg tables
+  if (!is.null(register_table_name)){
+    postfix_template <- readLines(CONFIG$TEMPLATE_DIR[["reg"]][["postfix"]], warn = FALSE)
+    # Render the template with the correct hrefs
+    hrefs <- generate_html_postfix_hrefs_reg(filter, register_table_name)
+  }
+
+  # Generating the postfix for non-register table pages (e.g. list of venues and codecheckers)
+  else{
+    postfix_template <- readLines(CONFIG$TEMPLATE_DIR[["non_reg"]][["postfix"]], warn = FALSE)
+    hrefs <- list(
+      json_href = paste0("https://codecheck.org.uk/register/", filter, "/index.json")
+    )
+  }
 
-  # Using the index_postfix_template
-  postfix_template <- readLines(paste0(getwd(), "/docs/index_postfix_template.html"), warn = FALSE)
-  # Render the template with the correct hrefs
   output <- whisker.render(postfix_template, hrefs)
-  writeLines(output, paste0(get_output_dir(filter, register_table_name), "index_postfix.html"))
+  writeLines(output, paste0(output_dir, "index_postfix.html"))
 }
 
 #' Dynamically generates the index_prefix.html from a template file 
 #' 
-#' @param filter The filter name
-#' @param register_table_name The register table name
-create_index_prefix_html <- function(filter, register_table_name){
+#' @param output_dir The output directory
+create_index_prefix_html <- function(output_dir){
   # Using the index_prefix_template
-  prefix_template <- readLines(paste0(getwd(), "/docs/index_prefix_template.html"), warn = FALSE)
-
-  writeLines(prefix_template, paste0(get_output_dir(filter, register_table_name), "index_prefix.html"))
+  prefix_template <- readLines(CONFIG$TEMPLATE_DIR[["reg"]][["prefix"]], warn = FALSE)
+  writeLines(prefix_template, paste0(output_dir, "index_prefix.html"))
 }
 
 #' Dynamically generates the index_header.html from a template file 
 #' 
-#' @param filter The filter name
-#' @param register_table_name The register table name
-create_index_header_html <- function(filter, register_table_name){
+#' @param output_dir The output directory
+create_index_header_html <- function(output_dir){
   # Using the index_header_template
-  header_template <- readLines(paste0(getwd(), "/docs/index_header_template.html"), warn = FALSE)
+  header_template <- readLines(CONFIG$TEMPLATE_DIR[["reg"]][["header"]], warn = FALSE)
 
-  writeLines(header_template, paste0(get_output_dir(filter, register_table_name), "index_header.html"))
+  writeLines(header_template, paste0(output_dir, "index_header.html"))
 }
 
-#' Generates the hrefs to set in the postfix.html file.
+#' Generates the hrefs to set in the postfix.html file for the rendering of register tables.
 #' 
 #' @param filter The filter name
 #' @param register_table_name The register table name
-generate_html_postfix_hrefs <- function(filter, register_table_name) {
+generate_html_postfix_hrefs_reg <- function(filter, register_table_name) {
   hrefs <- list(
     csv_source_href = generate_href(filter, register_table_name, "csv_source"),
     searchable_csv_href = generate_href(filter, register_table_name, "searchable_csv"),
@@ -155,14 +163,15 @@ generate_href <- function(filter, register_table_name, href_type) {
   }
 }
 
-#' Creates html files for each index section- the index postfix, prefix and the header 
+#' Creates index postfix, prefix and the header 
 #'
+#' @param output_dir The output directory of the section files
 #' @param filter The filter name 
 #' @param register_table_name The register table name
-create_index_section_files <- function(filter, register_table_name) {
-  create_index_postfix_html(filter, register_table_name)
-  create_index_prefix_html(filter, register_table_name)
-  create_index_header_html(filter, register_table_name)
+create_index_section_files <- function(output_dir, filter, register_table_name = NULL) {
+  create_index_postfix_html(output_dir, filter, register_table_name)
+  create_index_prefix_html(output_dir)
+  create_index_header_html(output_dir)
 }
 
 #' Renders register html for a single register_table
@@ -171,14 +180,14 @@ create_index_section_files <- function(filter, register_table_name) {
 #' @param register_table The register table
 #' @param register_table_name The register table name
 render_register_html <- function(filter, register_table, register_table_name){  
-  # Add icons to the Repository column for HTML output, use a copy of the register.md
+  
+  output_dir <- get_output_dir(filter, register_table_name)
   register_table <- add_repository_links_html(register_table)
 
   # Dynamically create the index header, prefix and postfix files
-  create_index_section_files(filter, register_table_name)
-  generate_html_document_yml(filter, register_table_name)
+  create_index_section_files(output_dir, filter, register_table_name)
+  generate_html_document_yml(output_dir)
 
-  output_dir <- get_output_dir(filter, register_table_name)
   # Capture the HTML output from a markdown file
   # Note that the temp md file must be created even if a md exists because the register table
   # now has different icons under "Repository" column
@@ -214,8 +223,10 @@ render_register_html <- function(filter, register_table, register_table_name){
 render_register_htmls <- function(list_register_tables) {
   # Loop over each register table
   for (filter in names(list_register_tables)){
-    for (register_table_name in names(list_register_tables[[filter]])) {
-      register_table <- list_register_tables[[filter]][[register_table_name]]
+    list_filtered_reg_tables <- list_register_tables[[filter]]
+
+    for (register_table_name in names(list_filtered_reg_tables)) {
+      register_table <- list_filtered_reg_tables[[register_table_name]]
       render_register_html(filter, register_table, register_table_name)
     }
   }

R/utils_render_table_codecheckers.R

@@ -0,0 +1,78 @@
+#' Renders codecheckers table in JSON format.
+#' 
+#' @param list_codechecker_reg_tables The list of codechecker register tables. The indices are the ORCID IDs.
+render_table_codecheckers_json <- function(list_codechecker_reg_tables){
+  list_orcid_ids <- names(list_codechecker_reg_tables)
+  table_codecheckers <- data.frame(matrix(ncol=0, nrow = length(list_orcid_ids)), stringsAsFactors = FALSE)
+  
+  col_names <- CONFIG$CODECHECKER_TABLE_COL_NAMES[["codechecker_table"]]
+
+  # Column- codechecker names
+  table_codecheckers[[col_names[["codechecker"]]]] <- sapply(
+    X = list_orcid_ids,
+    FUN = function(orcid_id) {
+      paste0(CONFIG$DICT_ORCID_ID_NAME[[orcid_id]])
+    }
+  )
+
+  table_codecheckers[[col_names[["orcid"]]]] <- list_orcid_ids
+
+  # Column- No. of codechecks
+  table_codecheckers[[col_names[["no_codechecks"]]]] <- sapply(
+    X = list_orcid_ids,
+    FUN = function(orcid_id) {
+      paste0(nrow(list_codechecker_reg_tables[[orcid_id]]))
+    }
+  )
+
+  return(table_codecheckers)
+}
+
+#' Renders codecheckers table in HTML format.
+#' Each codechecker name links to the register table for that specific
+#' codechecker. The ORCID IDs link to their ORCID pages.
+#' 
+#' @param list_codechecker_reg_tables The list of codechecker register tables. The indices are the ORCID IDs.
+render_table_codecheckers_html <- function(list_codechecker_reg_tables){
+
+  list_orcid_ids <- names(list_codechecker_reg_tables)
+  col_names <- CONFIG$NON_REG_TABLE_COL_NAMES[["codechecker_table"]]
+
+  no_rows <- length(list_orcid_ids)
+  
+  # Initializing the table
+  table_codecheckers <- data.frame(matrix(ncol= 0, nrow = no_rows), stringsAsFactors = FALSE)
+
+  # Column- codechecker names
+  # Each codechecker name will be a hyperlink to the register table
+  # with all their codechecks
+  table_codecheckers[col_names[["codechecker"]]] <- sapply(
+    X = list_orcid_ids,
+    FUN = function(orcid_id) {
+      codechecker_name <- CONFIG$DICT_ORCID_ID_NAME[[orcid_id]]
+      paste0("[", codechecker_name, "](https://codecheck.org.uk/register/codecheckers/",
+      orcid_id, "/)")
+    }
+  )
+  # Column- ORCID ID 
+  table_codecheckers[col_names[["orcid"]]] <- sapply(
+    X = list_orcid_ids,
+    FUN = function(orcid_id) {
+      paste0("[", orcid_id, "](https://orcid.org/", orcid_id, ")")
+    }
+  )
+  # Column- No. of codechecks
+  # Shown as "no_codechecks (sell all checks)" where "see all checks" links to the checks by 
+  # the codechecker
+  table_codecheckers[col_names[["no_codechecks"]]] <- sapply(
+    X = list_orcid_ids,
+    FUN = function(orcid_id) {
+      no_codechecks <- nrow(list_codechecker_reg_tables[[orcid_id]])
+      paste0(nrow(list_codechecker_reg_tables[[orcid_id]])," [(see all checks)](https://codecheck.org.uk/register/codecheckers/",
+      orcid_id, "/)")
+    }
+  )
+
+  return(table_codecheckers)
+}
+

R/utils_render_table_non_registers.R

@@ -0,0 +1,80 @@
+#' Renders non-register pages such as codecheckers or venues page.
+#' 
+#' @param list_reg_tables The list of register tables to link to in this html page
+render_non_register_htmls <- function(list_reg_tables, page_type){
+  output_dir <- paste0("docs/", page_type, "/")
+
+  if (page_type == "codecheckers"){
+    table <- render_table_codecheckers_html(list_reg_tables)
+    table <- kable(table)
+    # Counting number of codecheckers based of number of codechecker reg tables
+    # The table is a kable table and hence we cannot count rows
+    no_codecheckers <- length(list_reg_tables)
+    # Using number of codechecks from CONFIG instead of "no. of codechecks" column to avoid double count
+    subtext <- paste("In total,", no_codecheckers, "codecheckers contributed", CONFIG$NO_CODECHECKS, "codechecks*")
+    
+    # Extra text to explain why total_codechecks != SUM(no.of codechecks)
+    extra_text <- "<i>\\*Note that the total codechecks is less than the collective sum of 
+    individual codecheckers' number of codechecks. 
+    This is because some codechecks involved more than one codechecker.</i>"
+  }
+
+  else{
+    return()
+  }
+  # Creating and adjusting the markdown table
+  md_table <- load_md_template(CONFIG$TEMPLATE_DIR[["non_reg"]][["md_template"]])
+  title <- paste0("CODECHECK List of ", page_type)
+  md_table <- gsub("\\$title\\$", title, md_table)
+  md_table <- gsub("\\$subtitle\\$", subtext, md_table)
+  md_table <- gsub("\\$content\\$", paste(table, collapse = "\n"), md_table)
+  md_table <- gsub("\\$extra_text\\$", extra_text, md_table)
+
+  # Saving the table to a temp md file
+  temp_md_path <- paste0(output_dir, "temp.md")
+  writeLines(md_table, temp_md_path)
+
+  # Creating the correct html yaml and index files
+  create_index_section_files(output_dir, page_type)
+  generate_html_document_yml(output_dir)
+  yaml_path <- normalizePath(file.path(getwd(), paste0(output_dir, "html_document.yml")))
+
+  # Render index.html from markdown
+  rmarkdown::render(
+    input = temp_md_path,
+    output_file = "index.html",
+    output_dir = output_dir,
+    output_yaml = yaml_path
+  )
+
+  # Deleting the temp file
+  file.remove(temp_md_path)
+
+  # Changing the html file so that the path to the libs folder refers to 
+  # the libs folder "docs/libs".
+  # This is done to remove duplicates of "libs" folders.
+  html_file_path <- paste0(output_dir, "index.html")
+  edit_html_lib_paths(html_file_path)
+  # Deleting the libs folder after changing the html lib path
+  unlink(paste0(output_dir, "/libs"), recursive = TRUE)
+}
+
+#' Renders JSON file of non register tables such as list of venues, list of codecheckers
+#' 
+#' @param list_reg_tables The list of register tables needed for the information.
+render_non_register_jsons <- function(list_reg_tables, page_type){
+  output_dir <- paste0("docs/", page_type, "/")
+
+  if (page_type == "codeheckers"){
+    table <- render_table_codecheckers_json(list_reg_tables)
+  }
+
+  else{
+    return()
+  }
+  jsonlite::write_json(
+    table,
+    path = paste0(output_dir, "index.json"),
+    pretty = TRUE
+  )
+}