tests/testthat/_snaps/inline-2.md

In cli: Helpers for Developing Command Line Interfaces

quoting phrases that don't start or end with letter or number [plain]

Code
  local({
    x0 <- "good-name"
    cli_text("The name is {.file {x0}}.")
    x <- "weird-name "
    cli_text("The name is {.file {x}}.")
    cli_text("The name is {.path {x}}.")
    cli_text("The name is {.email {x}}.")
  })
Message
  The name is 'good-name'.
  The name is 'weird-name '.
  The name is 'weird-name '.
  The name is 'weird-name '.

quoting phrases that don't start or end with letter or number [ansi]

Code
  local({
    x0 <- "good-name"
    cli_text("The name is {.file {x0}}.")
    x <- "weird-name "
    cli_text("The name is {.file {x}}.")
    cli_text("The name is {.path {x}}.")
    cli_text("The name is {.email {x}}.")
  })
Message
  The name is [34mgood-name[39m.
  The name is '[34mweird-name[39m[44m [49m'.
  The name is '[34mweird-name[39m[44m [49m'.
  The name is '[34mweird-name[39m[44m [49m'.

quoting weird names, still [plain]

Code
  local({
    cat_line(nb(quote_weird_name("good")))
    cat_line(nb(quote_weird_name("  bad")))
    cat_line(nb(quote_weird_name("bad  ")))
    cat_line(nb(quote_weird_name("  bad  ")))
  })
Output
  'good'
  '  bad'
  'bad  '
  '  bad  '

quoting weird names, still [ansi]

Code
  local({
    cat_line(nb(quote_weird_name("good")))
    cat_line(nb(quote_weird_name("  bad")))
    cat_line(nb(quote_weird_name("bad  ")))
    cat_line(nb(quote_weird_name("  bad  ")))
  })
Output
  good
  '[44m  [49mbad'
  'bad[44m  [49m'
  '[44m  [49mbad[44m  [49m'

~/ files are not weird [ansi]

Code
  local({
    cat_line(nb(quote_weird_name("~/good")))
    cat_line(nb(quote_weird_name("~~bad")))
    cat_line(nb(quote_weird_name("bad~  ")))
    cat_line(nb(quote_weird_name(" ~ bad ~ ")))
  })
Output
  ~/good
  '~~bad'
  'bad~[44m  [49m'
  '[44m [49m~ bad ~[44m [49m'

custom truncation [plain]

Code
  x <- cli_vec(1:100, list(`vec-trunc` = 5))
  cli_text("Some numbers: {x}.")
Message
  Some numbers: 1, 2, 3, ..., 99, and 100.
Code
  cli_text("Some numbers: {.val {x}}.")
Message
  Some numbers: 1, 2, 3, ..., 99, and 100.

custom truncation [ansi]

Code
  x <- cli_vec(1:100, list(`vec-trunc` = 5))
  cli_text("Some numbers: {x}.")
Message
  Some numbers: 1, 2, 3, ..., 99, and 100.
Code
  cli_text("Some numbers: {.val {x}}.")
Message
  Some numbers: [34m1[39m, [34m2[39m, [34m3[39m, ..., [34m99[39m, and [34m100[39m.

custom truncation [unicode]

Code
  x <- cli_vec(1:100, list(`vec-trunc` = 5))
  cli_text("Some numbers: {x}.")
Message
  Some numbers: 1, 2, 3, …, 99, and 100.
Code
  cli_text("Some numbers: {.val {x}}.")
Message
  Some numbers: 1, 2, 3, …, 99, and 100.

custom truncation [fancy]

Code
  x <- cli_vec(1:100, list(`vec-trunc` = 5))
  cli_text("Some numbers: {x}.")
Message
  Some numbers: 1, 2, 3, …, 99, and 100.
Code
  cli_text("Some numbers: {.val {x}}.")
Message
  Some numbers: [34m1[39m, [34m2[39m, [34m3[39m, …, [34m99[39m, and [34m100[39m.

collapsing class names [plain]

Code
  local({
    cc <- c("one", "two")
    cli_text("this is a class: {.cls myclass}")
    cli_text("multiple classes: {.cls {cc}}")
  })
Message
  this is a class: <myclass>
  multiple classes: <one/two>

collapsing class names [ansi]

Code
  local({
    cc <- c("one", "two")
    cli_text("this is a class: {.cls myclass}")
    cli_text("multiple classes: {.cls {cc}}")
  })
Message
  this is a class: [34m<myclass>[39m
  multiple classes: [34m<one/two>[39m

transform [plain]

Code
  local({
    cli_text("This is a {.field field} (before)")
    foo <- (function(x) toupper(x))
    cli_div(theme = list(span.field = list(transform = foo)))
    cli_text("This is a {.field field} (during)")
    cli_end()
    cli_text("This is a {.field field} (after)")
  })
Message
  This is a field (before)
  This is a FIELD (during)
  This is a field (after)

transform [ansi]

Code
  local({
    cli_text("This is a {.field field} (before)")
    foo <- (function(x) toupper(x))
    cli_div(theme = list(span.field = list(transform = foo)))
    cli_text("This is a {.field field} (during)")
    cli_end()
    cli_text("This is a {.field field} (after)")
  })
Message
  This is a [32mfield[39m (before)
  This is a [32mFIELD[39m (during)
  This is a [32mfield[39m (after)

cli_format

Code
  cli_format(1:4 / 7, list(digits = 2))
Output
  [1] 0.14 0.29 0.43 0.57

cli_format() is used for .val

Code
  local({
    cli_div(theme = list(.val = list(digits = 2)))
    cli_text("Some random numbers: {.val {runif(4)}}.")
  })
Message
  Some random numbers: 0.91, 0.94, 0.29, and 0.83.

.q always double quotes

Code
  cli_text("just a {.q string}, nothing more")
Message
  just a "string", nothing more

.or

Code
  cli_text("{.or {letters[1:5]}}")
Message
  a, b, c, d, or e

Code
  cli_text("{.or {letters[1:2]}}")
Message
  a or b

line breaks

Code
  ansi_strwrap(txt2, width = 60)
Output
  <cli_ansi_string>
  [1] Cupidatat deserunt culpa enim deserunt minim aliqua tempor
  [2] fugiat cupidatat laboris officia esse ex aliqua. Ullamco  
  [3] mollit adipisicing anim.                                  
  [4] Cupidatat deserunt culpa enim deserunt minim aliqua tempor
  [5] fugiat cupidatat laboris officia esse ex aliqua. Ullamco  
  [6] mollit adipisicing anim.

double ticks [ansi]

Code
  format_inline("{.code {x}}")
Output
  [1] "\033[31m`a`\033[39m, \033[31m`` `x` ``\033[39m, and \033[31m`b`\033[39m"

Code
  format_inline("{.fun {x}}")
Output
  [1] "\033[31m`a()`\033[39m, \033[31m`` `x` ()``\033[39m, and \033[31m`b()`\033[39m"

do not inherit 'transform' issue #422

Code
  d <- deparse(c("cli", "glue"))
  cli::cli_alert_info("To install, run {.code install.packages({d})}")
Message
  i To install, run `install.packages(c("cli", "glue"))`

Code
  cli::cli_text("{.code foo({1+1})}")
Message
  `foo(2)`

no inherit color, issue #474 [plain]

Code
  cli::cli_text("pre {.val x {'foo'} y} post")
Message
  pre "x foo y" post

no inherit color, issue #474 [ansi]

Code
  cli::cli_text("pre {.val x {'foo'} y} post")
Message
  pre [34m"x foo y"[39m post

\f at the end, issue #491 [plain]

Code
  cli_fmt(cli::cli_text("{.val a}{.val b}"))
Output
  [1] "\"a\"\"b\""
Code
  cli_fmt(cli::cli_text("\f{.val a}{.val b}"))
Output
  [1] ""           "\"a\"\"b\""
Code
  cli_fmt(cli::cli_text("\f\f{.val a}{.val b}"))
Output
  [1] ""           ""           "\"a\"\"b\""
Code
  cli_fmt(cli::cli_text("{.val a}\f{.val b}"))
Output
  [1] "\"a\"" "\"b\""
Code
  cli_fmt(cli::cli_text("{.val a}\f\f{.val b}"))
Output
  [1] "\"a\"" ""      "\"b\""
Code
  cli_fmt(cli::cli_text("{.val a}{.val b}\f"))
Output
  [1] "\"a\"\"b\"" ""          
Code
  cli_fmt(cli::cli_text("{.val a}{.val b}\f\f"))
Output
  [1] "\"a\"\"b\"" ""           ""          
Code
  cli_fmt(cli::cli_text("\f\f\f{.val a}\f\f\f{.val b}\f\f\f"))
Output
   [1] ""      ""      ""      "\"a\"" ""      ""      "\"b\"" ""      ""     
  [10] ""

\f at the end, issue #491 [ansi]

Code
  cli_fmt(cli::cli_text("{.val a}{.val b}"))
Output
  [1] "\033[34m\"a\"\"b\"\033[39m"
Code
  cli_fmt(cli::cli_text("\f{.val a}{.val b}"))
Output
  [1] ""                           "\033[34m\"a\"\"b\"\033[39m"
Code
  cli_fmt(cli::cli_text("\f\f{.val a}{.val b}"))
Output
  [1] ""                           ""                          
  [3] "\033[34m\"a\"\"b\"\033[39m"
Code
  cli_fmt(cli::cli_text("{.val a}\f{.val b}"))
Output
  [1] "\033[34m\"a\"\033[39m" "\033[34m\"b\"\033[39m"
Code
  cli_fmt(cli::cli_text("{.val a}\f\f{.val b}"))
Output
  [1] "\033[34m\"a\"\033[39m" ""                      "\033[34m\"b\"\033[39m"
Code
  cli_fmt(cli::cli_text("{.val a}{.val b}\f"))
Output
  [1] "\033[34m\"a\"\"b\"\033[39m" ""                          
Code
  cli_fmt(cli::cli_text("{.val a}{.val b}\f\f"))
Output
  [1] "\033[34m\"a\"\"b\"\033[39m" ""                          
  [3] ""                          
Code
  cli_fmt(cli::cli_text("\f\f\f{.val a}\f\f\f{.val b}\f\f\f"))
Output
   [1] ""                      ""                      ""                     
   [4] "\033[34m\"a\"\033[39m" ""                      ""                     
   [7] "\033[34m\"b\"\033[39m" ""                      ""                     
  [10] ""

truncate vectors at 20

Code
  cli::cli_text("Some letters: {letters}")
Message
  Some letters: a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, ..., y, and
  z

brace expresssion edge cases [ansi]

Code
  cli_text("{.code {foo} and {bar}}")
Message
  `foo and bar`
Code
  cli_text("{.emph {foo} and {bar}}")
Message
  [3mfoo and bar[23m
Code
  cli_text("{.q {foo} and {bar}}")
Message
  "foo and bar"

various errors

! Invalid cli literal: `{.foobar}` starts with a dot.
i Interpreted literals must not start with a dot in cli >= 3.4.0.
i `{}` expressions starting with a dot are now only used for cli styles.
i To avoid this error, put a space character after the starting `{` or use parentheses: `{(.foobar)}`.

! Invalid cli literal: `{.someve...}` starts with a dot.
i Interpreted literals must not start with a dot in cli >= 3.4.0.
i `{}` expressions starting with a dot are now only used for cli styles.
i To avoid this error, put a space character after the starting `{` or use parentheses: `{(.someve...)}`.

Code
  cli_text("xx {1 + 'a'} yy")
Condition
  Error:
  ! Could not evaluate cli `{}` expression: `1 + 'a'`.
  Caused by error:
  ! non-numeric argument to binary operator

format_inline and newlines

Code
  format_inline("foo\nbar")
Output
  [1] "foo\nbar"
Code
  format_inline("\nfoo\n\nbar\n")
Output
  [1] "\nfoo\n\nbar\n"
Code
  format_inline("foo\fbar")
Output
  [1] "foo\fbar"
Code
  format_inline("\ffoo\f\fbar\f")
Output
  [1] "\ffoo\f\fbar\f"

Code
  format_inline("foo\nbar", keep_whitespace = FALSE)
Output
  [1] "foo bar"
Code
  format_inline("\nfoo\n\nbar\n", keep_whitespace = FALSE)
Output
  [1] "foo\n\nbar"
Code
  format_inline("foo\fbar", keep_whitespace = FALSE)
Output
  [1] "foo\nbar"
Code
  format_inline("\ffoo\f\fbar\f", keep_whitespace = FALSE)
Output
  [1] "\nfoo\n\nbar\n"

cli documentation built on March 31, 2023, 9:04 p.m.