(ns pixie.string

(:require [pixie.stdlib :as std]

[pixie.string.internal :as si]))

; reexport native string functions

(def substring si/substring)

(def index-of (comp #(if (not= -1 %) %) si/index-of))

(def split si/split)

(defn split-lines

"Splits on \\n or \\r\\n, the two typical line breaks."

[s]

(when s (apply concat (map #(split % "\n") (split s "\r\n")))))

(def ends-with? si/ends-with)

(def starts-with? si/starts-with)

(def trim si/trim)

(def triml si/triml)

(def trimr si/trimr)

(def capitalize si/capitalize)

(def lower-case si/lower-case)

(def upper-case si/upper-case)

; TODO: There should be locale-aware variants of these values

(def lower "abcdefghijklmnopqrstuvwxyz")

(def upper "ABCDEFGHIJKLMNOPQRSTUVWXYZ")

(def digits "0123456789")

(def punctuation "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~")

(def whitespace (str \space \newline \tab \backspace \formfeed \return))

(def letters (str lower upper))

(def printable (str letters digits punctuation whitespace))

(def hexdigits "0123456789abcdefABCDEF")

(def octdigits "012345678")

(defn trim-newline

"Replace all trailing newline characters (\\r and \\n) from the end of a string."

[s]

(loop [index (count s)]

(if (zero? index)

""

(let [ch (nth s (dec index))]

(if (or (= ch \newline) (= ch \return))

(recur (dec index))

(substring s 0 index))))))

(defn replace

"Replace all occurrences of x in s with r."

[s x r]

(let [offset (if (zero? (count x)) (+ 1 (count r)) (count r))]

(loop [start 0

s s]

(if-let [i (index-of s x start)]

(recur (+ i offset) (str (substring s 0 i) r (substring s (+ i (count x)))))

s))))

(defn replace-first

"Replace the first occurrence of x in s with r."

[s x r]

(if-let [i (index-of s x)]

(str (substring s 0 i) r (substring s (+ i (count x))))

s))

(defn reverse

"Returns s with its characters reversed."

[s]

(when s

(apply str (std/reverse s))))

(defn join

{:doc "Join the elements of the collection using an optional separator"

:examples [["(require pixie.string :as s)"]

["(s/join [1 2 3])" nil "123"]

["(s/join \", \" [1 2 3])" nil "1, 2, 3"]]}

([coll] (join "" coll))

([separator coll]

(loop [s (seq coll)

res ""]

(cond

(nil? s) res

(nil? (next s)) (str res (first s))

:else (recur (next s) (str res (first s) separator))))))

(defn blank?

"True if s is nil, empty, or contains only whitespace."

[s]

(if s

(let [white (set whitespace)]

(every? white s))

true))

(defn escape

"Return a new string, using cmap to escape each character ch

from s as follows:

If (cmap ch) is nil, append ch to the new string.

If (cmap ch) is non-nil, append (str (cmap ch)) instead."

[s cmap]

(if (or (nil? s)

(nil? cmap))

s

(apply str (map #(if-let [c (cmap %)] c %)

(vec s)))))

(defmacro interp

; TODO: This might merit special read syntax

{:doc "String interpolation."

:examples [["(require pixie.string :refer [interp])"]

["(interp \"2 plus 2 is $(+ 2 2)$!\")" nil "2 plus 2 is 4!"]

["(let [x \"locals\"] (interp \"You can use arbitrary forms; for example $x$\"))"

nil "You can use arbitrary forms; for example locals"]

["(interp \"$$$$ is the escape for a literal $$\")"

nil "$$ is the escape for a literal $"]

]}

[txt]

(loop [forms [], txt txt]

(cond

(empty? txt) `(str ~@ forms)

(starts-with? txt "$")

(let [pos (or (index-of txt "$" 1)

(throw "Unmatched $ in interp argument!"))

form-str (subs txt 1 pos)

form (if (empty? form-str) "$"

(read-string form-str))

rest-str (subs txt (inc pos))]

(recur (conj forms form) rest-str))

:else

(let [pos (or (index-of txt "$")

(count txt))

form (subs txt 0 pos)

rest-str (subs txt pos)]

(recur (conj forms form) rest-str)))))