niki/vendor/golang.org/x/text/secure/bidirule/bidirule.go

// Copyright 2016 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Package bidirule implements the Bidi Rule defined by RFC 5893.

//

// This package is under development. The API may change without notice and

// without preserving backward compatibility.

package bidirule

import (
	"errors"
	"unicode/utf8"

	"golang.org/x/text/transform"
	"golang.org/x/text/unicode/bidi"
)

// This file contains an implementation of RFC 5893: Right-to-Left Scripts for

// Internationalized Domain Names for Applications (IDNA)

//

// A label is an individual component of a domain name.  Labels are usually

// shown separated by dots; for example, the domain name "www.example.com" is

// composed of three labels: "www", "example", and "com".

//

// An RTL label is a label that contains at least one character of class R, AL,

// or AN. An LTR label is any label that is not an RTL label.

//

// A "Bidi domain name" is a domain name that contains at least one RTL label.

//

//  The following guarantees can be made based on the above:

//

//  o  In a domain name consisting of only labels that satisfy the rule,

//     the requirements of Section 3 are satisfied.  Note that even LTR

//     labels and pure ASCII labels have to be tested.

//

//  o  In a domain name consisting of only LDH labels (as defined in the

//     Definitions document [RFC5890]) and labels that satisfy the rule,

//     the requirements of Section 3 are satisfied as long as a label

//     that starts with an ASCII digit does not come after a

//     right-to-left label.

//

//  No guarantee is given for other combinations.

// ErrInvalid indicates a label is invalid according to the Bidi Rule.

var ErrInvalid = errors.New("bidirule: failed Bidi Rule")

type ruleState uint8

const (
	ruleInitial ruleState = iota

	ruleLTR

	ruleLTRFinal

	ruleRTL

	ruleRTLFinal

	ruleInvalid
)

type ruleTransition struct {
	next ruleState

	mask uint16
}

var transitions = [...][2]ruleTransition{

	// [2.1] The first character must be a character with Bidi property L, R, or

	// AL. If it has the R or AL property, it is an RTL label; if it has the L

	// property, it is an LTR label.

	ruleInitial: {

		{ruleLTRFinal, 1 << bidi.L},

		{ruleRTLFinal, 1<<bidi.R | 1<<bidi.AL},
	},

	ruleRTL: {

		// [2.3] In an RTL label, the end of the label must be a character with

		// Bidi property R, AL, EN, or AN, followed by zero or more characters

		// with Bidi property NSM.

		{ruleRTLFinal, 1<<bidi.R | 1<<bidi.AL | 1<<bidi.EN | 1<<bidi.AN},

		// [2.2] In an RTL label, only characters with the Bidi properties R,

		// AL, AN, EN, ES, CS, ET, ON, BN, or NSM are allowed.

		// We exclude the entries from [2.3]

		{ruleRTL, 1<<bidi.ES | 1<<bidi.CS | 1<<bidi.ET | 1<<bidi.ON | 1<<bidi.BN | 1<<bidi.NSM},
	},

	ruleRTLFinal: {

		// [2.3] In an RTL label, the end of the label must be a character with

		// Bidi property R, AL, EN, or AN, followed by zero or more characters

		// with Bidi property NSM.

		{ruleRTLFinal, 1<<bidi.R | 1<<bidi.AL | 1<<bidi.EN | 1<<bidi.AN | 1<<bidi.NSM},

		// [2.2] In an RTL label, only characters with the Bidi properties R,

		// AL, AN, EN, ES, CS, ET, ON, BN, or NSM are allowed.

		// We exclude the entries from [2.3] and NSM.

		{ruleRTL, 1<<bidi.ES | 1<<bidi.CS | 1<<bidi.ET | 1<<bidi.ON | 1<<bidi.BN},
	},

	ruleLTR: {

		// [2.6] In an LTR label, the end of the label must be a character with

		// Bidi property L or EN, followed by zero or more characters with Bidi

		// property NSM.

		{ruleLTRFinal, 1<<bidi.L | 1<<bidi.EN},

		// [2.5] In an LTR label, only characters with the Bidi properties L,

		// EN, ES, CS, ET, ON, BN, or NSM are allowed.

		// We exclude the entries from [2.6].

		{ruleLTR, 1<<bidi.ES | 1<<bidi.CS | 1<<bidi.ET | 1<<bidi.ON | 1<<bidi.BN | 1<<bidi.NSM},
	},

	ruleLTRFinal: {

		// [2.6] In an LTR label, the end of the label must be a character with

		// Bidi property L or EN, followed by zero or more characters with Bidi

		// property NSM.

		{ruleLTRFinal, 1<<bidi.L | 1<<bidi.EN | 1<<bidi.NSM},

		// [2.5] In an LTR label, only characters with the Bidi properties L,

		// EN, ES, CS, ET, ON, BN, or NSM are allowed.

		// We exclude the entries from [2.6].

		{ruleLTR, 1<<bidi.ES | 1<<bidi.CS | 1<<bidi.ET | 1<<bidi.ON | 1<<bidi.BN},
	},

	ruleInvalid: {

		{ruleInvalid, 0},

		{ruleInvalid, 0},
	},
}

// [2.4] In an RTL label, if an EN is present, no AN may be present, and

// vice versa.

const exclusiveRTL = uint16(1<<bidi.EN | 1<<bidi.AN)

// From RFC 5893

// An RTL label is a label that contains at least one character of type

// R, AL, or AN.

//

// An LTR label is any label that is not an RTL label.

// Direction reports the direction of the given label as defined by RFC 5893.

// The Bidi Rule does not have to be applied to labels of the category

