Emacs用文字列操作ライブラリ s.el の使い方

(s-trim-left " a ")    ; => "a "

" a ".lstrip    # => "a "

(s-trim-right " a ")    ; => " a"

" a ".rstrip    # => " a"

(s-trim " a ")    ; => "a"

" a ".strip    # => "a"

(s-collapse-whitespace "  a  b  c  ")    ; => " a b c "

"  a  b  c  ".squeeze(" ")    # => " a b c "

(s-split "," "a,b,c")    ; => ("a" "b" "c")

"a,b,c".split(/,/)    # => ["a", "b", "c"]

(s-split-up-to "," "a,b,c" 1)    ; => ("a" "b,c")

"a,b,c".split(/,/, 2)    # => ["a", "b,c"]

(s-lines "a\nb\nc")    ; => ("a" "b" "c")

"a\nb\nc".split(/\n/)    # => ["a", "b", "c"]

(s-join "," '("a" "b" "c"))    ; => "a,b,c"

["a", "b", "c"].join(",")    # => "a,b,c"

(s-concat "a" "b" "c")    ; => "abc"

"a" "b" "c"    # => "abc"

(s-prepend "_" "foo")    ; => "_foo"

"_" + "foo"    # => "_foo"

(s-append "_" "foo")    ; => "foo_"

"foo" + "_"    # => "foo_"

(s-repeat 3 "a")    ; => "aaa"

"a" * 3    # => "aaa"

(s-chop-prefix "a" "ax")    ; => "x"

"ax".sub(/\Aa/, "")    # => "x"

(s-chop-prefixes '("a" "b") "abx")    ; => "x"

["a", "b"].inject("abx") { |a, e| a.sub(/\A#{e}/, "") }    # => "x"

(s-chop-suffix "a" "xa")    ; => "x"

"xa".sub(/a\z/, "")    # => "x"

(s-chop-suffixes '("a" "b") "xba")    ; => "x"

["a", "b"].inject("xba") { |a, e| a.sub(/#{e}\z/, "") }    # => "x"

(s-shared-start "axb" "ayb")    ; => "a"

a = "axb"
b = "ayb"
it = b.each_char
i = a.chars.find_index { |e| e != it.next }
i ? a[0...i] : ""    # => "a"

(s-shared-end "axb" "ayb")    ; => "b"

a = "axb"
b = "ayb"
it = b.chars.reverse.each
i = a.chars.reverse.find_index { |e| e != it.next }
i ? a.chars.last(i).join : ""    # => "b"

(s-chomp "a\r\n")    ; => "a"

"a\r\n".chomp    # => "a"

(s-truncate 5 "0123456789")    ; => "01..."

"0123456789".truncate(5)    # => "01..."

(s-word-wrap 4 "a b c")    ; => "a b\nc"

require "nkf"
NKF.nkf("-f#{4.pred} -w", "a b c").rstrip    # => "a b\nc"

# マルチバイト未対応だけど
require "action_view"
include ActionView::Helpers::TextHelper
word_wrap("a b c", line_width: 4)    # => "a b\nc"

(s-center 5 "a")    ; => "  a  "

"a".center(5)    # => "  a  "

(s-pad-right 5 " " "a")    ; => "a    "

"a".ljust(5)    # => "a    "

(s-pad-left 5 " " "a")    ; => "    a"

"a".rjust(5)    # => "    a"

(s-left 2 "012")    ; => "01"

"012"[0...2]    # => "01"

(s-right 2 "012")    ; => "12"

"012"[-2..-1]    # => "12"

(s-ends-with? "c" "abc")    ; => t

"abc".end_with?("c")    # => true

(s-starts-with? "a" "abc")    ; => t

"abc".start_with?("a")    # => true

(s-contains? "b" "abc")    ; => t

"abc".include?("b")    # => true

(s-equals? "a" "a")    ; => t

"a" == "a"    # => true

(s-less? "a" "b")    ; => t

"a" < "b"    # => true

(s-matches? "\\w+" "foo")    ; => t

"foo".match?(/\w+/)    # => true

(s-blank? "")    ; => t

"".blank?    # => true

(s-present? "x")    ; => t

"x".present?    # => true

(s-presence "x")    ; => "x"

"x".presence    # => "x"

(s-lowercase? "foo")    ; => t

"foo".match?(/\A[[:lower:]]*\z/)    # => true

(s-uppercase? "FOO")    ; => t

"FOO".match?(/\A[[:upper:]]*\z/)    # => true

(s-mixedcase? "aBc")    ; => t

str = "aBc"    # => "aBc"
str.match?(/[[:upper:]]/) && str.match?(/[[:lower:]]/)    # => true

(s-capitalized? "Foo")    ; => t

"Foo".match?(/\A[[:upper:]][[:lower:]]/)    # => true

(s-numeric? "123")    ; => t

"123".match?(/\A\d+\z/)    # => true

(s-replace "a" "x" "abab")    ; => "xbxb"

"abab".gsub(/a/, "x")    # => "xbxb"

(s-replace-all '(("a" . "x") ("b" . "y")) "abab")    ; => "xyxy"

{"a" => "x", "b" => "y"}.inject("abab") { |s, (a, b)| s.gsub(a, b) }    # => "xyxy"

(s-downcase "Foo")    ; => "foo"

"Foo".downcase    # => "foo"

(s-upcase "Foo")    ; => "FOO"

"Foo".upcase    # => "FOO"

(s-capitalize "foo_bar")    ; => "Foo_bar"

"foo_bar".capitalize    # => "Foo_bar"

(s-titleize "foo bar")    ; => "Foo Bar"

"foo bar".titleize    # => "Foo Bar"

(s-with "abc" s-upcase s-reverse)    ; => "CBA"

[:upcase, :reverse].reduce("abc", &:send)    # => "CBA"

(s-index-of "bc" "abcd")    ; => 1

"abcd".index("bc")    # => 1

(s-reverse "abc")    ; => "cba"

"abc".reverse    # => "cba"

(s-match-strings-all "\\w\\(\\w\\)" "a1 a2")    ; => (("a1" "1") ("a2" "2"))

"a1 a2".scan(/(\w(\w+))/)    # => [["a1", "1"], ["a2", "2"]]

(s-match "\\w\\(\\w+\\)" "a1 a2")    ; => ("a1" "1")

"a1 a2".match(/\w(\w+)/).to_a    # => ["a1", "1"]

(s-slice-at "a" "a1a2a3")    ; => ("a1" "a2" "a3")

"a1a2a3".split(/(?=a)/)    # => ["a1", "a2", "a3"]

; どんなルールだこれ
(s-split-words "ABCde ABC1 AbCd")    ; => ("AB" "Cde" "AB" "C1" "Ab" "Cd")

s = "ABCde ABC1 AbCd"
s = s.gsub(/([[:upper:]])([[:upper:]][\d[:lower:]])/, '\1 \2')    # => "AB Cde AB C1 AbCd"
s = s.gsub(/([[:lower:]])([[:upper:]])/, '\1 \2')    # => "AB Cde AB C1 Ab Cd"
s.split(/[^[:word:]]+/)    # => ["AB", "Cde", "AB", "C1", "Ab", "Cd"]

(s-lower-camel-case "foo-bar")    ; => "fooBar"

"foo-bar".underscore.camelize(:lower)    # => "fooBar"

(s-upper-camel-case "foo-bar")    ; => "FooBar"

"foo-bar".underscore.camelize    # => "FooBar"

(s-snake-case "foo-bar")    ; => "foo_bar"

"foo-bar".underscore    # => "foo_bar"

(s-dashed-words "FooBar")    ; => "foo-bar"

"FooBar".underscore.dasherize    # => "foo-bar"

(s-capitalized-words "FOO BAR")    ; => "Foo bar"

words = "FOO BAR".split(/\s+/)
[words.first.capitalize, words.drop(1).collect(&:downcase)].join(" ")    # => "Foo bar"

(s-titleized-words "foo bar")    ; => "Foo Bar"

"foo bar".split(/\s+/).collect(&:capitalize) * " "    # => "Foo Bar"

(s-word-initials "foo bar")    ; => "fb"

"foo bar".scan(/(\w)\w*/).join    # => "fb"

;; alist
(s-format "${a}" 'aget '(("a" . "x") ("b" . "y")))    ; => "x"
;; sequence
(s-format "$0" 'elt ["x" "y"])    ; => "x"
;; hash
(setq v (make-hash-table :test 'equal))
(puthash "a" "x" v)
(puthash "b" "y" v)
(s-format "${a}" 'gethash v)    ; => "x"

"%{a}" % {a: "x", b: "y"}    # => "x"
"%1$s" % ["x", "y"]    # => "x"

(setq a '(1 2 3))
(s-lex-format "a = ${a}")    ; => "a = (1 2 3)"

a = [1, 2, 3]
"a = #{a}"    # => "a = [1, 2, 3]"

(setq a '(1 . 2))    ; => (1 . 2)
(setq v (s-lex-fmt|expand "${a}"))    ; => (s-format "${a}" (quote aget) (list (cons "a" (format (if s-lex-value-as-lisp "%S" "%s") a))))
(eval v)    ; => "(1 . 2)"

(s-count-matches "\\w+" "a b c")    ; => 3

"a b c".scan(/\w+/).count    # => 3

(s-wrap "foo" "(" ")")    ; => "(foo)"

"(" + "foo" + ")"    # => "(foo)"