135 lines
4.8 KiB
Go
135 lines
4.8 KiB
Go
package uniseg
|
|
|
|
import "unicode/utf8"
|
|
|
|
// FirstLineSegment returns the prefix of the given byte slice after which a
|
|
// decision to break the string over to the next line can or must be made,
|
|
// according to the rules of [Unicode Standard Annex #14]. This is used to
|
|
// implement line breaking.
|
|
//
|
|
// Line breaking, also known as word wrapping, is the process of breaking a
|
|
// section of text into lines such that it will fit in the available width of a
|
|
// page, window or other display area.
|
|
//
|
|
// The returned "segment" may not be broken into smaller parts, unless no other
|
|
// breaking opportunities present themselves, in which case you may break by
|
|
// grapheme clusters (using the [FirstGraphemeCluster] function to determine the
|
|
// grapheme clusters).
|
|
//
|
|
// The "mustBreak" flag indicates whether you MUST break the line after the
|
|
// given segment (true), for example after newline characters, or you MAY break
|
|
// the line after the given segment (false).
|
|
//
|
|
// This function can be called continuously to extract all non-breaking sub-sets
|
|
// from a byte slice, as illustrated in the example below.
|
|
//
|
|
// If you don't know the current state, for example when calling the function
|
|
// for the first time, you must pass -1. For consecutive calls, pass the state
|
|
// and rest slice returned by the previous call.
|
|
//
|
|
// The "rest" slice is the sub-slice of the original byte slice "b" starting
|
|
// after the last byte of the identified line segment. If the length of the
|
|
// "rest" slice is 0, the entire byte slice "b" has been processed. The
|
|
// "segment" byte slice is the sub-slice of the input slice containing the
|
|
// identified line segment.
|
|
//
|
|
// Given an empty byte slice "b", the function returns nil values.
|
|
//
|
|
// Note that in accordance with [UAX #14 LB3], the final segment will end with
|
|
// "mustBreak" set to true. You can choose to ignore this by checking if the
|
|
// length of the "rest" slice is 0 and calling [HasTrailingLineBreak] or
|
|
// [HasTrailingLineBreakInString] on the last rune.
|
|
//
|
|
// Note also that this algorithm may break within grapheme clusters. This is
|
|
// addressed in Section 8.2 Example 6 of UAX #14. To avoid this, you can use
|
|
// the [Step] function instead.
|
|
//
|
|
// [Unicode Standard Annex #14]: https://www.unicode.org/reports/tr14/
|
|
// [UAX #14 LB3]: https://www.unicode.org/reports/tr14/#Algorithm
|
|
func FirstLineSegment(b []byte, state int) (segment, rest []byte, mustBreak bool, newState int) {
|
|
// An empty byte slice returns nothing.
|
|
if len(b) == 0 {
|
|
return
|
|
}
|
|
|
|
// Extract the first rune.
|
|
r, length := utf8.DecodeRune(b)
|
|
if len(b) <= length { // If we're already past the end, there is nothing else to parse.
|
|
return b, nil, true, lbAny // LB3.
|
|
}
|
|
|
|
// If we don't know the state, determine it now.
|
|
if state < 0 {
|
|
state, _ = transitionLineBreakState(state, r, b[length:], "")
|
|
}
|
|
|
|
// Transition until we find a boundary.
|
|
var boundary int
|
|
for {
|
|
r, l := utf8.DecodeRune(b[length:])
|
|
state, boundary = transitionLineBreakState(state, r, b[length+l:], "")
|
|
|
|
if boundary != LineDontBreak {
|
|
return b[:length], b[length:], boundary == LineMustBreak, state
|
|
}
|
|
|
|
length += l
|
|
if len(b) <= length {
|
|
return b, nil, true, lbAny // LB3
|
|
}
|
|
}
|
|
}
|
|
|
|
// FirstLineSegmentInString is like [FirstLineSegment] but its input and outputs
|
|
// are strings.
|
|
func FirstLineSegmentInString(str string, state int) (segment, rest string, mustBreak bool, newState int) {
|
|
// An empty byte slice returns nothing.
|
|
if len(str) == 0 {
|
|
return
|
|
}
|
|
|
|
// Extract the first rune.
|
|
r, length := utf8.DecodeRuneInString(str)
|
|
if len(str) <= length { // If we're already past the end, there is nothing else to parse.
|
|
return str, "", true, lbAny // LB3.
|
|
}
|
|
|
|
// If we don't know the state, determine it now.
|
|
if state < 0 {
|
|
state, _ = transitionLineBreakState(state, r, nil, str[length:])
|
|
}
|
|
|
|
// Transition until we find a boundary.
|
|
var boundary int
|
|
for {
|
|
r, l := utf8.DecodeRuneInString(str[length:])
|
|
state, boundary = transitionLineBreakState(state, r, nil, str[length+l:])
|
|
|
|
if boundary != LineDontBreak {
|
|
return str[:length], str[length:], boundary == LineMustBreak, state
|
|
}
|
|
|
|
length += l
|
|
if len(str) <= length {
|
|
return str, "", true, lbAny // LB3.
|
|
}
|
|
}
|
|
}
|
|
|
|
// HasTrailingLineBreak returns true if the last rune in the given byte slice is
|
|
// one of the hard line break code points defined in LB4 and LB5 of [UAX #14].
|
|
//
|
|
// [UAX #14]: https://www.unicode.org/reports/tr14/#Algorithm
|
|
func HasTrailingLineBreak(b []byte) bool {
|
|
r, _ := utf8.DecodeLastRune(b)
|
|
property, _ := propertyLineBreak(r)
|
|
return property == prBK || property == prCR || property == prLF || property == prNL
|
|
}
|
|
|
|
// HasTrailingLineBreakInString is like [HasTrailingLineBreak] but for a string.
|
|
func HasTrailingLineBreakInString(str string) bool {
|
|
r, _ := utf8.DecodeLastRuneInString(str)
|
|
property, _ := propertyLineBreak(r)
|
|
return property == prBK || property == prCR || property == prLF || property == prNL
|
|
}
|