lobstr/ 0000755 0001762 0000144 00000000000 14254721642 011566 5 ustar ligges users lobstr/NAMESPACE 0000644 0001762 0000144 00000001161 14254621577 013012 0 ustar ligges users # Generated by roxygen2: do not edit by hand
S3method("[",lobstr_bytes)
S3method(c,lobstr_bytes)
S3method(format,lobstr_bytes)
S3method(format,lobstr_inspector)
S3method(print,lobstr_bytes)
S3method(print,lobstr_inspector)
S3method(print,lobstr_raw)
S3method(tree_label,"NULL")
S3method(tree_label,"function")
S3method(tree_label,character)
S3method(tree_label,default)
S3method(tree_label,environment)
export(ast)
export(cst)
export(mem_used)
export(obj_addr)
export(obj_addrs)
export(obj_size)
export(obj_sizes)
export(ref)
export(sxp)
export(tree)
export(tree_label)
import(rlang)
useDynLib(lobstr, .registration = TRUE)
lobstr/LICENSE 0000644 0001762 0000144 00000000054 14032635514 012566 0 ustar ligges users YEAR: 2020
COPYRIGHT HOLDER: lobstr authors
lobstr/README.md 0000644 0001762 0000144 00000004374 14254675357 013070 0 ustar ligges users
# lobstr 
[](https://cran.r-project.org/package=lobstr)
[](https://github.com/r-lib/lobstr/actions/workflows/R-CMD-check.yaml)
[](https://app.codecov.io/gh/r-lib/lobstr?branch=main)
lobstr provides tools in the same vein as `str()`, which allow you to
dig into the detail of an object.
## Installation
Install the released version of lobstr from CRAN:
``` r
install.packages("lobstr")
```
You can install the development version with:
``` r
# install.packages("devtools")
devtools::install_github("r-lib/lobstr")
```
## Example
### Abstract syntax trees
`ast()` draws the abstract syntax tree of R expressions:
``` r
ast(a + b + c)
#> █─`+`
#> ├─█─`+`
#> │ ├─a
#> │ └─b
#> └─c
ast(function(x = 1) {
if (x > 0) print("Hi!")
})
#> █─`function`
#> ├─█─x = 1
#> ├─█─`{`
#> │ └─█─`if`
#> │ ├─█─`>`
#> │ │ ├─x
#> │ │ └─0
#> │ └─█─print
#> │ └─"Hi!"
#> └─
```
### References
`ref()` shows hows objects can be shared across data structures by
digging into the underlying \_\_ref\_\_erences:
``` r
x <- 1:1e6
y <- list(x, x, x)
ref(y)
#> █ [1:0x7fed114eaea8]
#> ├─[2:0x7fed21f373b8]
#> ├─[2:0x7fed21f373b8]
#> └─[2:0x7fed21f373b8]
e <- rlang::env()
e$self <- e
ref(e)
#> █ [1:0x7fecf1856f00]
#> └─self = [1:0x7fecf1856f00]
```
A related tool is `obj_size()`, which computes the size of an object
taking these shared references into account:
``` r
obj_size(x)
#> 680 B
obj_size(y)
#> 760 B
```
### Call stack trees
`cst()` shows how frames on the call stack are connected:
``` r
f <- function(x) g(x)
g <- function(x) h(x)
h <- function(x) x
f(cst())
#> ▆
#> 1. ├─global f(cst())
#> 2. │ └─global g(x)
#> 3. │ └─global h(x)
#> 4. └─lobstr::cst()
```
lobstr/man/ 0000755 0001762 0000144 00000000000 14254716056 012344 5 ustar ligges users lobstr/man/obj_size.Rd 0000644 0001762 0000144 00000005133 13477777720 014454 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/size.R
\name{obj_size}
\alias{obj_size}
\alias{obj_sizes}
\title{Calculate the size of an object.}
\usage{
obj_size(..., env = parent.frame())
obj_sizes(..., env = parent.frame())
}
\arguments{
\item{...}{Set of objects to compute size.}
\item{env}{Environment in which to terminate search. This defaults to the
current environment so that you don't include the size of objects that
are already stored elsewhere.
Regardless of the value here, \code{obj_size()} never looks past the
global or base environments.}
}
\value{
An estimate of the size of the object, in bytes.
}
\description{
\code{obj_size()} computes the size of an object or set of objects;
\code{obj_sizes()} breaks down the individual contribution of multiple objects
to the total size.
}
\section{Compared to \code{object.size()}}{
Compared to \code{\link[=object.size]{object.size()}}, \code{obj_size()}:
\itemize{
\item Accounts for all types of shared values, not just strings in
the global string pool.
\item Includes the size of environments (up to \code{env})
\item Accurately measures the size of ALTREP objects.
}
}
\section{Environments}{
\code{obj_size()} attempts to take into account the size of the
environments associated with an object. This is particularly important
for closures and formulas, since otherwise you may not realise that you've
accidentally captured a large object. However, it's easy to over count:
you don't want to include the size of every object in every environment
leading back to the \code{\link[=emptyenv]{emptyenv()}}. \code{obj_size()} takes
a heuristic approach: it never counts the size of the global environment,
the base environment, the empty environment, or any namespace.
Additionally, the \code{env} argument allows you to specify another
environment at which to stop. This defaults to the environment from which
\code{obj_size()} is called to prevent double-counting of objects created
elsewhere.
}
\examples{
# obj_size correctly accounts for shared references
x <- runif(1e4)
obj_size(x)
z <- list(a = x, b = x, c = x)
obj_size(z)
# this means that object size is not transitive
obj_size(x)
obj_size(z)
obj_size(x, z)
# use obj_size() to see the unique contribution of each component
obj_sizes(x, z)
obj_sizes(z, x)
obj_sizes(!!!z)
# obj_size() also includes the size of environments
f <- function() {
x <- 1:1e4
a ~ b
}
obj_size(f())
#' # In R 3.5 and greater, `:` creates a special "ALTREP" object that only
# stores the first and last elements. This will make some vectors much
# smaller than you'd otherwise expect
obj_size(1:1e6)
}
lobstr/man/sxp.Rd 0000644 0001762 0000144 00000003757 13762501764 013462 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/sxp.R
\name{sxp}
\alias{sxp}
\title{Inspect an object}
\usage{
sxp(x, expand = character(), max_depth = 5L)
}
\arguments{
\item{x}{Object to inspect}
\item{expand}{Optionally, expand components of the true that are usually
suppressed. Use:
\itemize{
\item "character" to show underlying entries in the global string pool.
\item "environment" to show the underlying hashtables.
\item "altrep" to show the underlying data.
\item "call" to show the full AST (but \code{\link[=ast]{ast()}} is usually superior)
\item "bytecode" to show generated bytecode.
}}
\item{max_depth}{Maximum depth to recurse. Use \code{max_depth = Inf} (with care!)
to recurse as deeply as possible. Skipped elements will be shown as \code{...}.`}
}
\description{
\code{sxp(x)} is similar to \code{.Internal(inspect(x))}, recursing into the C data
structures underlying any R object. The main difference is the output is a
little more compact, it recurses fully, and avoids getting stuck in infinite
loops by using a depth-first search. It also returns a list that you can
compute with, and carefully uses colour to highlight the most important
details.
}
\details{
The name \code{sxp} comes from \code{SEXP}, the name of the C data structure that
underlies all R objects.
}
\examples{
x <- list(
TRUE,
1L,
runif(100),
"3"
)
sxp(x)
# Expand "character" to see underlying CHARSXP entries in the global
# string pool
x <- c("banana", "banana", "apple", "banana")
sxp(x)
sxp(x, expand = "character")
# Expand altrep to see underlying data
x <- 1:10
sxp(x)
sxp(x, expand = "altrep")
# Expand environmnets to see the underlying implementation details
e1 <- new.env(hash = FALSE, parent = emptyenv(), size = 3L)
e2 <- new.env(hash = TRUE, parent = emptyenv(), size = 3L)
e1$x <- e2$x <- 1:10
sxp(e1)
sxp(e1, expand = "environment")
sxp(e2, expand = "environment")
}
\seealso{
Other object inspectors:
\code{\link{ast}()},
\code{\link{ref}()}
}
\concept{object inspectors}
lobstr/man/cst.Rd 0000644 0001762 0000144 00000002127 13304255332 013414 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/cst.R
\name{cst}
\alias{cst}
\title{Call stack tree}
\usage{
cst()
}
\description{
Shows the relationship between calls on the stack. This function
combines the results of \code{\link[=sys.calls]{sys.calls()}} and \code{\link[=sys.parents]{sys.parents()}} yielding a display
that shows how frames on the call stack are related.
}
\examples{
# If all evaluation is eager, you get a single tree
f <- function() g()
g <- function() h()
h <- function() cst()
f()
# You get multiple trees with delayed evaluation
try(f())
# Pay attention to the first element of each subtree: each
# evaluates the outermost call
f <- function(x) g(x)
g <- function(x) h(x)
h <- function(x) x
try(f(cst()))
# With a little ingenuity you can use it to see how NSE
# functions work in base R
with(mtcars, {cst(); invisible()})
invisible(subset(mtcars, {cst(); cyl == 0}))
# You can also get unusual trees by evaluating in frames
# higher up the call stack
f <- function() g()
g <- function() h()
h <- function() eval(quote(cst()), parent.frame(2))
f()
}
lobstr/man/tree.Rd 0000644 0001762 0000144 00000005634 14253140421 013564 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/tree.R
\name{tree}
\alias{tree}
\title{Pretty tree-like object printing}
\usage{
tree(
x,
...,
index_unnamed = FALSE,
max_depth = 10L,
max_length = 1000L,
show_environments = TRUE,
hide_scalar_types = TRUE,
val_printer = crayon::blue,
class_printer = crayon::silver,
show_attributes = FALSE,
remove_newlines = TRUE,
tree_chars = box_chars()
)
}
\arguments{
\item{x}{A tree like object (list, etc.)}
\item{...}{Ignored (used to force use of names)}
\item{index_unnamed}{Should children of containers without names have indices
used as stand-in?}
\item{max_depth}{How far down the tree structure should be printed. E.g. \code{1}
means only direct children of the root element will be shown. Useful for
very deep lists.}
\item{max_length}{How many elements should be printed? This is useful in case
you try and print an object with 100,000 items in it.}
\item{show_environments}{Should environments be treated like normal lists and
recursed into?}
\item{hide_scalar_types}{Should atomic scalars be printed with type and
length like vectors? E.g. \code{x <- "a"} would be shown as \verb{x: "a"}
instead of \code{x: "a"}.}
\item{val_printer}{Function that values get passed to before being drawn to
screen. Can be used to color or generally style output.}
\item{class_printer}{Same as \code{val_printer} but for the the class types of
non-atomic tree elements.}
\item{show_attributes}{Should attributes be printed as a child of the list or
avoided?}
\item{remove_newlines}{Should character strings with newlines in them have
the newlines removed? Not doing so will mess up the vertical flow of the
tree but may be desired for some use-cases if newline structure is
important to understanding object state.}
\item{tree_chars}{List of box characters used to construct tree. Needs
elements \verb{$h} for horizontal bar, \verb{$hd} for dotted horizontal bar, \verb{$v} for
vertical bar, \verb{$vd} for dotted vertical bar, \verb{$l} for l-bend, and \verb{$j} for
junction (or middle child).}
}
\value{
console output of structure
}
\description{
A cleaner and easier to read replacement for \code{str} for nested list-like
objects
}
\examples{
x <- list(
list(id = "a", val = 2),
list(
id = "b",
val = 1,
children = list(
list(id = "b1", val = 2.5),
list(
id = "b2",
val = 8,
children = list(
list(id = "b21", val = 4)
)
)
)
),
list(
id = "c",
val = 8,
children = list(
list(id = "c1"),
list(id = "c2", val = 1)
)
)
)
# Basic usage
tree(x)
# Even cleaner output can be achieved by not printing indices
tree(x, index_unnamed = FALSE)
# Limit depth if object is potentially very large
tree(x, max_depth = 2)
# You can customize how the values and classes are printed if desired
tree(x, val_printer = function(x) {
paste0("_", x, "_")
})
}
lobstr/man/mem_used.Rd 0000644 0001762 0000144 00000001237 13251236036 014423 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/mem.R
\name{mem_used}
\alias{mem_used}
\title{How much memory is currently used by R?}
\usage{
mem_used()
}
\description{
\code{mem_used()} wraps around \code{gc()} and returns the exact number of bytes
currently used by R. Note that changes will not match up exactly to
\code{\link[=obj_size]{obj_size()}} as session specific state (e.g. \link{.Last.value}) adds minor
variations.
}
\examples{
prev_m <- 0; m <- mem_used(); m - prev_m
x <- 1:1e6
prev_m <- m; m <- mem_used(); m - prev_m
obj_size(x)
rm(x)
prev_m <- m; m <- mem_used(); m - prev_m
prev_m <- m; m <- mem_used(); m - prev_m
}
lobstr/man/figures/ 0000755 0001762 0000144 00000000000 13406770053 014003 5 ustar ligges users lobstr/man/figures/logo.png 0000644 0001762 0000144 00000067477 13406770053 015476 0 ustar ligges users PNG
IHDR X? gAMA a cHRM z& u0 ` : pQ< bKGD pHYs !7 !73Xz tIME N n.IDATxw| y~:L `搜 5f%˒`$ZٽpvϽ{w:QV%I0&p"s&A @: `?PC6Oe~ Ѐ /5zb+'P`qUaW`/ P fA "ilSG/\>X Fӈ[
|
VO1Q $:/ bϋV D@⍈7&W ǰ% 2M&"o$0]n ~ ,PB/1R)p+` >2o^C+p)& ŎsU~i;H(80]>k J'
WuK= !1 9p'`Ŗ
XEL" 'R)uc8trH u
]^Kwߣ`Obǹ K=$Cgۮ- 8ք.έ;$I< w#
^Ls3˟ zL)%P]WزM ,4lɫtwarq ? .e ,yQ bq+~ضcf }p HKNyPXkm\:|"ر2P Z@5$zcwQ SZŮ.E~@"Ϸ* qM/".YZ@BIUG SZhh&*kBB>wg vT"\"'ƿCAf(xp2ECJʚ2 ofˋPT;p}]XֲaNlq
P
c29aVIϾv{v^ג; B"qn\͕͌ۏ/ȷ{ UD+i2_d~3 -`m?Ҡ""Kֱq.˭"*@*Ri*uj8t-(ĝ!e5ȅSWM:^. UBjqnYe 7m bb!A*3;e +[.@@%be~$_;s߽ĝ"(͗Zrc!@< s ;U-.#ށ >2d~Ғ8\;4p J+ŗVY;<83ʹ\k# M,.W /~(ːI)QUJ KmC%
q# wkt`rlq(xOPZ^āc{رXwwy O|3?qvK)4GGsLiI<~7M{x'iB#\µ 7 GV-l8H<
d~O`ǹ+&;xʒ{jWdPO_ [\S< k)ĝ!DA(ĭ ~e&oQiGhܻuVfPX[W۸tfEe=ڧ [~$.6zL hn[{{6d7*eA4&FC ƞZnXlKx(
q:VIvT@#dC6>kd+!tRq{4cqfסu%7$VY4Y/ ] >4U)K)y9D.&]
ŕ}O9#TESVZAQfNJ"ضo :5elV(H%!q1ǀxS[Րm1.7@ 5g=WJ{y.Hb-3dIVDmOdpx<(bx lJ [\ 6 =Me n\24M#RZ\\nhl߷g
\ U NGC$ ![`Wމmnl!3?`6vjYVWQ|^ %x=Y sѰ* - Au]u[lb,dOY5.
<bf"wWCvrLsRJJ*<B,Ӣ [\Z ,!0 wVJ8~4}8:kd+M%[ܐwjlPU?@iqɒdiQRs2K?v[Q7ն
EIq=`eu!z .3m
'q8x..aTNٯ @F#pgoɂ,N'A]ي_eʪ7xL8I&SOVVxe^@uE1 S˖K01h!R$]_ v4t:iǶ4Ğ T+e%4GX 1秤ˍC,ϴ 3?nx|s!t(REQ . UUX*;`żsWSv 8 Bs ,ibQV[Ďˊ
n=4-^[5; zUT|\6l1oH&wt'u;3Q% got:
r_nEaw|eeabQۃG׳W&"N6 =XiS#\9;HKrxp8L(Ʋtm[\O Ů~.>?Ns=ڒ!%y`K!H뷹qPCsvr12@<g"4A4 [75%j v{PU^,fxr7H&tu|Trxp.L$2 L)lqni2a/Mz<>TuC%CJp{ "2%KbV.;=mgx"ϚWFgX!~ܮtt;Y¾- ǒǣƢD&" qԹߙKZDQBTr%N++[s#JyE nx^4ug##;;: Vx LN)%I"$< ao"Q,k-4 EB#aL\Ym+Bw ^?q48HtcOieQ
/T2Ӿ^Y+--Isky/D^FyY% ?G6wvy>H)) X#%884J+x{m{k'B @UTTƇtud
˴ R
I$ 1.t]4f5`7hVIi-^22?Uq_ C; @@._jP6+X&C(vb@Q&@% N2;BOG C#) ˙#eZD"Qtm{SfrP؍=dՔn _n.Cή![wPZUYu
˔8 Nan(/d.!^BhJ)Hir,-R n á(J.c=40ʹL O0LLT7'hp"%s7m O͚B9d~ ˻ӉkqF\su ҒUuO A }MԷuRZDw N&DU%~(.wjS폔qZN4 x>tՑ,[2714
BQֲ]nlSL-fRߡβwE6qUUCaǾzH!}\8u
s;&EזnQ#l]țKPecT2EoW?N_tJƬ nuhیd*H)lASnt kP0-s_- Ƕ @nw|ul/B`hٔ~eJ1OJIi:g ˲u6xh
yaڛi:}B^AJ/ѻrV$#v(T]5155 e4 NQY gŧ>*Kpz ̨4Y#kTd: Z,s -iݿ^ ݡ`CuζiDSttCՖR+4H$i GwAFI&R(Bh>i(`Kc{ ؎ZK)q]Upz/fDqx14d,mpհ]* Swah L~v$ҰM!D#1|P@<`w
vsuFGFbXDUUtՁESuh
iw.]iT*MDz$%4쪙$m)04ߓPi: mBBaN8KxsζnwԱi'Uue8"EvQVYo@yճ?Qfnw`YHa2yN^f,Sq(* .Hb! OL%0PQXIyE`Kn:h]s2f A ]wz5aY^좪lʍ"ot?AYU7 d&?~xt.p$voAUfYbuRHAx"g}N ^*Ӵy6xsm !KbuQqG>BJIuC902~D5Oݙ/VÏٙaڮwxaBpj+7BUE-Y[ %!HSjFP]t hNIEÏ!Xs8uT*EOG .ޤ3mbN7NZܼNķجPUŨ c D&b=ڈ/0w˿e1z***<N UUDU,Ӛ1C l{m| d?}Gb!q!w ~{wwK tyU)}nqК'0Y 5x ʪf$vr
Eb>`o)%Ã4_Ivb8
ޝ!sp+ {1@8A;tC_cC9JCQE~G4vZ.!LDy%Vmɳ~:FW+k8 Ӵ4r Ҳs<$˲n# E4QCꤛ0=]\U4C4pxn*JR6eÞ%6MDiVS'qm1|h}NE^%>E <>7NݡD^6-]A8kǴ,yWE٠
Tp
wnw/b8jp70yu eu?EQ(nh&FC }qwܨz4]wzp:\SZQLIeEe~7swu-#'#Jsܸ| C3U-PVQnl|^\8u ';(P]W=qTfv=be=|irf FƆD546m^~d-nSW@S[_KqY-ZUYM$)&B 'iܻ =%is
n\xEeg=_a>BqYm;&)%`0
ME,,K"XKk,a|$LJ#M :N3HJR '{)
#Ã# ?ݐCcn^l{?(*
R&/ !(-/Ld&WYnD (eqX Ӵ0Mt*(xh$F$% G⤒iLB P
M~QQSO҆z3rx14,aR47\|Ɨ'
|%)ϖMO,%1-{ !wzplt:E:mbMi˴,Q)䛊4eJVuC9 ۃ7rciξy8tNC61{RRVȖǛp
ܴY,$W,n écF,@%CZٵx,A$%N "4 @d TaW5 ٍkE[.hκ"jKGhb#nD>/)%t9Ŧ6恴d
Zf4<8t7DW%Ъe 7;mM3+so]Den l`tx:CyuofX YqY&8,y?k&;gEvJgLwVs=8ݶ<OpY[:p<?Wlv+`U(
aXdK-,sBPU
J8ypn ӓV5q~[˲x
m- 8 ' ct@n+w(x]bȼ`I*r>I\pU~wSveiz=v."T\˔4Md"Z @ɯ$
rUΒyXW#gգ:ۺ9%)pJR)7 l`wn!|,dCh7/ݱ3*,z֗\k5]l`#EeY;?/&rx6?]Ws8 Kg 2ӆIn_뤿k`'au?#f#OJ6R} !#xmFqn ՙ=U4 c;P̒paʧ_;oW*tkw
fL$ YZJwY`CX oCQN`ldW&= }vF&Fv ڊ#-3y6 2|> _Ѓ7s冽EB1(BH89 ~جch[h
^AL_ *[/fh4 >clm>:q99ûй8$K8y$PqpꨚiZDBQ2@_ tg(%_!l<{tE襄T2};W pг=UJjUPP>?8`0݅k:Su6jWNCrc8]zQ()QUѹ~63x_ֆ ,xMR4 -}l5De),D"uky8;v lȍۜg M5挻@p;sӮDϰLW[IĒx] 9Z(F).^ڵH&Ru?
^G!(. Jsue˲0&dD&
xqn3-eI.YAgInlRrC&a~.p86mc
BcaFƗt ,btx YTUés +#7 zh ̌Kgq͋ LArOMb8WO"X-{+yA2O#Kdn@ȽwB
5sld<_ًX p CJ[[Y_:%]}N8
Nذg{
vk,^3$aFE ƴ Qҩ=|'"+8J'RJJ}<0vݧt:q3eqslWe|6Ks!i116A4 gb$ /L, 4!I5B024F"M_*
S(C
x'B'^|o_FZ*2QuhJ
a]^é/YA"$4dH).= UF !:U/
ît~'opva\x"h Gl"N[6D!TE]a!TUeǾ-vdfٵ7?LwG/݅@]l>BFljhȜ*%x} N iR .:%`|48J@K22f$}] tW K@.،YiO65}7aolywΙkMotCcW7Gjn;_!KSUu7Ғ{lt$f7L;sf|huUU{| Nʊ
,t A"QTe-RJJ+J6Οh&_AiqL+Aʪv8 Wrc\ob^):&OqSHRp\lib|8̹7/ai<%6#D&b1\fDkt7g(]Q`0XsV3"歏J)iܷ꼲PKo6hBnJbZ 멨+Wfڢv?
> A"F/q;^یM5HCJa8獃%`8 \M:e %ck+w
s̭):\)% ?wmMu}.tCuuO-"/.
L3e/c !coi[d"E<$sy~2<8 eZ̙V55o)I .cΞf!#tƚ\|dl<|] ;xnv l=a|E | (x Lwj+kZn^jÒPQ ى4fK%AǸx
](Bc,fW& ԡ(
n51>wfJͫEbxrWTMEʆJ)x ",p/H-.ud2ŶZ<^7Bd'
E)!R[Ҋb!L`I@Ǿc; WiF<ǡ9qh Eve]CJ3.r;M`UUs dhh,
'Hpy xf Doݠz
TU, r9QCK~ H& tqM;6Tc8tT%DZ|IN9s Av )Aw9+x ~M
#,&Ix,]KY & O`ߚؙ
$h j[.;\8]N id"I,'<\8}UpjnrNK QRF뺖g%o)sβt=c}o^mEUGGS;>z; OD8q TMlK
EXzg(
$fd< egSZHi9K nc[]b:rnrh4C[#:/%XJ*\욙Y.@ØRrbKԳ@<qot@L yۉv*HJL" I0?FWk }Cģů>]whde6f[t|?%Ōts?E$civ ʹW&v hpMx
W]AQy zy5~h2
3$Rf݇$~{L/0cߑ*xnA7u+ ZwZzl"kzhP3Xs]gNAzvB`)CJ* yr/jVd ]OeZqj '`o `H I签)I4Ui$wwUc^@y!lK:D[s-X!CΖהsN 7
!sbHuD1ǨQGqQޙ: ݝeYgDK(.p9r x4΅SWH&Ruf
CH)q8
a)5ص&H iIEsr ,`d`h(PVQBIe`J^t͑jƎ}[0CYb.ûY(8/`7U%UBÎ: m]ba { [d!vk áSs ɬyWRyS k2^P p@ӵLgbÞᣢ\ԂEhv pSEi5ٖ
8ڒYi* ^䅯[3Ӱ_(8O*JUsRUl^h`HĒ2{\n' {̜xV>*a,Z.v$ Ïٔ{AQy)%eU8<% L_5{ɤ̸D 9@Ie`yn<.<e-2\=Jʊ+vSPuq{9U(kY633=USmg'bJ= _;6(̴\c%)zP
Uh @UTبW2:8HK,PUּGւY\h;;s_J DZ {GIwsN+4
4U#2\83WZsc7sde@Q잃`~M.+Ba Aw[?#amqmz&BBcƇC l!PZ6еBEfmjI,U4&BikhfTWkߢi4R@, ݪ89')GrS$A Z'˒XS2p{8"Lk٭`Op{];KRJB@3.G\W74K.zH΅!oRaC! = %QT ? )b:T1Zur
:Z{ʽL˲8p|5RY[j+S 1>&\Z/h$f˞= D E) yK dj9"H%$\vy!cCƣp{ܨ%-T:
˲(.= Gu{]G ^_~KɡG}7g %{-/^R,,$O,BϚL
SR71DJ
'6I& e-ǒ R\ r%l>\I,
o}9ɛEQ| ~2懔q_?C]][ùwҒSER K^˲HēpuHl?xhY9rB,;"p3m:C_,Oe{Uh8Ƶs\Cd"F˞Cup+zq_= wzx
ɶu@Ҋ"߳E$-˶諩UB s"\;ʩW.s|+#cCf"U 'p8 :Qk
ƾ}O!one0nGuO|=hY'~wĢYɣ
/k=ei*5%< f*,[ 4R姻ΊgEB\.'N.!9
iq&ɧ4`Gy>@o jfdx HҘ}4 cK} spc= +\@UT;?I"c@vcM {r p1LQU"|7p.wdi? EP閅(ң#)%NҊ"Jʂ=N I:i
n ;^do˲7,IEM ? z^/Mv[%*IҌW32P3m5L*tCsk3'``O_[NGY gmvS;ΩW/feI6)݇N|K/co=[k 2Pآ9+A]}%;(~ܿ}I95N|4:풛2l*}aI GlS79F?#cB NǢ\
@7 ;ص+ڤZx"Փq9<i: q yp*CZc!>wEQt&CH)y}w-̇.XiBteilX VAӑeEtCUv/vp& <>{i6+?iaol/Eܸpv26Nh$;d/T*@Hf $]FiPYv]E܉X^ڲv DJhэxNjS\aﱧS,!thL2WdI(UU ֕;n݇Kl];& =.IEm IJ+x['ysģ Q J a{+ʹ }M` =)xt֡s } 7 /$6j˨.Y|~X )%2l߽8FμVvxޣAN4X4Nؗ̇D wgZ!{
{`MYq|k=ϓ3ͩTn ,B. jJcS=NcߒR<Dgph8> }~\h`_(Clos8] wi nD NkNhwCW9+@YKGA)WӴ5r2 ]A~IyʢElFiE($x,AGkϼ^74>qHɍKm4_9{y dfO|=W/xa\ o|-;(KZ])!H&npy8E'-%/M#(9WSAO P) JRM-R?#'s/nmz;dOp O0o_qg
w~ObM*Z*20 ;V \\nb#=TU:MrL.[zx3=! nԐqeXiI/zqyDN @W[ _Bu}9 &-cM<',%Ist 8ujVp&n\j'Ik~?&0B&n q_ AnY! N]rRғ[2"+[R z$b Ct~
hx%bn`(=4c a-Sin^n.)é324 8sHGir/_$2i=-4 ˒הϽ_üʷOگ-l춏جՠ%>wb۔{< f|-bKc5;3Eub G5:>%ٹc w!-ɵ3Jg>WZTlN}?ػs|}`/7Nk= ݔUv/)áN7* pJ;? LO 5JpBma4- j(I.6܄|6=9 2j?4
hgϭH-9 `/vͲÿC?jV =hI.=E9/]= lo2k6G>c<ù$/}dFnczF4Ͻmk3Ƕ,*<'8݄8obNh
|_RJ/
2MCc$02BXm֭<bS߇Ŷݵϼ9
L|o_yc[:p |_9hn+3#oUE?+ vˤeYsu,@0e}}A;=PT:;>{ݹyS|OL@:~e6#Ȳ"vo`l8$BU| J)WOƋfcC wQ Em7:ؽMGvH8Ɲ֞n #i .߸`])wM /ɗ.?.Tz/{kE˧orKt_g3iz`;nn
XXH OI Esg |"o]˯g9u/&SR C3M qL J~7Sz^>ghYïpJ-$)@)1ŷoRNDo6
)9NZR*J8x|)ωS?T}[| fYnhx|)>8G iZw?Hl^Mq} ~X4py =Gv07ʵ{* 5P p"8e .O(. xx<љ¶6_dwtFsrp<_zR | N}wqz `l84던 f~k<ø}$u]||ܱ_xs<ܹ7&/⟾}fֲU*"4 }XšGޟxjQ,k :o-z -;?7'?ʣ:BOo֕5Vo 6%,IM}~/
0
qGB
sx,A<ɛ RYW:;osg e >_2R7˗ O~}ph6Bu}9 j}ڹ5.v\p%jӢ]=w4 ΡwSX/EQq0Ϸrv "MR|so\ȵM {r?
;kl⌏iWrt\ (n\^' Y5 :~ 㽟xR~ =:oQvQ'I;),o(
>Kʙ1MsDR})?&)'PU]³$c"QR|_\|Gf\ ("qΜׯt8\BCфi= ܲ$gN\ˮiS&jҩ8]OĒcp{'%ܸІe֩Ȗ~OOg}*4I&Si1iC6Q^S2wĚeY䂿cY ^Us] |h7u+XR27ʩ/O1>ڰ$o(=̈́tYRMboY< @m
B]
e-l042gCz M;vucO< ET&L {8~ |0.x3 M ?}]$TԔ~ׂ*T2?y۰O~+y |gc~`V,@zv ƟĆ$}CeAR<JF3Ұ&&-I͖*juc UՈz;s&>RP5
iY"qGܺk;å7H%ӹ 2w.SL79/e$aǧ}Tח/xq[%Xcg!*jJg }b W_z@B$N\C-s$V5dktL}4\9BG{/5[9YTD1 LOit o_unk_>xrJ\/$X&HT>S{X J*̭$}CH @Qg*Lz~"Fa οy}
y-w_~ ?{>Dyz>qLē|˯?Ͽ0M 5sRZ 1NzZ(/Z)g4hFqݠb:n~d+='2 #ahcC˲gw zxό./7'1u*}'s7x/3+l? ag͂1?6W?$H !NK7>ljeYv -yh+ey?dd<ŅכI&R9
MӨd\yb3L)qh.E|"Gr]lY ҘPR 973uYϾ#|x4ۼ7l!<7ybnc-S;qV _#?5>f,fX2B*iO<[Cs] ~@0o~K㾅[1o^nw_33FRJ8T|Q#!2eD$N݉mΙ ~τ ڷ`) nTĴ@S7=[G0YE 2-YH)q
>EޡQweQ]_HT(wyVhW38uZ(+,ɼq` dZ#KaIss *V/VT>&| 7,yVx2F*\ߺNN@wS/_o[A~ޒ6rDn3_V gfXx '-B+B)d X$ }}*O63> s xP]o1e&&"SN u{@ &&T8*s/2B aЖϦe!@;oҩ&ۮ^ ~x%0N=G%RE(8t'ݹiLR"-k3{zn*ծ
8 -
wŬ$~ع3R
*) $i&'ca^?>8@4"&Id誁p/X@isS%Wd
!p-lbQfpUlw׀%A)]2 ؘ0-x*qnx;=A; q'?v= _Nx- .l4X"JOǗ s`q➉7ͭ> u9DS[mI*̴?.; p/eXiD 2qh9ȵe\Zn#8uF{%n6uOa_E?nu!>.`=DlH/cǹ?"AX*qX1_u ^) X?,S7 =0'n+lNs뀟]q5U/ X#/^/?ڳyaFM#a_ L=QQ-XA_.3dD+I,V՜M";>~ẹV ;
X1r Mu8{ U!nkN"rv3K8tW&>.;2x*q
&ya
YOs v-yU Bז.>D*ӷZ~;-vrK&nkn
k%[+9./P-JXkZa]inu)
V%[+=ld. W,N]OZ!/EAXt( -wVXwGZ!,/ ǖsxcAJ<>'olDZ!/MRe22S챷vvHf7|*<GL < 06 ee~d$#:X 'nXj!/ 6'9}1|;vaId:%n24S}.n7wѸ/]$Hr&ߞB6xrq&_ nN
` vaZ&)3%[] Rk`e,{."εETxn?l;nF1$keZҲj,y+[=^v7(QZUDyu ]~2=ùX2\q} {ͯa\ G,6 Fnl{[Wpg2ؾڭ5w{rǟO"k9qx=1,w\V.1J,6-D4p ~܇.Y1m)3P?*(?[=:+x|."qku7.aYTh"b&ob8'Ν]W-,V q{W xl/?{|U=*-3e~kMo'c[=-{ bKcɩe !PUt$PCQN})oth##8 :[wpm.Rqn{c'aƹᾲ1MA\ G}[W;( z^=Kgk/G mbx`W}ѡՐ>op_Y&[=lee-SJfhx >gL7~pGuqzyr{g9%n\l# []ako´x ꏱmC7EӴ)w 8] ֝< [uD<"&BY<
mSa8tv4m`K'o03 "PW E,@0\m~`Ym~
ρY-krQ-f]]á0[wϳ6o_bGJXR.b`+`ͷm6,=`eb
e+n(Z%A*kK iΎܸƭk Qf?bv7oPKĴ6@E^BQG vk`th m7BQx=ʕ- CֵG()pR;dp(JLd~ I {)Ǖi e(#@,/|"/7{vOL)Z!JRRvYh]T#_b{! DPZ
\UĴmb9W}ۢb }aNtg?0锉?xK
>~PIYw@ h%}Vzޱ>B$E~= 3.2)
Imports: crayon, methods, prettyunits, rlang (>= 1.0.0)
Suggests: covr, pillar, pkgdown, testthat (>= 3.0.0)
LinkingTo: cpp11 (>= 0.4.2)
Config/Needs/website: tidyverse/tidytemplate
Config/testthat/edition: 3
Encoding: UTF-8
RoxygenNote: 7.2.0
SystemRequirements: C++11
NeedsCompilation: yes
Packaged: 2022-06-22 22:48:14 UTC; hadleywickham
Author: Hadley Wickham [aut, cre],
RStudio [cph]
Maintainer: Hadley Wickham
Repository: CRAN
Date/Publication: 2022-06-22 23:20:02 UTC
lobstr/tests/ 0000755 0001762 0000144 00000000000 14254716056 012733 5 ustar ligges users lobstr/tests/testthat/ 0000755 0001762 0000144 00000000000 14254721642 014570 5 ustar ligges users lobstr/tests/testthat/test-sxp.R 0000644 0001762 0000144 00000004510 14253140421 016467 0 ustar ligges users test_that("retrieves truelength", {
skip_if_not(getRversion() >= "3.4")
# true length is only updated after assignment
x <- runif(100)
x[101] <- 1
obj <- sxp(x)
# weak test because R doesn't make any guarantees about what the object
# will be
expect_true(attr(obj, "truelength") > length(obj))
})
test_that("computes spanning tree", {
x <- 1:10
y <- list(x, x, x)
obj <- sxp(y)
expect_false(attr(obj[[1]], "has_seen"))
expect_true(attr(obj[[2]], "has_seen"))
})
test_that("captures names of special environments", {
x <- list(
emptyenv(),
baseenv(),
globalenv()
)
obj <- sxp(x)
expect_equal(attr(obj[[1]], "value"), "empty")
expect_equal(attr(obj[[2]], "value"), "base")
expect_equal(attr(obj[[3]], "value"), "global")
})
test_that("captures names of lists", {
x <- list(a = 1, b = 2, c = 3)
obj <- sxp(x)
expect_named(obj, c(names(x), "_attrib"))
})
test_that("can expand lists", {
x <- c("xxx", "xxx", "y")
obj <- sxp(x, expand = "character")
expect_length(obj, 3)
expect_equal(attr(obj[[1]], "ref"), attr(obj[[2]], "ref"))
})
test_that("can inspect active bindings", {
e <- new.env(hash = FALSE)
env_bind_active(e, f = function() stop("!"))
x <- sxp(e)
expect_named(x, c("f", "_enclos"))
})
# Regression tests --------------------------------------------------------
test_that("can inspect all atomic vectors", {
x <- list(
TRUE,
1L,
1,
"3",
1i,
raw(1)
)
expect_snapshot(sxp(x))
})
test_that("can inspect functions", {
f <- function(x, y = 1, ...) x + 1
attr(f, "srcref") <- NULL
environment(f) <- globalenv()
expect_snapshot(sxp(f))
})
test_that("can inspect environments", {
e1 <- new.env(parent = emptyenv(), size = 5L)
e1$x <- 10
e1$y <- e1
e2 <- new.env(parent = e1, size = 5L)
expect_snapshot({
print(sxp(e2))
print(sxp(e2, expand = "environment", max_depth = 5L))
})
})
test_that("can expand altrep", {
skip_if_not(getRversion() >= "3.5")
skip_if_not(.Machine$sizeof.pointer == 8) # _class RAWSXP has different size
expect_snapshot({
x <- 1:10
print(sxp(x, expand = "altrep", max_depth = 4L))
})
})
test_that("can inspect cons cells", {
expect_snapshot({
cell <- new_node(1, 2)
sxp(cell)
non_nil_terminated_list <- new_node(1, new_node(2, 3))
sxp(non_nil_terminated_list)
})
})
lobstr/tests/testthat/test-ast.R 0000644 0001762 0000144 00000001421 14253140421 016442 0 ustar ligges users test_that("quosures print same as expressions", {
expect_equal(ast_tree(quo(x)), ast_tree(expr(x)))
})
test_that("can print complex expression", {
skip_on_os("windows")
x <- expr(function(x) if (x > 1) f(y$x, "x", g()))
expect_snapshot({
ast(!!x)
})
})
test_that("can print complex expression without unicode", {
old <- options(lobstr.fancy.tree = FALSE)
on.exit(options(old))
x <- expr(function(x) if (x > 1) f(y$x, "x", g()))
expect_snapshot({
ast(!!x)
})
})
test_that("can print scalar expressions nicely", {
old <- options(lobstr.fancy.tree = FALSE)
on.exit(options(old))
x <- expr(list(
logical = c(FALSE, TRUE, NA),
integer = 1L,
double = 1,
character = "a",
complex = 1i
))
expect_snapshot({
ast(!!x)
})
})
lobstr/tests/testthat/test-address.R 0000644 0001762 0000144 00000002440 14253140421 017302 0 ustar ligges users test_that("address of expression varies", {
a <- obj_addr(1:10)
b <- obj_addr(1:10)
expect_false(identical(a, b))
})
test_that("address of variable is constant", {
x <- 1:10
expect_equal(obj_addr(x), obj_addr(x))
})
test_that("address flows through function wrappers", {
x <- 1:10
f <- function(x) obj_addr(x)
g <- function(y) f(y)
h <- function(z) g(z)
address <- obj_addr(x)
expect_equal(f(x), address)
expect_equal(g(x), address)
expect_equal(h(x), address)
})
# addresses ---------------------------------------------------------------
test_that("can find addresses of list elements", {
x <- 1:3
y <- 1:3
addr <- c(obj_addr(x), obj_addr(y))
l <- list(x, y)
expect_equal(obj_addrs(l), addr)
})
test_that("can find addresses of environment elements", {
x <- 1:3
y <- 1:3
addr <- c(obj_addr(x), obj_addr(y))
e1 <- new.env(hash = TRUE)
e1$x <- x
e1$y <- y
expect_setequal(obj_addrs(e1), addr)
e2 <- new.env(hash = FALSE)
e2$x <- x
e2$y <- y
expect_setequal(obj_addrs(e2), addr)
})
test_that("address of character vectors points to global string pool", {
addr <- obj_addrs(c("a", "a", "a"))
expect_equal(addr[[1]], addr[[2]])
})
test_that("addresses of other elements throws errors", {
expect_error(obj_addrs(1:10), "must be a list")
})
lobstr/tests/testthat/test-ref.R 0000644 0001762 0000144 00000002110 14253143157 016434 0 ustar ligges users test_that("basic list display", {
skip_on_os("windows")
test_addr_reset()
expect_snapshot({
x <- 1:10
y <- list(x, x)
ref(
x,
list(),
list(x, x, x),
list(a = x, b = x),
letters
)
})
})
test_that("basic environment display", {
skip_on_os("windows")
test_addr_reset()
expect_snapshot({
e <- env(a = 1:10)
e$b <- e$a
e$c <- e
ref(e)
})
})
test_that("environment shows objects beginning with .", {
skip_on_os("windows")
test_addr_reset()
expect_snapshot({
e <- env(. = 1:10)
ref(e)
})
})
test_that("can display ref to global string pool on request", {
skip_on_os("windows")
test_addr_reset()
expect_snapshot({
ref(c("string", "string", "new string"), character = TRUE)
})
})
test_that("custom methods are never called (#30)", {
# `[[.numeric_number` causes infinite recursion
expect_error(ref(package_version("1.1.1")), NA)
e <- env(a = 1:10)
e$b <- e$a
e$c <- e
# `as.list.data.frame`(, ...) fails
class(e) <- "data.frame"
expect_error(ref(e), NA)
})
lobstr/tests/testthat/test-tree.R 0000644 0001762 0000144 00000011536 14253140421 016622 0 ustar ligges users
test_that("Array-like indices can be shown or hidden", {
testthat::skip_on_os("windows")
expect_snapshot({
tree(list(a = "a", "b", "c"), index_unnamed = TRUE)
})
expect_snapshot({
tree(list(a = "a", "b", "c"), index_unnamed = FALSE)
})
})
test_that("Atomic arrays have sensible defaults w/ truncation for longer than 10-elements",{
testthat::skip_on_os("windows")
expect_snapshot(
tree(
list(
name = "vectored list",
num_vec = 1:10,
char_vec = letters
)
)
)
expect_snapshot(
tree(
list(
name = "vectored list",
num_vec = 1:10,
char_vec = letters
),
hide_scalar_types = FALSE
)
)
})
test_that("Large and multiline strings are handled gracefully", {
testthat::skip_on_os("windows")
expect_snapshot({
long_strings <- list(
"normal string" = "first element",
"really long string" = paste(rep(letters, 4), collapse = ""),
"vec of long strings" = c(
"a long\nand multi\nline string element",
"a fine length",
"another long\nand also multi\nline string element"
)
)
# No truncation of first string
# Really long single string is truncated and elipsesed
# Short string inside vector with long strings is not truncated
tree(long_strings)
# Newline removal can be disabled
tree(long_strings, remove_newlines = FALSE)
})
})
test_that("Max depth and length can be enforced", {
# This test also disables the unicode printing so it can be run on windows
# platforms
old_opts <- options("lobstr.fancy.tree" = FALSE)
on.exit(options(old_opts))
expect_snapshot({
deep_list <- list(
list(
id = "b",
val = 1,
children = list(
list(id = "b1",val = 2.5),
list(
id = "b2",
val = 8,
children = list(
list(id = "b21", val = 4)
)
)
)
),
list(id = "a", val = 2)
)
tree(deep_list, max_depth = 1)
tree(deep_list, max_depth = 2)
tree(deep_list, max_depth = 3)
tree(deep_list, max_length = 0)
tree(deep_list, max_length = 2)
tree(deep_list, max_depth = 1, max_length = 4)
})
})
test_that("Missing values are caught and printed properly", {
testthat::skip_on_os("windows")
expect_snapshot(
tree(
list(
"null-element" = NULL,
"NA-element" = NA
)
)
)
})
test_that("non-named elements in named list", {
testthat::skip_on_os("windows")
expect_snapshot(
tree(list("a" = 1, "el w/o id"))
)
})
test_that("Attributes are properly displayed as special children nodes", {
testthat::skip_on_os("windows")
expect_snapshot({
list_w_attrs <- structure(
list(
structure(
list(id = "a", val = 2),
level = 2,
name = "first child"
),
structure(
list(
id = "b",
val = 1,
children = list(
list(id = "b1", val = 2.5)
)
),
level = 2,
name = "second child",
class = "custom-class"
),
level = "1",
name = "root"
)
)
# Shows attributes
tree(list_w_attrs, show_attributes = TRUE)
# Hides attributes (default)
tree(list_w_attrs, show_attributes = FALSE)
})
})
test_that("Can optionally recurse into environments", {
testthat::skip_on_os("windows")
# Wrapped in a local to avoid different environment setup for code running in
# test_that instead of interactively
# Can't use snapshots here because environment address change on each run
env_printing <- capture.output(
local(
{
ea <- rlang::env(d = 4, e = 5)
tree(rlang::env(ea, a = 1, b = 2, c = 3))
},
envir = rlang::global_env()
)
)
# Seven total nodes should be printed
expect_equal(
length(env_printing),
4
)
# Printed only the names we expected
expect_equal(
mean(
grepl(
pattern = "(environment|a|b|c):",
env_printing
)
),
1
)
# Should only print two environment nodes (aka didn't escape past global env)
expect_equal(
sum(grepl(pattern = "`
│ │ ├─x
│ │ └─1
│ └─█─f
│ ├─█─`$`
│ │ ├─y
│ │ └─x
│ ├─"x"
│ └─█─g
└─
# can print complex expression without unicode
Code
ast(!!x)
Output
o-`function`
+-o-x = ``
+-o-`if`
| +-o-`>`
| | +-x
| | \-1
| \-o-f
| +-o-`$`
| | +-y
| | \-x
| +-"x"
| \-o-g
\-
# can print scalar expressions nicely
Code
ast(!!x)
Output
o-list
+-logical = o-c
| +-FALSE
| +-TRUE
| \-NA
+-integer = 1L
+-double = 1
+-character = "a"
\-complex = 1i
lobstr/tests/testthat/_snaps/ref.md 0000644 0001762 0000144 00000002130 14254707572 017153 0 ustar ligges users # basic list display
Code
x <- 1:10
y <- list(x, x)
ref(x, list(), list(x, x, x), list(a = x, b = x), letters)
Output
[1:0x001]
█ [2:0x002]
█ [3:0x003]
├─[1:0x001]
├─[1:0x001]
└─[1:0x001]
█ [4:0x004]
├─a = [1:0x001]
└─b = [1:0x001]
[5:0x005]
# basic environment display
Code
e <- env(a = 1:10)
e$b <- e$a
e$c <- e
ref(e)
Output
█ [1:0x001]
├─a = [2:0x002]
├─b = [2:0x002]
└─c = [1:0x001]
# environment shows objects beginning with .
Code
e <- env(. = 1:10)
ref(e)
Output
█ [1:0x001]
└─. = [2:0x002]
# can display ref to global string pool on request
Code
ref(c("string", "string", "new string"), character = TRUE)
Output
█ [1:0x001]
├─[2:0x002]
├─[2:0x002]
└─[3:0x003]
lobstr/tests/testthat/_snaps/sxp.md 0000644 0001762 0000144 00000004076 14254707573 017225 0 ustar ligges users # can inspect all atomic vectors
Code
sxp(x)
Output
[1] ()
[2] ()
[3] ()
[4] ()
[5] ()
[6] ()
[7] ()
# can inspect functions
Code
sxp(f)
Output
[1] ()
_formals [2] ()
x [3] ()
y [4] ()
... [3]
_body [5] ()
...
_env [6] ()
# can inspect environments
Code
print(sxp(e2))
Output
[1] ()
_enclos [2] ()
x [3] ()
y [2]
_enclos [4] ()
Code
print(sxp(e2, expand = "environment", max_depth = 5L))
Output
[1] ()
_frame
_hashtab [3] ()
_enclos [4] ()
_frame
_hashtab [5] ()
[6] ()
x [7] ()
[8] ()
y [4]
_enclos [9] ()
# can expand altrep
Code
x <- 1:10
print(sxp(x, expand = "altrep", max_depth = 4L))
Output
[1] (altrep )
_class [2] ()
_attrib [3] ()
[4] ()
[5] ()
[6] ()
_data1 [7] ()
_data2
# can inspect cons cells
Code
cell <- new_node(1, 2)
sxp(cell)
Output
[1] ()
[2] ()
_cdr [3] ()
Code
non_nil_terminated_list <- new_node(1, new_node(2, 3))
sxp(non_nil_terminated_list)
Output
[1] ()
[2] ()
[3] ()
_cdr [4] ()
lobstr/tests/testthat/_snaps/tree.md 0000644 0001762 0000144 00000013141 14254707573 017343 0 ustar ligges users # Array-like indices can be shown or hidden
Code
tree(list(a = "a", "b", "c"), index_unnamed = TRUE)
Output
├─a: "a"
├─2: "b"
└─3: "c"
---
Code
tree(list(a = "a", "b", "c"), index_unnamed = FALSE)
Output
├─a: "a"
├─"b"
└─"c"
# Atomic arrays have sensible defaults w/ truncation for longer than 10-elements
Code
tree(list(name = "vectored list", num_vec = 1:10, char_vec = letters))
Output
├─name: "vectored list"
├─num_vec: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
└─char_vec: "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", ...
---
Code
tree(list(name = "vectored list", num_vec = 1:10, char_vec = letters),
hide_scalar_types = FALSE)
Output
├─name: "vectored list"
├─num_vec: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
└─char_vec: "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", ...
# Large and multiline strings are handled gracefully
Code
long_strings <- list(`normal string` = "first element", `really long string` = paste(
rep(letters, 4), collapse = ""), `vec of long strings` = c(
"a long\nand multi\nline string element", "a fine length",
"another long\nand also multi\nline string element"))
tree(long_strings)
Output
├─normal string: "first element"
├─really long string: "abcdefghijklmnopqrstuvwxyzabcdef..."
└─vec of long strings: "a long↵and m...", "a fine length", "another long..."
Code
tree(long_strings, remove_newlines = FALSE)
Output
├─normal string: "first element"
├─really long string: "abcdefghijklmnopqrstuvwxyzabcdef..."
└─vec of long strings: "a long
and m...", "a fine length", "another long..."
# Max depth and length can be enforced
Code
deep_list <- list(list(id = "b", val = 1, children = list(list(id = "b1", val = 2.5),
list(id = "b2", val = 8, children = list(list(id = "b21", val = 4))))), list(
id = "a", val = 2))
tree(deep_list, max_depth = 1)
Output
+-...
\-...
Code
tree(deep_list, max_depth = 2)
Output
+-
| +-id: "b"
| +-val: 1
| \-children: ...
\-
+-id: "a"
\-val: 2
Code
tree(deep_list, max_depth = 3)
Output
+-
| +-id: "b"
| +-val: 1
| \-children:
| +-...
| \-...
\-
+-id: "a"
\-val: 2
Code
tree(deep_list, max_length = 0)
Output
...
Code
tree(deep_list, max_length = 2)
Output
+-
...
Code
tree(deep_list, max_depth = 1, max_length = 4)
Output
+-...
\-...
# Missing values are caught and printed properly
Code
tree(list(`null-element` = NULL, `NA-element` = NA))
Output
├─null-element:
└─NA-element: NA
# non-named elements in named list
Code
tree(list(a = 1, "el w/o id"))
Output
├─a: 1
└─"el w/o id"
# Attributes are properly displayed as special children nodes
Code
list_w_attrs <- structure(list(structure(list(id = "a", val = 2), level = 2,
name = "first child"), structure(list(id = "b", val = 1, children = list(list(
id = "b1", val = 2.5))), level = 2, name = "second child", class = "custom-class"),
level = "1", name = "root"))
tree(list_w_attrs, show_attributes = TRUE)
Output
├─
│ ├─id: "a"
│ ├─val: 2
│ ├┄attr(,"names"): "id", "val"
│ ├┄attr(,"level"): 2
│ └┄attr(,"name"): "first child"
├─S3
│ ├─id: "b"
│ ├─val: 1
│ ├─children:
│ ┊ └─
│ ┊ ├─id: "b1"
│ ┊ ├─val: 2.5
│ ┊ └┄attr(,"names"): "id", "val"
│ ├┄attr(,"names"): "id", "val", "children"
│ ├┄attr(,"level"): 2
│ ├┄attr(,"name"): "second child"
│ └┄attr(,"class"): "custom-class"
├─level: "1"
├─name: "root"
└┄attr(,"names"): "", "", "level", "name"
Code
tree(list_w_attrs, show_attributes = FALSE)
Output
├─
│ ├─id: "a"
│ └─val: 2
├─S3
│ ├─id: "b"
│ ├─val: 1
│ └─children:
│ └─
│ ├─id: "b1"
│ └─val: 2.5
├─level: "1"
└─name: "root"
# Function arguments get printed
Code
tree(list(no_args = function() { }, few_args = function(a, b, c) { },
lots_of_args = function(d, e, f, g, h, i, j, k, l, m, n, o, p) { }))
Output
├─no_args: function()
├─few_args: function(a, b, c)
└─lots_of_args: function(d, e, f, g, h, ...)
# Handles expressions
Code
tree(list(a = quote(a), b = quote(a + 1), c = y ~ mx + b))
Output
├─a: a
├─b: a + 1
└─c: S3 y ~ mx + b
# Hidden lists dont cause infinite recursion
Code
tree(packageVersion("lobstr"))
Output
S3
└─1, 1, 1, 9000
lobstr/tests/testthat/test-size.R 0000644 0001762 0000144 00000011161 14254621577 016650 0 ustar ligges users expect_same <- function(x, ...) {
lab <- as.character(expr_text(enexpr(x)))
act <- as.vector(obj_size(x))
exp <- as.vector(object.size(x))
msg <- sprintf("`obj_size(%s)` is %s, not %s (\u0394%+i)", lab, act, exp, act - exp)
expect(identical(act, exp), msg)
invisible(act)
}
# S3 methods --------------------------------------------------------------
test_that("combined bytes are aligned", {
expect_snapshot({
new_bytes(c(400, 400000))
})
})
# Compatibility with base ---------------------------------------------------
test_that("size correct for length one vectors", {
expect_same(1)
expect_same(1L)
expect_same("abc")
expect_same(paste(rep("banana", 100), collapse = ""))
expect_same(charToRaw("a"))
expect_same(5 + 1i)
})
test_that("size scales correctly with length (accounting for vector pool)", {
expect_same(numeric())
expect_same(1)
expect_same(2)
expect_same(c(1:10))
expect_same(c(1:1000))
})
test_that("size of list computed recursively", {
expect_same(list())
expect_same(as.list(1))
expect_same(as.list(1:2))
expect_same(as.list(1:3))
expect_same(list(list(list(list(list())))))
})
test_that("size of symbols same as base", {
expect_same(quote(x))
expect_same(quote(asfsadfasdfasdfds))
})
test_that("size of pairlists same as base", {
expect_same(pairlist())
expect_same(pairlist(1))
expect_same(pairlist(1, 2))
expect_same(pairlist(1, 2, 3))
expect_same(pairlist(1, 2, 3, 4))
})
test_that("don't crash with large pairlists", {
n <- 1e5
x <- pairlist(1)
xn <- as.pairlist(rep(1, n))
expect_equal(obj_size(xn), n * obj_size(x))
})
test_that("size of S4 objects same as base", {
Z <- methods::setClass("Z", slots = c(x = "integer"))
z <- Z(x = 1L)
expect_same(z)
})
test_that("size of attributes included in object size", {
expect_same(c(x = 1))
expect_same(list(x = 1))
expect_same(c(x = "y"))
})
test_that("duplicated CHARSXPS only counted once", {
expect_same("x")
expect_same(c("x", "y", "x"))
expect_same(c("banana", "banana", "banana"))
})
test_that("obj_sizes computes relative size", {
x <- 1:10 + 1
out <- obj_sizes(x, x)
expect_equal(out[1], obj_size(x))
expect_equal(out[2], new_bytes(0))
})
# Improved behaviour for shared components ------------------------------------
test_that("shared components only counted once", {
x <- 1:1e3
z <- list(x, x, x)
expect_equal(obj_size(z), obj_size(x) + obj_size(vector("list", 3)))
})
test_that("size of closures same as base", {
f <- function() NULL
attributes(f) <- NULL # zap srcrefs
environment(f) <- emptyenv()
expect_same(f)
})
# Improved behaviour for ALTREP objects -----------------------------------
test_that("altrep size measured correctly", {
skip_if_not(getRversion() > "3.5.0")
# Currently reported size is 640 B
# If regular vector would be 4,000,040 B
# This test is conservative so shouldn't fail in case representation
# changes in the future
expect_true(obj_size(1:1e6) < 10000)
})
test_that("can compute size of deferred string vectors", {
x <- 1:10
names(x) <- 10:1
y <- names(x)
obj_size(y)
# Just assert that it doesn't crash
succeed("Didn't crash")
})
# Environment sizes -----------------------------------------------------------
test_that("terminal environments have size zero", {
expect_equal(obj_size(globalenv()), new_bytes(0))
expect_equal(obj_size(baseenv()), new_bytes(0))
expect_equal(obj_size(emptyenv()), new_bytes(0))
expect_equal(obj_size(asNamespace("stats")), new_bytes(0))
})
test_that("environment size computed recursively", {
e <- new.env(parent = emptyenv())
e_size <- obj_size(e)
f <- new.env(parent = e)
obj_size(f)
expect_equal(obj_size(f), 2 * obj_size(e))
})
test_that("size of function includes environment", {
f <- function() {
y <- 1:1e3
a ~ b
}
g <- function() {
y <- 1:1e3
function() 10
}
expect_true(obj_size(f()) > obj_size(1:1e3))
expect_true(obj_size(g()) > obj_size(1:1e3))
})
test_that("size doesn't include parents of current environment", {
x <- c(1:1e4)
embedded <- (function() {
g <- function() {
x <- c(1:1e3)
a ~ b
}
obj_size(g())
})()
expect_true(embedded < obj_size(x))
})
test_that("support dots in closure environments", {
fn <- (function(...) function() NULL)(foo)
expect_error(obj_size(fn), NA)
})
test_that("supports cons cells", {
cell <- new_node(1, 2)
expect_equal(
obj_size(cell),
obj_size(new_node(NULL, NULL)) + obj_size(1) + obj_size(2)
)
non_nil_terminated_list <- new_node(1, new_node(2, 3))
expect_equal(
obj_size(non_nil_terminated_list),
obj_size(new_node(1, NULL)) + obj_size(cell)
)
})
lobstr/tests/testthat.R 0000644 0001762 0000144 00000000070 13162455060 014703 0 ustar ligges users library(testthat)
library(lobstr)
test_check("lobstr")
lobstr/src/ 0000755 0001762 0000144 00000000000 14254716056 012360 5 ustar ligges users lobstr/src/inspect.cpp 0000644 0001762 0000144 00000023327 14254707527 014543 0 ustar ligges users #include
#include
#include
#include
#include