str.go

package typing

import (
	"strconv"
	"strings"
	"unicode"
)

type Str string

func (s Str) Equals(other string) bool {
	return string(s) == other
}

func (s Str) Len() int {
	return len(s)
}

func (s Str) ToBytes() []byte {
	return []byte(s)
}

func (s Str) ToString() string {
	return string(s)
}

func (s Str) ToRunes() []rune {
	return []rune(s)
}

func (s Str) ToInt() (int, error) {
	return strconv.Atoi(string(s))
}

func (s Str) ToInt64() (int64, error) {
	return strconv.ParseInt(string(s), 10, 64)
}

func (s Str) ToFloat64() (float64, error) {
	return strconv.ParseFloat(string(s), 64)
}

func (s Str) ToBool() (bool, error) {
	return strconv.ParseBool(string(s))
}

func (s Str) Upper() Str {
	return Str(strings.ToUpper(string(s)))
}

func (s Str) Lower() Str {
	return Str(strings.ToLower(string(s)))
}

func (s Str) Split(sep string) []Str {
	return s.SplitN(sep, -1)
}

func (s Str) SplitN(sep string, n int) []Str {
	ss := strings.SplitN(string(s), sep, n)
	ret := make([]Str, len(ss))
	for i, s_ := range ss {
		ret[i] = Str(s_)
	}
	return ret
}

func (s Str) SplitLines() []Str {
	return s.Split("\n")
}

func (s Str) RSplitN(sep string, n int) []Str {
	if n <= 0 {
		return s.Split(sep)
	}

	if sep == "" {
		return []Str{s}
	}

	var res []Str
	for n > 0 {
		idx := s.LastIndex(sep)
		if idx == -1 {
			break
		}
		res = append([]Str{s[idx+len(sep):]}, res...)
		s = s[:idx]
		n--
	}
	res = append([]Str{s}, res...)
	return res
}

func (s Str) Replace(old, new string) Str {
	return s.ReplaceN(old, new, -1)
}

func (s Str) ReplaceN(old, new string, n int) Str {
	return Str(strings.Replace(string(s), old, new, n))
}

func (s Str) Trim(cutset string) Str {
	return Str(strings.Trim(string(s), cutset))
}

func (s Str) TrimLeft(cutset string) Str {
	return Str(strings.TrimLeft(string(s), cutset))
}

func (s Str) TrimRight(cutset string) Str {
	return Str(strings.TrimRight(string(s), cutset))
}

func (s Str) IsLower() bool {
	hasLetter := false
	for _, r := range s {
		if unicode.IsLetter(r) {
			hasLetter = true
			if !unicode.IsLower(r) {
				return false
			}
		}
	}
	return hasLetter
}

func (s Str) IsUpper() bool {
	return s == s.Upper()
}

func (s Str) HasPrefix(prefix string) bool {
	return strings.HasPrefix(string(s), prefix)
}

func (s Str) HasSuffix(suffix string) bool {
	return strings.HasSuffix(string(s), suffix)
}

func (s Str) Contains(substr string) bool {
	return s.Index(substr) >= 0
}

func (s Str) ContainsAny(chars string) bool {
	return s.IndexAny(chars) >= 0
}

func (s Str) RemovePrefix(prefix string) Str {
	return s.TrimLeft(prefix)
}

func (s Str) RemoveSuffix(suffix string) Str {
	return s.TrimRight(suffix)
}

func (s Str) Repeat(count int) Str {
	return Str(strings.Repeat(string(s), count))
}

func (s Str) Join(ss []string) Str {
	return Str(strings.Join(ss, string(s)))
}

func (s Str) Index(sub string) int {
	return strings.Index(string(s), sub)
}

func (s Str) IndexAny(chars string) int {
	return strings.IndexAny(string(s), chars)
}

func (s Str) LastIndex(sub string) int {
	return strings.LastIndex(string(s), sub)
}

func (s Str) SwapCase() Str {
	var b strings.Builder
	for _, r := range s {
		switch {
		case unicode.IsUpper(r):
			b.WriteRune(unicode.ToLower(r))
		case unicode.IsLower(r):
			b.WriteRune(unicode.ToUpper(r))
		default:
			b.WriteRune(r)
		}
	}
	return Str(b.String())
}

func tokenize(s string) []string {
	var tokens []string
	var buf []rune

	flush := func() {
		if len(buf) > 0 {
			tokens = append(tokens, strings.ToLower(string(buf)))
			buf = buf[:0]
		}
	}

	runes := []rune(s)
	for i, r := range runes {
		// 1. 非字母数字，直接切
		if !unicode.IsLetter(r) && !unicode.IsDigit(r) {
			flush()
			continue
		}

		// 2. 大小写边界
		if unicode.IsUpper(r) {
			if len(buf) > 0 {
				prev := buf[len(buf)-1]
				var next rune
				if i+1 < len(runes) {
					next = runes[i+1]
				}

				if unicode.IsLower(prev) ||
					(next != 0 && unicode.IsLower(next)) {
					flush()
				}
			}
		}

		// 3. 字母 ↔ 数字边界
		if len(buf) > 0 {
			prev := buf[len(buf)-1]
			if unicode.IsDigit(r) != unicode.IsDigit(prev) {
				flush()
			}
		}

		buf = append(buf, r)
	}

	flush()
	return tokens
}

func (s Str) SnakeCase() Str {
	tokens := tokenize(string(s))
	return Str(strings.Join(tokens, "_"))
}

func (s Str) CamelCase() Str {
	tokens := tokenize(string(s))
	if len(tokens) == 0 {
		return ""
	}

	var b strings.Builder

	for i, t := range tokens {
		if i == 0 {
			b.WriteString(t)
			continue
		}
		b.WriteString(strings.ToTitle(t))
	}
	return Str(b.String())
}