blob: 9f538708dfe64ce3c63e09135f3440387a87abff [file] [log] [blame]
// Copyright 2018 The CUE Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package strings implements simple functions to manipulate UTF-8 encoded
// strings.package strings.
//
// Some of the functions in this package are specifically intended as field
// constraints. For instance, MaxRunes as used in this CUE program
//
// import "strings"
//
// myString: strings.MaxRunes(5)
//
// specifies that the myString should be at most 5 code points.
package strings
import (
"fmt"
"strings"
"unicode"
)
// ByteAt reports the ith byte of the underlying strings or byte.
func ByteAt(b []byte, i int) (byte, error) {
if i < 0 || i >= len(b) {
return 0, fmt.Errorf("index out of range")
}
return b[i], nil
}
// ByteSlice reports the bytes of the underlying string data from the start
// index up to but not including the end index.
func ByteSlice(b []byte, start, end int) ([]byte, error) {
if start < 0 || start > end || end > len(b) {
return nil, fmt.Errorf("index out of range")
}
return b[start:end], nil
}
// Runes returns the Unicode code points of the given string.
func Runes(s string) []rune {
return []rune(s)
}
// MinRunes reports whether the number of runes (Unicode codepoints) in a string
// is at least a certain minimum. MinRunes can be used a a field constraint to
// except all strings for which this property holds.
func MinRunes(s string, min int) bool {
// TODO: CUE strings cannot be invalid UTF-8. In case this changes, we need
// to use the following conversion to count properly:
// s, _ = unicodeenc.UTF8.NewDecoder().String(s)
return len([]rune(s)) >= min
}
// MaxRunes reports whether the number of runes (Unicode codepoints) in a string
// exceeds a certain maximum. MaxRunes can be used a a field constraint to
// except all strings for which this property holds
func MaxRunes(s string, max int) bool {
// See comment in MinRunes implementation.
return len([]rune(s)) <= max
}
// ToTitle returns a copy of the string s with all Unicode letters that begin
// words mapped to their title case.
func ToTitle(s string) string {
// Use a closure here to remember state.
// Hackish but effective. Depends on Map scanning in order and calling
// the closure once per rune.
prev := ' '
return strings.Map(
func(r rune) rune {
if unicode.IsSpace(prev) {
prev = r
return unicode.ToTitle(r)
}
prev = r
return r
},
s)
}
// ToCamel returns a copy of the string s with all Unicode letters that begin
// words mapped to lower case.
func ToCamel(s string) string {
// Use a closure here to remember state.
// Hackish but effective. Depends on Map scanning in order and calling
// the closure once per rune.
prev := ' '
return strings.Map(
func(r rune) rune {
if unicode.IsSpace(prev) {
prev = r
return unicode.ToLower(r)
}
prev = r
return r
},
s)
}
// SliceRunes returns a string of the underlying string data from the start index
// up to but not including the end index.
func SliceRunes(s string, start, end int) (string, error) {
runes := []rune(s)
if start < 0 || start > end || end > len(runes) {
return "", fmt.Errorf("index out of range")
}
return string(runes[start:end]), nil
}