// LeftToRight.

func Direction(b []byte) bidi.Direction {

	for i := 0; i < len(b); {

		e, sz := bidi.Lookup(b[i:])

		if sz == 0 {

			i++

		}

		c := e.Class()

		if c == bidi.R || c == bidi.AL || c == bidi.AN {

			return bidi.RightToLeft

		}

		i += sz

	}

	return bidi.LeftToRight

}

// DirectionString reports the direction of the given label as defined by RFC

// 5893. The Bidi Rule does not have to be applied to labels of the category

// LeftToRight.

func DirectionString(s string) bidi.Direction {

	for i := 0; i < len(s); {

		e, sz := bidi.LookupString(s[i:])

		if sz == 0 {

			i++

			continue

		}

		c := e.Class()

		if c == bidi.R || c == bidi.AL || c == bidi.AN {

			return bidi.RightToLeft

		}

		i += sz

	}

	return bidi.LeftToRight

}

// Valid reports whether b conforms to the BiDi rule.

func Valid(b []byte) bool {

	var t Transformer

	if n, ok := t.advance(b); !ok || n < len(b) {

		return false

	}

	return t.isFinal()

}

// ValidString reports whether s conforms to the BiDi rule.

func ValidString(s string) bool {

	var t Transformer

	if n, ok := t.advanceString(s); !ok || n < len(s) {

		return false

	}

	return t.isFinal()

}

// New returns a Transformer that verifies that input adheres to the Bidi Rule.

func New() *Transformer {

	return &Transformer{}

}

// Transformer implements transform.Transform.

type Transformer struct {
	state ruleState

	hasRTL bool

	seen uint16
}

// A rule can only be violated for "Bidi Domain names", meaning if one of the

// following categories has been observed.

func (t *Transformer) isRTL() bool {

	const isRTL = 1<<bidi.R | 1<<bidi.AL | 1<<bidi.AN

	return t.seen&isRTL != 0

}

// Reset implements transform.Transformer.

func (t *Transformer) Reset() { *t = Transformer{} }

// Transform implements transform.Transformer. This Transformer has state and

// needs to be reset between uses.

func (t *Transformer) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {

	if len(dst) < len(src) {

		src = src[:len(dst)]

		atEOF = false

		err = transform.ErrShortDst

	}

	n, err1 := t.Span(src, atEOF)

	copy(dst, src[:n])

	if err == nil || err1 != nil && err1 != transform.ErrShortSrc {

		err = err1

	}

	return n, n, err

}

// Span returns the first n bytes of src that conform to the Bidi rule.

func (t *Transformer) Span(src []byte, atEOF bool) (n int, err error) {

	if t.state == ruleInvalid && t.isRTL() {

		return 0, ErrInvalid

	}

	n, ok := t.advance(src)

	switch {

	case !ok:

		err = ErrInvalid

	case n < len(src):

		if !atEOF {

			err = transform.ErrShortSrc

			break

		}

		err = ErrInvalid

	case !t.isFinal():

		err = ErrInvalid

	}

	return n, err

}

// Precomputing the ASCII values decreases running time for the ASCII fast path

// by about 30%.

var asciiTable [128]bidi.Properties

func init() {

	for i := range asciiTable {

		p, _ := bidi.LookupRune(rune(i))

		asciiTable[i] = p

	}

}

func (t *Transformer) advance(s []byte) (n int, ok bool) {

	var e bidi.Properties

	var sz int

	for n < len(s) {

		if s[n] < utf8.RuneSelf {

			e, sz = asciiTable[s[n]], 1

		} else {

			e, sz = bidi.Lookup(s[n:])

			if sz <= 1 {

				if sz == 1 {

					// We always consider invalid UTF-8 to be invalid, even if

					// the string has not yet been determined to be RTL.

					// TODO: is this correct?

					return n, false

				}

				return n, true // incomplete UTF-8 encoding

			}

		}

		// TODO: using CompactClass would result in noticeable speedup.

		// See unicode/bidi/prop.go:Properties.CompactClass.

		c := uint16(1 << e.Class())

		t.seen |= c

		if t.seen&exclusiveRTL == exclusiveRTL {

			t.state = ruleInvalid

			return n, false

		}

		switch tr := transitions[t.state]; {

		case tr[0].mask&c != 0:

			t.state = tr[0].next

		case tr[1].mask&c != 0:

			t.state = tr[1].next

		default:

			t.state = ruleInvalid

			if t.isRTL() {

				return n, false

			}

		}

		n += sz

	}

	return n, true

}

func (t *Transformer) advanceString(s string) (n int, ok bool) {

	var e bidi.Properties

	var sz int

	for n < len(s) {

		if s[n] < utf8.RuneSelf {

			e, sz = asciiTable[s[n]], 1

		} else {

			e, sz = bidi.LookupString(s[n:])

			if sz <= 1 {

				if sz == 1 {

					return n, false // invalid UTF-8

				}

				return n, true // incomplete UTF-8 encoding

			}

		}

		// TODO: using CompactClass results in noticeable speedup.

		// See unicode/bidi/prop.go:Properties.CompactClass.

		c := uint16(1 << e.Class())

		t.seen |= c

		if t.seen&exclusiveRTL == exclusiveRTL {

			t.state = ruleInvalid

			return n, false

		}

		switch tr := transitions[t.state]; {

		case tr[0].mask&c != 0:

			t.state = tr[0].next

		case tr[1].mask&c != 0:

			t.state = tr[1].next

		default:

			t.state = ruleInvalid

			if t.isRTL() {

				return n, false

			}

		}

		n += sz

	}

	return n, true

}