#' Initialize a changelog for a LiPD object
#'
#' @description This function will create a changelog for a file that doesn't already have one.
#' @inheritParams updateChangelog
#' @return A LiPD object with a changelog
#' @export
<- (L,
notes = "Starting the changelog",
curator = ()"user"]],
= lubridate::now(tzone = "UTC"),
= "1.0.0"){
(!(L$changelog)){#it already exists
("It looks like this file already has a change log, you probably want `updateChangelog()`. returning the input LiPD object without modification.")
(L)
}
thisChange <- ( = (),
curator = curator,
= (,lubridate::tz()),
notes = notes)
L$changelog <- (thisChange)
(L)
}
tibDiff <- (tcol){
#check for a change
((tcol) > 0){
old <- tcol[1]
<- tcol[2]
((old) | (old) == "na" | (old)){
old <- ""
}
(() | () == "na" | ()){
<- ""
}
(old != ){
(glue::glue("'{old}' has been replaced by '{new}'"))
}
}
}
#' Create a changelog by comparing two LiPD files
#'
#' @param Lold Old lipd object
#' @param Lnew New lipd object
#' @param good.base A vector of base level metadata to check
#' @param exclude.paleo A vector of paleo metadata to exclude
#' @param exclude.chron A vector of chron metadata to exclude
#'
#' @return a changelog data frame
#' @export
<- (Lold,
Lnew,
good.base = ("archiveType",
"createdBy",
"dataSetName",
"dataSource",
"notes",
"originalDataUrl"),
exclude.paleo = ("paleoData_meanValue12k",
"paleoData_mostRecentCompilations",
"paleoData_medianRes12k",
"paleoData_tableName",
"paleoData_values"),
exclude.chron = ("chronData_values")){
cl <- () #initialize changelog
ct <- () #initialize change type
cv <- () #initialize change variable
checked.base <- #initialize
lastVers <- (Lold)
# Check for paleo and chronData -------------------------------------------
#paleoData
npdo <- (Lold$paleoData)
npdn <- (Lnew$paleoData)
(npdn>0){
hasPaleo <-
}{
hasPaleo <-
}
#if paleoData was added or removed, let's report that
(npdo == 0 & npdn > 0){
cl <- (cl,"PaleoData has been added to this dataset")
ct <- (ct,"Dataset")
cv <- (cv,)
}
(npdo > 0 & npdn == 0){
cl <- (cl,"All PaleoData have been removed from this dataset")
ct <- (ct,"Dataset")
cv <- (cv,)
}
#chronData
ncdo <- (Lold$chronData)
ncdn <- (Lnew$chronData)
(ncdn>0){
hasChron <-
}{
hasChron <-
}
#if chronData was added or removed, let's report that
(ncdo == 0 & ncdn > 0){
cl <- (cl,"chronData has been added to this dataset")
ct <- (ct,"Dataset")
cv <- (cv,)
}
(ncdo > 0 & ncdn == 0){
cl <- (cl,"All chronData have been removed from this dataset")
ct <- (ct,"Dataset")
cv <- (cv,)
}
# Go through paleoData ----------------------------------------------------
(hasPaleo){
#get tibbles
to <- Lold %>%
() %>%
() %>%
dplyr::arrange(paleoData_TSid)
tn <- Lnew %>%
() %>%
() %>%
dplyr::arrange(paleoData_TSid)
#check TSids are unique
(((to$paleoData_TSid))){
(glue::glue("{to$dataSetName[1]}: the original dataset has duplicated TSids"))
}
(((tn$paleoData_TSid))){
(glue::glue("{tn$dataSetName[1]}: the new dataset has duplicated TSids"))
}
# Check for added/removed columns -----------------------------------------
#check for added columns
((!tn$paleoData_TSid %in% to$paleoData_TSid)){#then one was added
wa <- (!tn$paleoData_TSid %in% to$paleoData_TSid)
(i wa){
cl <- (cl,
glue::glue("Column '{tn$paleoData_TSid[i]}', with variable name '{tn$paleoData_variableName[i]}', was added to the dataset")
)
ct <- (ct,"PaleoData table")
cv <- (cv,)
}
#then remove them - we won't describe the details of added columns
tn <- tn-wa,]
}
#check for removed columns
((!to$paleoData_TSid %in% tn$paleoData_TSid)){#then one was added
wr <- (!to$paleoData_TSid %in% tn$paleoData_TSid)
(i wr){
cl <- (cl,
glue::glue("Column '{to$paleoData_TSid[i]}', with variable name '{to$paleoData_variableName[i]}', was removed from the dataset")
)
ct <- (ct,"PaleoData table")
cv <- (cv,)
}
#then remove them - this should force the datasets to always have the same number of columns
to <- to-wr,]
}
#make sure there are some rows remaining
((tn) == 1 | (to) == 1){
(glue::glue("{Lnew$dataSetName}: there is only 1 matching TSids in the paleoData. This is not typical."))
}
#make sure there are some rows remaining
((tn) < 1 | (to) < 1){
(glue::glue("{Lnew$dataSetName}: there is no matching TSids in the paleoData. You probably entered an incorrect file or fixed some TSid issues"))
("trying by variableName")
#get tibbles
to <- Lold %>%
( = "paleo") %>%
() %>%
dplyr::arrange(paleoData_variableName)
tn <- Lnew %>%
( = "paleo") %>%
() %>%
dplyr::arrange(paleoData_variableName)
#check TSids are unique
(((to$paleoData_variableName))){
("the original dataset has duplicated paleo variableName")
ct <- (ct,"PaleoData table")
cv <- (cv,(to$to$paleoData_variableName[duplicated(to$paleoData_variableName)],collapse = ", "))
changelog <- tibble::tibble( = ct, change = cl, variable = cv,dataSetName = ,lastVersion = )
(changelog)
}
(((tn$paleoData_variableName))){
("the original dataset has duplicated paleo variableName")
ct <- (ct,"PaleoData table")
cv <- (cv,(tn$paleoData_variableName[duplicated(tn$paleoData_variableName)],collapse = ", "))
changelog <- tibble::tibble( = ct, change = cl, variable = cv,dataSetName = ,lastVersion = )
(changelog)
}
# Check for added/removed columns -----------------------------------------
#check for added columns
((!tn$paleoData_variableName %in% to$paleoData_variableName)){#then one was added
wa <- (!tn$paleoData_variableName %in% to$paleoData_variableName)
(i wa){
cl <- (cl,
glue::glue("Column '{tn$paleoData_TSid[i]}', with variable name '{tn$paleoData_variableName[i]}', was added to the dataset")
)
ct <- (ct,"paleoData table")
cv <- (cv,)
}
#then remove them - we won't describe the details of added columns
tn <- tn-wa,]
}
#check for removed columns
((!to$paleoData_variableName %in% tn$paleoData_variableName)){#then one was added
wr <- (!to$paleoData_variableName %in% tn$paleoData_variableName)
(i wr){
cl <- (cl,
glue::glue("Column '{to$paleoData_TSid[i]}', with variable name '{to$paleoData_variableName[i]}', was removed from the dataset")
)
ct <- (ct,"paleoData table")
cv <- (cv,)
}
#then remove them - this should force the datasets to always have the same number of columns
to <- to-wr,]
}
((tn) < 1 | (to) < 1){
("there are 0 or 1 matching TSids AND variableNames in the paleoData. You probably entered an incorrect file, or fixed a TSid problem")
}
}
#check to make sure that the TSids and number of rows are identical
tn <- tn %>% dplyr::arrange(paleoData_TSid)
to <- to %>% dplyr::arrange(paleoData_TSid)
# Check base metadata -----------------------------------------------------
#make sure the names are present
ne <- good.base!good.base %in% (to)]
((ne) > 0){
(n ne){
to <- dplyr::mutate(to,!!n := )
}
}
ne <- good.base!good.base %in% (tn)]
((ne) > 0){
(n ne){
tn <- dplyr::mutate(tn,!!n := )
}
}
#filter and collapse to just non-paleo metadata
bto <- dplyr::select(to,!!good.base,
starts_with("pub"),
starts_with("geo_"),
starts_with("funding")) %>%
dplyr::distinct() %>%
dplyr::mutate(dplyr::across(tidyselect::everything(),))
#should only be one row now
((bto) != 1){
("The old dataset has discrepencies in metadata between columns that shouldn't exist")
}
btn <- dplyr::select(tn,!!good.base,
starts_with("pub"),
starts_with("geo_"),
starts_with("funding")) %>%
dplyr::distinct() %>%
dplyr::mutate(dplyr::across(tidyselect::everything(),))
((btn) != 1){
("The new dataset has discrepencies in metadata between columns that shouldn't exist")
}
tcdf <- dplyr::bind_rows(bto,btn)
tcdf[is.null(tcdf)] <-
#check for changes and report back
cldf <- purrr::map_dfc(tcdf,tibDiff)
((cldf)>0){
#fold into changelog
cl <- (cl,((cldf),cldf,sep = ": "))
#what type of base change?
(cli 1:(cldf)){
(("pub[0-9]_",(cldf)[cli])){
ct <- (ct,"Publication metadata")
} (("funding[0-9]_",(cldf)[cli])){
ct <- (ct,"Funding metadata")
} (("geo_",(cldf)[cli])){
ct <- (ct,"Geographic metadata")
}{
ct <- (ct,"Base metadata")
}
}
cv <- (cv,(cldf))
}
checked.base <-
# Check paleoData column metadata -----------------------------------------
paleoSelect <- (x,exclude.paleo){
exclude.paleo <- exclude.paleo[exclude.paleo %in% (x)]
o <- dplyr::select(x,starts_with("paleoData_"),
starts_with("interpretation"),
starts_with("calibration")) %>%
dplyr::select(-starts_with("paleoData_has"),
-!!exclude.paleo)
(o)}
#make all columns character for this comparison
ptn <- paleoSelect(tn,exclude.paleo) %>%
dplyr::mutate(dplyr::across(tidyselect::everything(),))
pto <- paleoSelect(to,exclude.paleo) %>%
dplyr::mutate(dplyr::across(tidyselect::everything(),))
#loop through TSids
(i 1:(ptn)){
tsi <- ptn$paleoData_TSid[i]
tsname <- ptn$paleoData_variableName[i]
#prep the comparison
tcdf <- dplyr::bind_rows(pto[i,],ptn[i,])
tcdf[is.null(tcdf)] <-
#check for changes and report back
cldf <- purrr::map_dfc(tcdf,tibDiff)
#fold into changelog
((cldf) > 0){
cl <- (cl,
(glue::glue("{tsname} ({tsi})"),(cldf),cldf,sep = ": "))
(cli 1:(cldf)){
(( = "interpretation[0-9]_",(cldf)[cli])){
ct <- (ct,"Paleo Interpretation metadata")
} ((prefix = "calibration",(cldf)[cli])){
ct <- (ct,"Paleo Calibration metadata")
}{
ct <- (ct,"Paleo Column metadata")
}
}
cv <- (cv,(cldf))
}
}
# compare the paleoData_values --------------------------------------------
(i 1:(tn)){
tov <- to$paleoData_values[i]]
tov[is.na(tov)] <- -999
tnv <- tn$paleoData_values[i]]
tnv[is.na(tnv)] <- -999
((tov) & (tnv)){
valChange <- !(tov == tnv)
} ((tov) & (tnv)){
valChange <- !(dplyr::near(tov,tnv))
}{
("it seems like the old and new values are of different classes, which is bad. Converting to character for comparison")
valChange <- !((tov) == (tnv))
}
(valChange){
tsi <- tn$paleoData_TSid[i]
tsname <- tn$paleoData_variableName[i]
cl <- (cl,
glue::glue("{tsname} ({tsi}): The size of the paleoData_values have changed, from {length(tov)} to {length(tnv)} entries."))
ct <- (ct,"PaleoData values")
cv <- (cv,"paleoData_values")
}{
(!(tov == tnv)){
tsi <- tn$paleoData_TSid[i]
tsname <- tn$paleoData_variableName[i]
cl <- (cl,
glue::glue("{tsname} ({tsi}): The paleoData_values have changed"))
ct <- (ct,"PaleoData values")
cv <- (cv,"paleoData_values")
}
}
}
}
# Go through chronData ----------------------------------------------------
totest <- Lold %>%
( = "chron")
(hasChron & (totest) > 0){# only check for new columns if there was an old chron.
#get tibbles
to <- Lold %>%
( = "chron") %>%
() %>%
dplyr::arrange(chronData_TSid)
tn <- Lnew %>%
( = "chron") %>%
() %>%
dplyr::arrange(chronData_TSid)
#check TSids are unique
(((to$chronData_TSid))){
("the original dataset has duplicated chron TSids, can't proceed")
cl <- (cl,
glue::glue("ChronData: Duplicated TSids names in original dataset, couldn't log column-level changes.")
)
ct <- (ct,"ChronData table")
cv <- (cv,(to$chronData_TSid[duplicated(to$chronData_TSid)],collapse = ", "))
changelog <- tibble::tibble( = ct, change = cl, variable = cv,dataSetName = ,lastVersion = )
(changelog)
}
(((tn$chronData_TSid))){
("the new dataset has duplicated chron TSids")
}
# Check for added/removed columns -----------------------------------------
#check for added columns
((!tn$chronData_TSid %in% to$chronData_TSid)){#then one was added
wa <- (!tn$chronData_TSid %in% to$chronData_TSid)
(i wa){
cl <- (cl,
glue::glue("Column '{tn$chronData_TSid[i]}', with variable name '{tn$chronData_variableName[i]}', was added to the dataset")
)
ct <- (ct,"ChronData table")
cv <- (cv,)
}
#then remove them - we won't describe the details of added columns
tn <- tn-wa,]
}
#check for removed columns
((!to$chronData_TSid %in% tn$chronData_TSid)){#then one was added
wr <- (!to$chronData_TSid %in% tn$chronData_TSid)
(i wr){
cl <- (cl,
glue::glue("Column '{to$chronData_TSid[i]}', with variable name '{to$chronData_variableName[i]}', was removed from the dataset")
)
ct <- (ct,"ChronData table")
cv <- (cv,)
}
#then remove them - this should force the datasets to always have the same number of columns
to <- to-wr,]
}
#make sure there are some rows remaining
((tn) < 1 | (to) < 1){
("there are 0 or 1 matching TSids in the chronData. You probably entered an incorrect file, or fixed a TSid problem")
("trying by variableName")
to <- Lold %>%
( = "chron") %>%
()
tn <- Lnew %>%
( = "chron") %>%
()
((to) == 0){
("there seems to be no data in the old chronData table")
}
((tn) == 0){
("there seems to be no data in the new chronData table")
}
(to$dataSetName)
to <- dplyr::arrange(to,chronData_variableName)
tn <- dplyr::arrange(tn,chronData_variableName)
#check TSids are unique
(((to$chronData_variableName))){
("the original dataset has duplicated chron variableName, can't proceed")
cl <- (cl,
glue::glue("ChronData: Duplicated variable names in original dataset, couldn't log column-level changes.")
)
ct <- (ct,"ChronData table")
cv <- (cv,(to$chronData_variableName[duplicated(to$chronData_variableName)],collapse = ", "))
changelog <- tibble::tibble( = ct, change = cl, variable = cv,dataSetName = ,lastVersion = )
(changelog)
}
(((tn$chronData_variableName))){
("the new dataset has duplicated variableName")
}
# Check for added/removed columns -----------------------------------------
#check for added columns
((!tn$chronData_variableName %in% to$chronData_variableName)){#then one was added
wa <- (!tn$chronData_variableName %in% to$chronData_variableName)
(i wa){
cl <- (cl,
glue::glue("Column '{tn$chronData_TSid[i]}', with variable name '{tn$chronData_variableName[i]}', was added to the dataset")
)
ct <- (ct,"ChronData table")
cv <- (cv,)
}
#then remove them - we won't describe the details of added columns
tn <- tn-wa,]
}
#check for removed columns
((!to$chronData_variableName %in% tn$chronData_variableName)){#then one was added
wr <- (!to$chronData_variableName %in% tn$chronData_variableName)
(i wr){
cl <- (cl,
glue::glue("Column '{to$chronData_TSid[i]}', with variable name '{to$chronData_variableName[i]}', was removed from the dataset")
)
ct <- (ct,"ChronData table")
cv <- (cv,)
}
#then remove them - this should force the datasets to always have the same number of columns
to <- to-wr,]
}
((tn) < 1 | (to) < 1){
("there are 0 or 1 matching TSids AND variableNames in the chronData. You probably entered an incorrect file, or fixed a TSid problem")
cl <- (cl,
glue::glue("ChronData: There are 0 or 1 matching TSids AND variableNames in the chronData. You probably entered an incorrect file, or fixed a TSid problem")
)
ct <- (ct,"ChronData table")
cv <- (cv,"unknown")
changelog <- tibble::tibble( = ct, change = cl, variable = cv,dataSetName = ,lastVersion = )
(changelog)
}
}
#check to make sure that the TSids and number of rows are identical
tn <- tn %>% dplyr::arrange(chronData_TSid)
to <- to %>% dplyr::arrange(chronData_TSid)
# Check base metadata -----------------------------------------------------
(!checked.base){
#make sure the names are present
ne <- good.base!good.base %in% (to)]
((ne) > 0){
(n ne){
to <- dplyr::mutate(to,!!n := )
}
}
ne <- good.base!good.base %in% (tn)]
((ne) > 0){
(n ne){
tn <- dplyr::mutate(tn,!!n := )
}
}
#filter and collapse to just non-chron metadata
bto <- dplyr::select(to,!!good.base,
starts_with("pub"),
starts_with("geo_"),
starts_with("funding")) %>%
dplyr::distinct() %>%
dplyr::mutate(dplyr::across(tidyselect::everything(),))
#should only be one row now
((bto) != 1){
("The old dataset has discrepencies in metadata between columns that shouldn't exist")
}
btn <- dplyr::select(tn,!!good.base,
starts_with("pub"),
starts_with("geo_"),
starts_with("funding")) %>%
dplyr::distinct() %>%
dplyr::mutate(dplyr::across(tidyselect::everything(),))
((btn) != 1){
("The new dataset has discrepencies in metadata between columns that shouldn't exist")
}
tcdf <- dplyr::bind_rows(bto,btn)
tcdf[is.null(tcdf)] <-
#check for changes and report back
cldf <- purrr::map_dfc(tcdf,tibDiff)
((cldf)>0){
#fold into changelog
cl <- (cl,((cldf),cldf,sep = ": "))
#what type of base change?
(cli 1:(cldf)){
(("pub[0-9]_",(cldf)[cli])){
ct <- (ct,"Publication metadata")
} (("funding[0-9]_",(cldf)[cli])){
ct <- (ct,"Funding metadata")
} (("geo_",(cldf)[cli])){
ct <- (ct,"Geographic metadata")
}{
ct <- (ct,"Base metadata")
}
}
cv <- (cv,(cldf))
}
checked.base <-
}
# Check chronData column metadata -----------------------------------------
chronSelect <- (x,exclude.chron){
exclude.chron <- exclude.chron[exclude.chron %in% (x)]
o <- dplyr::select(x,starts_with("chronData_"),
starts_with("interpretation"),
starts_with("calibration")) %>%
dplyr::select(-starts_with("chronData_has"),
-!!exclude.chron)
(o)}
#make all columns character for this comparison
ptn <- chronSelect(tn,exclude.chron) %>%
dplyr::mutate(dplyr::across(tidyselect::everything(),))
pto <- chronSelect(to,exclude.chron) %>%
dplyr::mutate(dplyr::across(tidyselect::everything(),))
#loop through TSids
(i 1:(ptn)){
tsi <- ptn$chronData_TSid[i]
tsname <- ptn$chronData_variableName[i]
#prep the comparison
tcdf <- dplyr::bind_rows(pto[i,],ptn[i,])
tcdf[is.null(tcdf)] <-
#check for changes and report back
cldf <- purrr::map_dfc(tcdf,tibDiff)
#fold into changelog
((cldf) > 0){
cl <- (cl,
(glue::glue("{tsname} ({tsi})"),(cldf),cldf,sep = ": "))
ct <- (ct,
("Chron Column metadata",times = (cldf)))
cv <- (cv,(cldf))
}
}
# compare the chronData_values --------------------------------------------
(i 1:(tn)){
#change NAs to allow testing
tov <- to$chronData_values[i]]
tov[is.na(tov)] <- -999
tnv <- tn$chronData_values[i]]
tnv[is.na(tnv)] <- -999
((tov) & (tnv)){
valChange <- !(tov == tnv)
} ((tov) & (tnv)){
valChange <- !(dplyr::near(tov,tnv))
}{
("it seems like the old and new values are of different classes, which is bad. Converting to character for comparison")
valChange <- !((tov) == (tnv))
}
(valChange){
tsi <- tn$chronData_TSid[i]
tsname <- tn$chronData_variableName[i]
cl <- (cl,
glue::glue("{tsname} ({tsi}): The size of the chronData_values have changed, from {length(tov)} to {length(tnv)} entries."))
ct <- (ct,"ChronData values")
cv <- (cv,"chronData_values")
}{
(!(tov == tnv)){
tsi <- tn$chronData_TSid[i]
tsname <- tn$chronData_variableName[i]
cl <- (cl,
glue::glue("{tsname} ({tsi}): The chronData_values have changed"))
ct <- (ct,"ChronData values")
cv <- (cv,"chronData_values")
}
}
}
} (hasChron & (totest) == 0){
tn <- Lnew %>%
( = "chron") %>%
() %>%
dplyr::arrange(chronData_TSid)
#check TSids are unique
#check for added columns
wa <- (tn$chronData_TSid)
(i wa){
cl <- (cl,
glue::glue("Column '{tn$chronData_TSid[i]}', with variable name '{tn$chronData_variableName[i]}', was added to the dataset")
)
ct <- (ct,"ChronData table")
cv <- (cv,)
}
}
((cl)>0){
changelog <- tibble::tibble( = ct, change = cl, variable = cv,dataSetName = Lnew$dataSetName,lastVersion = lastVers)
}{
changelog <- tibble::tibble( = ct, change = cl, variable = cv,dataSetName = ,lastVersion = )
}
(changelog)
}
#' Update the changelog entry in a LiPD file with new changes
#'
#' @param L a LiPD object
#' @param changelog a changelog data.frame
#' @param version version of the dataset
#' @param notes notes
#' @param curator who made these changes
#' @param timestamp when was this made
#'
#' @return An updated LiPD object
#' @export
<- (L,
changelog,
= ,
notes = ,
curator = ()"user"]],
= lubridate::now(tzone = "UTC")){
((changelog) == 0){#no changes, don't write
(L)
}
#get the comparison version
lastVers <- changelog$lastVersion[1]
#restrict to just type and change for now
changelog <- dplyr::select(changelog,,change)
#get prior changes
allChanges <- L$changelog
#prepare changelog
changes <- changelog %>% dplyr::group_by() %>% tidyr::nest()
#change to list structure
changelist <- (changes[2]],changes[1]]) %>%
map() %>%
map(,)
getVers <- (x){(x$)}
#version check and increment
(()){#automatically increment version
lastVers <- ((purrr::map_chr(allChanges,getVers)))
#check to make sure there is a previous version
((lastVers)==0){
lastVers <- ("1.0.0") #we'll start here.
}
#initialize
vers <- lastVers
#increment intelligently
((("values",(changelist)))){#minor
vers[1,2]] <- lastVers[1,2]]+1
vers[1,3]] <- 0
}{#patch
vers[1,3]] <- lastVers[1,3]]+1
}
}{
#increment intelligently
( == "major"){
((notes)){
("the `notes` field must be present for a major version change")
}
lastVers <- ((purrr::map_chr(allChanges,getVers)))
#check to make sure there is a previous version
((lastVers)==0){
("there don't seem to be any previous versions - version must be specified")
}
vers[1,1]] <- lastVers[1,1]]+1
vers[1,2:3]] <- 0
}{
vers <- (())
}
}
(!(notes)){#add in notes if present
thisChange <- ( = (vers),
lastVersion = (lastVers),
curator = curator,
= (,lubridate::tz()),
notes = notes,
changes = changelist)
}{
#create this instance of the changelog
thisChange <- ( = (vers),
lastVersion = (lastVers),
curator = curator,
= (,lubridate::tz()),
changes = changelist)
}
#update the changes
L$changelog <- ((thisChange),L$changelog)
L$lipdverseLink <- ("https://lipdverse.org/data/",L$datasetId,"/",stringr::str_replace_all((vers),"[.]","_"))
(L)
}
#' Get one instance from a LiPD changelog
#'
#' @param L Lipd object
#' @param version which version to get changelog for
#'
#' @return Changelog output
#' @export
<- (L, = "newest"){
allvers <- (purrr::map_chr(L$changelog,"version"))
((allvers) == 0){
("This dataset does not appear to have a changelog yet. Use createChangelog() and updateChangelog() to add one.")
}
(( = "new",,ignore.case = T)){
wv <- (allvers == (allvers))
((wv)>1){wv <- 1}
} (( = "previous",,ignore.case = T)){
wv <- (allvers == (allvers,decreasing = T)[2])
} (( = "old",,ignore.case = T)){
wv <- (allvers == (allvers))
((wv)>1){wv <- (allvers)}
}{#try to match the version
wv <- (allvers == (()))
((wv)>1){("multiple version matches")}
}
((wv) == 0){
("failed to find a match for this version")
}
((wv) > 1){
("Found multiple matches for this version. This is bad.")
}
#spit it out
(L$changelog[wv]])
}
#' Get the current version of a LiPD file from it's changelog
#'
#' @param L a Lipd object
#'
#' @return the version as a string
#' @export
<- (L){
<- (purrr::map_chr(L$changelog,"version")) %>%
() %>%
()
(()==0){
<- "0.0.0"
}
()
}
#' Get the timestamp frmo current version of a LiPD file from it's changelog
#'
#' @param L LiPD object
#'
#' @return the timestamp as a string
#' @export
<- (L){
<- lubridate::as_datetime(purrr::map_chr(L$changelog,"timestamp")) %>%
() %>%
()
(()==0){
<- "none"
}
()
}
#' write dataset version to a variable in the LiPD file
#'
#' @param L A LiPD object
#'
#' @return A LiPD object
#' @export
<- (L){
L$datasetVersion <- (L)
L$datasetTimestamp <- (L)
(L)
}
#' Create a Markdown representation of a LiPD changelog
#'
#' @param L a Lipd Object
#'
#' @return markdown version of changelog
#' @export
<- (L){
#Initialize Rmd
mdcl <- "---" %>%
str_c("pagetitle: changelog",sep = "\n") %>%
str_c("output: html_document",sep = "\n") %>%
str_c("---",sep = "\n") %>%
str_c("\n") %>%
str_c("\n\n") %>%
str_c(glue::glue("# Version history for {L$datasetId} - {L$dataSetName}"))
((L$changelog)){
mdcl <- mdcl %>%
str_c("\n\n") %>%
str_c(glue::glue("No changelog for {L$dataSetName}"))
}{
cl <- L$changelog
mdcl <- mdcl %>%
str_c("\n\n")
(i 1:(cl)){
mdcl <- mdcl %>%
str_c(createSingleMarkdownChangelog(cl[i]])) %>%
str_c("\n\n")
}
mdcl <- stringr::str_replace_all(mdcl, = "''",replacement = "NULL")
}
(mdcl)
}
createSingleMarkdownChangelog<- (scl){
#don;t show fourth digit version
printvers <- ((scl$)[1,1:3])
scl$ <-
clmd <- glue::glue("### Version: {printvers} \n") %>%
str_c("\n")
lev1 <- (scl)
(l1 1:(lev1)){
tb <- lev1[l1]
#do level one changes
((scl[l1]])){#then write the bullets
clmd <- str_c(clmd, glue::glue("* *{lev1[l1]}*: {scl[[l1]]}\n")) %>%
str_c("\n")
}{
clmd <- str_c(clmd, glue::glue("* *{lev1[l1]}*:\n")) %>%
str_c("\n")
lev2 <- scl[l1]]
(l2 1:(lev2)){
thisType <- (lev2)[l2]
clmd <- str_c(clmd, glue::glue("\t + *{thisType}*:\n",.trim = ))
theseChanges <- lev2[l2]]
( 1:(theseChanges)){
clmd <- str_c(clmd, glue::glue("\t \t - {theseChanges[t]}\n",.trim = ))
}
clmd <- str_c(clmd,"\n")
}
}
}
clmd <- str_replace_all(clmd,"\\\\","\\") %>%
str_remove_all("textemdash")
(clmd)
}
#' Create a random Dataset ID for a LiPD dataset
#'
#' @return a random datasetId
#' @export
<- (){
((((,,0:9),size = 20, = ),collapse = ""))
}
