Documentation
¶
Index ¶
Constants ¶
const Name = "camelCase"
Variables ¶
This section is empty.
Functions ¶
Types ¶
type CamelCaseFilter ¶
type CamelCaseFilter struct{}
CamelCaseFilter splits a given token into a set of tokens where each resulting token falls into one the following classes:
- Upper case followed by lower case letters. Terminated by a number, an upper case letter, and a non alpha-numeric symbol.
- Upper case followed by upper case letters. Terminated by a number, an upper case followed by a lower case letter, and a non alpha-numeric symbol.
- Lower case followed by lower case letters. Terminated by a number, an upper case letter, and a non alpha-numeric symbol.
- Number followed by numbers. Terminated by a letter, and a non alpha-numeric symbol.
- Non alpha-numeric symbol followed by non alpha-numeric symbols. Terminated by a number, and a letter.
It does a one-time sequential pass over an input token, from left to right. The scan is greedy and generates the longest substring that fits into one of the classes.
See the test file for examples of classes and their parsings.
func NewCamelCaseFilter ¶
func NewCamelCaseFilter() *CamelCaseFilter
func (*CamelCaseFilter) Filter ¶
func (f *CamelCaseFilter) Filter(input analysis.TokenStream) analysis.TokenStream
type LowerCaseState ¶
type LowerCaseState struct{}
func (*LowerCaseState) StartSym ¶
func (s *LowerCaseState) StartSym(sym rune) bool
type NonAlphaNumericCaseState ¶
type NonAlphaNumericCaseState struct{}
func (*NonAlphaNumericCaseState) Member ¶
func (s *NonAlphaNumericCaseState) Member(sym rune, peek *rune) bool
func (*NonAlphaNumericCaseState) StartSym ¶
func (s *NonAlphaNumericCaseState) StartSym(sym rune) bool
type NumberCaseState ¶
type NumberCaseState struct{}
func (*NumberCaseState) StartSym ¶
func (s *NumberCaseState) StartSym(sym rune) bool
type Parser ¶
type Parser struct {
// contains filtered or unexported fields
}
Parser accepts a symbol and passes it to the current state (representing a class). The state can accept it (and accumulate it). Otherwise, the parser creates a new state that starts with the pushed symbol.
Parser accumulates a new resulting token every time it switches state. Use FlushTokens() to get the results after the last symbol was pushed.
func (*Parser) FlushTokens ¶
func (*Parser) NextPosition ¶
type State ¶
type State interface {
// is _sym_ the start character
StartSym(sym rune) bool
// is _sym_ a member of a class.
// peek, the next sym on the tape, can also be used to determine a class.
Member(sym rune, peek *rune) bool
}
States codify the classes that the parser recognizes.
type UpperCaseState ¶
type UpperCaseState struct {
// contains filtered or unexported fields
}
func (*UpperCaseState) StartSym ¶
func (s *UpperCaseState) StartSym(sym rune) bool
Source Files