6 files changed, 272 insertions, 0 deletions
diff --git a/internal/config/config.go b/internal/config/config.go
new file mode 100644
index 0000000..ad35ee7
--- /dev/null
+++ b/internal/config/config.go
@@ -0,0 +1,56 @@
+package config
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"gopkg.in/yaml.v3"
+)
+
+type Config struct {
+	Filters    []string `yaml:"filters"`
+	Iterations int      `yaml:"iterations"`
+}
+
+func getDefaultConfigPath() (defaultPath string, err error) {
+	programName := "uptfs"
+	configFileName := "config.yaml"
+
+	if xdg := os.Getenv("XDG_CONFIG_HOME"); xdg != "" {
+		return filepath.Join(xdg, programName, configFileName), nil
+	}
+
+	if home := os.Getenv("HOME"); home != "" {
+		return filepath.Join(home, programName, configFileName), nil
+	}
+
+	return "", errors.New("both XDG_CONFIG_HOME and HOME are not set, can't proceed")
+}
+
+func (c *Config) LoadConfig(filepath string) *Config {
+	if filepath == "" {
+		var err error
+		filepath, err = getDefaultConfigPath()
+
+		if err != nil {
+			fmt.Printf("%v\n", err)
+			os.Exit(1)
+		}
+	}
+
+	yamlFile, err := os.ReadFile(filepath)
+
+	if err != nil {
+		fmt.Printf("%v\n", err)
+		os.Exit(1)
+	}
+	err = yaml.Unmarshal(yamlFile, c)
+	if err != nil {
+		fmt.Printf("%v\n", err)
+		os.Exit(1)
+	}
+
+	return c
+}
diff --git a/internal/filter/filter.go b/internal/filter/filter.go
new file mode 100644
index 0000000..3fff07f
--- /dev/null
+++ b/internal/filter/filter.go
@@ -0,0 +1,49 @@
+package filter
+
+import (
+	"fmt"
+)
+
+type Filter struct {
+	name       string
+	action     func(string) string
+	subfilters []Filter
+}
+
+type Greeter interface {
+	Greet()
+}
+
+type Filterer interface {
+	Greeter
+	Filter(string) string
+}
+
+func (f Filter) Greet() {
+	subfilterCount := len(f.subfilters)
+
+	fmt.Printf("I am a filter and my name is %v\n", f.name)
+	if subfilterCount > 0 {
+		fmt.Println("My subfilters are:")
+
+		for _, subfilter := range f.subfilters {
+			fmt.Printf("- %v\n", subfilter.name)
+		}
+	}
+}
+
+func (f Filter) Filter(token string) (modifiedToken string) {
+	subfilterCount := len(f.subfilters)
+	modifiedToken = token
+
+	if subfilterCount > 0 {
+		for _, subfilter := range f.subfilters {
+			modifiedToken = subfilter.action(modifiedToken)
+		}
+
+		return modifiedToken
+	}
+
+	modifiedToken = f.action(token)
+	return modifiedToken
+}
diff --git a/internal/filter/filters.go b/internal/filter/filters.go
new file mode 100644
index 0000000..8532fef
--- /dev/null
+++ b/internal/filter/filters.go
@@ -0,0 +1,46 @@
+package filter
+
+import (
+	"strings"
+)
+
+var filterList = map[string]interface{}{
+	"uppercase":       NewUppercaseFilter,
+	"lowercase":       NewLowercaseFilter,
+	"lowercase_extra": NewLowercaseFilterWithExtraSteps,
+}
+
+func NewUppercaseFilter() Filter {
+	uppercaseFilter := Filter{
+		name:       "Uppercase",
+		action:     strings.ToUpper,
+		subfilters: []Filter{},
+	}
+
+	return uppercaseFilter
+}
+
+func NewLowercaseFilter() Filter {
+	lowercaseFilter := Filter{
+		name:       "Lowercase",
+		action:     strings.ToLower,
+		subfilters: []Filter{},
+	}
+
+	return lowercaseFilter
+}
+
+func NewLowercaseFilterWithExtraSteps() Filter {
+	var subfilters []Filter
+
+	subfilters = append(subfilters, NewUppercaseFilter())
+	subfilters = append(subfilters, NewLowercaseFilter())
+
+	filter := Filter{
+		name:       "Lowercase (extra dumb)",
+		action:     func(string) string { return "" },
+		subfilters: subfilters,
+	}
+
+	return filter
+}
diff --git a/internal/split/split.go b/internal/split/split.go
new file mode 100644
index 0000000..e03335c
--- /dev/null
+++ b/internal/split/split.go
@@ -0,0 +1,55 @@
+package split
+
+import (
+	"strings"
+)
+
+func FormatInput(tokenArray []string, delimeterArray []string) []string {
+	for _, delimeter := range delimeterArray {
+		for index, element := range tokenArray {
+			tokenArray = NewArrayWithSplit(tokenArray, index, element, delimeter)
+		}
+	}
+
+	return tokenArray
+}
+
+func checkArrayElementsEmpty(array []string) bool {
+	for _, str := range array {
+		if str != "" {
+			return false
+		}
+	}
+	return true
+}
+
+func NewArrayWithSplit(initialArray []string, index int, token string, delimeter string) (result []string) {
+	split := strings.Split(token, delimeter)
+	splitLength := len(split)
+
+	/*
+		When a token only consists of delimeter * N (N >= 0),
+		the resulting split consists of N empty elements.
+		Here we check if it is so and essentialy remove that token
+		from resulting array.
+	*/
+
+	splitIsEmpty := checkArrayElementsEmpty(split)
+	if splitIsEmpty {
+		result = append(initialArray[:index], initialArray[index+1:]...)
+		return result
+	}
+
+	if splitLength > 1 {
+		if split[splitLength-1] == "" {
+			split = split[:splitLength-1]
+		}
+
+		result = append(initialArray[:index], append(split, initialArray[index+1:]...)...)
+	}
+	if splitLength == 1 {
+		result = initialArray
+	}
+
+	return result
+}
diff --git a/internal/token/linked_token_list.go b/internal/token/linked_token_list.go
new file mode 100644
index 0000000..5fe42a9
--- /dev/null
+++ b/internal/token/linked_token_list.go
@@ -0,0 +1,36 @@
+package token
+
+type LinkedTokenList struct {
+	head, tail *Token
+}
+
+func (lts *LinkedTokenList) GetHead() *Token {
+	return lts.head
+}
+
+func (lts *LinkedTokenList) GetTail() *Token {
+	return lts.tail
+}
+
+func (lts *LinkedTokenList) AddToken(content string) {
+	newToken := &Token{
+		content: content,
+		prev:    nil,
+		next:    nil,
+	}
+
+	if lts.head == nil {
+		lts.head = newToken
+		lts.tail = newToken
+	} else {
+		newToken.SetPreviousToken(lts.tail)
+		lts.tail.SetNextToken(newToken)
+		lts.tail = newToken
+	}
+}
+
+func SliceToLinkedTokenSlice(slice []string, tokenSlice *LinkedTokenList) {
+	for _, item := range slice {
+		tokenSlice.AddToken(item)
+	}
+}
diff --git a/internal/token/token.go b/internal/token/token.go
new file mode 100644
index 0000000..c4dffd8
--- /dev/null
+++ b/internal/token/token.go
@@ -0,0 +1,30 @@
+package token
+
+type Token struct {
+	content    string
+	prev, next *Token
+}
+
+func (t *Token) GetContent() string {
+	return t.content
+}
+
+func (t *Token) SetContent(content string) {
+	t.content = content
+}
+
+func (t *Token) GetPreviousToken() *Token {
+	return t.prev
+}
+
+func (t *Token) SetPreviousToken(newToken *Token) {
+	t.prev = newToken
+}
+
+func (t *Token) GetNextToken() *Token {
+	return t.next
+}
+
+func (t *Token) SetNextToken(newToken *Token) {
+	t.next = newToken
+}