rules

Documentation

Index

• Constants
• type Adapter
  • func NewAdapter() Adapter
• type Amount
• type AmountBuilder
  • func NewAmountBuilder() AmountBuilder
• type Builder
  • func NewBuilder() Builder
• type Content
• type ContentBuilder
  • func NewContentBuilder() ContentBuilder
• type Element
• type ElementBuilder
  • func NewElementBuilder() ElementBuilder
• type Interval
• type IntervalBuilder
  • func NewIntervalBuilder() IntervalBuilder
• type Pattern
• type PatternBuilder
  • func NewPatternBuilder() PatternBuilder
• type Patterns
• type PatternsBuilder
  • func NewPatternsBuilder() PatternsBuilder
• type Possibility
• type PossibilityBuilder
  • func NewPossibilityBuilder() PossibilityBuilder
• type Rule
• type RuleBuilder
  • func NewRuleBuilder() RuleBuilder
• type Rules

Constants

const RulePattern = "[A-Z\\_]+"

RulePattern represents the rule pattern

Types

type Adapter

type Adapter interface {
	ToRules(content string) (Rules, error)
}

Adapter represents a rule adapter

func NewAdapter

func NewAdapter() Adapter

NewAdapter creates a new adapter instance

type Amount

type Amount interface {
	IsExactly() bool
	Exactly() int
	IsInterval() bool
	Interval() Interval
}

Amount represents a possibility amount

type AmountBuilder

type AmountBuilder interface {
	Create() AmountBuilder
	WithExactly(exactly int) AmountBuilder
	WithInterval(interval Interval) AmountBuilder
	Now() (Amount, error)
}

AmountBuilder represents an amount builder

func NewAmountBuilder

func NewAmountBuilder() AmountBuilder

NewAmountBuilder creates a new amount builder

type Builder

type Builder interface {
	Create() Builder
	WithRules(rules []Rule) Builder
	Now() (Rules, error)
}

Builder represents a rules builder

func NewBuilder

func NewBuilder() Builder

NewBuilder creates a new builder instance

type Content

type Content interface {
	IsConstant() bool
	Constant() string
	IsPattern() bool
	Pattern() Pattern
}

Content represents an element content

type ContentBuilder

type ContentBuilder interface {
	Create() ContentBuilder
	WithConstant(constant string) ContentBuilder
	WithPattern(pattern Pattern) ContentBuilder
	Now() (Content, error)
}

ContentBuilder represents a content builder

func NewContentBuilder

func NewContentBuilder() ContentBuilder

NewContentBuilder creates a new content builder

type Element

type Element interface {
	Content() Content
	Code() string
}

Element represents a rule element

type ElementBuilder

type ElementBuilder interface {
	Create() ElementBuilder
	WithContent(content Content) ElementBuilder
	WithCode(code string) ElementBuilder
	Now() (Element, error)
}

ElementBuilder represents an element builder

func NewElementBuilder

func NewElementBuilder() ElementBuilder

NewElementBuilder creates a new element builder

type Interval

type Interval interface {
	Min() int
	HasMax() bool
	Max() int
}

Interval represents an interval

type IntervalBuilder

type IntervalBuilder interface {
	Create() IntervalBuilder
	WithMin(min int) IntervalBuilder
	WithMax(max int) IntervalBuilder
	Now() (Interval, error)
}

IntervalBuilder represents an interval builder

func NewIntervalBuilder

func NewIntervalBuilder() IntervalBuilder

NewIntervalBuilder creates a new interval builder instance

type Pattern

type Pattern interface {
	Name() string
	Code() string
	Pattern() *regexp.Regexp
	Possibility() Possibility
}

Pattern represents a rule pattern

type PatternBuilder

type PatternBuilder interface {
	Create() PatternBuilder
	WithCode(code string) PatternBuilder
	WithPattern(pattern string) PatternBuilder
	WithPossibility(possibility Possibility) PatternBuilder
	Now() (Pattern, error)
}

PatternBuilder represents a pattern builder

func NewPatternBuilder

func NewPatternBuilder() PatternBuilder

NewPatternBuilder creates a new pattern builder instance

type Patterns

type Patterns interface {
	All() []Pattern
	Find(name string) (Pattern, error)
}

Patterns represents a patterns

type PatternsBuilder

type PatternsBuilder interface {
	Create() PatternsBuilder
	WithPatterns(patterns []Pattern) PatternsBuilder
	Now() (Patterns, error)
}

PatternsBuilder represents a patterns builder

func NewPatternsBuilder

func NewPatternsBuilder() PatternsBuilder

NewPatternsBuilder creates a new patterns builder

type Possibility

type Possibility interface {
	List() []string
	Amount() Amount
}

Possibility represents a possibility

type PossibilityBuilder

type PossibilityBuilder interface {
	Create() PossibilityBuilder
	WithList(list []string) PossibilityBuilder
	WithAmount(amount Amount) PossibilityBuilder
	Now() (Possibility, error)
}

PossibilityBuilder represents a possibility builder

func NewPossibilityBuilder

func NewPossibilityBuilder() PossibilityBuilder

NewPossibilityBuilder creates a new possibility builder instance

type Rule

type Rule interface {
	Name() string
	Code() string
	Elements() []Element
}

Rule represents a rule

type RuleBuilder

type RuleBuilder interface {
	Create() RuleBuilder
	WithName(name string) RuleBuilder
	WithCode(code string) RuleBuilder
	WithElements(elements []Element) RuleBuilder
	Now() (Rule, error)
}

RuleBuilder represents a rule builder

func NewRuleBuilder

func NewRuleBuilder() RuleBuilder

NewRuleBuilder creates a new rule builder instance

type Rules

type Rules interface {
	All() []Rule
	Find(name string) (Rule, error)
}

Rules represents rules