about summary refs log tree commit diff
path: root/configs/shared/.emacs.d/wpc/string.el
blob: f8694d5f18a15afdabb3d9a7e1b806c3d65e179c (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
;; string.el --- Library for working with strings -*- lexical-binding: t -*-
;; Author: William Carroll <wpcarro@gmail.com>

;;; Commentary:
;; Library for working with string.

;;; Code:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Dependencies
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(require 's)
(require 'dash)
;; TODO: Resolve the circular dependency that this introduces.
;; (require 'prelude)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Library
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defconst string/test? t
  "When t, run the tests.")

(defun string/contains? (c x)
  "Return t if X is in C."
  (s-contains? c x))

(defun string/hookify (x)
  "Append \"-hook\" to X."
  (s-append "-hook" x))

(defun string/split (y x)
  "Map string X into a list of strings that were separated by Y."
  (s-split y x))

(defun string/ensure-hookified (x)
  "Ensure that X has \"-hook\" appended to it."
  (if (s-ends-with? "-hook" x)
      x
    (string/hookify x)))

(defun string/format (x &rest args)
  "Format template string X with ARGS."
  (apply #'format (cons x args)))

(defun string/concat (&rest strings)
  "Joins `STRINGS' into onto string."
  (apply #'s-concat strings))

(defun string/->symbol (string)
  "Maps `STRING' to a symbol."
  (intern string))

(defun string/<-symbol (symbol)
  "Maps `SYMBOL' into a string."
  (symbol-name symbol))

(defun string/prepend (prefix x)
  "Prepend `PREFIX' onto `X'."
  (s-concat prefix x))

(defun string/append (postfix x)
  "Appen `POSTFIX' onto `X'."
  (s-concat x postfix))

(defun string/surround (s x)
  "Surrounds `X' one each side with `S'."
  (->> x
       (string/prepend s)
       (string/append s)))

;; TODO: Define a macro for defining a function and a test.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Casing
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun string/caps->kebab (x)
  "Change the casing of `X' from CAP_CASE to kebab-case."
  (->> x
       s-downcase
       (s-replace "_" "-")))

(defun string/kebab->caps (x)
  "Change the casing of X from CAP_CASE to kebab-case."
  (->> x
       s-upcase
       (s-replace "-" "_")))

(defun string/lower->caps (x)
  "Change the casing of X from lowercase to CAPS_CASE."
  (->> x
       s-upcase
       (s-replace " " "_")))

(defun string/lower->kebab (x)
  "Change the casing of `X' from lowercase to kebab-case."
  (s-replace " " "-" x))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Predicates
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun string/instance? (x)
  "Return t if X is a string."
  (stringp x))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Tests
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; (when string/test?
;;   (prelude/assert
;;    (string=
;;     (string/surround "-*-" "surround")
;;     "-*-surround-*-"))
;;   (prelude/assert
;;    (string=
;;     (string/caps->kebab "CAPS_CASE_STRING")
;;     "caps-case-string"))
;;   (prelude/assert
;;    (string=
;;     (string/kebab->caps "kebab-case-string")
;;     "KEBAB_CASE_STRING")))

(provide 'string)
;;; string.el ends here