wordShuffler

type AdvanceSuffleRule interface {
	// shuffle the given sequence and return a list of possible "words"
	Shuffle(sequence string, optionalArgs ...map[string]interface{}) ([]string, error)
}

type CambridgeRule struct{}

type DLGlosbe struct {
	// contains filtered or unexported fields
}

type DLPearson struct {
	// contains filtered or unexported fields
}

type DictionaryLookup struct {
	// contains filtered or unexported fields
}

type DictionaryLookupEngine interface {
	// returns an arbitrary string to describe the lookup engine (e.g. webster dictionary api)
	Source() string
	// do the lookup for the given "word", wraps the results into
	// an array of DictionaryLookupResult
	Lookup(word string, optionalParams map[string]interface{}) ([]DictionaryLookupResult, error)
}

type DictionaryLookupResult struct {
	Text     string
	Language string
}

type DictionaryMatcher struct {
	// contains filtered or unexported fields
}

type GramSequencer struct {
	// the sequence involved for "word" formation and matching later on
	Sequence string
	// contains filtered or unexported fields
}

type MatcherRule interface {
	// method to match the given word against a "source"; could be a dictionary.
	MatchWord(word string) (bool, error)
}

type SequenceShufflerRule struct {
	// the minimum size of the "words" to be created from the given sequence.
	// Theoretically it should be at least "2"
	MinGramSize int
	// optional size threshold for the sequence generation (remember the
	// longer is the sequence, the more computation is required)
	MaxGramSize int
	// contains filtered or unexported fields
}

type ShuffleRule interface {
	// shuffle the given / old text based on its unique rules
	Shuffle(oldText string) (string, error)
}

type Shuffler struct {
	// location of the file containing the text (could be empty value "")
	Location string
	// Shuffle Rule
	Rule ShuffleRule
	// contains filtered or unexported fields
}