camelcase

Documentation

Index

• Constants
• func CamelCaseFilterConstructor(config map[string]interface{}, cache *registry.Cache) (analysis.TokenFilter, error)
• type CamelCaseFilter
  • func NewCamelCaseFilter() *CamelCaseFilter
  • func (f *CamelCaseFilter) Filter(input analysis.TokenStream) analysis.TokenStream
• type LowerCaseState
  • func (s *LowerCaseState) Member(sym rune, peek *rune) bool
  • func (s *LowerCaseState) StartSym(sym rune) bool
• type NonAlphaNumericCaseState
  • func (s *NonAlphaNumericCaseState) Member(sym rune, peek *rune) bool
  • func (s *NonAlphaNumericCaseState) StartSym(sym rune) bool
• type NumberCaseState
  • func (s *NumberCaseState) Member(sym rune, peek *rune) bool
  • func (s *NumberCaseState) StartSym(sym rune) bool
• type Parser
  • func NewParser(length, position, index int) *Parser
  • func (p *Parser) FlushTokens() []*analysis.Token
  • func (p *Parser) NewState(sym rune) State
  • func (p *Parser) NextPosition() int
  • func (p *Parser) Push(sym rune, peek *rune)
• type State
• type UpperCaseState
  • func (s *UpperCaseState) Member(sym rune, peek *rune) bool
  • func (s *UpperCaseState) StartSym(sym rune) bool

Constants

const Name = "camelCase"

Functions

func CamelCaseFilterConstructor

func CamelCaseFilterConstructor(config map[string]interface{}, cache *registry.Cache) (analysis.TokenFilter, error)

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:

1. Upper case followed by lower case letters. Terminated by a number, an upper case letter, and a non alpha-numeric symbol.
2. 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.
3. Lower case followed by lower case letters. Terminated by a number, an upper case letter, and a non alpha-numeric symbol.
4. Number followed by numbers. Terminated by a letter, and a non alpha-numeric symbol.
5. 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) Member

func (s *LowerCaseState) Member(sym rune, peek *rune) bool

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) Member

func (s *NumberCaseState) Member(sym rune, peek *rune) bool

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 NewParser

func NewParser(length, position, index int) *Parser

func (*Parser) FlushTokens

func (p *Parser) FlushTokens() []*analysis.Token

func (*Parser) NewState

func (p *Parser) NewState(sym rune) State

Note. States have to have different starting symbols.

func (*Parser) NextPosition

func (p *Parser) NextPosition() int

func (*Parser) Push

func (p *Parser) Push(sym rune, peek *rune)

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) Member

func (s *UpperCaseState) Member(sym rune, peek *rune) bool

func (*UpperCaseState) StartSym

func (s *UpperCaseState) StartSym(sym rune) bool