", x, fixed=TRUE) # x <- gsub(" ", " ", x, fixed=TRUE) } x } # Helper function for align_eq; splits up a vector into matched elements and # interstitial elements, including possibly empty interstitial elements when # two matches are abutting align_split <- function(v, m) { match.len <- sum(!!m) res.len <- match.len * 2L + 1L splits <- cumsum( c( if(length(m)) 1L, (!!diff(m) < 0L & !tail(m, -1L)) | (head(m, -1L) & tail(m, -1L)) ) ) m.all <- match(m, sort(unique(m[!!m])), nomatch=0L) # normalize m.all[!m.all] <- -ave(m.all, splits, FUN=max)[!m.all] m.all[!m.all] <- -match.len - 1L # trailing zeros m.fin <- ifelse(m.all < 0, -m.all * 2 - 1, m.all * 2) if(any(diff(m.fin) < 0L)) stop("Logic Error: non monotonic alignments; contact maintainer") # nocov res <- replicate(res.len, character(0L), simplify=FALSE) res[unique(m.fin)] <- unname(split(v, m.fin)) res } # Align lists based on equalities on other vectors # # This is used for hunks that are word diffed. Once the word differences are # accounted for, the remaining strings (A.eq/B.eq) are compared to try to align # them with a naive algorithm on a line basis. This works best when lines as a # whole are equal except for a few differences. There can be funny situations # where matched words are on one line in e.g. A, but spread over multiple lines # in B. This isn't really handled well currently. # # See issue #37. # # The A/B vecs will be split up into matchd elements, and non-matched elements. # Each matching element will be surrounding by (possibly empty) non-matching # elements. # # Need to reconcile the padding that happens as a result of alignment as well # as the padding that happens with atomic vectors align_eq <- function(A, B, x, context) { stopifnot( is.integer(A), is.integer(B), !anyNA(c(A, B)), is(x, "Diff") ) A.fill <- get_dat(x, A, "fill") B.fill <- get_dat(x, B, "fill") A.fin <- get_dat(x, A, "fin") B.fin <- get_dat(x, B, "fin") if(context) { # Nothing to align if this is context hunk A.chunks <- list(A.fin) B.chunks <- list(B.fin) } else { etc <- x@etc A.eq <- get_dat(x, A, "eq") B.eq <- get_dat(x, B, "eq") # Cleanup so only relevant stuff is allowed to match A.tok.ratio <- get_dat(x, A, "tok.rat") B.tok.ratio <- get_dat(x, B, "tok.rat") if(etc@align@count.alnum.only) { A.eq.trim <- gsub("[^[:alnum:]]", "", A.eq, perl=TRUE) B.eq.trim <- gsub("[^[:alnum:]]", "", B.eq, perl=TRUE) } else { A.eq.trim <- A.eq B.eq.trim <- B.eq } # TBD whether nchar here should be ansi-aware; probably if in alnum only # mode... A.valid <- which( nchar2(A.eq.trim, sgr.supported=etc@sgr.supported) >= etc@align@min.chars & A.tok.ratio >= etc@align@threshold ) B.valid <- which( nchar2(B.eq.trim, sgr.supported=etc@sgr.supported) >= etc@align@min.chars & B.tok.ratio >= etc@align@threshold ) B.eq.seq <- seq_along(B.eq.trim) align <- integer(length(A.eq)) min.match <- 0L # Need to match each element in A.eq to B.eq, though each match consumes the # match so we can't use `match`; unfortunately this is slow; for context # hunks the match is one to one for each line; also, this whole matching # needs to be improved (see issue #37) if(length(A.valid) & length(B.valid)) { B.max <- length(B.valid) B.eq.val <- B.eq.trim[B.valid] for(i in A.valid) { if(min.match >= B.max) break B.match <- which( A.eq.trim[[i]] == if(min.match) tail(B.eq.val, -min.match) else B.eq.val ) if(length(B.match)) { align[[i]] <- B.valid[B.match[[1L]] + min.match] min.match <- B.match[[1L]] + min.match } } } # Group elements together. We number the interstitial buckest as the # negative of the next match. There are always matches together, split # by possibly empty interstitial elements align.b <- seq_along(B.eq) align.b[!align.b %in% align] <- 0L A.chunks <- align_split(A.fin, align) B.chunks <- align_split(B.fin, align.b) } if(length(A.chunks) != length(B.chunks)) # nocov start stop("Logic Error: aligned chunks unequal length; contact maintainer.") # nocov end list(A=A.chunks, B=B.chunks, A.fill=A.fill, B.fill=B.fill) } # Calculate how many lines of screen space are taken up by the diff hunks # # `disp.width` should be the available display width, this function computes # the net real estate account for mode, padding, etc. nlines <- function(txt, disp.width, mode, etc) { # stopifnot(is.character(txt), all(!is.na(txt))) capt.width <- calc_width_pad(disp.width, mode) pmax( 1L, as.integer( ceiling( nchar2(txt, sgr.supported=etc@sgr.supported ) / capt.width ) ) ) } # Gets rid of tabs and carriage returns # # Assumes each line is one screen line # @param stops may be a single positive integer value, or a vector of values # whereby the last value will be repeated as many times as necessary strip_hz_c_int <- function(txt, stops, sgr.supported) { # remove trailing and leading CRs (need to record if trailing remains to add # back at end? no, not really since by structure next thing must be a newline w.chr <- nzchar(txt) # corner case with strsplit and zero length strings txt <- gsub("^\r+|\r+$", "", txt) has.tabs <- grep("\t", txt, fixed=TRUE) has.crs <- grep("\r", txt, fixed=TRUE) txt.s <- as.list(txt) txt.s[has.crs] <- if(!any(has.crs)) list() else strsplit2(txt[has.crs], "\r+", sgr.supported=sgr.supported) # Assume \r resets tab stops as it would on a type writer; so now need to # generate the set maximum set of possible tab stops; approximate here by # using largest stop if(length(has.tabs)) { max.stop <- max(stops) width.w.tabs <- max( vapply( txt.s[has.tabs], function(x) { # add number of chars and number of tabs times max tab length sum( nchar2(x, sgr.supported=sgr.supported) + ( vapply( strsplit2(x, "\t", sgr.supported=sgr.supported), length, integer(1L) ) + grepl("\t$", x) - 1L ) * max.stop ) }, integer(1L) ) ) extra.chars <- width.w.tabs - sum(stops) extra.stops <- ceiling(extra.chars / tail(stops, 1L)) stop.vec <- cumsum(c(stops, rep(tail(stops, 1L), extra.stops))) # For each line, assess effects of tabs txt.s[has.tabs] <- lapply(txt.s[has.tabs], function(x) { if(length(h.t <- grep("\t", x, fixed=T))) { # workaround for strsplit dropping trailing tabs x.t <- sub("\t$", "\t\t", x[h.t]) x.s <- strsplit2(x.t, "\t", sgr.supported=sgr.supported) # Now cycle through each line with tabs and replace them with # spaces res <- vapply(x.s, function(y) { topad <- head(y, -1L) rest <- tail(y, 1L) chrs <- nchar2(topad, sgr.supported=sgr.supported) pads <- character(length(topad)) txt.len <- 0L for(i in seq_along(topad)) { txt.len <- chrs[i] + txt.len tab.stop <- head(which(stop.vec > txt.len), 1L) if(!length(tab.stop)) # nocov start stop( "Logic Error: failed trying to find tab stop; contact ", "maintainer" ) # nocov end tab.len <- stop.vec[tab.stop] pads[i] <- paste0(rep(" ", tab.len - txt.len), collapse="") txt.len <- tab.len } paste0(paste0(topad, pads, collapse=""), rest) }, character(1L) ) x[h.t] <- res } x } ) } # Simulate the effect of \r by collapsing every \r separated element on top # of each other with some special handling for ansi escape seqs txt.fin <- txt.s txt.fin[has.crs] <- vapply( txt.s[has.crs], function(x) { if(length(x) > 1L) { chrs <- nchar2(x, sgr.supported=sgr.supported) max.disp <- c(tail(rev(cummax(rev(chrs))), -1L), 0L) res <- paste0( rev( substr2(x, max.disp + 1L, chrs, sgr.supported=sgr.supported) ), collapse="" ) # add back every ANSI esc sequence from last line to very end # to ensure that we leave in correct ANSI escaped state if(grepl(ansi_regex, res, perl=TRUE)) { res <- paste0( res, gsub(paste0(".*", ansi_regex, ".*"), "\\1", tail(x, 1L), perl=TRUE) ) } res } else x # nocov has.cr elements can't have length zero after split... }, character(1L) ) # txt.fin should only have one long char vectors as elements if(!length(txt.fin)) txt else { # handle strsplit corner case where splitting empty string txt.fin[!nzchar(txt)] <- "" unlist(txt.fin) } } #' Replace Horizontal Spacing Control Characters #' #' Removes tabs, newlines, and manipulates the text so that #' it looks the same as it did with those horizontal control #' characters embedded. Currently carriage returns are also processed, but #' in the future they no longer will be. This function is used when the #' \code{convert.hz.white.space} parameter to the #' \code{\link[=diffPrint]{diff*}} methods is active. The term \dQuote{strip} #' is a misnomer that remains for legacy reasons and lazyness. #' #' This is an internal function with exposed documentation because it is #' referenced in an external function's documentation. #' #' @keywords internal #' @param txt character to covert #' @param stops integer, what tab stops to use #' @param sgr.supported logical whether the current display device supports #' ANSI CSI SGR. See \code{\link[=diffPrint]{diff*}}'s \code{sgr.supported} #' parameter. #' @return character, `txt` with horizontal control sequences #' replaced. strip_hz_control <- function(txt, stops=8L, sgr.supported) { # stopifnot( # is.character(txt), !anyNA(txt), # is.integer(stops), length(stops) >= 1L, !anyNA(stops), all(stops > 0L) # ) # for speed in case no special chars, just skip; obviously this adds a penalty # for other cases but it is small if(!any(grepl("\n|\t|\r", txt, perl=TRUE))) { txt } else { if(length(has.n <- grep("\n", txt, fixed=TRUE))) { txt.l <- as.list(txt) txt.l.n <- strsplit2(txt[has.n], "\n", sgr.supported=sgr.supported) txt.l[has.n] <- txt.l.n txt <- unlist(txt.l) } has.ansi <- grepl(ansi_regex, txt, perl=TRUE) w.ansi <- which(has.ansi) wo.ansi <- which(!has.ansi) # since for the time being the crayon funs are a bit slow, only us them on # strings that are known to have ansi escape sequences strip_hz_c_int(txt, stops, sgr.supported=sgr.supported) } } # Normalize strings so whitespace differences don't show up as differences normalize_whitespace <- function(txt) gsub(" ([[:punct:]])", "\\1", gsub("(\t| )+", " ", trimws(txt))) # Simple text manip functions chr_trim <- function(text, width, sgr.supported) { stopifnot(all(width > 2L)) ifelse( nchar2(text, sgr.supported=sgr.supported) > width, paste0(substr2(text, 1L, width - 2L, sgr.supported=sgr.supported), ".."), text ) } rpad <- function(text, width, pad.chr=" ", sgr.supported) { stopifnot(is.character(pad.chr), length(pad.chr) == 1L, nchar(pad.chr) == 1L) pad.count <- width - nchar2(text, sgr.supported=sgr.supported) pad.count[pad.count < 0L] <- 0L pad.chrs <- vapply( pad.count, function(x) paste0(rep(pad.chr, x), collapse=""), character(1L) ) paste0(text, pad.chrs) } # Breaks long character vectors into vectors of length width # # Right pads them to full length if requested. Only attempt to wrap if # longer than width since wrapping is pretty expensive # # Returns a list of split vectors wrap_int <- function(txt, width, sgr.supported) { nchars <- nchar2(txt, sgr.supported=sgr.supported) res <- as.list(txt) too.wide <- which(nchars > width) res[too.wide] <- lapply( too.wide, function(i) { split.end <- seq( from=width, by=width, length.out=ceiling(nchars[[i]] / width) ) split.start <- split.end - width + 1L substr2( rep(txt[[i]], length(split.start)), split.start, split.end, sgr.supported=sgr.supported ) } ) res } wrap <- function(txt, width, pad=FALSE, sgr.supported) { if(length(grep("\n", txt, fixed=TRUE))) # nocov start stop("Logic error: wrap input contains newlines; contact maintainer.") # nocov end # If there are ansi escape sequences, account for them; either way, create # a vector of character positions after which we should split our character # vector has.na <- is.na(txt) has.chars <- nchar2(txt, sgr.supported=sgr.supported) & !has.na w.chars <- which(has.chars) wo.chars <- which(!has.chars & !has.na) txt.sub <- txt[has.chars] # Wrap differently depending on whether contains ansi or not, exclude zero # length char elements res.l <- vector("list", length(txt)) res.l[has.na] <- NA_character_ res.l[wo.chars] <- "" res.l[w.chars] <- wrap_int(txt.sub, width, sgr.supported=sgr.supported) # pad if requested if(pad) res.l[!has.na] <- lapply(res.l[!has.na], rpad, width=width, sgr.supported=sgr.supported) res.l } diffobj/R/summmary.R 0000755 0001762 0000144 00000026046 13777704534 014107 0 ustar ligges users # Copyright (C) 2021 Brodie Gaslam # # This file is part of "diffobj - Diffs for R Objects" # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # Go to
%s
", x.chr),
sprintf( "
", if(style@scale) "true" else "false"
)
)
rez.fun <- if(style@scale)
"resize_diff_out_scale" else "resize_diff_out_no_scale"
js <- try(readLines(style@js), silent=TRUE)
if(inherits(js, "try-error")) {
cond <- attr(js, "condition")
warning(
"Unable to read provided js file \"", style@js, "\" (error: ",
paste0(conditionMessage(cond), collapse=""), ")."
)
js <- ""
} else {
js <- paste0(
c(
js,
sprintf(
"window.addEventListener('resize', %s, true);\n %s();",
rez.fun, rez.fun
) ),
collapse="\n"
) }
} else js <- ""
callNextMethod(x, x.chr, js=js, ...)
} )
# Helper fun used by `show` for Diff and DiffSummary objects
show_w_pager <- function(txt, pager) {
use.pager <- use_pager(pager, attr(txt, "len"))
file.keep <- !is.na(pager@file.path)
# Finalize and output
if(use.pager) {
disp.f <- if(!is.na(pager@file.path)) pager@file.path
else paste0(tempfile(), ".", pager@file.ext)
if(!file.keep) on.exit(add=TRUE, unlink(disp.f))
writeLines(txt, disp.f)
if(
isTRUE(pager@make.blocking) ||
(is.na(pager@make.blocking) && !file.keep)
)
make_blocking(pager@pager)(disp.f) else pager@pager(disp.f)
} else {
cat(txt, sep="\n")
}
}
setMethod("show", "Diff",
function(object) {
txt <- as.character(object)
show_w_pager(txt, object@etc@style@pager)
invisible(NULL)
}
)
# Compute what fraction of the lines in target and current actually end up
# in the diff; some of the complexity is driven by repeated context hunks
setGeneric("lineCoverage", function(x) standardGeneric("lineCoverage"))
setMethod("lineCoverage", "Diff",
function(x) {
lines_in_hunk <- function(z, ind)
if(z[[ind]][[1L]]) z[[ind]][[1L]]:z[[ind]][[2L]]
hunks.f <- unlist(x@diffs, recursive=FALSE)
lines.tar <- length(
unique(unlist(lapply(hunks.f, lines_in_hunk, "tar.rng.sub")))
)
lines.cur <- length(
unique(unlist(lapply(hunks.f, lines_in_hunk, "cur.rng.sub")))
)
min(
1, (lines.tar + lines.cur) / (
length(x@tar.dat$raw) + length(x@cur.dat$raw))
)
}
)
#' Determine if Diff Object Has Differences
#'
#' @param x a \code{Diff} object
#' @param ... unused, for compatibility with generic
#' @param na.rm unused, for compatibility with generic
#' @return TRUE if there are differences, FALSE if not, FALSE with warning if
#' there are no differences but objects are not \code{\link{all.equal}}
#' @examples
#' any(diffChr(letters, letters))
#' any(diffChr(letters, letters[-c(1, 5, 8)]))
setMethod("any", "Diff",
function(x, ..., na.rm = FALSE) {
dots <- list(...)
if(length(dots))
stop("`any` method for `Diff` supports only one argument", call. = FALSE)
res <- any(
which(
!vapply(
unlist(x@diffs, recursive=FALSE), "[[", logical(1L), "context"
) ) )
if(!res && !isTRUE(all.equal(x@target, x@current)))
warning(
"No visible differences, but objects are NOT `all.equal`.",
call.=FALSE
)
res
} )
# See diff_myers for explanation of slots
setClass(
"MyersMbaSes",
slots=c(
a="character",
b="character",
type="factor",
length="integer",
offset="integer",
diffs="integer"
),
prototype=list(
type=factor(character(), levels=c("Match", "Insert", "Delete"))
),
validity=function(object) {
if(!identical(levels(object@type), c("Match", "Insert", "Delete")))
return("Slot `type` levels incorrect")
if(any(is.na(c(object@a, object@b))))
return("Slots `a` and `b` may not contain NA values")
if(any(is.na(c(object@type, object@length, object@offset))))
return("Slots `type`, `length`, or `offset` may not contain NA values")
if(any(c(object@type, object@length, object@offset)) < 0)
return(
paste0(
"Slots `type`, `length`, and `offset` must have values greater ",
"than zero"
) )
if(!is.int.1L(object@diffs))
return("Slot `diffs` must be integer(1L) and not NA")
TRUE
}
)
# Run validity on S4 objects
#
# Intended for use within check_args; unfortunately can't use complete=TRUE
# because we are using ANY slots with S3 objects there-in, which causes
# the complete check to freak out with "trying to get slot 'package' from..."
#
# @param x object to test
# @param err.tpl a string used with sprintf, must contain two \dQuote{%s} for
# respectively \code{arg.name} and the class name
# @param arg.name argument the object is supposed to come from
# @param err error reporting function
valid_object <- function(
x, arg.name, err, err.tpl="Argument `%s` is an invalid `%s` object because:"
) {
if(isS4(x)) {
if(!isTRUE(test <- validObject(x, test=TRUE))) {
err(
paste(
sprintf(err.tpl, arg.name, class(x)[[1L]]),
strwrap(test, initial="- ", prefix=" "),
collapse="\n"
) ) } } }
diffobj/R/rdiff.R 0000755 0001762 0000144 00000012535 13777704534 013325 0 ustar ligges users # Copyright (C) 2021 Brodie Gaslam
#
# This file is part of "diffobj - Diffs for R Objects"
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# Go to ",
"%s} tags.
#'
#' @export
#' @param x character
#' @param ... unused for compatibility with internal use
#' @return integer(length(x)) with number of characters of each element
#' @examples
#' nchar_html("hello")
nchar_html <- function(x, ...) {
stopifnot(is.character(x) && !anyNA(x))
tag.less <- gsub("<[^>]*>", "", x)
# Thanks ridgerunner for html entity removal regex
# http://stackoverflow.com/users/433790/ridgerunner
# http://stackoverflow.com/a/8806462/2725969
ent.less <-
gsub("&(?:[a-z\\d]+|#\\d+|#x[a-f\\d]+);", "X", tag.less, perl=TRUE)
nchar(ent.less)
}
diffobj/R/capt.R 0000755 0001762 0000144 00000033311 13777704532 013153 0 ustar ligges users # Copyright (C) 2021 Brodie Gaslam
#
# This file is part of "diffobj - Diffs for R Objects"
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# Go to for a copy of the license.
# Capture output of print/show/str; unfortunately doesn't have superb handling
# of errors during print/show call, though hopefully these are rare
#
# x is a quoted call to evaluate
capture <- function(x, etc, err) {
capt.width <- etc@text.width
if(capt.width) {
opt.set <- try(width.old <- options(width=capt.width), silent=TRUE)
if(inherits(opt.set, "try-error")) {
warning(
"Unable to set desired width ", capt.width, ", (",
conditionMessage(attr(opt.set, "condition")), ");",
"proceeding with existing setting."
)
} else on.exit(options(width.old))
}
# Note, we use `tempfile` for capture as that appears much faster than normal
# capture without a file
capt.file <- tempfile()
on.exit(unlink(capt.file), add=TRUE)
res <- try({
capture.output(eval(x, etc@frame), file=capt.file)
obj.out <- readLines(capt.file)
})
if(inherits(res, "try-error"))
err(
"Failed attempting to get text representation of object: ",
conditionMessage(attr(res, "condition"))
)
html_ent_sub(res, etc@style)
}
# capture normal prints, along with default prints to make sure that if we
# do try to wrap an atomic vector print it is very likely to be in a format
# we are familiar with and not affected by a non-default print method
capt_print <- function(target, current, etc, err, extra){
dots <- extra
# What about S4?
if(getRversion() >= "3.2.0") {
print.match <- try(
match.call(
get("print", envir=etc@frame, mode='function'),
as.call(c(list(quote(print), x=NULL), dots)),
envir=etc@frame
) )
} else {
# this may be sub-optimal, but match.call does not support the envir arg
# prior to this
# nocov start
print.match <- try(
match.call(
get("print", envir=etc@frame),
as.call(c(list(quote(print), x=NULL), dots))
) )
# nocov end
}
if(inherits(print.match, "try-error"))
err("Unable to compose `print` call")
names(print.match)[[2L]] <- ""
tar.call <- cur.call <- print.match
if(length(dots)) {
if(!is.null(etc@tar.exp)) tar.call[[2L]] <- etc@tar.exp
if(!is.null(etc@cur.exp)) cur.call[[2L]] <- etc@cur.exp
etc@tar.banner <- deparse(tar.call)[[1L]]
etc@cur.banner <- deparse(cur.call)[[1L]]
}
tar.call.q <- if(is.call(target) || is.symbol(target))
call("quote", target) else target
cur.call.q <- if(is.call(current) || is.symbol(current))
call("quote", current) else current
if(!is.null(target)) tar.call[[2L]] <- tar.call.q
if(!is.null(current)) cur.call[[2L]] <- cur.call.q
# If dimensioned object, and in auto-mode, switch to side by side if stuff is
# narrow enough to fit
if((!is.null(dim(target)) || !is.null(dim(current)))) {
cur.capt <- capture(cur.call, etc, err)
tar.capt <- capture(tar.call, etc, err)
etc <- set_mode(etc, tar.capt, cur.capt)
} else {
etc <- if(etc@mode == "auto") sideBySide(etc) else etc
cur.capt <- capture(cur.call, etc, err)
tar.capt <- capture(tar.call, etc, err)
}
if(isTRUE(etc@guides)) etc@guides <- guidesPrint
if(isTRUE(etc@trim)) etc@trim <- trimPrint
diff.out <- line_diff(target, current, tar.capt, cur.capt, etc=etc, warn=TRUE)
diff.out@capt.mode <- "print"
diff.out
}
# Tries various different `str` settings to get the best possible output
capt_str <- function(target, current, etc, err, extra){
# Match original call and managed dots, in particular wrt to the
# `max.level` arg
dots <- extra
frame <- etc@frame
line.limit <- etc@line.limit
if("object" %in% names(dots))
err("You may not specify `object` as part of `extra`")
if(getRversion() < "3.2.0") {
# nocov start
str.match <- match.call(
str_tpl,
call=as.call(c(list(quote(str), object=NULL), dots))
)
# nocov end
} else {
str.match <- match.call(
str_tpl,
call=as.call(c(list(quote(str), object=NULL), dots)), envir=etc@frame
)
}
names(str.match)[[2L]] <- ""
# Handle auto mode (side by side always for `str`)
if(etc@mode == "auto") etc <- sideBySide(etc)
# Utility function; defining in body so it has access to `err`
eval_try <- function(match.list, index, envir)
tryCatch(
eval(match.list[[index]], envir=envir),
error=function(e)
err("Error evaluating `", index, "` arg: ", conditionMessage(e))
)
# Setup / process extra args
auto.mode <- FALSE
max.level.supplied <- FALSE
if(
max.level.pos <- match("max.level", names(str.match), nomatch=0L)
) {
# max.level specified in call; check for special 'auto' case
max.level.eval <- eval_try(str.match, "max.level", etc@frame)
if(identical(max.level.eval, "auto")) {
auto.mode <- TRUE
str.match[["max.level"]] <- NA
} else {
max.level.supplied <- TRUE
}
} else {
str.match[["max.level"]] <- NA
auto.mode <- TRUE
max.level.pos <- length(str.match)
max.level.supplied <- FALSE
}
# Was wrap specified in strict width mode? Not sure this is correct any more;
# should probably be looking at extra args.
wrap <- FALSE
if("strict.width" %in% names(str.match)) {
res <- eval_try(str.match, "strict.width", etc@frame)
wrap <- is.character(res) && length(res) == 1L && !is.na(res) &&
nzchar(res) && identical(res, substr("wrap", 1L, nchar(res)))
}
if(auto.mode) {
msg <-
"Specifying `%s` may cause `str` output level folding to be incorrect"
if("comp.str" %in% names(str.match)) warning(sprintf(msg, "comp.str"))
if("indent.str" %in% names(str.match)) warning(sprintf(msg, "indent.str"))
}
# don't want to evaluate target and current more than once, so can't eval
# tar.exp/cur.exp, so instead run call with actual object
tar.call <- cur.call <- str.match
tar.call.q <- if(is.call(target) || is.symbol(target))
call("quote", target) else target
cur.call.q <- if(is.call(current) || is.symbol(current))
call("quote", current) else current
if(!is.null(target)) tar.call[[2L]] <- tar.call.q
if(!is.null(current)) cur.call[[2L]] <- cur.call.q
# Run str
capt.width <- etc@text.width
has.diff <- has.diff.prev <- FALSE
# we used to strip_hz_control here, but shouldn't have to since handled by
# line_diff
tar.capt <- capture(tar.call, etc, err)
tar.lvls <- str_levels(tar.capt, wrap=wrap)
cur.capt <- capture(cur.call, etc, err)
cur.lvls <- str_levels(cur.capt, wrap=wrap)
prev.lvl.hi <- lvl <- max.depth <- max(tar.lvls, cur.lvls)
prev.lvl.lo <- 0L
first.loop <- TRUE
safety <- 0L
warn <- TRUE
if(isTRUE(etc@guides)) etc@guides <- guidesStr
if(isTRUE(etc@trim)) etc@trim <- trimStr
tar.str <- tar.capt
cur.str <- cur.capt
diff.obj <- diff.obj.full <- line_diff(
target, current, tar.str, cur.str, etc=etc, warn=warn
)
if(!max.level.supplied) {
repeat{
if((safety <- safety + 1L) > max.depth && !first.loop)
# nocov start
stop(
"Logic Error: exceeded list depth when comparing structures; contact ",
"maintainer."
)
# nocov end
if(!first.loop) {
tar.str <- tar.capt[tar.lvls <= lvl]
cur.str <- cur.capt[cur.lvls <= lvl]
diff.obj <- line_diff(
target, current, tar.str, cur.str, etc=etc, warn=warn
)
}
if(diff.obj@hit.diffs.max) warn <- FALSE
has.diff <- suppressWarnings(any(diff.obj))
# If there are no differences reducing levels isn't going to help to
# find one; additionally, if not in auto.mode we should not be going
# through this process
if(first.loop && !has.diff) break
first.loop <- FALSE
if(line.limit[[1L]] < 1L) break
line.len <- diff_line_len(
diff.obj@diffs, etc=etc, tar.capt=tar.str, cur.capt=cur.str
)
# We need a higher level if we don't have diffs
if(!has.diff && prev.lvl.hi - lvl > 1L) {
prev.lvl.lo <- lvl
lvl <- lvl + as.integer((prev.lvl.hi - lvl) / 2)
tar.call[[max.level.pos]] <- lvl
cur.call[[max.level.pos]] <- lvl
next
} else if(!has.diff) {
diff.obj <- diff.obj.full
lvl <- NULL
break
}
# If we have diffs, need to check whether we should try to reduce lines
# to get under line limit
if(line.len <= line.limit[[1L]]) {
# We fit, nothing else to do
break
}
if(lvl - prev.lvl.lo > 1L) {
prev.lvl.hi <- lvl
lvl <- lvl - as.integer((lvl - prev.lvl.lo) / 2)
tar.call[[max.level.pos]] <- lvl
cur.call[[max.level.pos]] <- lvl
next
}
# Couldn't get under limit, so use first run results
diff.obj <- diff.obj.full
lvl <- NULL
break
}
} else {
tar.str <- tar.capt[tar.lvls <= max.level.eval]
cur.str <- cur.capt[cur.lvls <= max.level.eval]
lvl <- max.level.eval
diff.obj <- line_diff(target, current, tar.str, cur.str, etc=etc, warn=warn)
}
if(auto.mode && !is.null(lvl) && lvl < max.depth) {
str.match[[max.level.pos]] <- lvl
} else if (!max.level.supplied || is.null(lvl)) {
str.match[[max.level.pos]] <- NULL
}
tar.call <- cur.call <- str.match
if(!is.null(etc@tar.exp)) tar.call[[2L]] <- etc@tar.exp
if(!is.null(etc@cur.exp)) cur.call[[2L]] <- etc@cur.exp
if(is.null(etc@tar.banner))
diff.obj@etc@tar.banner <- deparse(tar.call)[[1L]]
if(is.null(etc@cur.banner))
diff.obj@etc@cur.banner <- deparse(cur.call)[[1L]]
# Track total differences in fully expanded view so we can report hidden
# diffs when folding levels
diff.obj@diff.count.full <- count_diffs(diff.obj.full@diffs)
diff.obj@capt.mode <- "str"
diff.obj
}
capt_chr <- function(target, current, etc, err, extra){
tar.capt <- if(!is.character(target))
do.call(as.character, c(list(target), extra), quote=TRUE) else target
cur.capt <- if(!is.character(current))
do.call(as.character, c(list(current), extra), quote=TRUE) else current
# technically possible to have a character method that doesn't return a
# character object...
if((tt <- typeof(tar.capt)) != 'character')
stop("Coercion of `target` did not produce character object (", tt, ").")
if((tc <- typeof(cur.capt)) != 'character')
stop("Coercion of `current` did not produce character object (", tc, ").")
# drop attributes
tar.capt <- c(tar.capt)
cur.capt <- c(cur.capt)
if(anyNA(tar.capt)) tar.capt[is.na(tar.capt)] <- "NA"
if(anyNA(cur.capt)) cur.capt[is.na(cur.capt)] <- "NA"
etc <- set_mode(etc, tar.capt, cur.capt)
if(isTRUE(etc@guides)) etc@guides <- guidesChr
if(isTRUE(etc@trim)) etc@trim <- trimChr
diff.out <- line_diff(
target, current, html_ent_sub(tar.capt, etc@style),
html_ent_sub(cur.capt, etc@style), etc=etc
)
diff.out@capt.mode <- "chr"
diff.out
}
capt_deparse <- function(target, current, etc, err, extra){
dep.try <- try({
tar.capt <- do.call(deparse, c(list(target), extra), quote=TRUE)
cur.capt <- do.call(deparse, c(list(current), extra), quote=TRUE)
})
if(inherits(dep.try, "try-error"))
err("Error attempting to deparse object(s)")
etc <- set_mode(etc, tar.capt, cur.capt)
if(isTRUE(etc@guides)) etc@guides <- guidesDeparse
if(isTRUE(etc@trim)) etc@trim <- trimDeparse
diff.out <- line_diff(
target, current, html_ent_sub(tar.capt, etc@style),
html_ent_sub(cur.capt, etc@style), etc=etc
)
diff.out@capt.mode <- "deparse"
diff.out
}
capt_file <- function(target, current, etc, err, extra) {
tar.capt <- try(do.call(readLines, c(list(target), extra), quote=TRUE))
if(inherits(tar.capt, "try-error")) err("Unable to read `target` file.")
cur.capt <- try(do.call(readLines, c(list(current), extra), quote=TRUE))
if(inherits(cur.capt, "try-error")) err("Unable to read `current` file.")
etc <- set_mode(etc, tar.capt, cur.capt)
if(isTRUE(etc@guides)) etc@guides <- guidesFile
if(isTRUE(etc@trim)) etc@trim <- trimFile
diff.out <- line_diff(
tar.capt, cur.capt, html_ent_sub(tar.capt, etc@style),
html_ent_sub(cur.capt, etc@style), etc=etc
)
diff.out@capt.mode <- "file"
diff.out
}
capt_csv <- function(target, current, etc, err, extra){
tar.df <- try(do.call(read.csv, c(list(target), extra), quote=TRUE))
if(inherits(tar.df, "try-error")) err("Unable to read `target` file.")
if(!is.data.frame(tar.df))
err("`target` file did not produce a data frame when read") # nocov
cur.df <- try(do.call(read.csv, c(list(current), extra), quote=TRUE))
if(inherits(cur.df, "try-error")) err("Unable to read `current` file.")
if(!is.data.frame(cur.df))
err("`current` file did not produce a data frame when read") # nocov
capt_print(tar.df, cur.df, etc, err, extra)
}
# Sets mode to "unified" if stuff is too wide to fit side by side without
# wrapping otherwise sets it in "sidebyside"
set_mode <- function(etc, tar.capt, cur.capt) {
stopifnot(is(etc, "Settings"), is.character(tar.capt), is.character(cur.capt))
if(etc@mode == "auto") {
if(
any(
nchar2(cur.capt, sgr.supported=etc@sgr.supported) > etc@text.width.half
) ||
any(
nchar2(tar.capt, sgr.supported=etc@sgr.supported) > etc@text.width.half
)
) {
etc@mode <- "unified"
} }
if(etc@mode == "auto") etc <- sideBySide(etc)
etc
}
diffobj/R/diff.R 0000755 0001762 0000144 00000107711 14123062122 013114 0 ustar ligges users # Copyright (C) 2021 Brodie Gaslam
#
# This file is part of "diffobj - Diffs for R Objects"
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# Go to for a copy of the license.
#' Diffs for R Objects
#'
#' Generate a colorized diff of two R objects for an intuitive visualization of
#' their differences. See `vignette(package="diffobj", "diffobj")` for details.
#'
#' @import crayon
#' @import methods
#' @importFrom utils capture.output file_test packageVersion read.csv
#' @importFrom stats ave frequency is.ts setNames
#' @importFrom grDevices rgb
#' @name diffobj-package
#' @docType package
NULL
# Because all these functions are so similar, we have constructed them with a
# function factory. This allows us to easily maintain consistent formals during
# initial development process when they have not been set in stone yet.
make_diff_fun <- function(capt_fun) {
# nocov start
function(
target, current,
mode=gdo("mode"),
context=gdo("context"),
format=gdo("format"),
brightness=gdo("brightness"),
color.mode=gdo("color.mode"),
word.diff=gdo("word.diff"),
pager=gdo("pager"),
guides=gdo("guides"),
trim=gdo("trim"),
rds=gdo("rds"),
unwrap.atomic=gdo("unwrap.atomic"),
max.diffs=gdo("max.diffs"),
disp.width=gdo("disp.width"),
ignore.white.space=gdo("ignore.white.space"),
convert.hz.white.space=gdo("convert.hz.white.space"),
tab.stops=gdo("tab.stops"),
line.limit=gdo("line.limit"),
hunk.limit=gdo("hunk.limit"),
align=gdo("align"),
style=gdo("style"),
palette.of.styles=gdo("palette"),
frame=par_frame(),
interactive=gdo("interactive"),
term.colors=gdo("term.colors"),
tar.banner=NULL,
cur.banner=NULL,
strip.sgr=gdo("strip.sgr"),
sgr.supported=gdo("sgr.supported"),
extra=list()
) {
# nocov end
frame # force frame so that `par_frame` called in this context
call.dat <- extract_call(sys.calls(), frame)
target # force target/current so if one missing we get an error here
current # and not later
# Check args and evaluate all the auto-selection arguments
etc.proc <- check_args(
call=call.dat$call, tar.exp=call.dat$tar, cur.exp=call.dat$cur,
mode=mode, context=context, line.limit=line.limit, format=format,
brightness=brightness, color.mode=color.mode, pager=pager,
ignore.white.space=ignore.white.space, max.diffs=max.diffs,
align=align, disp.width=disp.width,
hunk.limit=hunk.limit, convert.hz.white.space=convert.hz.white.space,
tab.stops=tab.stops, style=style, palette.of.styles=palette.of.styles,
frame=frame, tar.banner=tar.banner, cur.banner=cur.banner, guides=guides,
rds=rds, trim=trim, word.diff=word.diff, unwrap.atomic=unwrap.atomic,
extra=extra, interactive=interactive, term.colors=term.colors,
strip.sgr=strip.sgr, sgr.supported=sgr.supported,
call.match=match.call()
)
# If in rds mode, try to see if either target or current reference an RDS
if(rds) {
target <- get_rds(target)
current <- get_rds(current)
}
# Force crayon to whatever ansi status we chose; note we must do this after
# touching vars in case someone passes `options(crayon.enabled=...)` as one
# of the arguments
# old.crayon.opt <- options(
# crayon.enabled=
# is(etc.proc@style, "StyleAnsi") ||
# (!is(etc.proc@style, "StyleHtml") && etc.proc@sgr.supported)
# )
# on.exit(options(old.crayon.opt), add=TRUE)
err <- make_err_fun(sys.call())
# Compute gutter values so that we know correct widths to use for capture,
# etc. If not a base text type style, assume gutter and column padding are
# zero even though that may not always be correct
etc.proc@gutter <- gutter_dat(etc.proc)
col.pad.width <-
nchar2(etc.proc@style@text@pad.col, sgr.supported=etc.proc@sgr.supported)
gutt.width <- etc.proc@gutter@width
half.width <- as.integer((etc.proc@disp.width - col.pad.width) / 2)
etc.proc@line.width <-
max(etc.proc@disp.width, .min.width + gutt.width)
etc.proc@text.width <- etc.proc@line.width - gutt.width
etc.proc@line.width.half <- max(half.width, .min.width + gutt.width)
etc.proc@text.width.half <- etc.proc@line.width.half - gutt.width
# If in side by side mode already then we know we want half-width, and if
# width is less than 80 we know we want unitfied
if(etc.proc@mode == "auto" && etc.proc@disp.width < 80L)
etc.proc@mode <- "unified"
if(etc.proc@mode == "sidebyside") etc.proc <- sideBySide(etc.proc)
# Capture and diff
diff <- capt_fun(target, current, etc=etc.proc, err=err, extra)
diff
}
}
#' Diff \code{print}ed Objects
#'
#' Runs the diff between the \code{print} or \code{show} output produced by
#' \code{target} and \code{current}. Given the extensive parameter list, this
#' documentation page is intended as a reference for all the \code{diff*}
#' methods. For a high level introduction see \code{vignette("diffobj")}.
#'
#' Almost all aspects of how the diffs are computed and displayed are
#' controllable through the \code{diff*} methods parameters. This results in a
#' lengthy parameter list, but in practice you should rarely need to adjust
#' anything past the \code{color.mode} parameter. Default values are specified
#' as options so that users may configure diffs in a persistent manner.
#' \code{\link{gdo}} is a shorthand function to access \code{diffobj} options.
#'
#' Parameter order after \code{color.mode} is not guaranteed. Future versions
#' of \code{diffobj} may add parameters and re-order existing parameters past
#' \code{color.mode}.
#'
#' This and other \code{diff*} functions are S4 generics that dispatch on the
#' \code{target} and \code{current} parameters. Methods with signature
#' \code{c("ANY", "ANY")} are defined and act as the default methods. You can
#' use this to set up methods to pre-process or set specific parameters for
#' selected classes that can then \code{callNextMethod} for the actual diff.
#' Note that while the generics include \code{...} as an argument, none of the
#' methods do.
#'
#' Strings are re-encoded to UTF-8 with \code{\link{enc2utf8}} prior to
#' comparison to avoid encoding-only differences.
#'
#' The text representation of `target` and `current` should each have no more
#' than ~INT_MAX/4 lines.
#'
#' @section Matrices and Data Frames:
#'
#' While \code{diffPrint} attempts to handle the default R behavior that wraps
#' wide tables, the results are often sub-optimal. A better approach is to set
#' the \code{disp.width} parameter to a large enough value such that wrapping is
#' not necessary, and a browser-based \code{pager}. In the future we will add
#' the capability to specify different capture widths and wrap widths so that
#' this is an option for terminal output (see
#' \href{https://github.com/brodieG/diffobj/issues/109}{issue 109}).
#'
#' One thing to keep in mind is that \code{diffPrint} is not designed to work
#' with very large data frames.
#'
#' @export
#' @seealso \code{\link{diffObj}}, \code{\link{diffStr}},
#' \code{\link{diffChr}} to compare character vectors directly,
#' \code{\link{diffDeparse}} to compare deparsed objects, \code{\link{ses}}
#' for a minimal and fast diff @param target the reference object
#' @param target the reference object
#' @param current the object being compared to \code{target}
#' @param mode character(1L), one of:
#' \itemize{
#' \item \dQuote{unified}: diff mode used by \code{git diff}
#' \item \dQuote{sidebyside}: line up the differences side by side
#' \item \dQuote{context}: show the target and current hunks in their
#' entirety; this mode takes up a lot of screen space but makes it easier
#' to see what the objects actually look like
#' \item \dQuote{auto}: default mode; pick one of the above, will favor
#' \dQuote{sidebyside} unless \code{getOption("width")} is less than 80,
#' or in \code{diffPrint} and objects are dimensioned and do not fit side
#' by side, or in \code{diffChr}, \code{diffDeparse}, \code{diffFile} and
#' output does not fit in side by side without wrapping
#' }
#' @param context integer(1L) how many lines of context are shown on either side
#' of differences (defaults to 2). Set to \code{-1L} to allow as many as
#' there are. Set to \dQuote{auto} to display as many as 10 lines or as few
#' as 1 depending on whether total screen lines fit within the number of lines
#' specified in \code{line.limit}. Alternatively pass the return value of
#' \code{\link{auto_context}} to fine tune the parameters of the auto context
#' calculation.
#' @param format character(1L), controls the diff output format, one of:
#' \itemize{
#' \item \dQuote{auto}: to select output format based on terminal
#' capabilities; will attempt to use one of the ANSI formats if they
#' appear to be supported, and if not or if you are in the Rstudio console
#' it will attempt to use HTML and browser output if in interactive mode.
#' \item \dQuote{raw}: plain text
#' \item \dQuote{ansi8}: color and format diffs using basic ANSI escape
#' sequences
#' \item \dQuote{ansi256}: like \dQuote{ansi8}, except using the full range
#' of ANSI formatting options
#' \item \dQuote{html}: color and format using HTML markup; the resulting
#' string is processed with \code{\link{enc2utf8}} when output as a full
#' web page (see docs for \code{html.output} under \code{\link{Style}}).
#' }
#' Defaults to \dQuote{auto}. See \code{palette.of.styles} for details
#' on customization, \code{\link{style}} for full control of output format.
#' See `pager` parameter for more discussion of Rstudio behavior.
#' @param brightness character, one of \dQuote{light}, \dQuote{dark},
#' \dQuote{neutral}, useful for adjusting color scheme to light or dark
#' terminals. \dQuote{neutral} by default. See \code{\link{PaletteOfStyles}}
#' for details and limitations. Advanced: you may specify brightness as a
#' function of \code{format}. For example, if you typically wish to use a
#' \dQuote{dark} color scheme, except for when in \dQuote{html} format when
#' you prefer the \dQuote{light} scheme, you may use
#' \code{c("dark", html="light")} as the value for this parameter. This is
#' particularly useful if \code{format} is set to \dQuote{auto} or if you
#' want to specify a default value for this parameter via options. Any names
#' you use should correspond to a \code{format}. You must have one unnamed
#' value which will be used as the default for all \code{format}s that are
#' not explicitly specified.
#' @param color.mode character, one of \dQuote{rgb} or \dQuote{yb}.
#' Defaults to \dQuote{yb}. \dQuote{yb} stands for \dQuote{Yellow-Blue} for
#' color schemes that rely primarily on those colors to style diffs.
#' Those colors can be easily distinguished by individuals with
#' limited red-green color sensitivity. See \code{\link{PaletteOfStyles}} for
#' details and limitations. Also offers the same advanced usage as the
#' \code{brightness} parameter.
#' @param word.diff TRUE (default) or FALSE, whether to run a secondary word
#' diff on the in-hunk differences. For atomic vectors setting this to
#' FALSE could make the diff \emph{slower} (see the \code{unwrap.atomic}
#' parameter). For other uses, particularly with \code{\link{diffChr}}
#' setting this to FALSE can substantially improve performance.
#' @param pager one of \dQuote{auto} (default), \dQuote{on},
#' \dQuote{off}, a \code{\link{Pager}} object, or a list; controls whether and
#' how a pager is used to display the diff output. If you require a
#' particular pager behavior you must use a \code{\link{Pager}}
#' object, or \dQuote{off} to turn off the pager. All other settings will
#' interact with other parameters such as \code{format}, \code{style}, as well
#' as with your system capabilities in order to select the pager expected to
#' be most useful.
#'
#' \dQuote{auto} and \dQuote{on} are the same, except that in non-interactive
#' mode \dQuote{auto} is equivalent to \dQuote{off}. \dQuote{off} will always
#' send output to the console. If \dQuote{on}, whether the output
#' actually gets routed to the pager depends on the pager \code{threshold}
#' setting (see \code{\link{Pager}}). The default behavior is to use the
#' pager associated with the \code{Style} object. The \code{Style} object is
#' itself is determined by the \code{format} or \code{style} parameters.
#'
#' Depending on your system configuration different styles and corresponding
#' pagers will get selected, unless you specify a \code{Pager} object
#' directly. On a system with a system pager that supports ANSI CSI SGR
#' colors, the pager will only trigger if the output is taller than one
#' window. If the system pager is not known to support ANSI colors then the
#' output will be sent as HTML to the IDE viewer if available or to the web
#' browser if not. Even though Rstudio now supports ANSI CSI SGR at the
#' console output is still formatted as HTML and sent to the IDE viewer.
#' Partly this is for continuity of behavior, but also because the default
#' Rstudio pager does not support ANSI CSI SGR, at least as of this writing.
#'
#' If \code{pager} is a list, then the same as with \dQuote{on}, except that
#' the \code{Pager} object associated with the selected \code{Style} object is
#' re-instantiated with the union of the list elements and the existing
#' settings of that \code{Pager}. The list should contain named elements that
#' correspond to the \code{\link{Pager}} instantiation parameters. The names
#' must be specified in full as partial parameter matching will not be carried
#' out because the pager is re-instantiated with \code{\link{new}}.
#'
#' See \code{\link{Pager}}, \code{\link{Style}}, and
#' \code{\link{PaletteOfStyles}} for more details and for instructions on how
#' to modify the default behavior.
#' @param guides TRUE (default), FALSE, or a function that accepts at least two
#' arguments and requires no more than two arguments. Guides
#' are additional context lines that are not strictly part of a hunk, but
#' provide important contextual data (e.g. column headers). If TRUE, the
#' context lines are shown in addition to the normal diff output, typically
#' in a different color to indicate they are not part of the hunk. If a
#' function, the function should accept as the first argument the object
#' being diffed, and the second the character representation of the object.
#' The function should return the indices of the elements of the
#' character representation that should be treated as guides. See
#' \code{\link{guides}} for more details.
#' @param trim TRUE (default), FALSE, or a function that accepts at least two
#' arguments and requires no more than two arguments. Function should compute
#' for each line in captured output what portion of those lines should be
#' diffed. By default, this is used to remove row meta data differences
#' (e.g. \code{[1,]}) so they alone do not show up as differences in the
#' diff. See \code{\link{trim}} for more details.
#' @param rds TRUE (default) or FALSE, if TRUE will check whether
#' \code{target} and/or \code{current} point to a file that can be read with
#' \code{\link{readRDS}} and if so, loads the R object contained in the file
#' and carries out the diff on the object instead of the original argument.
#' Currently there is no mechanism for specifying additional arguments to
#' \code{readRDS}
#' @param unwrap.atomic TRUE (default) or FALSE. Relevant primarily for
#' \code{diffPrint}, if TRUE, and \code{word.diff} is also TRUE, and both
#' \code{target} and \code{current} are \emph{unnamed} one-dimension atomics ,
#' the vectors are unwrapped and diffed element by element, and then
#' re-wrapped. Since \code{diffPrint} is fundamentally a line diff, the
#' re-wrapped lines are lined up in a manner that is as consistent as possible
#' with the unwrapped diff. Lines that contain the location of the word
#' differences will be paired up. Since the vectors may well be wrapped with
#' different periodicities this will result in lines that are paired up that
#' look like they should not be paired up, though the locations of the
#' differences should be. If is entirely possible that setting this parameter
#' to FALSE will result in a slower diff. This happens if two vectors are
#' actually fairly similar, but their line representations are not. For
#' example, in comparing \code{1:100} to \code{c(100, 1:99)}, there is really
#' only one difference at the \dQuote{word} level, but every screen line is
#' different. \code{diffChr} will also do the unwrapping if it is given a
#' character vector that contains output that looks like the atomic vectors
#' described above. This is a bug, but as the functionality could be useful
#' when diffing e.g. \code{capture.output} data, we now declare it a feature.
#' @param line.limit integer(2L) or integer(1L), if length 1 how many lines of
#' output to show, where \code{-1} means no limit. If length 2, the first
#' value indicates the threshold of screen lines to begin truncating output,
#' and the second the number of lines to truncate to, which should be fewer
#' than the threshold. Note that this parameter is implemented on a
#' best-efforts basis and should not be relied on to produce the exact
#' number of lines requested. In particular do not expect it to work well for
#' for values small enough that the banner portion of the diff would have to
#' be trimmed. If you want a specific number of lines use \code{[} or
#' \code{head} / \code{tail}. One advantage of \code{line.limit} over these
#' other options is that you can combine it with \code{context="auto"} and
#' auto \code{max.level} selection (the latter for \code{diffStr}), which
#' allows the diff to dynamically adjust to make best use of the available
#' display lines. \code{[}, \code{head}, and \code{tail} just subset the text
#' of the output.
#' @param hunk.limit integer(2L) or integer (1L), how many diff hunks to show.
#' Behaves similarly to \code{line.limit}. How many hunks are in a
#' particular diff is a function of how many differences, and also how much
#' \code{context} is used since context can cause two hunks to bleed into
#' each other and become one.
#' @param max.diffs integer(1L), number of \emph{differences} (default 50000L)
#' after which we abandon the \code{O(n^2)} diff algorithm in favor of a naive
#' \code{O(n)} one. Set to \code{-1L} to stick to the original algorithm up to
#' the maximum allowed (~INT_MAX/4).
#' @param disp.width integer(1L) number of display columns to take up; note that
#' in \dQuote{sidebyside} \code{mode} the effective display width is half this
#' number (set to 0L to use default widths which are \code{getOption("width")}
#' for normal styles and \code{80L} for HTML styles. Future versions of
#' \code{diffobj} may change this to larger values for two dimensional objects
#' for better diffs (see details).
#' @param ignore.white.space TRUE or FALSE, whether to consider differences in
#' horizontal whitespace (i.e. spaces and tabs) as differences (defaults to
#' TRUE).
#' @param convert.hz.white.space TRUE or FALSE, whether modify input strings
#' that contain tabs and carriage returns in such a way that they display as
#' they would \bold{with} those characters, but without using those
#' characters (defaults to TRUE). The conversion assumes that tab stops are
#' spaced evenly eight characters apart on the terminal. If this is not the
#' case you may specify the tab stops explicitly with \code{tab.stops}.
#' @param tab.stops integer, what tab stops to use when converting hard tabs to
#' spaces. If not integer will be coerced to integer (defaults to 8L). You
#' may specify more than one tab stop. If display width exceeds that
#' addressable by your tab stops the last tab stop will be repeated.
#' @param align numeric(1L) between 0 and 1, proportion of
#' words in a line of \code{target} that must be matched in a line of
#' \code{current} in the same hunk for those lines to be paired up when
#' displayed (defaults to 0.25), or an \code{\link{AlignThreshold}} object.
#' Set to \code{1} to turn off alignment which will cause all lines in a hunk
#' from \code{target} to show up first, followed by all lines from
#' \code{current}. Note that in order to be aligned lines must meet the
#' threshold and have at least 3 matching alphanumeric characters (see
#' \code{\link{AlignThreshold}} for details).
#' @param style \dQuote{auto}, a \code{\link{Style}} object, or a list.
#' \dQuote{auto} by default. If a \code{Style} object, will override the
#' the \code{format}, \code{brightness}, and \code{color.mode} parameters.
#' The \code{Style} object provides full control of diff output styling.
#' If a list, then the same as \dQuote{auto}, except that if the auto-selected
#' \code{Style} requires instantiation (see \code{\link{PaletteOfStyles}}),
#' then the list contents will be used as arguments when instantiating the
#' style object. See \code{\link{Style}} for more details, in particular the
#' examples.
#' @param palette.of.styles \code{\link{PaletteOfStyles}} object; advanced
#' usage, contains all the \code{\link{Style}} objects or
#' \dQuote{classRepresentation} objects extending \code{\link{Style}} that are
#' selected by specifying the \code{format}, \code{brightness}, and
#' \code{color.mode} parameters. See \code{\link{PaletteOfStyles}} for more
#' details.
#' @param frame an environment to use as the evaluation frame for the
#' \code{print/show/str}, calls and for \code{diffObj}, the evaluation frame
#' for the \code{diffPrint} / \code{diffStr} calls. Defaults to the return
#' value of \code{\link{par_frame}}.
#' @param interactive TRUE or FALSE whether the function is being run in
#' interactive mode, defaults to the return value of
#' \code{\link{interactive}}. If in interactive mode, pager will be used if
#' \code{pager} is \dQuote{auto}, and if ANSI styles are not supported and
#' \code{style} is \dQuote{auto}, output will be send to viewer/browser as
#' HTML.
#' @param term.colors integer(1L) how many ANSI colors are supported by the
#' terminal. This variable is provided for when
#' \code{\link[=num_colors]{crayon::num_colors}} does not properly detect how
#' many ANSI colors are supported by your terminal. Defaults to return value
#' of \code{\link[=num_colors]{crayon::num_colors}} and should be 8 or 256 to
#' allow ANSI colors, or any other number to disallow them. This only
#' impacts output format selection when \code{style} and \code{format} are
#' both set to \dQuote{auto}.
#' @param tar.banner character(1L), language, or NULL, used to generate the
#' text to display ahead of the diff section representing the target output.
#' If NULL will use the deparsed \code{target} expression, if language, will
#' use the language as it would the \code{target} expression, if
#' character(1L), will use the string with no modifications. The language
#' mode is provided because \code{diffStr} modifies the expression prior to
#' display (e.g. by wrapping it in a call to \code{str}). Note that it is
#' possible in some cases that the substituted value of \code{target} actually
#' is character(1L), but if you provide a character(1L) value here it will be
#' assumed you intend to use that value literally.
#' @param cur.banner character(1L) like \code{tar.banner}, but for
#' \code{current}
#' @param strip.sgr TRUE, FALSE, or NULL (default), whether to strip ANSI CSI
#' SGR sequences prior to comparison and for display of diff. If NULL,
#' resolves to TRUE if `style` resolves to an ANSI formatted diff, and
#' FALSE otherwise. The default behavior is to avoid confusing diffs where
#' the original SGR and the SGR added by the diff are mixed together.
#' @param sgr.supported TRUE, FALSE, or NULL (default), whether to assume the
#' standard output device supports ANSI CSI SGR sequences. If TRUE, strings
#' will be manipulated accounting for the SGR sequences. If NULL,
#' resolves to TRUE if `style` resolves to an ANSI formatted diff, and
#' to `crayon::has_color()` otherwise. This only controls how the strings are
#' manipulated, not whether SGR is added to format the diff, which is
#' controlled by the `style` parameter. This parameter is exposed for the
#' rare cases where you might wish to control string manipulation behavior
#' directly.
#' @param extra list additional arguments to pass on to the functions used to
#' create text representation of the objects to diff (e.g. \code{print},
#' \code{str}, etc.)
#' @param ... unused, for compatibility of methods with generics
#' @return a \code{Diff} object; this object has a \code{show}
#' method that will display the diff to screen or pager, as well as
#' \code{summary}, \code{any}, and \code{as.character} methods.
#' If you store the return value instead of displaying it to screen, and
#' display it later, it is possible for the display to be thrown off if
#' there are environment changes (e.g. display width changes) in between
#' the time you compute the diff and the time you display it.
#' @rdname diffPrint
#' @name diffPrint
#' @export
#' @examples
#' ## `pager="off"` for CRAN compliance; you may omit in normal use
#' diffPrint(letters, letters[-5], pager="off")
setGeneric(
"diffPrint", function(target, current, ...) standardGeneric("diffPrint")
)
#' @rdname diffPrint
setMethod("diffPrint", signature=c("ANY", "ANY"), make_diff_fun(capt_print))
#' Diff Object Structures
#'
#' Compares the \code{str} output of \code{target} and \code{current}. If
#' the \code{max.level} parameter to \code{str} is left unspecified, will
#' attempt to find the largest \code{max.level} that fits within
#' \code{line.limit} and shows at least one difference.
#'
#' Due to the seemingly inconsistent nature of \code{max.level} when used with
#' objects with nested attributes, and also due to the relative slowness of
#' \code{str}, this function simulates the effect of \code{max.level} by hiding
#' nested lines instead of repeatedly calling \code{str} with varying values of
#' \code{max.level}.
#'
#' @inheritParams diffPrint
#' @seealso \code{\link{diffPrint}} for details on the \code{diff*} functions,
#' \code{\link{diffObj}}, \code{\link{diffStr}},
#' \code{\link{diffChr}} to compare character vectors directly,
#' \code{\link{diffDeparse}} to compare deparsed objects,
#' \code{\link{ses}} for a minimal and fast diff
#' @return a \code{Diff} object; see \code{\link{diffPrint}}.
#' @rdname diffStr
#' @export
#' @examples
#' ## `pager="off"` for CRAN compliance; you may omit in normal use
#' with(mtcars, diffStr(lm(mpg ~ hp)$qr, lm(mpg ~ disp)$qr, pager="off"))
setGeneric("diffStr", function(target, current, ...) standardGeneric("diffStr"))
#' @rdname diffStr
setMethod("diffStr", signature=c("ANY", "ANY"), make_diff_fun(capt_str))
#' Diff Character Vectors Element By Element
#'
#' Will perform the diff on the actual string values of the character vectors
#' instead of capturing the printed screen output. Each vector element is
#' treated as a line of text. NA elements are treated as the string
#' \dQuote{NA}. Non character inputs are coerced to character and attributes
#' are dropped with \code{\link{c}}.
#'
#' @inheritParams diffPrint
#' @seealso \code{\link{diffPrint}} for details on the \code{diff*} functions,
#' \code{\link{diffObj}}, \code{\link{diffStr}},
#' \code{\link{diffDeparse}} to compare deparsed objects,
#' \code{\link{ses}} for a minimal and fast diff
#' @return a \code{Diff} object; see \code{\link{diffPrint}}.
#' @export
#' @rdname diffChr
#' @examples
#' ## `pager="off"` for CRAN compliance; you may omit in normal use
#' diffChr(LETTERS[1:5], LETTERS[2:6], pager="off")
setGeneric("diffChr", function(target, current, ...) standardGeneric("diffChr"))
#' @rdname diffChr
setMethod("diffChr", signature=c("ANY", "ANY"), make_diff_fun(capt_chr))
#' Diff Deparsed Objects
#'
#' Perform diff on the character vectors produced by \code{\link{deparse}}ing
#' the objects. Each element counts as a line. If an element contains newlines
#' it will be split into elements new lines by the newlines.
#'
#' @export
#' @inheritParams diffPrint
#' @seealso \code{\link{diffPrint}} for details on the \code{diff*} functions,
#' \code{\link{diffObj}}, \code{\link{diffStr}},
#' \code{\link{diffChr}} to compare character vectors directly,
#' \code{\link{ses}} for a minimal and fast diff
#' @return a \code{Diff} object; see \code{\link{diffPrint}}.
#' @export
#' @rdname diffDeparse
#' @examples
#' ## `pager="off"` for CRAN compliance; you may omit in normal use
#' diffDeparse(matrix(1:9, 3), 1:9, pager="off")
setGeneric(
"diffDeparse", function(target, current, ...) standardGeneric("diffDeparse")
)
#' @rdname diffDeparse
setMethod("diffDeparse", signature=c("ANY", "ANY"), make_diff_fun(capt_deparse))
#' Diff Files
#'
#' Reads text files with \code{\link{readLines}} and performs a diff on the
#' resulting character vectors.
#'
#' @export
#' @param target character(1L) or file connection with read capability; if
#' character should point to a text file
#' @param current like \code{target}
#' @inheritParams diffPrint
#' @seealso \code{\link{diffPrint}} for details on the \code{diff*} functions,
#' \code{\link{diffObj}}, \code{\link{diffStr}},
#' \code{\link{diffChr}} to compare character vectors directly,
#' \code{\link{ses}} for a minimal and fast diff
#' @return a \code{Diff} object; see \code{\link{diffPrint}}.
#' @export
#' @rdname diffFile
#' @examples
#' \dontrun{
#' url.base <- "https://raw.githubusercontent.com/wch/r-source"
#' f1 <- file.path(url.base, "29f013d1570e1df5dc047fb7ee304ff57c99ea68/README")
#' f2 <- file.path(url.base, "daf0b5f6c728bd3dbcd0a3c976a7be9beee731d9/README")
#' diffFile(f1, f2)
#' }
setGeneric(
"diffFile", function(target, current, ...) standardGeneric("diffFile")
)
#' @rdname diffFile
setMethod("diffFile", signature=c("ANY", "ANY"), make_diff_fun(capt_file))
#' Diff CSV Files
#'
#' Reads CSV files with \code{\link{read.csv}} and passes the resulting data
#' frames onto \code{\link{diffPrint}}. \code{extra} values are passed as
#' arguments are passed to both \code{read.csv} and \code{print}. To the
#' extent you wish to use different \code{extra} arguments for each of those
#' functions you will need to \code{read.csv} the files and pass them to
#' \code{diffPrint} yourself.
#'
#' @export
#' @param target character(1L) or file connection with read capability;
#' if character should point to a CSV file
#' @param current like \code{target}
#' @inheritParams diffPrint
#' @seealso \code{\link{diffPrint}} for details on the \code{diff*} functions,
#' \code{\link{diffObj}}, \code{\link{diffStr}},
#' \code{\link{diffChr}} to compare character vectors directly,
#' \code{\link{ses}} for a minimal and fast diff
#' @return a \code{Diff} object; see \code{\link{diffPrint}}.
#' @export
#' @rdname diffCsv
#' @examples
#' iris.2 <- iris
#' iris.2$Sepal.Length[5] <- 99
#' f1 <- tempfile()
#' f2 <- tempfile()
#' write.csv(iris, f1, row.names=FALSE)
#' write.csv(iris.2, f2, row.names=FALSE)
#' ## `pager="off"` for CRAN compliance; you may omit in normal use
#' diffCsv(f1, f2, pager="off")
#' unlink(c(f1, f2))
setGeneric(
"diffCsv", function(target, current, ...) standardGeneric("diffCsv")
)
#' @rdname diffCsv
setMethod("diffCsv", signature=c("ANY", "ANY"), make_diff_fun(capt_csv))
#' Diff Objects
#'
#' Compare either the \code{print}ed or \code{str} screen representation of
#' R objects depending on which is estimated to produce the most useful
#' diff. The selection process tries to minimize screen lines while maximizing
#' differences shown subject to display constraints. The decision algorithm is
#' likely to evolve over time, so do not rely on this function making
#' a particular selection under specific circumstances. Instead, use
#' \code{\link{diffPrint}} or \code{\link{diffStr}} if you require one or the
#' other output.
#'
#' @inheritParams diffPrint
#' @seealso \code{\link{diffPrint}} for details on the \code{diff*} methods,
#' \code{\link{diffStr}},
#' \code{\link{diffChr}} to compare character vectors directly
#' \code{\link{diffDeparse}} to compare deparsed objects,
#' \code{\link{ses}} for a minimal and fast diff
#' @return a \code{Diff} object; see \code{\link{diffPrint}}.
#' @export
#' @examples
#' ## `pager="off"` for CRAN compliance; you may omit in normal use
#' diffObj(letters, c(letters[1:10], LETTERS[11:26]), pager="off")
#' with(mtcars, diffObj(lm(mpg ~ hp)$qr, lm(mpg ~ disp)$qr, pager="off"))
setGeneric("diffObj", function(target, current, ...) standardGeneric("diffObj"))
diff_obj <- make_diff_fun(identity) # we overwrite the body next
body(diff_obj) <- quote({
if(length(extra))
stop("Argument `extra` must be empty in `diffObj`.")
# frame # force frame so that `par_frame` called in this context
# Need to generate calls inside a new child environment so that we do not
# pollute the environment and create potential conflicts with ... args
# used to run this inside a `local` call, but issues cropped up with the
# advent of JIT, and can't recall why just storing arguments at first
# was a problem
args <- as.list(environment())
call.dat <- extract_call(sys.calls(), frame)
err <- make_err_fun(call.dat$call)
if(is.null(args$tar.banner)) args$tar.banner <- call("quote", call.dat$tar)
if(is.null(args$cur.banner)) args$cur.banner <- call("quote", call.dat$cur)
call.print <- as.call(c(list(quote(diffobj::diffPrint)), args))
call.str <- as.call(c(list(quote(diffobj::diffStr)), args))
call.str[["extra"]] <- list(max.level="auto")
res.print <- try(eval(call.print, frame), silent=TRUE)
res.str <- try(eval(call.str, frame), silent=TRUE)
if(inherits(res.str, "try-error"))
err(
"Error in calling `diffStr`: ",
conditionMessage(attr(res.str, "condition"))
)
if(inherits(res.print, "try-error"))
err(
"Error in calling `diffPrint`: ",
conditionMessage(attr(res.print, "condition"))
)
# Run both the print and str versions, and then decide which to use based
# on some weighting of various factors including how many lines needed to be
# omitted vs. how many differences were reported
diff.p <- count_diff_hunks(res.print@diffs)
diff.s <- count_diff_hunks(res.str@diffs)
diff.l.p <- diff_line_len(
res.print@diffs, res.print@etc, tar.capt=res.print@tar.dat$raw,
cur.capt=res.print@cur.dat$raw
)
diff.l.s <- diff_line_len(
res.str@diffs, res.str@etc, tar.capt=res.str@tar.dat$raw,
cur.capt=res.str@cur.dat$raw
)
# How many lines of the input are in the diffs, vs how many lines of input
diff.line.ratio.p <- lineCoverage(res.print)
diff.line.ratio.s <- lineCoverage(res.str)
# Only show the one with differences
res <- if(!diff.s && diff.p) {
res.print
} else if(!diff.p && diff.s) {
res.str
# If one fits in full and the other doesn't, show the one that fits in full
} else if(
!res.str@trim.dat$lines[[1L]] &&
res.print@trim.dat$lines[[1L]]
) {
res.str
} else if(
res.str@trim.dat$lines[[1L]] &&
!res.print@trim.dat$lines[[1L]]
) {
res.print
} else if (diff.l.p <= console_lines() / 2) {
# Always use print if print output is reasonable size
res.print
} else {
# Calculate the trade offs between the two options
s.score <- diff.s / diff.l.s * diff.line.ratio.s
p.score <- diff.p / diff.l.p * diff.line.ratio.p
if(p.score >= s.score) res.print else res.str
}
res
})
#' @export
setMethod("diffObj", signature=c("ANY", "ANY"), diff_obj)
diffobj/R/tochar.R 0000755 0001762 0000144 00000050750 13777704534 013514 0 ustar ligges users # Copyright (C) 2021 Brodie Gaslam
#
# This file is part of "diffobj - Diffs for R Objects"
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# Go to for a copy of the license.
# @include S4.R
NULL
# Compute the ranges of a hunk group based on atomic hunk ids
#
# rng.o is a matrix where each column represents `c(tar.rng, cur.rng)`
# and rng.o has the original untrimmed values (ACTUALLY, not clear this is
# what we are doing currently, seems like we're passing the post context
# assesment hunks)
#
# fill indicates which lines where fill lines and should not be picked to
# represent the start or end point of a range (these are added by the atomic
# word diff)
find_rng <- function(ids, rng.o, fill) {
# first row of rng.o is the start of the hunk
with.rng <- ids[which(rng.o[1L, ids] > 0L)]
rng <- if(!length(with.rng)) {
# Find previous earliest originally existing item we want to insert
# after; note we need to look at the non-trimmed ranges, and we include
# the first context atomic hunk in the group as a potential match
prev <- rng.o[
2L, seq_len(ncol(rng.o)) <= max(ids[[1L]], 0L) &
rng.o[1L, ] > 0L
]
if(!length(prev)) integer(2L) else c(max(prev), 0L)
} else {
c(min(rng.o[1L, intersect(ids, with.rng)]), max(rng.o[2L, ids]))
}
}
# Create a text representation of a file line range to use in the hunk header
rng_as_chr <- function(range) {
if(length(range) < 2L) "0" else {
a <- range[[1L]]
b <- if(diff(range))
paste0(",", if(range[[2L]]) diff(range) + 1L else 0)
paste0(a, b)
}
}
# Finalization function should return a list with two character vectors for
# diff contents, and two factor vectors denoting the type of content for
# each of the character vectors where valid data types are ins, del, mtc, hdr,
# ctx; chrt is just a helper function to generate factors with those possible
# values
chrt <- function(...)
factor(
c(...),
levels=c(
"insert", "delete", "match", "header", "context.sep",
"banner.insert", "banner.delete", "guide", "fill"
)
)
hunkl <- function(col.1=NULL, col.2=NULL, type.1=NULL, type.2=NULL)
c(
list(
if(is.null(col.1)) list(dat=character(), type=chrt()) else
list(dat=col.1, type=type.1)
),
if(!is.null(col.2)) list(list(dat=col.2, type=type.2))
)
# finalization functions take aligned data and juxtapose it according to
# selected display mode. Note that _context must operate on all the hunks
# in a hunk group, whereas the other two operate on each hunk atom. Padding
# is identified in two forms: as actual A.fill and B.fill values when there
# was a wrapped diff, and in side by side mode when the lengths of A and B
# are not the same and end up adding NAs. Padding is really only meaningful
# for side by side mode so is removed in the other modes
# The A.fill and B.fill business is a bit of a mess, because ideally we woudl
# want a structure parallel to the data structure instead of just vectors that
# we need to line up with the data lists, but this is all a result of trying
# to shoehorn new functionality in...
fin_fun_context <- function(dat) {
dat_wo_fill <- function(x, ind) unlist(x[[ind]])[!x[[sprintf("%s.fill", ind)]]]
A.dat <- lapply(dat, dat_wo_fill, "A")
B.dat <- lapply(dat, dat_wo_fill, "B")
A.lens <- vapply(A.dat, function(x) length(unlist(x)), integer(1L))
B.lens <- vapply(B.dat, function(x) length(unlist(x)), integer(1L))
A.ul <- unlist(A.dat)
B.ul <- unlist(B.dat)
context <- vapply(dat, "[[", logical(1L), "context")
guide <- vapply(dat, "[[", logical(1L), "guide")
A.ctx <- rep(context, A.lens)
A.guide <- rep(guide, A.lens)
B.ctx <- rep(context, B.lens)
B.guide <- rep(guide, B.lens)
A.types <- ifelse(A.guide, "guide", ifelse(A.ctx, "match", "delete"))
B.types <- ifelse(B.guide, "guide", ifelse(B.ctx, "match", "insert"))
# return in list so compatible with post `lapply` return values for other
# finalization functions
list(
hunkl(
col.1=c(A.ul, if(length(B.ul)) NA, B.ul),
type.1=chrt(A.types, if(length(B.ul)) "context.sep", B.types)
)
)
}
fin_fun_unified <- function(A, B, A.fill, B.fill, context, guide) {
A.lens <- vapply(A, length, integer(1L))
B.lens <- vapply(B, length, integer(1L))
A.ord <- rep(seq_along(A.lens), A.lens)[!A.fill]
B.ord <- rep(seq_along(B.lens), B.lens)[!B.fill]
A <- unlist(A)[!A.fill]
B <- unlist(B)[!B.fill]
ord <- order(c(A.ord, B.ord))
types <- c(
rep(if(guide) "guide" else if(context) "match" else "delete", sum(A.lens)),
rep(if(guide) "guide" else if(context) "match" else "insert", sum(B.lens))
)
hunkl(
col.1=unlist(c(A, B)[ord]), type.1=chrt(unlist(types[ord]))
)
}
fin_fun_sidebyside <- function(A, B, A.fill, B.fill, context, guide) {
for(i in seq_along(A)) {
A.ch <- A[[i]]
B.ch <- B[[i]]
A.l <- length(A.ch)
B.l <- length(B.ch)
max.l <- max(A.l, B.l)
length(A.ch) <- length(B.ch) <- max.l
A[[i]] <- A.ch
B[[i]] <- B.ch
}
A.ul <- unlist(A)
B.ul <- unlist(B)
A.fill.u <- B.fill.u <- !logical(length(A.ul))
A.fill.u[!is.na(A.ul)] <- A.fill
B.fill.u[!is.na(B.ul)] <- B.fill
A.len <- length(A.ul)
B.len <- length(B.ul)
hunkl(
col.1=ifelse(is.na(A.ul), "", A.ul),
col.2=ifelse(is.na(B.ul), "", B.ul),
type.1=chrt(
ifelse(
rep(guide, A.len), "guide",
ifelse(A.fill.u, "fill",
ifelse(context, "match", "delete")
) ) ),
type.2=chrt(
ifelse(
rep(guide, B.len), "guide",
ifelse(B.fill.u, "fill",
ifelse(context, "match", "insert")
) ) ) )
}
# Convert a hunk group into text representation
hunk_atom_as_char <- function(h.a, x) {
etc <- x@etc
mode <- x@etc@mode
if(mode=="context") {
ghd.mode.1 <- "A"
ghd.mode.2 <- "B"
ghd.type.1 <- ghd.type.2 <- "both"
} else if(mode == "unified") {
ghd.mode.1 <- ghd.mode.2 <-"A"
ghd.type.1 <- "pos"
ghd.type.2 <- "neg"
} else if(mode == "sidebyside") {
ghd.mode.1 <- "A"
ghd.mode.2 <- "B"
ghd.type.1 <- "pos"
ghd.type.2 <- "neg"
}
A.ind <- get_hunk_ind(h.a, mode=ghd.mode.1, ghd.type.1)
B.ind <- get_hunk_ind(h.a, mode=ghd.mode.2, ghd.type.2)
# Align the lines accounting for partial matching post word-diff,
# each diff style has a different finalization function
dat.align <- align_eq(A.ind, B.ind, x=x, context=h.a$context)
list(
A=dat.align$A, B=dat.align$B,
A.fill=dat.align$A.fill, B.fill=dat.align$B.fill,
context=h.a$context, guide=h.a$guide
)
}
hunk_as_char <- function(h.g, h.h, x) {
stopifnot(is(x, "Diff"))
etc <- x@etc
mode <- etc@mode
hunk.head <- if(length(h.g) && !h.g[[1L]]$completely.empty) {
list(
if(mode == "sidebyside") {
hunkl(
col.1=h.h[1L], col.2=h.h[2L],
type.1=chrt("header"), type.2=chrt("header")
)
} else {
hunkl(col.1=h.h, type.1=chrt("header"))
} ) }
# Generate hunk contents in aligned form
hunk.res <- lapply(h.g, hunk_atom_as_char, x=x)
# Run finalization functions; context mode is different because we need to
# re-order across atomic hunks
fin_fun <- switch(
mode, unified=fin_fun_unified, sidebyside=fin_fun_sidebyside,
context=fin_fun_context
)
hunk.fin <- if(mode != "context") {
lapply(hunk.res, function(x) do.call(fin_fun, x))
} else {
fin_fun_context(hunk.res)
}
# Add header and return; this a list of lists, though all sub-lists should
# have same format
c(hunk.head, hunk.fin)
}
# Helper functions for 'as.character'
# Get trimmed character ranges; positives are originally from target, and
# negatives from current
get_hunk_ind <- function(h.a, mode, type="both") {
stopifnot(
mode %in% LETTERS[1:2], length(mode) == 1L,
is.chr.1L(type), type %in% c("both", "pos", "neg")
)
rng.raw <- c(
if(type %in% c("pos", "both"))
seq(h.a$tar.rng.trim[[1L]], h.a$tar.rng.trim[[2L]]),
if(type %in% c("neg", "both"))
-seq(h.a$cur.rng.trim[[1L]], h.a$cur.rng.trim[[2L]])
)
rng.raw[rng.raw %in% h.a[[mode]]]
}
#' @rdname diffobj_s4method_doc
setMethod("as.character", "Diff",
function(x, ...) {
old.crayon.opt <- options(crayon.enabled=is(x@etc@style, "StyleAnsi"))
on.exit(options(old.crayon.opt), add=TRUE)
hunk.limit <- x@etc@hunk.limit
line.limit <- x@etc@line.limit
hunk.limit <- x@etc@hunk.limit
disp.width <- x@etc@disp.width
hunk.grps <- x@diffs
mode <- x@etc@mode
tab.stops <- x@etc@tab.stops
ignore.white.space <- x@etc@ignore.white.space
sgr.supported <- x@etc@sgr.supported
# legacy from when we had different max diffs for different parts of diff
max.diffs <- x@etc@max.diffs
max.diffs.in.hunk <- x@etc@max.diffs
max.diffs.wrap <- x@etc@max.diffs
s <- x@etc@style # shorthand
len.max <- max(length(x@tar.dat$raw), length(x@cur.dat$raw))
no.diffs <- if(!suppressWarnings(any(x))) {
# This needs to account for "trim" effects
msg <- "No visible differences between objects"
if(
(
ignore.white.space || x@etc@convert.hz.white.space ||
!identical(x@etc@trim, trim_identity) || x@etc@strip.sgr
) &&
!isTRUE(all.equal(x@tar.dat$orig, x@cur.dat$orig)) &&
isTRUE(all.equal(x@tar.dat$comp, x@cur.dat$comp))
) {
paste0(
msg, ", but there are some differences suppressed by ",
"`ignore.white.space`, `convert.hz.white.space`, `strip.sgr`, ",
"and/or `trim`. Set all those arguments to FALSE to highlight ",
"the differences.",
collapse=""
)
} else if (!isTRUE(all.eq <- all.equal(x@target, x@current))) {
c(
paste0(
msg, ", but objects are *not* `all.equal`",
if(length(all.eq)) ":" else "."
),
if(length(all.eq)) paste0("- ", all.eq)
)
} else paste0(msg, ".")
}
# Basic width computation and banner size; start by computing gutter so we
# can figure out what's left
gutter.dat <- x@etc@gutter
# Trim hunks to the extented needed to make sure we fit in lines
hunks.flat <- unlist(hunk.grps, recursive=FALSE)
ranges <- vapply(
hunks.flat, function(h.a) c(h.a$tar.rng.trim, h.a$cur.rng.trim),
integer(4L)
)
ranges.orig <- vapply(
hunks.flat, function(h.a) c(h.a$tar.rng.sub, h.a$cur.rng.sub), integer(4L)
)
hunk.heads <- x@hunk.heads
h.h.chars <- nchar2(
chr_trim(
unlist(hunk.heads), x@etc@line.width, sgr.supported=sgr.supported
),
sgr.supported=sgr.supported
)
# Make the object banner and compute more detailed widths post trim
tar.banner <- if(!is.null(x@etc@tar.banner)) x@etc@tar.banner else
deparse(x@etc@tar.exp)[[1L]]
cur.banner <- if(!is.null(x@etc@cur.banner)) x@etc@cur.banner else
deparse(x@etc@cur.exp)[[1L]]
ban.A.trim <- if(s@wrap)
chr_trim(tar.banner, x@etc@text.width, sgr.supported=sgr.supported)
else tar.banner
ban.B.trim <- if(s@wrap)
chr_trim(cur.banner, x@etc@text.width, sgr.supported=sgr.supported)
else cur.banner
banner.A <- s@funs@word.delete(ban.A.trim)
banner.B <- s@funs@word.insert(ban.B.trim)
# Trim banner doesn't currently work, so we just comment the nulling out and
# updated the docs. This doesn't seem worth fixing. The banner portion
# would still show up with the banners themselves NULLed.
if(line.limit[[1L]] >= 0) {
ll2 <- line.limit[[2L]]
# if(ll2 < 2L && mode != "sidebyside") {
# banner.A <- NULL
# }
# if(ll2 < 1L) {
# banner.B <- banner.A <- NULL
# }
}
if(mode == "sidebyside") {
line.limit <- pmax(integer(2L), line.limit - 2L)
} else {
line.limit <- pmax(integer(2L), line.limit - 1L)
}
# Post trim, figure out max lines we could possibly be showing from capture
# strings; careful with ranges,
trim.meta <- attr(hunk.grps, "meta")
if(is.null(trim.meta))
stop("Internal error: missing trim meta data, contact maintainer") # nocov
lim.line <- trim.meta$lines
lim.hunk <- trim.meta$hunks
ll <- !!lim.line[[1L]]
lh <- !!lim.hunk[[1L]]
diff.count <- count_diffs(hunk.grps)
str.fold.out <- if(x@capt.mode == "str" && x@diff.count.full > diff.count) {
paste0(
x@diff.count.full - diff.count,
" differences are hidden by our use of `max.level`"
)
}
limit.out <- if(ll || lh) {
if(!is.null(str.fold.out)) {
# nocov start
stop(
"Internal Error: should not be str folding when limited; contact ",
"maintainer."
)
# nocov end
}
paste0(
"... omitted ",
if(ll) sprintf("%d/%d lines", lim.line[[1L]], lim.line[[2L]]),
if(ll && lh) ", ",
if(lh) sprintf("%d/%d hunks", lim.hunk[[1L]], lim.hunk[[2L]])
)
}
tar.max <- max(ranges[2L, ], 0L)
cur.max <- max(ranges[4L, ], 0L)
# At this point we need to actually reconstitute the final output string by:
# - Applying word diffs
# - Reconstructing untrimmed strings
# - Substitute appropriate values for empty strings
f.f <- x@etc@style@funs
if(x@etc@word.diff) {
tar.w.c <- word_color(x@tar.dat$trim, x@tar.dat$word.ind, f.f@word.delete)
cur.w.c <- word_color(x@cur.dat$trim, x@cur.dat$word.ind, f.f@word.insert)
} else {
tar.w.c <- x@tar.dat$trim
cur.w.c <- x@cur.dat$trim
}
x@tar.dat$fin <- untrim(x@tar.dat, tar.w.c, x@etc)
x@cur.dat$fin <- untrim(x@cur.dat, cur.w.c, x@etc)
# Generate the pre-rendered hunk data as text columns; a bit complicated
# as we need to unnest stuff; use rbind to make it a little easier.
pre.render.raw <- unlist(
Map(hunk_as_char, hunk.grps, hunk.heads, x=list(x)),
recursive=FALSE
)
pre.render.mx <- do.call(rbind, pre.render.raw)
pre.render.mx.2 <- lapply(
split(pre.render.mx, col(pre.render.mx)), do.call, what="rbind"
)
pre.render <- lapply(
unname(pre.render.mx.2),
function(mx) list(
dat=unlist(mx[, 1L]),
type=unlist(mx[, 2L], recursive=FALSE)
) )
# Add the banners; banners are rendered exactly like normal text, except
# for the line level functions
if(mode == "sidebyside") {
pre.render[[1L]]$dat <- c(banner.A, pre.render[[1L]]$dat)
pre.render[[1L]]$type <- c(chrt("banner.delete"), pre.render[[1L]]$type)
pre.render[[2L]]$dat <- c(banner.B, pre.render[[2L]]$dat)
pre.render[[2L]]$type <- c(chrt("banner.insert"), pre.render[[2L]]$type)
} else {
pre.render[[1L]]$dat <- c(banner.A, banner.B, pre.render[[1L]]$dat)
pre.render[[1L]]$type <- c(
chrt("banner.delete", "banner.insert"), pre.render[[1L]]$type
)
}
# Generate wrapped version of the text; if in sidebyside, make sure that
# all elements are same length
pre.render.w <- if(s@wrap) {
pre.render.w <- replicate(
length(pre.render),
vector("list", length(pre.render[[1L]]$dat)), simplify=FALSE
)
for(i in seq_along(pre.render)) {
hdr <- pre.render[[i]]$type == "header"
pre.render.w[[i]][hdr] <- wrap(
pre.render[[i]]$dat[hdr], x@etc@line.width,
sgr.supported=sgr.supported
)
pre.render.w[[i]][!hdr] <- wrap(
pre.render[[i]]$dat[!hdr], x@etc@text.width,
sgr.supported=sgr.supported
)
}
pre.render.w
} else lapply(pre.render, function(y) as.list(y$dat))
line.lens <- lapply(pre.render.w, vapply, length, integer(1L))
types.raw <- lapply(pre.render, "[[", "type")
types <- lapply(
types.raw, function(y) sub("^banner\\.", "", as.character(y))
)
if(mode == "sidebyside") {
line.lens.max <- replicate(2L, do.call(pmax, line.lens), simplify=FALSE)
pre.render.w <- lapply(
pre.render.w, function(y) {
Map(
function(dat, len) {
length(dat) <- len
dat
},
y, line.lens.max[[1L]]
) } )
} else line.lens.max <- line.lens
# Substitute NA elements with the appropriate values as dictated by the
# styles; also record lines NA positions
lines.na <- lapply(pre.render.w, lapply, is.na)
pre.render.w <- lapply(
pre.render.w, lapply,
function(y) {
res <- y
res[is.na(y)] <- x@etc@style@na.sub
res
} )
# Compute gutter, padding, and continuations
gutters <- render_gutters(
types=types, lens=line.lens, lens.max=line.lens.max, etc=x@etc
)
# Pad text
pre.render.w.p <- if(s@pad) {
Map(
function(col, type) {
diff.line <- type %in% c("insert", "delete", "match", "guide", "fill")
col[diff.line] <- lapply(
col[diff.line], rpad, x@etc@text.width, sgr.supported=sgr.supported
)
col[!diff.line] <- lapply(
col[!diff.line], rpad, x@etc@line.width, sgr.supported=sgr.supported
)
col
},
pre.render.w, types
)
} else pre.render.w
# Apply text level styles; make sure that all types are defined here
# otherwise you'll get lines missing in output; note that fill lines were
# represented by NAs originally and we indentify them within each aligned
# group with `lines.na`
# NOTE: any changes here need to be reflected in `make_dummy_row`
# CAN WE MOVE THIS WAY EARLIER SO WE CAN GET THE CORRECT TEXT WIDTHS?
# SEE #65
es <- x@etc@style
funs.ts <- list(
insert=function(x) es@funs@text(es@funs@text.insert(x)),
delete=function(x) es@funs@text(es@funs@text.delete(x)),
match=function(x) es@funs@text(es@funs@text.match(x)),
guide=function(x) es@funs@text(es@funs@text.guide(x)),
fill=function(x) es@funs@text(es@funs@text.fill(x)),
context.sep=function(x)
es@funs@text(es@funs@context.sep(es@text@context.sep)),
header=es@funs@header
)
pre.render.s <- Map(
function(dat, type, l.na) {
res <- vector("list", length(dat))
for(i in names(funs.ts)) # really need to loop through all?
res[type == i] <- Map(
function(y, l.na.i) {
res.s <- y
if(any(l.na.i))
res.s[l.na.i] <- funs.ts$fill(y[l.na.i])
res.s[!l.na.i | i == "context.sep"] <- funs.ts[[i]](y[!l.na.i])
res.s
},
dat[type == i],
l.na[type == i]
)
res
},
pre.render.w.p, types, lines.na
)
# Reconstruct 'types.raw' with the appropriate lenghts, and replacing
# types with 'fill' if elements were extended due to wrap
types.raw.x <- Map(
function(y, z) {
Map(
function(y.s, z.s) {
res <- rep(y.s, length(z.s))
res[z.s] <- "fill"
res
},
y, z
) },
types.raw, lines.na
)
# Render columns; note here we use 'types.raw' to distinguish banner lines
cols <- render_cols(
cols=pre.render.s, gutters=gutters, types=types.raw.x, etc=x@etc
)
# Render rows
rows <- render_rows(cols, etc=x@etc)
# Collect all the pieces, and for the meta pieces wrap, pad, and format
pre.fin.l <- list(no.diffs, rows, limit.out, str.fold.out)
meta.elem <- c(1L, 3:4)
pre.fin.l[meta.elem] <- lapply(
pre.fin.l[meta.elem],
# meta should not have any csi, so plain strwrap is okay
function(m) es@funs@meta(strwrap(m, width=disp.width))
)
pre.fin <- unlist(pre.fin.l)
# Apply subsetting as needed
ind <- seq_along(pre.fin)
ind <- if(length(x@sub.index)) ind[x@sub.index] else ind
if(length(x@sub.head)) ind <- head(ind, x@sub.head)
if(length(x@sub.tail)) ind <- tail(ind, x@sub.tail)
# Do the finalization
pre.fin <- pre.fin[ind]
res.len <- length(pre.fin)
finalize(es@funs@container(pre.fin), x, res.len)
} )
# Finalizing fun used by both Diff and DiffSummary as.character methods
finalize <- function(txt, obj, len) {
style <- obj@etc@style
pager <- style@pager
obj@etc@style@pager <- if(use_pager(pager, len)) pager else PagerOff()
fin <- style@finalizer(obj, txt)
attr(fin, "len") <- len
fin
}
diffobj/R/myerssimple.R 0000755 0001762 0000144 00000013670 13777704534 014605 0 ustar ligges users # Copyright (C) 2021 Brodie Gaslam
#
# This file is part of "diffobj - Diffs for R Objects"
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# Go to for a copy of the license.
# These are deprecated legacy functions from before we incorporated the
# libmba versions of the myers algo
# Alternate implementation of Myers algorithm in R, without linear space
# modification. Included here mostly for reference purposes and not intended
# for use since the MBA myers implemenation should be far superior
myers_simple <- function(target, current) {
path <- myers_simple_int(target, current)
diff_path_to_diff(path, target, current)
}
myers_simple_int <- function(A, B) {
N <- length(A)
M <- length(B)
MAX <- M + N + 1L
OFF <- MAX + 1L # offset to adjust to R indexing
Vl <- vector("list", MAX)
for(D in seq_len(MAX) - 1L) {
Vl[[D + 1L]] <- if(!D) integer(2L * MAX + 1L) else Vl[[D]]
for(k in seq(-D, D, by=2L)) {
# not sure of precendence for || vs &&
# k == -D means x == 0
V <- Vl[[D + 1L]]
if(k == -D || (k != D && V[k - 1L + OFF] < V[k + 1L + OFF])) {
x <- V[k + 1L + OFF]
} else {
x <- V[k - 1L + OFF] + 1L
}
y <- x - k
# Move on diagonal
while (x < N && y < M && A[x + 1L] == B[y + 1L]) {
x <- x + 1L
y <- y + 1L
}
# Record last match or end; if a mismatch no longer increment
Vl[[D + 1L]][k + OFF] <- x
if(x >= N && y >= M) {
# Create matrix to hold entire result path; should be longest of
# A and B plus recorded differences
path.len <- D + max(N, M)
res <- matrix(integer(1L), nrow=path.len, ncol=2)
res[path.len, ] <- c(x, y)
path.len <- path.len - 1L
for(d in rev(seq_len(D))) {
Vp <- Vl[[d]]
break.out <- FALSE
repeat {
# can't match to zero since that is the initialized value
shift.up <- Vp[k + 1L + OFF] == x && x
shift.left <- Vp[k - 1L + OFF] == x - 1L && x > 1L
if(x <= 0L && y <= 0L) {
break
} else if(!shift.up && !shift.left) {
# must be on snake or about to hit 0,0
x <- max(x - 1L, 0L)
y <- max(y - 1L, 0L)
} else {
if(shift.up) {
y <- y - 1L
k <- k + 1L
} else {
x <- x - 1L
k <- k - 1L
}
break.out <- TRUE
}
res[path.len, ] <- c(x, y)
path.len <- path.len - 1L
if(break.out) break
}
}
if(any(res < 0L)) {
# nocov start
stop(
"Logic Error: diff generated illegal coords; contact maintainer."
)
# nocov end
}
return(res)
}
}
}
stop("Logic Error, should not get here") # nocov
}
# Translates a diff path produced by the simple Myers Algorithm into the
# standard format we use in the rest of the package
diff_path_to_diff <- function(path, target, current) {
stopifnot(
is.character(target), is.character(current),
is.matrix(path), is.integer(path), ncol(path) == 2,
all(path[, 1L] %in% c(0L, seq_along(target))),
all(path[, 2L] %in% c(0L, seq_along(current)))
)
# Path specifies 0s as well as duplicate coordinates, which we don't use
# in our other formats. For dupes, find first value for each index that is
# lined up with a real value in the other column
get_dupe <- function(x) {
base <- !logical(length(x))
if(!length(y <- which(x != 0L)))
base[[1L]] <- FALSE else base[[min(y)]] <- FALSE
base
}
cur.dup <- as.logical(ave(path[, 1L], path[, 2L], FUN=get_dupe))
tar.dup <- as.logical(ave(path[, 2L], path[, 1L], FUN=get_dupe))
path[!path] <- NA_integer_
path[tar.dup, 1L] <- NA_integer_
path[cur.dup, 2L] <- NA_integer_
# Now create the character equivalents of the path matrix
tar.path <- target[path[, 1L]]
cur.path <- current[path[, 2L]]
# Mark the equalities in the path matrix by setting them negative
path[which(tar.path == cur.path), ] <- -path[which(tar.path == cur.path), ]
# Remaining numbers are the mismatches which we will arbitrarily assign to
# each other; to do so we first split our data into groups of matches and
# mismatches and do the mapping there-in. We also get rid of non-matching
# entries.
matched <- ifelse(!is.na(path[, 1]) & path[, 1] < 0L, 1L, 0L)
splits <- cumsum(abs(diff(c(0, matched))))
chunks <- split.data.frame(path, splits)
res.tar <- res.cur <- vector("list", length(chunks))
mm.count <- 0L # for tracking matched mismatches
for(i in seq_along(chunks)) {
x <- chunks[[i]]
if((neg <- any(x < 0L, na.rm=TRUE)) && !all(x < 0L, na.rm=TRUE))
stop("Internal Error: match group error; contact maintainer") # nocov
if(neg) {
# Matches, so equal length and set to zero
res.tar[[i]] <- res.cur[[i]] <- integer(nrow(x))
} else {
# Mismatches
tar.mm <- Filter(Negate(is.na), x[, 1L])
cur.mm <- Filter(Negate(is.na), x[, 2L])
x.min.len <- min(length(tar.mm), length(cur.mm))
res.tar[[i]] <- res.cur[[i]] <- seq_len(x.min.len) + mm.count
mm.count <- x.min.len + mm.count
length(res.tar[[i]]) <- length(tar.mm)
length(res.cur[[i]]) <- length(cur.mm)
}
}
if(!length(res.tar)) res.tar <- integer()
if(!length(res.cur)) res.cur <- integer()
return(list(target=unlist(res.tar), current=unlist(res.cur)))
}
diffobj/NEWS.md 0000755 0001762 0000144 00000026174 14126712602 012771 0 ustar ligges users # diffobj
## v0.3.5
* Options automatically fallback to factory defaults if they are unset (h/t
@gadenbui).
* [#158](https://github.com/brodieG/diffobj/issues/158): Calling `diff*` with
`do.call` now works without warnings.
* [#117](https://github.com/brodieG/diffobj/issues/117): Fix guide detection
with very wide wrapped data.frames (h/t @bastician, @overvolting).
## v0.3.4
* Add a print method for `ses_dat` return values that makes it easier to
interpret the diff.
* [#152](https://github.com/brodieG/diffobj/issues/152): Rewrite the
fall-back "O(n)" algorithm that kicks in when there are `max.diffs`
differences to be more robust (h/t @hadley, @DanChaltiel, @gadenbui).
* Related to #152: `max.diffs=0` used to mean the same as `max.diffs=-1` (i.e.
unlimited), but this was undocumented and an error. `max.diffs=0` will now
immediately fall back to the "O(n)" algorithm.
## v0.3.3
* Implement experimental .Rout / .Rout.save testing.
* Fix `all.equal` test breakages from
[r79555](https://github.com/r-devel/r-svn/commit/66d016544fe9deb64aa74ae55fa3edfcb721b1c4).
## v0.3.1-2
* [#150](https://github.com/brodieG/diffobj/issues/150): Make tests compatible
with new `testthat` release (h/t @hadley).
* Remove pre-built vignettes and note `testthat` change to `waldo` release.
## v0.3.0
* [#143](https://github.com/brodieG/diffobj/issues/143): Add `ses_dat` to
provide a more computable version of `ses` (h/t @hadley).
* [#144](https://github.com/brodieG/diffobj/issues/144): Re-encode strings to
UTF-8 prior to comparison to avoid spurious encoding-only differences (h/t
@hadley).
* [#142](https://github.com/brodieG/diffobj/issues/142): Typos in
`standardGeneric` in trim/guide generic definitions.
* Drop attributes from inputs to `diffChr` (revealed as an issue by #142).
* Banish ghosts of `stringsAsFactors`.
## v0.2.4
* Tests explicitly set `stringsAsFactors=TRUE` so they don't fail with the
anticipated changed for R4.0.
* [#140](https://github.com/brodieG/diffobj/issues/140): Bad link in `?ses`.
## v0.2.3
This is a bugfix release.
* [#136](https://github.com/brodieG/diffobj/issues/136): Documentation for
`ignore.white.space` (h/t @flying-sheep) and `max.diffs` parameters listed
incorrect defaults.
* [#135](https://github.com/brodieG/diffobj/issues/135): Incorrect handling of
potential meta data strings when unwrapping atomics would cause a "wrong sign
in by argument" error (h/t @flying-sheep). We also fixed other bugs related
to the handling of meta data in atomic vectors that were uncovered while
debugging this issue.
* [#134](https://github.com/brodieG/diffobj/issues/134): Forwarding `...` to
`diff*` functions no longer breaks substitution of arguments for diff banners
(h/t @noamross)..
* [#133](https://github.com/brodieG/diffobj/issues/133): `diffFile` considers
files with equal content but different locations to be `all.equal` now (h/t
@noamross).
* [#132](https://github.com/brodieG/diffobj/issues/132): Duplicate pager slot
for baseline `Pager` removed (h/t Bill Dunlap).
There are also several other small internal changes that in theory should not
affect user facing behavior.
## v0.2.2
* Set `RNGversion()` due to changes to sampling mechanism.
## v0.2.0-1
### Features
* [#129](https://github.com/brodieG/diffobj/issues/129): Allow pager
specification via lists rather than full `Pager` objects for easier changes to
defaults. As part of this we changed `StyleRaw` objects to use default
pager instead of `PagerOff`.
* [#126](https://github.com/brodieG/diffobj/issues/126): Add embedding diffs in
Shiny to vignette.
* [#119](https://github.com/brodieG/diffobj/issues/119): `ignore.whitespace` now
also ignores white space differences adjoining punctuation.
* [#118](https://github.com/brodieG/diffobj/issues/118): New option to preserve
temporary diff file output when using pager (see `?Pager`).
* [#114](https://github.com/brodieG/diffobj/issues/114): New options `strip.sgr`
and `sgr.supported` allow finer control of what happens when input already
contains ANSI CSI SGR and how ANSI CSI SGR is handled in string manipulations.
Related to this, `options(crayon.enabled=TRUE)` is no longer set when
capturing output prior to diff as it used to be. By default pre-existing ANSI
CSI SGR is stripped with a warning prior to comparison.
### Bugs
* [#131](https://github.com/brodieG/diffobj/issues/131): Fix missing slot in S4
class definition (discovered by Bill Dunlap).
* [#127](https://github.com/brodieG/diffobj/issues/127): Width CSS conflicts
with bootstrap (reported by @eckyu, debugged/fixed by @cpsievert).
## v0.1.11
* [#123](https://github.com/brodieG/diffobj/issues/123): Compatibility with R3.1
(@krlmlr).
* [#121](https://github.com/brodieG/diffobj/issues/121): Vignette describing how
to embed diffs in Rmd documents (@JBGruber).
* [#115](https://github.com/brodieG/diffobj/issues/115): Declare HTML page diff
encoding/charset as UTF-8 (@artemklevtsov).
## v0.1.10
* Comply with CRAN directive to remove references to packages not in
depends/imports/suggests in tests (these were run optionally before).
* Fix bugs in corner case handling when we hit `max.diffs`.
## v0.1.9
* Fix test failures caused by changes in tibble output
## v0.1.8
* [#111](https://github.com/brodieG/diffobj/issues/111): Fixed guides with
`row.names=FALSE` (thank you @[Henrik
Bengtsson](https://github.com/HenrikBengtsson)).
* [#113](https://github.com/brodieG/diffobj/issues/113): Adapt tests to new
`str` return values (thank you @[Martin
Mächler](https://github.com/mmaechler)).
## v0.1.7
* Fix tests for next `testthat` release.
* [#107](https://github.com/brodieG/diffobj/issues/107): Diffs on quoted
language
* [#108](https://github.com/brodieG/diffobj/issues/108): Problems caused by
copying `crayon` functions
([@seulki-choi](https://stackoverflow.com/users/7788015/seulki-choi),
@gaborcsardi)
* [#100](https://github.com/brodieG/diffobj/issues/100): R_useDynamicSymbols
* [#97](https://github.com/brodieG/diffobj/issues/97): 2D Guidelines fixes for
data.table, tibble
* [#96](https://github.com/brodieG/diffobj/issues/96): Warnings when comparing
large data tables.
* [#94](https://github.com/brodieG/diffobj/issues/94): Guide detection problems
in nested lists.
* [#105](https://github.com/brodieG/diffobj/issues/105): Copyright tweaks.
## v0.1.6
* [#87](https://github.com/brodieG/diffobj/issues/87): `diffobj` is now GPL (>=2)
instead of GPL-3.
* [#81](https://github.com/brodieG/diffobj/issues/81): Better handling of mixed
UTF-8 / ASCII strings, reported by [jennybc](https://github.com/jennybc)
* [#88](https://github.com/brodieG/diffobj/issues/88): correctly handle trimming
when empty lists are involved, reported by [wch](https://github.com/wch)
* [#77](https://github.com/brodieG/diffobj/issues/77): `diffObj` now favors
dispatching to `diffPrint` unless `diffPrint` output is large
* [#82](https://github.com/brodieG/diffobj/issues/82): `diffChr` and `ses` now
treat `NA` as "NA" (needed with change in `nchar(NA)` in base R)
* [#85](https://github.com/brodieG/diffobj/issues/85): Improved alignment of
unwrapped atomic vector diffs
* [#83](https://github.com/brodieG/diffobj/issues/83): Improve pager auto
detection (note now ANSI output is only allowed by default if terminal
supports ANSI colors and the system pager is `less`, see `?Pager` for details)
* [#92](https://github.com/brodieG/diffobj/issues/92),
[#80](https://github.com/brodieG/diffobj/issues/80),
[#45](https://github.com/brodieG/diffobj/issues/45): basic implementation of
S4 guidelines and trimming (full resolution eventually with
[#33](https://github.com/brodieG/diffobj/issues/33))
* [#84](https://github.com/brodieG/diffobj/issues/84): simplify how to call
`diffChr` for improved performance, including "optimization" of
`convert.hz.whitespace`.
* [#64](https://github.com/brodieG/diffobj/issues/64): fix line limit in corner
case
* More robust handling of external `diff*` methods and of how `diffObj` calls
`diffStr` and `diffPrint`
## v0.1.5
* [#71](https://github.com/brodieG/diffobj/issues/71): Buggy diffs b/w data
frames when one has sequential row numbers and the other does not, loosely
related to [#38](https://github.com/brodieG/diffobj/issues/38)
* [#69](https://github.com/brodieG/diffobj/issues/69): Improve performance on
outputs with large print/show output, and other assorted minor optimizations
* [#72](https://github.com/brodieG/diffobj/issues/72): Warn when `style`
parameter overrides other user supplied parameters
* [#70](https://github.com/brodieG/diffobj/issues/70): Improve word contrast in YB
HTML mode
* [#63](https://github.com/brodieG/diffobj/issues/63): Show `all.equal` output
when objects are not `all.equal` but there are no visible differences
* Add Mean Relative Indifference vignette and update vignette styling
## v0.1.4
* [#67](https://github.com/brodieG/diffobj/issues/67): Fix CRAN Binaries
* Clarified that C code is heavily modified and incompatible with original
`libmba` implementation
## v0.1.3
* First version on CRAN
* [#51](https://github.com/brodieG/diffobj/issues/51): use RStudio viewport to display HTML diffs when running in RStudio (h/t Noam Ross)
* [#54](https://github.com/brodieG/diffobj/issues/54): [#55](https://github.com/brodieG/diffobj/issues/55), scale HTML output to viewport width (see `?Style`)
* [#53](https://github.com/brodieG/diffobj/issues/53): default term colors computed on run instead of on package load
* [#56](https://github.com/brodieG/diffobj/issues/56): disable wrap for HTML output
* HTML output now captured with default width 80 since there is no explicit relationship between HTML viewport width and `getOption("width")`
* The `style` parameter now accepts lists to use as instantiation arguments for `Style` objects (see `?Style`)
* Fix subtle rendering and formatting application flaws
* Switch Travis shields to SVG per Gábor Csárdi
* Improve in-hunk alignment of partially matching lines
* Compile with `-pedantic`, fix related warnings [Arun](https://stackoverflow.com/users/559784/arun)
* Improved coverage and more robust testing
* Several internal structure changes to accommodate improvements
## v0.1.2
* [#46](https://github.com/brodieG/diffobj/issues/46): Guide and Trim Problems with Lists
* [#47](https://github.com/brodieG/diffobj/issues/47): Output Format in non-ANSI Terminals Without Browser (reported by [Frank](https://github.com/brodieG/diffobj/issues/47))
* [#48](https://github.com/brodieG/diffobj/issues/48): `make_blocking` Default prompt Confusing (reported by [Frank](https://github.com/brodieG/diffobj/issues/47))
* [#49](https://github.com/brodieG/diffobj/issues/49): In-Hunk Word Diffs Issues when Unwrap-diffing Atomics
* [#50](https://github.com/brodieG/diffobj/issues/50): CSS Lost in Rstudio Server Sessions (reported by [Steven Beaupré](https://chat.stackoverflow.com/users/4064778/steven-beaupre))
## v0.1.1
* Turn off unwrapping for _named_ atomic vectors (see [#43](https://github.com/brodieG/diffobj/issues/43))
* [#44](https://github.com/brodieG/diffobj/issues/44): Proper handling of NULL objects in `diffStr`
* [#41](https://github.com/brodieG/diffobj/issues/41): Compilation Issues in Winbuilder
## v0.1.0
* Initial Release
diffobj/MD5 0000644 0001762 0000144 00000052042 14126775131 012177 0 ustar ligges users 2e535c9911aec20a33313d1ee2dcc8db *DESCRIPTION
86ba5fc5c95a550a25db2f3df704cede *NAMESPACE
2f45de40307898b4042d61f42ffb95e7 *NEWS.md
49d3d45d7f8fbd5039931dec5e0a75ad *R/capt.R
15c25fba7f29c1ca25339d50c9db24e3 *R/check.R
8cc95339d84906b633c287b1c25d3b1e *R/core.R
e24157f15e4880e71e4b6327e1906e3a *R/diff.R
dcce37378f0cff4d10f9a4c132bc2898 *R/finalizer.R
f62077eb26090bdbb0003aee5b405a24 *R/get.R
b8bf43023e234425503bfa0e8dc9adc8 *R/guides.R
984ed8bdef48847c20f7d41939984bf9 *R/html.R
3866a281d271757572686dcd4323e1e9 *R/hunks.R
e7a548158b6bd4ef3079e2157a7f50eb *R/layout.R
9710803489104a33ba502ef4ee11d8e1 *R/misc.R
0a6b2d346328ee8c55e0cea53a36db3b *R/myerssimple.R
d37d716569d95a7d8b1f1eff73f24ad2 *R/options.R
6f3afe561497c8fe8f3dd16dff396552 *R/pager.R
dc315dbe26fbcf9af0c746df1cc7c0d5 *R/rdiff.R
1019d8520b1b2f8367f77341aaf0f1c4 *R/rds.R
201159662ccb306e427391315f5f2517 *R/s4.R
ef478064e67522a8627d4c390149235b *R/set.R
323789973b388f35b29cfbb5d397d44b *R/styles.R
140c8b32cf27466641ba6073c206a69c *R/subset.R
d264d7fd94ee63fc5ba90458cafc19c9 *R/summmary.R
6e41c09de0c77f265ab80103e8eda1bc *R/system.R
69f27658f5dad96c2b6dffac87c8b845 *R/text.R
14dce32be9ed0a23b2e8d8437c925357 *R/tochar.R
c3a42436e52a82143d6a23fc35e94b67 *R/trim.R
91bf02bacd231e90d1d8c8a5130d679a *R/word.R
178748ba5f9b47c21e928b4848561a78 *README.md
c5ffe1166423d4137c6ce3c1f91790ad *build/vignette.rds
320fc37b423b0e309fedfde4061bc906 *inst/COPYRIGHTS
4522b9ebe26e4d989bc7a27f933e3d21 *inst/css/diffobj.css
7076bea0a51f0cc75fcba4f2c8ad4078 *inst/doc/diffobj.R
c50e37261653c146d7542dafab786625 *inst/doc/diffobj.Rmd
42be10d705bffbf64e96521b82a8e71c *inst/doc/diffobj.html
d9b10adda8de36a85376cae8ecb9f552 *inst/doc/embed.R
9e93047aa59973c6475724b83fc6c321 *inst/doc/embed.Rmd
7e6979c508b4e7a4bb0f5f18c25d6c9c *inst/doc/embed.html
58457afa03757c75394dfb619876db3b *inst/script/diffobj.js
31419b3dc6ce97ed3345f193b7656d50 *man/AlignThreshold-class.Rd
93b232974dcc5131b6d2d3614b5e90bc *man/Diff-class.Rd
45e765d94003da598c35f61278cea156 *man/Extract_PaletteOfStyles.Rd
f2e40c1436601fc5c57e0d2fd58405cf *man/Pager.Rd
70f6f6c53819b288f32221a9037ccdd8 *man/PaletteOfStyles-class.Rd
44122be6966715471ea1071ab79f9a8d *man/Rdiff_chr.Rd
dc65bc321349383369bb285cafe8f377 *man/Style.Rd
7432f4de3d7eeac72497bdebce78fa99 *man/StyleFuns.Rd
2c94216969caf6341d74b9ffe80188b7 *man/StyleSummary.Rd
31afdced631cfa0ea225ea80e52f97bb *man/StyleText.Rd
acccbbfbe4b351a6ec2abf0214622580 *man/any-Diff-method.Rd
c6e0d308a833f0f506c82db170574449 *man/as.character-DiffSummary-method.Rd
5520ff92ad10370c9d2e8eaa23ee7301 *man/as.character-MyersMbaSes-method.Rd
9b1924f6d3ed312ae91c66dcaa12c867 *man/auto_context.Rd
42e7cd6e2e963cf61fde825fd0c48b53 *man/console_lines.Rd
70d8fbe6d8a252715546229b7e8a033d *man/diffChr.Rd
7e00f6a3c1b636f73bc29f103e2a550e *man/diffCsv.Rd
977de4f3e0ef7dfced765ae54dfe53b5 *man/diffDeparse.Rd
9e82eaf94e05a4b67ef803aea8e07a88 *man/diffFile.Rd
29916b9909caccb09b666d6a32acbb0c *man/diffObj.Rd
c7221ac49df3ea6b56ca72dcdcee5214 *man/diffPrint.Rd
01a60bfa69539835b8a7b1dbfde0da96 *man/diffStr.Rd
b0f022b9ecc50e339d59999b799bf995 *man/diff_myers.Rd
246ff7707c0b57375841ee6901cc4522 *man/diffobj-package.Rd
e90329bfecacee1de20b87230e5bb8cc *man/diffobj_s4method_doc.Rd
168591e0c6d3f6c40061e5fa5819f724 *man/diffobj_set_def_opts.Rd
504f92f3aa46bf96b5d7ceb9ced1cf39 *man/dimnames-PaletteOfStyles-method.Rd
7925b4c3808f54355ce4a7e27151351b *man/extract-Diff-method.Rd
0152556a38f12fec9826e2486c1b5503 *man/finalizeHtml.Rd
f5950a8e6e9dd92fc80cba49b7e6f753 *man/gdo.Rd
ed1a56df12ea7f95cd3d1a3401b1b761 *man/guides.Rd
e6fe3aeab53db02d9e281856a1895df8 *man/has_Rdiff.Rd
930d757bba96a859bbd528ba95d5056e *man/make_blocking.Rd
00ba016bdea25ea334451371bd616d3c *man/nchar_html.Rd
4f2341110f17057d5df37855d560c188 *man/pager_is_less.Rd
641f6695b008ea98b037ba7542b653f6 *man/par_frame.Rd
cc177a548625a2310c4b1b909f08a6a7 *man/ses.Rd
577dda8d444116bc3d5cd9c76b6dc0b1 *man/show-DiffSummary-method.Rd
6b3cf207b00a94134d319f5bbc1624eb *man/show-PaletteOfStyles-method.Rd
8686528d8af3c214b50ccd8383932e94 *man/show-Style-method.Rd
f6aec61ea0385eb48029f21361b4b36d *man/strip_hz_control.Rd
15e607283f82470ad098506338e6a56e *man/summary-Diff-method.Rd
7b3535e656b8011ff8298db338be16e9 *man/summary-MyersMbaSes-method.Rd
f79eb2ea6757ef2babf636c6222040f6 *man/summary-PaletteOfStyles-method.Rd
089e12b412655819fbd17fba92e02a2c *man/tag_f.Rd
9b8d5ebf572029a14064136e48907d4b *man/trim.Rd
a781aa55007885ab32eafa432f2e0d4d *man/view_or_browse.Rd
9dd8095f89982d2d197f849c9af145d6 *man/webfiles.Rd
4be9e7afc0e49598c44931d45eb41e66 *src/diff.c
2305ce0fbfec00b881bd460e956388d2 *src/diff.h
eea2cb88f3d7f5ab081b4396715c447c *src/diffobj.c
3a4d96a207313f8d062a150984b5b280 *src/diffobj.h
5b752a841b887c1ad5c862eb6679d9f6 *src/init.c
a7b2148e0e6c112c8724679fea3e80e4 *tests/_helper/breakdown.R
fc5f397522504e0bce404a5c2a5246e6 *tests/_helper/check.R
93a11280184e036685a9cd4c24d0ed78 *tests/_helper/commonobjects.R
168a72d71281bdb4c60a4546213dcd1a *tests/_helper/init.R
a45701a8a943fee86e2f7bfea68c554e *tests/_helper/objs/atomic/100.rds
dc3f364393561bd18b20d84286c3b7c7 *tests/_helper/objs/atomic/1000.rds
44c2381df681c732977077f5a46bd25c *tests/_helper/objs/atomic/1100.rds
69f4fa668d1680ac1dccebb25e315e99 *tests/_helper/objs/atomic/1200.rds
0734eca1d4d03680354c5612b93aed88 *tests/_helper/objs/atomic/1250.rds
37c577a82c7968d7997aebe1d3109ca5 *tests/_helper/objs/atomic/1300.rds
34a356139062b436b647f889e3a26a0a *tests/_helper/objs/atomic/1400.rds
e05e4ac9e2ac21a5be7ccf5ba4901412 *tests/_helper/objs/atomic/1425.rds
2432d32ed1495f36c39af5fa71db6a64 *tests/_helper/objs/atomic/1450.rds
ea6141ad68328e262fb39675bebc751b *tests/_helper/objs/atomic/1500.rds
c140a1be8612c04236c9741e044e7f8a *tests/_helper/objs/atomic/1600.rds
b6dc4bc12e54f95aa91224f02ee32bb8 *tests/_helper/objs/atomic/1700.rds
764f2019d89135c633fb547ed4e1a2b0 *tests/_helper/objs/atomic/1800.rds
221588368f319815137723249d330fe7 *tests/_helper/objs/atomic/1900.rds
c2a2f40ec2fb74e3732c84602b3f88f0 *tests/_helper/objs/atomic/200.rds
a74e6e21b9c01c44385949f20db6a701 *tests/_helper/objs/atomic/2000.rds
101109fd4be9f6920e256fa7f4902d42 *tests/_helper/objs/atomic/2100.rds
41fd3b188451f69fd9e1fecb6ca7647d *tests/_helper/objs/atomic/2200.rds
f23316310a5b9a7fc25895065a64c1da *tests/_helper/objs/atomic/2300.rds
2f5942ee3eedc6d18123ffcff4756ce7 *tests/_helper/objs/atomic/2400.rds
f0e8bb15dd4921aec2d0c224c3646234 *tests/_helper/objs/atomic/2500.rds
3f0cd800db66170eef9945861acd15aa *tests/_helper/objs/atomic/2520.rds
fab134028d4d441560b2a6847cae5091 *tests/_helper/objs/atomic/2530.rds
31764b7afd942315de7c9e7436081d93 *tests/_helper/objs/atomic/2540.rds
bfafd46faad18c70b7d7b2e6734ea3a3 *tests/_helper/objs/atomic/2600.rds
da093f2a3ce05c9b4b76c2bb7a9353a1 *tests/_helper/objs/atomic/2700.rds
f4d06103b2b62f64c2b60cfbf4ac4d36 *tests/_helper/objs/atomic/2800.rds
989d1180e3880b221aa73666b60bfd81 *tests/_helper/objs/atomic/2900.rds
7f9785d7bf351f9eee19af77fb04bac2 *tests/_helper/objs/atomic/3000.rds
5d368c9bac8fd272b810a4b15b33fc57 *tests/_helper/objs/atomic/3100.rds
91218647f129ad69cbc6ebd5c7dc172d *tests/_helper/objs/atomic/3200.rds
acb225308bc51c408162ad69a43a6863 *tests/_helper/objs/atomic/3300.rds
c1694e5b8fdec754a52c2b01e747ed7c *tests/_helper/objs/atomic/3400.rds
6ee314755262cba70a6fe4fd2dda4058 *tests/_helper/objs/atomic/400.rds
e5d81a992cfb76c65f2b4676f4cbebf3 *tests/_helper/objs/atomic/500.rds
02e31be899289c97b3a36a6c75ab47a8 *tests/_helper/objs/atomic/600.rds
4fff8918a763c31cd2f3f98e6df53acf *tests/_helper/objs/atomic/700.rds
3e8b6358cb2aa43179319f1bd6228486 *tests/_helper/objs/atomic/800.rds
8357b4e983f364f29582a41bf12ef315 *tests/_helper/objs/atomic/900.rds
48f39fcbb69b8703b42d00c23b2defbd *tests/_helper/objs/common/aaaa.RDS
f6d68e680e822b2808762d45d201b675 *tests/_helper/objs/context/100.rds
5dd71ce40c9679b4c95aaee45c565b37 *tests/_helper/objs/context/100.txt
f198a0849fac7b99820ea6694ed26990 *tests/_helper/objs/context/150.rds
41dc9a5fed17f5ee9d909000195c23e6 *tests/_helper/objs/context/200.rds
54ab37eccc5b0e7fe550ebd5467da5af *tests/_helper/objs/context/200.txt
f28717f7e31485ece3c0f8e2ce032b3f *tests/_helper/objs/context/300.rds
ec95a408b23380dfa98dcd5d44026a0e *tests/_helper/objs/context/400.rds
f00958307411ddfe90d8d45be4a6e917 *tests/_helper/objs/context/500.rds
6ea96d1d9b5da34720d14756cb5aada7 *tests/_helper/objs/diffChr/100.rds
5ea668dd799d006548506ff46c74b738 *tests/_helper/objs/diffChr/100.txt
d85efe2ce8b91e2acde6a2b1363211ca *tests/_helper/objs/diffChr/1000.rds
ca124f8c0b596d37f7a211162f40f018 *tests/_helper/objs/diffChr/1100.rds
f2cbabe3191df5d5e8d74db247af7af3 *tests/_helper/objs/diffChr/1200.rds
805bbf7455cce2d6e79bb5868535d99e *tests/_helper/objs/diffChr/1300.rds
5728b07f03543b472c9e8afe477a4218 *tests/_helper/objs/diffChr/1400.rds
11efd2c5b63c52ebef56eddc809547be *tests/_helper/objs/diffChr/1500.rds
3094895a0ae2a02c3df392b59110131b *tests/_helper/objs/diffChr/200.rds
3f61d4788d843555c01962fe9488f224 *tests/_helper/objs/diffChr/200.txt
c28135ec2ad960124c266f2d8e8f1449 *tests/_helper/objs/diffChr/225.rds
b858eca5629dab83ad71a0ceb4aeaf28 *tests/_helper/objs/diffChr/250.rds
3d5584a86016db6a893cf63a896bbd3d *tests/_helper/objs/diffChr/300.rds
7eec0dc151eacdc33d6fff179ce36d70 *tests/_helper/objs/diffChr/300.txt
a0a3531322d6651912d2b4bfc057fdfb *tests/_helper/objs/diffChr/400.rds
9387a8fc5bcf16bf042f6431a8f3dcc6 *tests/_helper/objs/diffChr/400.txt
14e6ba05956c075bc0dea7a806d1ce11 *tests/_helper/objs/diffChr/500.rds
c20342671fef7075a835980cba0f8878 *tests/_helper/objs/diffChr/500.txt
a7bff3a7d88f4be8a65fecedd1d6707b *tests/_helper/objs/diffChr/600.rds
ad335e2b030a318a911f7ce5b2d81c8c *tests/_helper/objs/diffChr/800.rds
da6d129bc1abde1f32243f14060437e2 *tests/_helper/objs/diffChr/900.rds
a892016365e770595c37c7cfeef280c4 *tests/_helper/objs/diffDeparse/100.rds
a3902e3d7357dc97b3abc4d323046096 *tests/_helper/objs/diffDeparse/200.rds
cfd11512ac2c0336d5f7ae6dcd3952b4 *tests/_helper/objs/diffFile/100.rds
125b7770618cee796f75f11fe42b513f *tests/_helper/objs/diffFile/s.o.30dbe0.R
9752f5d324622b136bad0666714cc101 *tests/_helper/objs/diffFile/s.o.3f1f68.R
1483c33e014566ac7c0307b4f875a190 *tests/_helper/objs/diffObj/100.rds
79eb3fb9a4533231c16a88da7c7e67f1 *tests/_helper/objs/diffObj/200.rds
3d2afca44733f3900578b5139c80ac6e *tests/_helper/objs/diffObj/300.rds
f28316a1fc903d296643e6730589f6de *tests/_helper/objs/diffObj/400.rds
37b17feb793bf07a25b90bea54db8dd5 *tests/_helper/objs/diffPrint/100.rds
85499e94ba78e61b81abb0a18c518aad *tests/_helper/objs/diffPrint/100.txt
60381bf784f270725eaf5f886df2e40f *tests/_helper/objs/diffPrint/1000.rds
c963e95d93e1419329faf4b3e4af8008 *tests/_helper/objs/diffPrint/1100.rds
5e701970a746e1f48a7aabcc27a886e9 *tests/_helper/objs/diffPrint/1200.rds
8f76c594527c84f9c094c41c1e954e15 *tests/_helper/objs/diffPrint/1300.rds
9bd8920b9f7d5e05d30c60d1739e58f5 *tests/_helper/objs/diffPrint/1400.rds
36c801641f202eb148e628da26a0f8bf *tests/_helper/objs/diffPrint/150.rds
90bb138a4f05b20b723cc13de8dfbf2e *tests/_helper/objs/diffPrint/150.txt
07497bf535c796d2b6207f9f0aabb023 *tests/_helper/objs/diffPrint/1500.rds
b2de18480bc61e62e2b4d7e14e00963f *tests/_helper/objs/diffPrint/1600.rds
e4f1b395cb2c812e12de73aaf57eb689 *tests/_helper/objs/diffPrint/1650.rds
31bec83015b12f4212e0a406c5c69923 *tests/_helper/objs/diffPrint/1700.rds
5778a7ce44ff70aa025f16aecb98a047 *tests/_helper/objs/diffPrint/175.rds
0abeac571d16a77cd414bc57c0d528cc *tests/_helper/objs/diffPrint/175.txt
fc035cf2e8ece3effb658e0919d7a9f7 *tests/_helper/objs/diffPrint/1800.rds
5dc5f7ba8f8d8fbc698dc145d0296736 *tests/_helper/objs/diffPrint/1900.rds
eec6a82dfed19356cf0d4f8c6b0dcc8b *tests/_helper/objs/diffPrint/200.rds
73d3abb805eaa7da254c6e46a9369b8d *tests/_helper/objs/diffPrint/200.txt
1be79c5818539f20125ac58eba1dcc44 *tests/_helper/objs/diffPrint/2000.rds
f6969b4e873c2626cba9655fa0ade92f *tests/_helper/objs/diffPrint/2100.rds
f14f24f4387d9ba302727c01c8dca2e6 *tests/_helper/objs/diffPrint/2150.rds
4883764bcc9b13ca249fa1759c2eb0cf *tests/_helper/objs/diffPrint/2200.rds
7acb31232169b734d4fa644446928ab1 *tests/_helper/objs/diffPrint/2250.rds
23e50dc91187ec68ffb8417c962732d2 *tests/_helper/objs/diffPrint/2300.rds
f6969b4e873c2626cba9655fa0ade92f *tests/_helper/objs/diffPrint/2350.rds
fb6e3e28a0fe590afa16470e491b897d *tests/_helper/objs/diffPrint/2370.rds
90f0c8e624026ae3ee09ff6b36af0a7e *tests/_helper/objs/diffPrint/2380.rds
4a8410c083b3f64cc8fce0ff5d3709a3 *tests/_helper/objs/diffPrint/2383.rds
f7adce81326a7bf1b2af4b9db98da099 *tests/_helper/objs/diffPrint/2400.rds
f7adce81326a7bf1b2af4b9db98da099 *tests/_helper/objs/diffPrint/2500.rds
88f94687cb1212e341dd409fef89f60e *tests/_helper/objs/diffPrint/2600.rds
51192ba9a08d8130611189b4b7a99717 *tests/_helper/objs/diffPrint/2700.rds
1462ff7687b98218c6dd5a5d79209fc6 *tests/_helper/objs/diffPrint/2800.rds
0fcf1dbaf973aff32c38642dea659515 *tests/_helper/objs/diffPrint/2900.rds
6428bd1ff765feaf9698cc6693cf1ac0 *tests/_helper/objs/diffPrint/300.rds
7266f76fb2b5f81db8f1c18858399827 *tests/_helper/objs/diffPrint/3000.rds
a35c08e11e8d7c403e3177c13a2d65f9 *tests/_helper/objs/diffPrint/3100.rds
2c958f4965b14694d30335b9f72807bd *tests/_helper/objs/diffPrint/3200.rds
86794d78ccec9b8dc582ab5a346da9b3 *tests/_helper/objs/diffPrint/3300.rds
4d0208a0b608b7d633f662b2092ed896 *tests/_helper/objs/diffPrint/3400.rds
26bb401980e8c6ddc54688448335eb75 *tests/_helper/objs/diffPrint/400.rds
8ba4fe3b4176287a49fc6ae3f6174ea7 *tests/_helper/objs/diffPrint/500.rds
207c5dd85b0c8df263deae230c68a2b2 *tests/_helper/objs/diffPrint/600.rds
f6b17f580422089c84bf2c16cea8579a *tests/_helper/objs/diffPrint/700.rds
cf0a10ed0b7939dfbd33366fbfe353c2 *tests/_helper/objs/diffPrint/800.rds
3732b9b1ed11bd4171627347310ee847 *tests/_helper/objs/diffPrint/900.rds
e1b09bf3fffdaac6189e86f1c49594b0 *tests/_helper/objs/diffStr/100.rds
8f8c0614f6610391dd23827baa721d2b *tests/_helper/objs/diffStr/100.txt
64fc1bd339dd438d0b4dff9fb26c6dbf *tests/_helper/objs/diffStr/1000.rds
d2ca22a1835e41ad7d0b60d1e0b4e252 *tests/_helper/objs/diffStr/1100.rds
0aebb54ccae30a57fa40c9e94d5a0b79 *tests/_helper/objs/diffStr/200.rds
8e82236f5a8dca6179790f610b9162e8 *tests/_helper/objs/diffStr/300.rds
afc2ddbcbb06ad13195f6111d352b141 *tests/_helper/objs/diffStr/400.rds
f16070308563105cd79766fcbe4731ce *tests/_helper/objs/diffStr/500.rds
c3438a71e37e39840f52f78e161941d8 *tests/_helper/objs/diffStr/550.rds
3d2afca44733f3900578b5139c80ac6e *tests/_helper/objs/diffStr/600.rds
60a797bb010593ff574c99320941a5c9 *tests/_helper/objs/diffStr/700.rds
e816514b74dcc98245ed28dcd05b04e6 *tests/_helper/objs/diffStr/800.rds
e816514b74dcc98245ed28dcd05b04e6 *tests/_helper/objs/diffStr/900.rds
81b4d6c860927ce9fe0b389f625f07c8 *tests/_helper/objs/guides/100.rds
9dadb9e30a566f057bb3449ca2e80ea4 *tests/_helper/objs/guides/200.rds
5cc7de0903649ea072c89294f6b8cda2 *tests/_helper/objs/html/100.rds
8b2d8f29e9b5c7e5e4315ec4bc4fa2a3 *tests/_helper/objs/html/200.rds
0143f228fcd903ce6540824af9868cd9 *tests/_helper/objs/html/300.rds
e1c6fae4d07bd0a9baeb86e3fed064b1 *tests/_helper/objs/html/350.rds
9cbccce90aea834d543f4d3742e96aa9 *tests/_helper/objs/html/400.rds
0aa5e953e2838d65352d867d456376e0 *tests/_helper/objs/limit/100.rds
90b9ae355f42a20f7839b2629fa05291 *tests/_helper/objs/limit/1000.rds
d1933542e8052ee44bb0b2ead7dfb387 *tests/_helper/objs/limit/1100.rds
0df077631f4d4c6b14d1479eb952aff5 *tests/_helper/objs/limit/1200.rds
c880da027a5854880a5cc29bb4a0865e *tests/_helper/objs/limit/1300.rds
dbe2410e259a09082784d9180d0e19cb *tests/_helper/objs/limit/200.rds
a95ecffebee4e50cd16d704cf3e3908b *tests/_helper/objs/limit/300.rds
4aaadb0768c247d2e5b10da4c4c9f537 *tests/_helper/objs/limit/500.rds
602b2ac1e4d2c6b523a9b9cf72ca530d *tests/_helper/objs/limit/600.rds
f939bf7d26cef1e59f088084433c10b0 *tests/_helper/objs/limit/700.rds
fb49940c1563c0d7e98eaf2d8acf1655 *tests/_helper/objs/limit/800.rds
df2834bd7e775c21b6c92e385e31d8f4 *tests/_helper/objs/limit/900.rds
162e195ad74eb4044591f87178a884da *tests/_helper/objs/methods/100.rds
a657fc69520a33fd5d0f7a1438b54a73 *tests/_helper/objs/methods/200.rds
ae0c8d3d54ce94d5ae3a529d2f07155f *tests/_helper/objs/pager/100.txt
8ee3d97210bc7915cc9b2dc52381f267 *tests/_helper/objs/pager/200.txt
d41d8cd98f00b204e9800998ecf8427e *tests/_helper/objs/pager/300.txt
d911852c9676e4833578c3bd5f385842 *tests/_helper/objs/style/100.rds
58d7a8816b2b516182879bf23bce19cf *tests/_helper/objs/style/200.rds
b02d528d5d7449feba4d502d68963f5d *tests/_helper/objs/style/300.rds
e78829dfa9acd41cc85022fbddf477f4 *tests/_helper/objs/style/400.rds
784e2b466f53d531e6bcaf9f7f834065 *tests/_helper/objs/style/500.rds
8ae83e9eaf20da0f0cca68fc184226d5 *tests/_helper/objs/summary/100.rds
98dd5589b90754b1c99677b156856280 *tests/_helper/objs/summary/100.txt
963be56fab7538f72248b353af820d9d *tests/_helper/objs/summary/200.rds
54b7fa3e99c02528b6455cf26004d424 *tests/_helper/objs/summary/300.rds
881a4f2d94f2799a11d97b2982fae9de *tests/_helper/objs/summary/400.rds
b8b7c6f80f1df44b42f5be1d379a8d67 *tests/_helper/objs/summary/450.rds
bfa07e2f8ba3c984ded34f47cc4f6441 *tests/_helper/objs/summary/500.rds
2022c580b6d6f555a7ed9e4d4c5d7eef *tests/_helper/objs/summary/600.rds
03683967ab30bcbeb1ab014d91d195ef *tests/_helper/objs/summary/700.rds
e828109ffc70f1d2767db1fa4b40fbdf *tests/_helper/objs/summary/800.rds
466531c9c8c58319d8a123c24cfcfc65 *tests/_helper/objs/summary/900.rds
bffab9bbb20319b1f24862c359640af6 *tests/_helper/objs/trim/100.rds
ab2c9cb8084ef78d1a4ab576f6ef3b77 *tests/_helper/objs/trim/200.rds
720332fc5f81d72cc6cbbd4b01c00bb0 *tests/_helper/objs/trim/300.rds
24167a5223c4095addff43e415899e5d *tests/_helper/objs/trim/50.rds
ef70f577c0ec4ce7513db0b6d5b78e84 *tests/_helper/string-gen.R
92e492f2f93d7e15ad4960863a1950ef *tests/_helper/tools.R
2d807b1c69afa0e80a300abe995341ad *tests/test-atomic.R
5c0756c1d64e779ef985ba6c38129cf2 *tests/test-atomic.Rout.save
2ce53858a1bd4a6affbcc1df5e570979 *tests/test-banner.R
9cdfa96b1f9db77c67bd8f664f479023 *tests/test-banner.Rout.save
ef6090e6b2bfd16295bc1e845d90a288 *tests/test-capture.R
f68fb6459e1b62f9f46dbcf0eade3268 *tests/test-capture.Rout.save
ff8ee6e20161d2b84c58664bea28f8b6 *tests/test-check.R
b052b4296bda795c96bb095752bbe502 *tests/test-check.Rout.save
a0f50f1b2cfd4db3fcdd137e07086803 *tests/test-context.R
033a46f2ae9717814bfc9d0cec370741 *tests/test-context.Rout.save
73ee13c582aeb67c67fd9697ce84f3e3 *tests/test-core.R
3c48c41748b057fbdf006acb2bee7b42 *tests/test-core.Rout.save
7e999d1dfc77cca6dbd57ccf7c5799cc *tests/test-diffChr.R
ce4f5f68765f0ac0239c9d31a4040afa *tests/test-diffChr.Rout.save
df8289564d876b0c3544b5900aae98ba *tests/test-diffDeparse.R
1e9da1500d09c228f6f8c5a0173ebb10 *tests/test-diffDeparse.Rout.save
8eb7cb812f16635b1d9fda98d81ce596 *tests/test-diffObj.R
0623d086cf584a66a56fe2db0c41c9e8 *tests/test-diffObj.Rout.save
4dcb80e502cec9b8ebd7b6a46c027a39 *tests/test-diffPrint.R
d0e9ff2ee8d3ba2e5d639fca96f91197 *tests/test-diffPrint.Rout.save
5a12fff5b0fb6fc0439da47db53fac57 *tests/test-diffStr.R
a2436bf9d2e0ce7df4311931d35c6ae0 *tests/test-diffStr.Rout.save
e0c634149591adda376e29362867b5b4 *tests/test-file.R
af3c4263118fd5b4aecb6cdec3c41138 *tests/test-file.Rout.save
6ef0da46f74a8658f1ed61e32ff98ac3 *tests/test-guide.R
dca94e0dea10450d1050a68d78cc3144 *tests/test-guide.Rout.save
57c322b182dd58a402335ab224d33357 *tests/test-html.R
58e1f53c1f5a7c7e10a20ce7d99fbefe *tests/test-html.Rout.save
e798365dcb28b3eb7bce0764238c8101 *tests/test-limit.R
1c6fbd12c51b2179ac5b1af7331f58d9 *tests/test-limit.Rout.save
92ad4b7e9a893b0e7a9a47a6b9b29271 *tests/test-methods.R
4b3fd6edfdda6ab6e6ea285fa9d98d5f *tests/test-methods.Rout.save
1af2ac3b1e7da77bad705910d328f044 *tests/test-misc.R
3e647672e0516648240e095e55d17eed *tests/test-misc.Rout.save
00ac0f315eb6d3deff28ab18020d7c78 *tests/test-pager.R
e7448b9e0027d9d279d9c9c6900eaccb *tests/test-pager.Rout.save
3aeae69d552f7a1e274964a36f4d3bee *tests/test-rdiff.R
d0677e8a86888c95f451d94122b3c47d *tests/test-rdiff.Rout.save
08c39fb1a5cce37a44c6dc54950a550e *tests/test-s4.R
1c19f34b17256c22ff72ed6c023cb983 *tests/test-s4.Rout.save
6be2b47afa8da5a82e686f67b7804303 *tests/test-scaling.R
fe59891c59b0fce386c7b8e33b032254 *tests/test-ses.R
b41dfd88eb631428064a5267e0688ea0 *tests/test-ses.Rout.save
8768717a5bb91a3743a1a5a380705b78 *tests/test-style.R
01ca69030e0ccb2295c0671d3b0ef4b5 *tests/test-style.Rout.save
940afbdf7933110c7ad5ea55dd9b502b *tests/test-subset.R
3cb6f6da3d85d9e3ef229f5572fc3558 *tests/test-subset.Rout.save
a9259fccca78e0fcab91f4608eb0f6f2 *tests/test-summary.R
e54a8cb65318104247f4d0fecc1d80a7 *tests/test-summary.Rout.save
252573b38413d9a359a49c3d3c03bfb3 *tests/test-text.R
bb8aa18d264f5091a3f505faad0e81e6 *tests/test-text.Rout.save
baea5e403d5277f053053f6a5b7a187d *tests/test-trim.R
dfb718afbd95a673de8a76e7f694c8ab *tests/test-trim.Rout.save
c7d3d4ff89fc984b06596636fab7d469 *tests/test-warnings.R
aae395c15d5d4fa004b7b836da260896 *tests/test-warnings.Rout.save
498f5f1c22d785221998c067e58cc456 *tests/valgrind/mdl-cur-all.txt
3ebdc9637d25ba9ada7fb03ea757a42e *tests/valgrind/mdl-cur.txt
190d0593d9f845f0afa81a7c23789387 *tests/valgrind/mdl-tar-all.txt
8478afde8a5625a16f8f3118ecec2219 *tests/valgrind/mdl-tar.txt
ddad15fc1b4b67a5b3e6cb7e520c2860 *tests/valgrind/tests-valgrind.R
b98a4202bca9af7409da6a63e0622f5d *tests/zz-test-check.R
b2d7b4d93f4eab544203b2d4160e0583 *vignettes/ansi256brightness.png
c50e37261653c146d7542dafab786625 *vignettes/diffobj.Rmd
9e93047aa59973c6475724b83fc6c321 *vignettes/embed.Rmd
53121e5e594fc9814e2f89ebfeeccf28 *vignettes/styles.css
diffobj/inst/ 0000755 0001762 0000144 00000000000 14126723607 012642 5 ustar ligges users diffobj/inst/doc/ 0000755 0001762 0000144 00000000000 14126723607 013407 5 ustar ligges users diffobj/inst/doc/diffobj.R 0000644 0001762 0000144 00000005635 14126723606 015145 0 ustar ligges users ## ---- echo=FALSE--------------------------------------------------------------
library(diffobj)
old.opt <- options(
diffobj.disp.width=80, diffobj.pager="off", diffobj.format="html"
)
## ---- results="asis"----------------------------------------------------------
a <- b <- matrix(1:100, ncol=2)
a <- a[-20,]
b <- b[-45,]
b[c(18, 44)] <- 999
diffPrint(target=a, current=b)
## ---- results="asis", echo=FALSE----------------------------------------------
diffPrint(target=a, current=b)[1]
## ---- results="asis", echo=FALSE----------------------------------------------
diffPrint(target=a, current=b)[2:10]
## ---- results="asis", echo=FALSE----------------------------------------------
diffPrint(target=a, current=b)[3]
## ---- results="asis", echo=FALSE----------------------------------------------
diffPrint(target=a, current=b)[6:9]
## ---- results="asis", echo=FALSE----------------------------------------------
diffPrint(target=a, current=b)[8:9]
## ---- results="asis"----------------------------------------------------------
state.abb2 <- state.abb[-16]
state.abb2[37] <- "Pennsylvania"
diffPrint(state.abb, state.abb2)
## ---- results="asis"----------------------------------------------------------
mdl1 <- lm(Sepal.Length ~ Sepal.Width, iris)
mdl2 <- lm(Sepal.Length ~ Sepal.Width + Species, iris)
diffStr(mdl1$qr, mdl2$qr, line.limit=15)
## ---- results="asis"----------------------------------------------------------
diffChr(letters[1:3], c("a", "B", "c"))
## ---- eval=FALSE--------------------------------------------------------------
# x <- diffPrint(letters, LETTERS)
# x # or equivalently: `show(x)`
## ---- results="asis"----------------------------------------------------------
summary(diffStr(mdl1, mdl2))
## ---- results="asis", eval=FALSE----------------------------------------------
# x <- y <- letters[24:26]
# y[2] <- "GREMLINS"
# diffChr(x, y)
## ---- results="asis", echo=FALSE----------------------------------------------
x <- y <- letters[24:26]
y[2] <- "GREMLINS"
diffChr(x, y, mode="sidebyside")
## ---- results="asis", echo=FALSE----------------------------------------------
x <- y <- letters[24:26]
y[2] <- "GREMLINS"
diffChr(x, y, mode="unified")
## ---- results="asis", echo=FALSE----------------------------------------------
x <- y <- letters[24:26]
y[2] <- "GREMLINS"
diffChr(x, y, mode="context")
## ---- results="asis"----------------------------------------------------------
diffChr(x, y, color.mode="rgb")
## ---- eval=FALSE--------------------------------------------------------------
# v1 <- 1:5e4
# v2 <- v1[-sample(v1, 100)]
# diffChr(v1, v2, word.diff=FALSE)
## ---- eval=FALSE--------------------------------------------------------------
# diffPrint(v1, v2)
## -----------------------------------------------------------------------------
ses(letters[1:5], letters[c(2:3, 5)])
## ---- echo=FALSE--------------------------------------------------------------
options(old.opt)
diffobj/inst/doc/embed.html 0000644 0001762 0000144 00000077676 14126723607 015400 0 ustar ligges users
Embed Diffs in R Markdown Or Shiny
Embed Diffs in R Markdown Or Shiny
Brodie Gaslam
Rmarkdown
Basic Requirements
Any R chunks that produce diffs should include the results='asis' option, e.g.:
```{r, comment="", results="asis"}
# R code here
```
Embedded CSS
This is what a basic code block should look like:
```{r, comment="", results="asis"}
cat( # output to screen
as.character( # convert to diff to character vector
diffPrint( # run diff
1:5, 2:6,
format="html", # specify html output
style=list(
html.output="diff.w.style" # configure html style
)
) ) )
```
Here we use this same code as an actual markdown R code block:
@@ 1 @@@@ 1 @@< [1] 1 2 3 4 5> [1] 2 3 4 5 6
This is an ugly implementation because it produces illegal HTML. The styles are directly embedded in the body of the document, outside of the HEAD tags. Although this is illegal HTML, it seems to work in most browsers. Another problem is that every diff you use in your document will inject the same CSS code over and over.
External CSS
A better option is to provide the CSS directly by modifying the output portion of the YAML header:
---
output:
rmarkdown::html_vignette:
toc: true
css: !expr diffobj::diffobj_css()
---
In reality you will probably want to specify multiple CSS files, including the original rmarkdown one:
---
output:
rmarkdown::html_vignette:
toc: true
css:
- !expr diffobj::diffobj_css()
- !expr system.file("rmarkdown", "templates", "html_vignette", "resources", "vignette.css", package = "rmarkdown")
---
Once you set this up then you can use:
cat(
as.character(
diffPrint(
1:5, 2:6,
format="html",
style=list(html.output="diff.only") # notice this changed
) ) )
@@ 1 @@@@ 1 @@< [1] 1 2 3 4 5> [1] 2 3 4 5 6
This will omit the CSS, but since we include it via the YAML everything should work as expected.
Use Options
Almost all diffobj parameters can be specified via options:
Then you can just run the diff as normal:
@@ 1 @@@@ 1 @@< [1] 1 2 3 4 5> [1] 2 3 4 5 6
Shiny
Shiny usage is very similar to rmarkdown. In both cases we want to get diffobj to produce HTML output to embed in our document. If we are willing to embed the CSS with each diff, we can use:
library(shiny)
shinyApp(
ui=fluidPage(htmlOutput('diffobj_element')),
server=function(input, output) {
output$diffobj_element <- renderUI({
HTML(
as.character(
diffPrint(
1:5, 2:6,
format="html",
style=list(html.output="diff.w.style")
) ) )}) } )
If we have many diffs, it may be preferable to use options and external style sheet:
options(
diffobj.format="html",
diffobj.style=list(html.output="diff.only")
)
shinyApp(
ui=fluidPage(
includeCSS(diffobj_css()),
htmlOutput('diffobj_element')
),
server=function(input, output) {
output$diffobj_element <- renderUI({
HTML(as.character(diffPrint(1:5, 2:6,)))
}) } )
Unlike with our rmarkdown example, this CSS is included in the body of the HTML document instead of in the header, so it is technically illegal like in our embedded css example.
diffobj/inst/doc/embed.Rmd 0000755 0001762 0000144 00000010132 13420351310 015107 0 ustar ligges users ---
title: "Embed Diffs in R Markdown Or Shiny"
author: "Brodie Gaslam"
output:
rmarkdown::html_vignette:
toc: true
css:
- !expr diffobj::diffobj_css()
- styles.css
vignette: >
%\VignetteIndexEntry{Embed Diffs in R Markdown Or Shiny}
%\VignetteEngine{knitr::rmarkdown}
\usepackage[utf8]{inputenc}
---
```{r echo=FALSE}
library(diffobj)
```
## Rmarkdown
### Basic Requirements
Any R chunks that produce diffs should include the `results='asis'` option,
e.g.:
````
```{r, comment="", results="asis"}`r ''`
# R code here
```
````
### Embedded CSS
This is what a basic code block should look like:
````
```{r, comment="", results="asis"}`r ''`
cat( # output to screen
as.character( # convert to diff to character vector
diffPrint( # run diff
1:5, 2:6,
format="html", # specify html output
style=list(
html.output="diff.w.style" # configure html style
)
) ) )
```
````
Here we use this same code as an actual markdown R code block:
```{r results='asis'}
cat(
as.character(
diffPrint(
1:5, 2:6,
format="html",
style=list(html.output="diff.w.style")
) ) )
```
This is an ugly implementation because it produces illegal HTML. The styles are
directly embedded in the body of the document, outside of the HEAD tags.
Although this is illegal HTML, it seems to work in most browsers. Another
problem is that every diff you use in your document will inject the same CSS
code over and over.
### External CSS
A better option is to provide the CSS directly by modifying the `output`
portion of the [YAML
header](https://bookdown.org/yihui/rmarkdown/r-package-vignette.html):
```
---
output:
rmarkdown::html_vignette:
toc: true
css: !expr diffobj::diffobj_css()
---
```
In reality you will probably want to specify multiple CSS files, including the
original `rmarkdown` one:
```
---
output:
rmarkdown::html_vignette:
toc: true
css:
- !expr diffobj::diffobj_css()
- !expr system.file("rmarkdown", "templates", "html_vignette", "resources", "vignette.css", package = "rmarkdown")
---
```
Once you set this up then you can use:
```{r results='asis'}
cat(
as.character(
diffPrint(
1:5, 2:6,
format="html",
style=list(html.output="diff.only") # notice this changed
) ) )
```
This will omit the CSS, but since we include it via the YAML everything should
work as expected.
### Use Options
Almost all `diffobj` parameters can be specified via options:
```{r eval=FALSE}
options(
diffobj.format="html",
diffobj.style=list(html.output="diff.only")
)
```
```{r echo=FALSE}
old.opts <- options(
diffobj.format="html",
diffobj.style=list(html.output="diff.only")
)
```
Then you can just run the diff as normal:
```{r results='asis'}
cat(as.character(diffPrint(1:5, 2:6)))
```
```{r echo=FALSE}
options(old.opts)
```
## Shiny
Shiny usage is very similar to `rmarkdown`. In both cases we want to get
`diffobj` to produce HTML output to embed in our document. If we are willing to
embed the CSS with each diff, we can use:
```{r, eval=FALSE}
library(shiny)
shinyApp(
ui=fluidPage(htmlOutput('diffobj_element')),
server=function(input, output) {
output$diffobj_element <- renderUI({
HTML(
as.character(
diffPrint(
1:5, 2:6,
format="html",
style=list(html.output="diff.w.style")
) ) )}) } )
```
If we have many diffs, it may be preferable to use options and external
style sheet:
```{r, eval=FALSE}
options(
diffobj.format="html",
diffobj.style=list(html.output="diff.only")
)
shinyApp(
ui=fluidPage(
includeCSS(diffobj_css()),
htmlOutput('diffobj_element')
),
server=function(input, output) {
output$diffobj_element <- renderUI({
HTML(as.character(diffPrint(1:5, 2:6,)))
}) } )
```
Unlike with our [rmarkdown example](#external-css), this CSS is included
in the body of the HTML document instead of in the header, so it is technically
illegal like in our [embedded css example](#embedded-css).
diffobj/inst/doc/embed.R 0000644 0001762 0000144 00000003657 14126723607 014621 0 ustar ligges users ## ----echo=FALSE---------------------------------------------------------------
library(diffobj)
## ----results='asis'-----------------------------------------------------------
cat(
as.character(
diffPrint(
1:5, 2:6,
format="html",
style=list(html.output="diff.w.style")
) ) )
## ----results='asis'-----------------------------------------------------------
cat(
as.character(
diffPrint(
1:5, 2:6,
format="html",
style=list(html.output="diff.only") # notice this changed
) ) )
## ----eval=FALSE---------------------------------------------------------------
# options(
# diffobj.format="html",
# diffobj.style=list(html.output="diff.only")
# )
## ----echo=FALSE---------------------------------------------------------------
old.opts <- options(
diffobj.format="html",
diffobj.style=list(html.output="diff.only")
)
## ----results='asis'-----------------------------------------------------------
cat(as.character(diffPrint(1:5, 2:6)))
## ----echo=FALSE---------------------------------------------------------------
options(old.opts)
## ---- eval=FALSE--------------------------------------------------------------
# library(shiny)
# shinyApp(
# ui=fluidPage(htmlOutput('diffobj_element')),
# server=function(input, output) {
# output$diffobj_element <- renderUI({
# HTML(
# as.character(
# diffPrint(
# 1:5, 2:6,
# format="html",
# style=list(html.output="diff.w.style")
# ) ) )}) } )
## ---- eval=FALSE--------------------------------------------------------------
# options(
# diffobj.format="html",
# diffobj.style=list(html.output="diff.only")
# )
# shinyApp(
# ui=fluidPage(
# includeCSS(diffobj_css()),
# htmlOutput('diffobj_element')
# ),
# server=function(input, output) {
# output$diffobj_element <- renderUI({
# HTML(as.character(diffPrint(1:5, 2:6,)))
# }) } )
diffobj/inst/doc/diffobj.html 0000644 0001762 0000144 00000461401 14126723606 015705 0 ustar ligges users
diffobj - Diffs for R Objects
diffobj - Diffs for R Objects
Brodie Gaslam
Introduction
diffobj uses the same comparison mechanism used by git diff and diff to highlight differences between rendered R objects:
a <- b <- matrix(1:100, ncol=2)
a <- a[-20,]
b <- b[-45,]
b[c(18, 44)] <- 999
diffPrint(target=a, current=b)
@@ 17,6 @@@@ 17,7 @@~ [,1] [,2]~ [,1] [,2] [16,] 16 66 [16,] 16 66 [17,] 17 67 [17,] 17 67< [18,] 18 68> [18,] 999 68 [19,] 19 69 [19,] 19 69~ > [20,] 20 70 [20,] 21 71 [21,] 21 71 [21,] 22 72 [22,] 22 72@@ 42,6 @@@@ 43,5 @@ [41,] 42 92 [42,] 42 92 [42,] 43 93 [43,] 43 93< [43,] 44 94> [44,] 999 94< [44,] 45 95~ [45,] 46 96 [45,] 46 96 [46,] 47 97 [46,] 47 97
diffobj comparisons work best when objects have some similarities, or when they are relatively small. The package was originally developed to help diagnose failed unit tests by comparing test results to reference objects in a human-friendly manner.
If your terminal supports formatting through ANSI escape sequences, diffobj will output colored diffs to the terminal. If not, it will output colored diffs to your IDE viewport if it is supported, or to your browser otherwise.
Interpreting Diffs
Shortest Edit Script
The output from diffobj is a visual representation of the Shortest Edit Script (SES). An SES is the shortest set of deletion and insertion instructions for converting one sequence of elements into another. In our case, the elements are lines of text. We encode the instructions to convert a to b by deleting lines from a (in yellow) and inserting new ones from b (in blue).
Diff Structure
The first line of our diff output acts as a legend to the diff by associating the colors and symbols used to represent differences present in each object with the name of the object:
After the legend come the hunks, which are portions of the objects that have differences with nearby matching lines provided for context:
@@ 17,6 @@@@ 17,7 @@~ [,1] [,2]~ [,1] [,2] [16,] 16 66 [16,] 16 66 [17,] 17 67 [17,] 17 67< [18,] 18 68> [18,] 999 68 [19,] 19 69 [19,] 19 69~ > [20,] 20 70 [20,] 21 71 [21,] 21 71 [21,] 22 72 [22,] 22 72
At the top of the hunk is the hunk header: this tells us that the first displayed hunk (including context lines), starts at line 17 and spans 6 lines for a and 7 for b. These are display lines, not object row indices, which is why the first row shown of the matrix is row 16. You might have also noticed that the line after the hunk header is out of place:
~ [,1] [,2]~ [,1] [,2]
This is a special context line that is not technically part of the hunk, but is shown nonetheless because it is useful in helping understand the data. The line is styled differently to highlight that it is not part of the hunk. Since it is not part of the hunk, it is not accounted for in the hunk header. See ?guideLines for more details.
The actual mismatched lines are highlighted in the colors of the legend, with additional visual cues in the gutters:
< [18,] 18 68> [18,] 999 68 [19,] 19 69 [19,] 19 69~ > [20,] 20 70 [20,] 21 71 [21,] 21 71
diffobj uses a line by line diff to identify which portions of each of the objects are mismatches, so even if only part of a line mismatches it will be considered different. diffobj then runs a word diff within the hunks and further highlights mismatching words.
Let’s examine the last two lines from the previous hunk more closely:
~ > [20,] 20 70 [20,] 21 71 [21,] 21 71
Here b has an extra line so diffobj adds an empty line to a to maintain the alignment for subsequent matching lines. This additional line is marked with a tilde in the gutter and is shown in a different color to indicate it is not part of the original text.
If you look closely at the next matching line you will notice that the a and b values are not exactly the same. The row indices are different, but diffobj excludes row indices from the diff so that rows that are identical otherwise are shown as matching. diffobj indicates this is happening by showing the portions of a line that are ignored in the diff in grey.
See ?guides and ?trim for details and limitations on guideline detection and unsemantic meta data trimming.
Atomic Vectors
Since R can display multiple elements in an atomic vector on the same line, and diffPrint is fundamentally a line diff, we use specialized logic when diffing atomic vectors. Consider:
@@ 1,5 @@@@ 6,5 @@ [1] "AL" "AK" "AZ" "AR" "CA" "CO" [11] "HI" "ID" [7] "CT" "DE" "FL" "GA" "HI" "ID" [13] "IL" "IN" < [13] "IL" "IN" "IA" "KS" "KY" "LA"> [15] "IA" "KY" [19] "ME" "MD" "MA" "MI" "MN" "MS" [17] "LA" "ME" [25] "MO" "MT" "NE" "NV" "NH" "NJ" [19] "MD" "MA" @@ 6,4 @@@@ 17,5 @@~ [33] "ND" "OH" [31] "NM" "NY" "NC" "ND" "OH" "OK" [35] "OK" "OR" < [37] "OR" "PA" "RI" "SC" "SD" "TN"> [37] "Pennsylvania" "RI" [43] "TX" "UT" "VT" "VA" "WA" "WV" [39] "SC" "SD" [49] "WI" "WY" [41] "TN" "TX"
Due to the different wrapping frequency no line in the text display of our two vectors matches. Despite this, diffPrint only highlights the lines that actually contain differences. The side effect is that lines that only contain matching elements are shown as matching even though the actual lines may be different. You can turn off this behavior in favor of a normal line diff with the unwrap.atomic argument to diffPrint.
Currently this only works for unnamed vectors, and even for them some inputs may produce sub-optimal results. Nested vectors inside lists will not be unwrapped. You can also use diffChr (see below) to do a direct element by element comparison.
Other Diff Functions
Method Overview
diffobj defines several S4 generics and default methods to go along with them. Each of them uses a different text representation of the inputs:
diffPrint: use the print/show output and is the one used in the examples so fardiffStr: use the output of strdiffObj: picks between print/show and str depending on which provides the “best” overview of differencesdiffChr: coerces the inputs to atomic character vectors with as.character, and runs the diff on the character vectordiffFile: compares the text content of two filesdiffCsv: loads two CSV files into data frames and compares the data frames with diffPrintdiffDeparse: deparses and compares the character vectors produced by the deparsingses: computes the element by element shortest edit script on two character vectors
Note the diff* functions use lowerCamelCase in keeping with S4 method name convention, whereas the package name itself is all lower case.
Compare Structure with diffStr
For complex objects it is often useful to compare structures:
mdl1 <- lm(Sepal.Length ~ Sepal.Width, iris)
mdl2 <- lm(Sepal.Length ~ Sepal.Width + Species, iris)
diffStr(mdl1$qr, mdl2$qr, line.limit=15)
@@ 1,9 @@@@ 1,10 @@ List of 5 List of 5< $ qr : num [1:150, 1:2] -12.2474 0.0816 0.0816 0.0816 0.0816 ...> $ qr : num [1:150, 1:4] -12.2474 0.0816 0.0816 0.0816 0.0816 ... ..- attr(*, "dimnames")=List of 2 ..- attr(*, "dimnames")=List of 2< ..- attr(*, "assign")= int [1:2] 0 1> ..- attr(*, "assign")= int [1:4] 0 1 2 2~ > ..- attr(*, "contrasts")=List of 1< $ qraux: num [1:2] 1.08 1.02> $ qraux: num [1:4] 1.08 1.02 1.05 1.11< $ pivot: int [1:2] 1 2> $ pivot: int [1:4] 1 2 3 4 $ tol : num 1e-07 $ tol : num 1e-07< $ rank : int 2> $ rank : int 4 - attr(*, "class")= chr "qr" - attr(*, "class")= chr "qr"3 differences are hidden by our use of `max.level`
If you specify a line.limit with diffStr it will fold nested levels in order to fit under line.limit so long as there remain visible differences. If you prefer to see all the differences you can leave line.limit unspecified.
Compare Vectors Elements with diffChr
Sometimes it is useful to do a direct element by element comparison:
@@ 1,3 @@@@ 1,3 @@ a a< b> B c c
Notice how we are comparing the contents of the vectors with one line per element.
Why S4?
The diff* functions are defined as S4 generics with default methods (signature c("ANY", "ANY")) so that users can customize behavior for their own objects. For example, a custom method could set many of the default parameters to values more suitable for a particular object. If the objects in question are S3 objects the S3 class will have to be registered with setOldClass.
Return Value
All the diff* methods return a Diff S4 object. It has a show method which is responsible for rendering the Diff and displaying it to the screen. Because of this you can compute and render diffs in two steps:
This may cause the diff to render funny if you change screen widths, etc., between the two steps.
There are also summary, any, and as.character methods. The summary method provides a high level overview of where the differences are, which can be helpful for large diffs:
Found differences in 12 hunks:45 insertions, 39 deletions, 18 matches (lines)
Diff map (line:char scale is 1:1 for single chars, 1-2:1 for char seqs):DDDIII.DDDIII.DI.DI..DDDIIIII.DI.DDDDDIIIIIII.DDDIII..DDDIII..DDIII.DDDIII..DDII.
any returns TRUE if there are differences, and as.character returns the character representation of the diff.
Controlling Diffs and Their Appearance
Parameters
The diff* family of methods has an extensive set of parameters that allow you to fine tune how the diff is applied and displayed. We will review some of the major ones in this section. For a full description see ?diffPrint.
While the parameter list is extensive, only the objects being compared are required. All the other parameters have default values, and most of them are for advanced use only. The defaults can all be adjusted via the diffobj.* options.
Display Mode
There are three built-in display modes that are similar to those found in GNU diff: “sidebyside”, “unified”, and “context”. For example, by varying the mode parameter with:
we get:
mode=“sidebyside”
mode=“unified”
mode=“context”
@@ 1,3 @@@@ 1,3 @@ x x< y> GREMLINS z z
@@ 1,3 / 1,3 @@ x< y> GREMLINS z
@@ 1,3 / 1,3 @@ x< y z~ ---------- x> GREMLINS z
By default diffobj will try to use mode="sidebyside" if reasonable given display width, and otherwise will switch to mode="unified". You can always force a particular display style by specifying it with the mode argument.
Color Mode
The default color mode uses yellow and blue to symbolize deletions and insertions for accessibility to dichromats. If you prefer the more traditional color mode you can specify color.mode="rgb" in the parameter list, or use options(diffobj.color.mode="rgb"):
@@ 1,3 @@@@ 1,3 @@ x x< y> GREMLINS z z
Output Formats
If your terminal supports it diffobj will format the output with ANSI escape sequences. diffobj uses Gábor Csárdi’s crayon package to detect ANSI support and to apply ANSI based formatting. If you are using RStudio or another IDE that supports getOption("viewer"), diffobj will output an HTML/CSS formatted diff to the viewport. In other terminals that do not support ANSI colors, diffobj will attempt to output to an HTML/CSS formatted diff to your browser using browseURL.
You can explicitly specify the output format with the format parameter:
format="raw" for unformatted diffsformat="ansi8" for standard ANSI 8 color formattingformat="ansi256" for ANSI 256 color formattingformat="html" for HTML/CSS output and styling
See Pagers for more details.
Brightness
The brightness parameter allows you to pick a color scheme compatible with the background color of your terminal. The options are:
- “light”: for use with light tone terminals
- “dark”: for use with dark tone terminals
- “neutral”: for use with either light or dark terminals
Here are examples of terminal screen renderings for both “rgb” and “yb” color.mode for the three brightness levels.
The examples for “light” and “dark” have the backgrounds forcefully set to a color compatible with the scheme. In actual use the base background and foreground colors are left unchanged, which will look bad if you use “dark” with light colored backgrounds or vice versa. Since we do not know of a good cross platform way of detecting terminal background color the default brightness value is “neutral”.
At this time the only format that is affected by this parameter is “ansi256”. If you want to specify your own light/dark/neutral schemes you may do so either by specifying a style directly or with Palette of Styles.
Pagers
In interactive mode, if the diff output is very long or if your terminal does not support ANSI colors, diff* methods will pipe output to a pager. This is done by writing the output to a temporary file and passing the file reference to the pager. The default action is to invoke the pager with file.show if your terminal supports ANSI colors and the pager is known to support ANSI colors as well (as of this writing, only less is assumed to support ANSI colors), or if not to use getOption("viewer") if available (this outputs to the viewport in RStudio), or if not to use browseURL.
You can fine tune when, how, and if a pager is used with the pager parameter. See ?diffPrint and ?Pager for more details.
Styles
You can control almost all aspects of the diff output formatting via the style parameter. To do so, pass an appropriately configured Style object. See ?Style for more details on how to do this.
The default is to auto pick a style based on the values of the format, color.mode, and brightness parameters. This is done by using the computed values for each of those parameters to subset the PaletteOfStyles object passed as the palette.of.styles parameter. This PaletteOfStyles object contains a Style object for all the possible permutations of the style, format, and color.mode parameters. See ?PaletteOfStyles.
If you specify the style parameter the values of the format, brightness, and color.mode parameters will be ignored.
Diff Algorithm
The primary diff algorithm is Myer’s solution to the shortest edit script / longest common sequence problem with the Hirschberg linear space refinement as described in:
E. Myers, “An O(ND) Difference Algorithm and Its Variations”, Algorithmica 1, 2 (1986), 251-266.
and should be the same algorithm used by GNU diff. The implementation used here is a heavily modified version of Michael B. Allen’s diff program from the libmba C library. Any and all bugs in the C code in this package were most likely introduced by yours truly. Please note that the resulting C code is incompatible with the original libmba library.
Performance Considerations
Diff
The diff algorithm scales with the square of the number of differences. For reasonably small diffs (< 10K differences), the diff itself is unlikely to be the bottleneck.
Capture and Processing
Capture of inputs for diffPrint and diffStr, and processing of output for all diff* methods will account for most of the execution time unless you have large numbers of differences. This input and output processing scales mostly linearly with the input size.
You can improve performance somewhat by using diffChr since that skips the capture part, and by turning off word.diff:
will be ~2x as fast as:
Note: turning off word.diff when using diffPrint with unnamed atomic vectors can actually slow down the diff because there may well be fewer element by element differences than line differences as displayed. For example, when comparing 1:1e6 to 2:1e6 there is only one element difference, but every line as displayed is different because of the shift. Using word.diff=TRUE (and unwrap.atomic=TRUE) allows diffPrint to compare element by element rather than line by line. diffChr always compares element by element.
Minimal Diff
If you are looking for the fastest possible diff you can use ses and completely bypass most input and output processing. Inputs will be coerced to character if they are not character.
## [1] "1d0" "4d2"
This will be 10-20x faster than diffChr, at the cost of less useful output.
diffobj/inst/doc/diffobj.Rmd 0000755 0001762 0000144 00000037341 13777704534 015502 0 ustar ligges users ---
title: "diffobj - Diffs for R Objects"
author: "Brodie Gaslam"
output:
rmarkdown::html_vignette:
toc: true
css:
- !expr diffobj::diffobj_css()
- styles.css
vignette: >
%\VignetteIndexEntry{Introduction to Diffobj}
%\VignetteEngine{knitr::rmarkdown}
\usepackage[utf8]{inputenc}
---
```{r, echo=FALSE}
library(diffobj)
old.opt <- options(
diffobj.disp.width=80, diffobj.pager="off", diffobj.format="html"
)
```
## Introduction
`diffobj` uses the same comparison mechanism used by `git diff` and `diff` to highlight differences between _rendered_ R objects:
```{r, results="asis"}
a <- b <- matrix(1:100, ncol=2)
a <- a[-20,]
b <- b[-45,]
b[c(18, 44)] <- 999
diffPrint(target=a, current=b)
```
`diffobj` comparisons work best when objects have some similarities, or when they are relatively small. The package was originally developed to help diagnose failed unit tests by comparing test results to reference objects in a human-friendly manner.
If your terminal supports formatting through ANSI escape sequences, `diffobj` will output colored diffs to the terminal. If not, it will output colored diffs to your IDE viewport if it is supported, or to your browser otherwise.
## Interpreting Diffs
### Shortest Edit Script
The output from `diffobj` is a visual representation of the Shortest Edit Script (SES). An SES is the shortest set of deletion and insertion instructions for converting one sequence of elements into another. In our case, the elements are lines of text. We encode the instructions to convert `a` to `b` by deleting lines from `a` (in yellow) and inserting new ones from `b` (in blue).
### Diff Structure
The first line of our diff output acts as a legend to the diff by associating the colors and symbols used to represent differences present in each object with the name of the object:
```{r, results="asis", echo=FALSE}
diffPrint(target=a, current=b)[1]
```
After the legend come the hunks, which are portions of the objects that have differences with nearby matching lines provided for context:
```{r, results="asis", echo=FALSE}
diffPrint(target=a, current=b)[2:10]
```
At the top of the hunk is the hunk header: this tells us that the first displayed hunk (including context lines), starts at line 17 and spans 6 lines for `a` and 7 for `b`. These are display lines, not object row indices, which is why the first row shown of the matrix is row 16. You might have also noticed that the line after the hunk header is out of place:
```{r, results="asis", echo=FALSE}
diffPrint(target=a, current=b)[3]
```
This is a special context line that is not technically part of the hunk, but is shown nonetheless because it is useful in helping understand the data. The line is styled differently to highlight that it is not part of the hunk. Since it is not part of the hunk, it is not accounted for in the hunk header. See `?guideLines` for more details.
The actual mismatched lines are highlighted in the colors of the legend, with additional visual cues in the gutters:
```{r, results="asis", echo=FALSE}
diffPrint(target=a, current=b)[6:9]
```
`diffobj` uses a line by line diff to identify which portions of each of the objects are mismatches, so even if only part of a line mismatches it will be considered different. `diffobj` then runs a word diff within the hunks and further highlights mismatching words.
Let's examine the last two lines from the previous hunk more closely:
```{r, results="asis", echo=FALSE}
diffPrint(target=a, current=b)[8:9]
```
Here `b` has an extra line so `diffobj` adds an empty line to `a` to maintain the alignment for subsequent matching lines. This additional line is marked with a tilde in the gutter and is shown in a different color to indicate it is not part of the original text.
If you look closely at the next matching line you will notice that the `a` and `b` values are not exactly the same. The row indices are different, but `diffobj` excludes row indices from the diff so that rows that are identical otherwise are shown as matching. `diffobj` indicates this is happening by showing the portions of a line that are ignored in the diff in grey.
See `?guides` and `?trim` for details and limitations on guideline detection and
unsemantic meta data trimming.
### Atomic Vectors
Since R can display multiple elements in an atomic vector on the same line, and `diffPrint` is fundamentally a line diff, we use specialized logic when diffing atomic vectors. Consider:
```{r, results="asis"}
state.abb2 <- state.abb[-16]
state.abb2[37] <- "Pennsylvania"
diffPrint(state.abb, state.abb2)
```
Due to the different wrapping frequency no line in the text display of our two vectors matches. Despite this, `diffPrint` only highlights the lines that actually contain differences. The side effect is that lines that only contain matching elements are shown as matching even though the actual lines may be different. You can turn off this behavior in favor of a normal line diff with the `unwrap.atomic` argument to `diffPrint`.
Currently this only works for _unnamed_ vectors, and even for them some inputs
may produce sub-optimal results. Nested vectors inside lists will not be
unwrapped. You can also use `diffChr` (see below) to do a direct element by
element comparison.
## Other Diff Functions
### Method Overview
`diffobj` defines several S4 generics and default methods to go along with them. Each of them uses a different text representation of the inputs:
* `diffPrint`: use the `print`/`show` output and is the one used in the examples so far
* `diffStr`: use the output of `str`
* `diffObj`: picks between `print`/`show` and `str` depending on which provides the "best" overview of differences
* `diffChr`: coerces the inputs to atomic character vectors with `as.character`, and runs the diff on the character vector
* `diffFile`: compares the text content of two files
* `diffCsv`: loads two CSV files into data frames and compares the data frames with `diffPrint`
* `diffDeparse`: deparses and compares the character vectors produced by the deparsing
* `ses`: computes the element by element shortest edit script on two character vectors
Note the `diff*` functions use lowerCamelCase in keeping with S4 method name convention, whereas the package name itself is all lower case.
### Compare Structure with `diffStr`
For complex objects it is often useful to compare structures:
```{r, results="asis"}
mdl1 <- lm(Sepal.Length ~ Sepal.Width, iris)
mdl2 <- lm(Sepal.Length ~ Sepal.Width + Species, iris)
diffStr(mdl1$qr, mdl2$qr, line.limit=15)
```
If you specify a `line.limit` with `diffStr` it will fold nested levels in order to fit under `line.limit` so long as there remain visible differences. If you prefer to see all the differences you can leave `line.limit` unspecified.
### Compare Vectors Elements with `diffChr`
Sometimes it is useful to do a direct element by element comparison:
```{r, results="asis"}
diffChr(letters[1:3], c("a", "B", "c"))
```
Notice how we are comparing the contents of the vectors with one line per element.
### Why S4?
The `diff*` functions are defined as S4 generics with default methods (signature `c("ANY", "ANY")`) so that users can customize behavior for their own objects. For example, a custom method could set many of the default parameters to values more suitable for a particular object. If the objects in question are S3 objects the S3 class will have to be registered with `setOldClass`.
### Return Value
All the `diff*` methods return a `Diff` S4 object. It has a `show` method which is responsible for rendering the `Diff` and displaying it to the screen. Because of this you can compute and render diffs in two steps:
```{r, eval=FALSE}
x <- diffPrint(letters, LETTERS)
x # or equivalently: `show(x)`
```
This may cause the diff to render funny if you change screen widths, etc., between the two steps.
There are also `summary`, `any`, and `as.character` methods. The `summary` method provides a high level overview of where the differences are, which can be helpful for large diffs:
```{r, results="asis"}
summary(diffStr(mdl1, mdl2))
```
`any` returns TRUE if there are differences, and `as.character` returns the character representation of the diff.
## Controlling Diffs and Their Appearance
### Parameters
The `diff*` family of methods has an extensive set of parameters that allow you to fine tune how the diff is applied and displayed. We will review some of the major ones in this section. For a full description see `?diffPrint`.
While the parameter list is extensive, only the objects being compared are required. All the other parameters have default values, and most of them are for advanced use only. The defaults can all be adjusted via the `diffobj.*` options.
### Display Mode
There are three built-in display modes that are similar to those found in GNU `diff`: "sidebyside", "unified", and "context". For example, by varying the `mode` parameter with:
```{r, results="asis", eval=FALSE}
x <- y <- letters[24:26]
y[2] <- "GREMLINS"
diffChr(x, y)
```
we get:
mode="sidebyside" mode="unified" mode="context"
```{r, results="asis", echo=FALSE}
x <- y <- letters[24:26]
y[2] <- "GREMLINS"
diffChr(x, y, mode="sidebyside")
```
```{r, results="asis", echo=FALSE}
x <- y <- letters[24:26]
y[2] <- "GREMLINS"
diffChr(x, y, mode="unified")
```
```{r, results="asis", echo=FALSE}
x <- y <- letters[24:26]
y[2] <- "GREMLINS"
diffChr(x, y, mode="context")
```
By default `diffobj` will try to use `mode="sidebyside"` if reasonable given display width, and otherwise will switch to `mode="unified"`. You can always force a particular display style by specifying it with the `mode` argument.
### Color Mode
The default color mode uses yellow and blue to symbolize deletions and insertions for accessibility to dichromats. If you prefer the more traditional color mode you can specify `color.mode="rgb"` in the parameter list, or use `options(diffobj.color.mode="rgb")`:
```{r, results="asis"}
diffChr(x, y, color.mode="rgb")
```
### Output Formats
If your terminal supports it `diffobj` will format the output with ANSI escape sequences. `diffobj` uses Gábor Csárdi's [`crayon`](https://github.com/r-lib/crayon) package to detect ANSI support and to apply ANSI based formatting. If you are using RStudio or another IDE that supports `getOption("viewer")`, `diffobj` will output an HTML/CSS formatted diff to the viewport. In other terminals that do not support ANSI colors, `diffobj` will attempt to output to an HTML/CSS formatted diff to your browser using `browseURL`.
You can explicitly specify the output format with the `format` parameter:
* `format="raw"` for unformatted diffs
* `format="ansi8"` for standard ANSI 8 color formatting
* `format="ansi256"` for ANSI 256 color formatting
* `format="html"` for HTML/CSS output and styling
See [Pagers](#pagers) for more details.
### Brightness
The `brightness` parameter allows you to pick a color scheme compatible with the background color of your terminal. The options are:
* "light": for use with light tone terminals
* "dark": for use with dark tone terminals
* "neutral": for use with either light or dark terminals
Here are examples of terminal screen renderings for both "rgb" and "yb" `color.mode` for the three `brightness` levels.
The examples for "light" and "dark" have the backgrounds forcefully set to a color compatible with the scheme. In actual use the base background and foreground colors are left unchanged, which will look bad if you use "dark" with light colored backgrounds or vice versa. Since we do not know of a good cross platform way of detecting terminal background color the default `brightness` value is "neutral".
At this time the only `format` that is affected by this parameter is "ansi256". If you want to specify your own light/dark/neutral schemes you may do so either by specifying a [style](#styles) directly or with [Palette of Styles](#styles).
### Pagers
In interactive mode, if the diff output is very long or if your terminal does not support ANSI colors, `diff*` methods will pipe output to a pager. This is done by writing the output to a temporary file and passing the file reference to the pager. The default action is to invoke the pager with `file.show` if your terminal supports ANSI colors and the pager is known to support ANSI colors as well (as of this writing, only `less` is assumed to support ANSI colors), or if not to use `getOption("viewer")` if available (this outputs to the viewport in RStudio), or if not to use `browseURL`.
You can fine tune when, how, and if a pager is used with the `pager` parameter. See `?diffPrint` and `?Pager` for more details.
### Styles
You can control almost all aspects of the diff output formatting via the `style` parameter. To do so, pass an appropriately configured `Style` object. See `?Style` for more details on how to do this.
The default is to auto pick a style based on the values of the `format`, `color.mode`, and `brightness` parameters. This is done by using the computed values for each of those parameters to subset the `PaletteOfStyles` object passed as the `palette.of.styles` parameter. This `PaletteOfStyles` object contains a `Style` object for all the possible permutations of the `style`, `format`, and `color.mode` parameters. See `?PaletteOfStyles`.
If you specify the `style` parameter the values of the `format`, `brightness`, and `color.mode` parameters will be ignored.
## Diff Algorithm
The primary diff algorithm is Myer's solution to the shortest edit script /
longest common sequence problem with the Hirschberg linear space refinement
as described in:
> E. Myers, "An O(ND) Difference Algorithm and Its Variations",
Algorithmica 1, 2 (1986), 251-266.
and should be the same algorithm used by GNU diff. The implementation used here is a heavily modified version of Michael B. Allen's diff program from the [`libmba`](http://www.ioplex.com/~miallen/libmba/dl/libmba-0.9.1.tar.gz) `C`
library. Any and all bugs in the C code in this package were most likely introduced by yours truly. Please note that the resulting C code is incompatible with the original `libmba` library.
## Performance Considerations
### Diff
The diff algorithm scales with the _square_ of the number of _differences_. For
reasonably small diffs (< 10K differences), the diff itself is unlikely to be
the bottleneck.
### Capture and Processing
Capture of inputs for `diffPrint` and `diffStr`, and processing of output for
all `diff*` methods will account for most of the execution time unless you have
large numbers of differences. This input and output processing scales mostly
linearly with the input size.
You can improve performance somewhat by using `diffChr` since that skips the
capture part, and by turning off `word.diff`:
```{r, eval=FALSE}
v1 <- 1:5e4
v2 <- v1[-sample(v1, 100)]
diffChr(v1, v2, word.diff=FALSE)
```
will be ~2x as fast as:
```{r, eval=FALSE}
diffPrint(v1, v2)
```
*Note*: turning off `word.diff` when using `diffPrint` with unnamed atomic
vectors can actually _slow down_ the diff because there may well be fewer
element by element differences than line differences as displayed. For
example, when comparing `1:1e6` to `2:1e6` there is only one element difference,
but every line as displayed is different because of the shift. Using
`word.diff=TRUE` (and `unwrap.atomic=TRUE`) allows `diffPrint` to compare
element by element rather than line by line. `diffChr` always compares element
by element.
### Minimal Diff
If you are looking for the fastest possible diff you can use `ses` and
completely bypass most input and output processing. Inputs will be coerced to
character if they are not character.
```{r}
ses(letters[1:5], letters[c(2:3, 5)])
```
This will be 10-20x faster than `diffChr`, at the cost of less useful output.
```{r, echo=FALSE}
options(old.opt)
```
diffobj/inst/script/ 0000755 0001762 0000144 00000000000 13777704534 014157 5 ustar ligges users diffobj/inst/script/diffobj.js 0000755 0001762 0000144 00000013223 13777704534 016124 0 ustar ligges users // diffobj - Compare R Objects with a Diff
// Copyright (C) 2021 Brodie Gaslam
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// Go to for a copy of the license.
/*
* Resizes diff by changing font-size using a hidden row of sample output as
* a reference
*
* NOTE: this code is intended to be loaded after the HTML has been rendered
* and is assumed to be the only JS on the page. It should only be included
* as part of output when in "page" mode and should not be embedded in other
* content. For that, use the HTML/CSS only outputs.
*/
var meta = document.getElementById("diffobj_meta");
var meta_cont = document.getElementById("diffobj_content_meta");
var meta_banner = document.getElementById("diffobj_banner_meta");
var content = document.getElementById("diffobj_content");
var outer = document.getElementById("diffobj_outer");
if(
meta == null || content == null || outer == null ||
meta_cont == null || meta_banner == null
)
throw new Error("Unable to find meta and content; contact maintainer.");
var row = meta_cont.getElementsByClassName("row");
if(row.length != 1)
throw new Error("Unexpected row struct in meta block; contact maintainer.");
var lines = meta_cont.getElementsByClassName("line");
if(lines.length != 1 && lines.length != 2)
throw new Error("Unexpected lines in meta block; contact maintainer.");
var meta_bnr_gutter =
document.querySelector("#diffobj_banner_meta .line .gutter");
var meta_bnr_delete =
document.querySelector("#diffobj_banner_meta .line .text>.delete");
var meta_bnr_text =
document.querySelector("#diffobj_banner_meta .line .text");
var bnr_gutters =
document.querySelectorAll("#diffobj_content .line.banner .gutter");
var bnr_text_div =
document.querySelectorAll("#diffobj_content .line.banner .text>DIV");
if(
meta_bnr_gutter == null || meta_bnr_delete == null ||
bnr_gutters.length != 2 || bnr_text_div.length != 2
)
throw new Error("Unable to get meta banner objects")
// Set the banners to 'fixed'; need to be in auto by default
for(i = 0; i < 2; i++) bnr_text_div[i].style.tableLayout = "fixed";
// - Set Min Width -------------------------------------------------------------
// Makes sure that we don't wrap under "native" width
// Note we need to pad because scrollWidth appears to truncate floats to int
meta.style.display = "block";
var min_width = 0;
for(i = 0; i < lines.length; i++) min_width += lines[i].scrollWidth + 1;
meta.style.display = "none";
content.style.minWidth = min_width + "px";
function resize_diff_out(scale) {
// - Get object refs ---------------------------------------------------------
// - Get Sizes ---------------------------------------------------------------
meta.style.display = "block";
// The getComputedStyle business won't work on IE9 or lower; need to detect
// and implement work-around
var b_t, b_d_w, b_d_o, b_g;
b_g = parseFloat(window.getComputedStyle(meta_bnr_gutter).width);
b_d_o = meta_bnr_delete.offsetWidth;
b_d_w = parseFloat(window.getComputedStyle(meta_bnr_delete).width);
b_t = parseFloat(window.getComputedStyle(meta_bnr_text).width);
meta.style.display = "none";
// - Set Sizes ---------------------------------------------------------------
for(i = 0; i < 2; i++) {
bnr_gutters[i].style.width = b_g + "px";
// for some reason table fixed width computation doesn't properly account
// for padding and lines
bnr_text_div[i].style.width = b_t - b_d_o + b_d_w + "px";
}
var w = document.body.clientWidth;
var scale_size = w / min_width;
if(scale_size < 1) {
if(scale) {
content.style.transform = "scale(" + scale_size + ")";
content.style.transformOrigin = "top left";
content.style.webkitTransform = "scale(" + scale_size + ")";
content.style.webkitTransformOrigin = "top left";
content.style.msTransform = "scale(" + scale_size + ")";
content.style.msTransformOrigin = "top left";
content.style.MozTransform = "scale(" + scale_size + ")";
content.style.MozTransformOrigin = "top left";
content.style.oTransform = "scale(" + scale_size + ")";
content.style.oTransformOrigin = "top left";
var cont_rec_h = content.getBoundingClientRect().height;
if(cont_rec_h) {
outer.style.height = cont_rec_h + "px";
}
}
var cont_rec_w = content.getBoundingClientRect().width;
if(cont_rec_w) {
outer.style.width = cont_rec_w + "px";
}
} else {
content.style.transform = "none";
content.style.MozTransform = "none";
content.style.webkitTransform = "none";
content.style.msTransform = "none";
content.style.oTransform = "none";
outer.style.height = "auto";
outer.style.width = "auto";
}
};
/*
* Manage resize timeout based on how large the object is
*/
var out_rows = content.getElementsByClassName("row").length;
var timeout_time;
if(out_rows < 100) {
timeout_time = 25;
} else {
timeout_time = Math.min(25 + (out_rows - 100) / 4, 500)
}
var timeout;
function resize_window(f, scale) {
clearTimeout(timeout);
timeout = setTimeout(f, timeout_time, scale);
}
function resize_diff_out_scale() {resize_window(resize_diff_out, true);}
function resize_diff_out_no_scale() {resize_window(resize_diff_out, false);}
diffobj/inst/COPYRIGHTS 0000755 0001762 0000144 00000001273 13777704534 014277 0 ustar ligges users The C implementation of the Myers' Diff Algorithm with Linear Space Refinement was originally written by Michael B. Allen with the following license and copyright:
diff - compute a shortest edit script (SES) given two sequences
Copyright (C) 2004 Michael B. Allen
License: MIT
The original source code is available at:
http://www.ioplex.com/~miallen/libmba/dl/libmba-0.9.1.tar.gz
The adapted and heavily modified code is available in src/diff.c, src/diff.h. See those files for additional details.
This package is released under the GPL (>= 2) or greater license:
diffobj - Compare R Objects with a Diff
Copyright (C) 2021 Brodie Gaslam
License: GPL (>= 2)
diffobj/inst/css/ 0000755 0001762 0000144 00000000000 13420351310 013412 5 ustar ligges users diffobj/inst/css/diffobj.css 0000755 0001762 0000144 00000011721 13420351310 015534 0 ustar ligges users /* Structural CSS ------------------------------------------------------------*/
/*
* TBD whether we want a more fully table like structure; some of the visual
* cues provided by the current set-up are useful (line wraps, etc.)
*/
DIV.diffobj-container PRE.diffobj-content {
white-space: pre-wrap;
margin: 0;
}
DIV.diffobj-container DIV.diffobj-row {
width: 100%;
font-family: monospace;
display: table;
table-layout: fixed;
}
DIV.diffobj-container DIV.diffobj-line {
width: auto;
display: table-cell;
overflow: hidden;
}
DIV.diffobj-container DIV.diffobj-line>DIV {
width: 100%;
display: table;
table-layout: auto;
}
DIV.diffobj-container DIV.diffobj-line.banner>DIV {
display: table;
table-layout: auto; /* set to fixed in JS */
}
DIV.diffobj-container DIV.diffobj-text {
display: table-cell;
width: 100%;
}
DIV.diffobj-container DIV.diffobj-gutter {
display: table-cell;
padding: 0 0.2em;
}
DIV.diffobj-container DIV.diffobj-gutter DIV {
display: table-cell;
}
#diffobj_content_meta DIV.diffobj-container DIV.diffobj-row {
width: auto;
}
#diffobj_banner_meta DIV.diffobj-container DIV.diffobj-line.banner>DIV {
table-layout: auto;
}
#diffobj_outer {
overflow: hidden;
}
/* Summary -------------------------------------------------------------------*/
DIV.diffobj-container DIV.diffobj-summary DIV.map {
word-wrap: break-word;
padding-left: 1em;
}
DIV.diffobj-container DIV.diffobj-summary DIV.detail {
padding-left: 1em;
}
/* Common elements -----------------------------------------------------------*/
DIV.diffobj-container DIV.diffobj-line.banner {
font-size: 1.2em;
font-weight: bold;
overflow: hidden;
}
/* truncate banners */
DIV.diffobj-container DIV.diffobj-line.banner DIV.diffobj-text DIV{
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
width: 100%; /* need to compute and set in JS */
}
DIV.diffobj-container DIV.diffobj-gutter,
DIV.diffobj-container DIV.diffobj-guide,
DIV.diffobj-container DIV.diffobj-fill,
DIV.diffobj-container DIV.context_sep,
DIV.diffobj-container SPAN.diffobj-trim {
color: #999;
}
DIV.diffobj-container DIV.diffobj-header {
font-size: 1.1em;
}
DIV.diffobj-container DIV.diffobj-text>DIV.diffobj-match,
DIV.diffobj-container DIV.diffobj-text>DIV.diffobj-guide {
background-color: #ffffff;
}
DIV.diffobj-container DIV.diffobj-text>DIV.diffobj-fill {
background-color: transparent;
}
DIV.diffobj-container DIV.diffobj-text>DIV {
padding-right: 3px;
}
DIV.diffobj-container DIV.diffobj-text>DIV {
border-left: 1px solid #888888;
}
DIV.diffobj-container DIV.diffobj-line {
background-color: #eeeeee;
}
DIV.diffobj-container DIV.diffobj-text>DIV,
DIV.diffobj-container DIV.diffobj-header {
padding-left: 0.5em;
}
DIV.diffobj-container DIV.diffobj-line>DIV.diffobj-match,
DIV.diffobj-container DIV.diffobj-line>DIV.diffobj-fill,
DIV.diffobj-container DIV.diffobj-line>DIV.diffobj-guide {
border-left: 1px solid #888888;
}
/* github inspired color scheme - default ------------------------------------*/
DIV.diffobj-container.light.rgb SPAN.diffobj-word.insert,
DIV.diffobj-container.light.rgb DIV.diffobj-line>DIV.insert {
background-color: #a6f3a6;
}
DIV.diffobj-container.light.rgb SPAN.diffobj-word.delete,
DIV.diffobj-container.light.rgb DIV.diffobj-line>DIV.delete {
background-color: #f8c2c2;
}
DIV.diffobj-container.light.rgb DIV.diffobj-text>DIV.insert {
background-color: #efffef;
}
DIV.diffobj-container.light.rgb DIV.diffobj-text>DIV.insert,
DIV.diffobj-container.light.rgb DIV.diffobj-line>DIV.insert {
border-left: 1px solid #33bb33;
}
DIV.diffobj-container.light.rgb DIV.diffobj-text>DIV.delete {
background-color: #ffefef;
}
DIV.diffobj-container.light.rgb DIV.diffobj-text>DIV.delete,
DIV.diffobj-container.light.rgb DIV.diffobj-line>DIV.delete {
border-left: 1px solid #cc6666;
}
DIV.diffobj-container.light.rgb DIV.diffobj-header {
background-color: #e0e6fa;
border-left: 1px solid #9894b6;
}
/* Yellow Blue variation -----------------------------------------------------*/
DIV.diffobj-container.light.yb SPAN.diffobj-word.insert,
DIV.diffobj-container.light.yb DIV.diffobj-line>DIV.insert {
background-color: #c0cfff;
}
DIV.diffobj-container.light.yb SPAN.diffobj-word.delete,
DIV.diffobj-container.light.yb DIV.diffobj-line>DIV.delete {
background-color: #e7e780;
}
DIV.diffobj-container.light.yb DIV.diffobj-text>DIV.insert {
background-color: #efefff;
}
DIV.diffobj-container.light.yb DIV.diffobj-text>DIV.insert,
DIV.diffobj-container.light.yb DIV.diffobj-line>DIV.insert {
border-left: 1px solid #3333bb;
}
DIV.diffobj-container.light.yb DIV.diffobj-text>DIV.delete {
background-color: #fefee5;
}
DIV.diffobj-container.light.yb DIV.diffobj-text>DIV.delete,
DIV.diffobj-container.light.yb DIV.diffobj-line>DIV.delete {
border-left: 1px solid #aaaa55;
}
DIV.diffobj-container.light.yb DIV.diffobj-header {
background-color: #afafaf;
border-left: 1px solid #e3e3e3;
color: #e9e9e9;
}
DIV.diffobj-container.light.yb DIV.diffobj-line {
background-color: #eeeeee;
}