tupelo.string — tupelo 0.9.108

Tupelo - Making Clojure even sweeter

alpha? clj/s

(alpha? & args)

alphanumeric? clj/s

(alphanumeric? & args)

clip-text clj/s

(clip-text N src-str)

Inputs: [N :- s/Int src-str :- s/Str] Returns: s/Str

Given a multi-line string, returns a string with each line clipped to a max of N chars

collapse-whitespace clj/s

(collapse-whitespace arg)

Replaces all consecutive runs of whitespace characters (including newlines) with a single space. Removes any leading or trailing whitespace. Returns a string composed of all tokens separated by a single space.

contains-match? clj/s

(contains-match? search-str re)

Inputs: [search-str :- s/Str re :- s/Any] Returns: s/Bool

Returns true if the regex matches any portion of the intput string.

contains-str? clj/s

(contains-str? search-str tgt-str)

Inputs: [search-str :- s/Str tgt-str :- s/Str] Returns: s/Bool

Returns true if the intput string contains the target string.

digit? clj/s

(digit? & args)

drop clj/s

(drop n txt)

Inputs: [n :- s/Int txt :- s/Str] Returns: s/Str

Drops the first N chars of a string, returning a string result.

equals-ignore-spacing? clj/s≠

clj

(equals-ignore-spacing? & args)

cljs

(equals-ignore-spacing? & rest25810)

Inputs: [& args :- [s/Str]] Returns: s/Bool

Compares arguments for equality using tupelo.misc/collapse-whitespace. Equivalent to separating tokens by whitespace and comparing the resulting sequences.

fgrep clj/s

(fgrep tgt text)

Inputs: [tgt :- s/Str text :- s/Str]

Given a multi-line text string, returns a string containing lines matching the target string.

grep clj/s

(grep pattern text)

Inputs: [pattern :- s/Regex text :- s/Str]

Given a multi-line text string, returns a string containing lines matching a regex pattern.

hex? clj/s

(hex? & args)

increasing-or-equal? clj/s

(increasing-or-equal? a b)

Inputs: [a :- s/Str b :- s/Str] Returns: s/Bool

Returns true if a pair of strings are in increasing lexicographic order, or equal.

increasing? clj/s

(increasing? a b)

Inputs: [a :- s/Str b :- s/Str] Returns: s/Bool

Returns true if a pair of strings are in increasing lexicographic order.

indent clj/s

(indent n txt)

Inputs: [n :- s/Int txt :- s/Str] Returns: s/Str

Indents a string by pre-pending N spaces. Returns a string result.

indent-lines clj/s

(indent-lines n txt)

Inputs: [n :- s/Int txt :- s/Str] Returns: s/Str

Splits out each line of txt using clojure.string/split-lines, then indents each line by prepending N spaces. Joins lines together into a single string result, with each line terminated by a single ewline.

indent-lines-with clj/s

(indent-lines-with indent-str txt)

Inputs: [indent-str :- s/Str txt :- s/Str] Returns: s/Str

Splits out each line of txt using clojure.string/split-lines, then indents each line by prepending it with the supplied string. Joins lines together into a single string result, with each line terminated by a single ewline.

kabob->snake clj/s

(kabob->snake arg)

Converts a string from a-kabob-case-value to a_snake_case_value

kw-kabob->snake clj/s

(kw-kabob->snake kw)

kw-snake->kabob clj/s

(kw-snake->kabob kw)

lowercase? clj/s

(lowercase? & args)

normalize-str clj/s

(normalize-str str-in)

Returns a 'normalized' version of str-in, stripped of leading/trailing blanks, and with all non-alphanumeric chars converted to hyphens.

not-blank? clj/s

(not-blank? it)

Returns true if the string is not blank.

pad-left clj/s≠

clj

(pad-left str-val N)

(pad-left str-val N pad-char)

cljs

(pad-left G__25909 G__25910)

(pad-left G__25914 G__25915 G__25916)

Inputs: ([str-val :- s/Str N :- s/Int] [str-val :- s/Str N :- s/Int pad-char]) Returns: s/Str

Pads a string on the left until it is at least N chars in size

pad-right clj/s≠

clj

(pad-right str-val N)

(pad-right str-val N pad-char)

cljs

(pad-right G__25923 G__25924)

(pad-right G__25928 G__25929 G__25930)

Inputs: ([str-val :- s/Str N :- s/Int] [str-val :- s/Str N :- s/Int pad-char]) Returns: s/Str

Pads a string on the right until it is at least N chars in size

phonetic-alphabet clj/s

A map from keyword character to string phonetic name: {:a "alpha" :b "bravo" :c "charlie" :d "delta" :e "echo" :f "foxtrot" :g "golf" :h "hotel" :i "india" :j "juliett" :k "kilo" :l "lima" :m "mike" :n "november" :o "oscar" :p "papa" :q "quebec" :r "romeo " :s "sierra" :t "tango" :u "uniform" :v "victor" :w "whiskey" :x "x-ray" :y "yankee" :z "zulu" }

quotes->double clj/s

(quotes->double arg)

Inputs: [arg :- s/Str] Returns: s/Str

quotes->single clj/s

(quotes->single arg)

Inputs: [arg :- s/Str] Returns: s/Str

snake->kabob clj/s

(snake->kabob arg)

Converts a string from a_snake_case_value to a-kabob-case-value

str->kw-normalized clj/s

(str->kw-normalized arg)

Returns a keyword constructed from a normalized string

string->stream clj

(string->stream str-val)

Inputs: [str-val :- s/Str] Returns: InputStream

tabs->spaces clj/s≠

clj

(tabs->spaces src-str)

(tabs->spaces tab-size src-str)

cljs

(tabs->spaces G__25794)

(tabs->spaces G__25798 G__25799)

Inputs: ([src-str :- s/Str] [tab-size :- s/Int src-str :- s/Str]) Returns: s/Str

Replaces all tabs with appropriate number of spaces (default tab-size => 8)

Usage: (tabs->spaces 'abc<tab>def' => 'ab cd' (tabs->spaces 4 'ab<tab>cd' => 'ab cd'

take clj/s

(take n txt)

Inputs: [n :- s/Int txt :- s/Str] Returns: s/Str

Drops the first N chars of a string, returning a string result.

text? clj/s

(text? & args)

uppercase? clj/s

(uppercase? & args)

visible? clj/s

(visible? & args)

whitespace-eol? clj/s

(whitespace-eol? & args)

whitespace-horiz? clj/s

(whitespace-horiz? & args)

whitespace? clj/s

(whitespace? & args)