You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

296 lines
11 KiB

package main
import (
"strings"
"github.com/Jeffail/gabs"
)
func duplicateText(original string, count int) string {
var result string
for i := 0; i < count; i++ {
result = result + original
}
return result
}
/*func replaceEntryOLD(templateContent string, entry dataEntry, jsonData *gabs.Container, elemName string) string {
//replace {{}} with data
var keys []string
for key, _ := range entry {
keys = append(keys, key)
}
//now, replace the keys with the values
for j := 0; j < len(keys); j++ {
templateContent = strings.Replace(templateContent, "{{"+keys[j]+"}}", entry[keys[j]], -1)
//templateContent = strings.Replace(templateContent, "[[i]]", strconv.Itoa(i), -1)
children, _ := jsonData.S(keys[j]).Children()
fmt.Println("-")
fmt.Println(keys[j])
fmt.Println(children)
for key, child := range children {
fmt.Print("key: " + strconv.Itoa(key) + ", value: ")
fmt.Println(child.Data().(string))
}
}
return templateContent
}*/
func replaceVariable(templateContent string, variable string, value string) string {
templateContent = strings.Replace(templateContent, "{{"+variable+"}}", value, -1)
return templateContent
}
func replaceEntry(templateContent string, entry dataEntry, jsonData *gabs.Container, elemName string) string {
//fmt.Println(jsonData)
children, _ := jsonData.S().ChildrenMap()
//_, ok := jsonData.S().Children()
for parameter, child := range children {
//subchildren, _ := child.S().ChildrenMap()
_, ok := child.S().Children()
if ok != nil {
templateContent = strings.Replace(templateContent, "{{"+parameter+"}}", child.Data().(string), -1)
} else {
/*for subparameter, subchild := range subchildren {
color.Red(subchild.Data().(string))
fmt.Println(subchild)
fmt.Println(subparameter)
//templateContent = strings.Replace(templateContent, "{{"+subparameter+"}}", subchild.Data().(string), -1)
}*/
}
}
return templateContent
}
func konstruiRepeatArray(templateContent string) string {
for strings.Contains(templateContent, "<konstrui-repeatArray") {
tlines := getLines(templateContent)
tp := locateStringInArray(tlines, "konstrui-repeatArray")
dataPath, _ := getTagParameters(tlines[tp[0]], "konstrui-repeatArray", "repeatArray", "nil")
dataPath = strings.Replace(dataPath, "\n", "", -1)
_, jsonData := getDataFromJson(rawFolderPath + "/" + dataPath)
//get the part of the html where is the konstrui-repeatArray
extracted := extractText(templateContent, "<konstrui-repeatArray", "</konstrui-repeatArray>")
var replaced string
children, _ := jsonData.S().Children()
for _, child := range children {
replaced = replaced + replaceVariable(extracted, "var", child.Data().(string))
}
fragmentLines := getLines(replaced)
fragmentLines = deleteArrayElementsWithString(fragmentLines, "konstrui-repeatArray")
//afegir fragment al newContent, substituint el fragment original
lines := getLines(templateContent)
p := locateStringInArray(lines, "konstrui-repeatArray")
lines = deleteLinesBetween(lines, p[0], p[1])
lines = addElementsToArrayPosition(lines, fragmentLines, p[0])
templateContent = concatStringsWithJumps(lines)
}
return templateContent
}
func konstruiRepeatJSONPartTwo(templateContent string, entries []dataEntry, jsonData *gabs.Container, elemName string) string {
var newContent string
newContent = templateContent
//replace <konstrui-repeatJSON>
if strings.Contains(newContent, "<konstrui-repeatJSON") && strings.Contains(newContent, "</konstrui-repeatJSON>") {
//get content inside tags
//get tags, and split by tags, get the content between tags
extracted := extractText(newContent, "<konstrui-repeatJSON", "</konstrui-repeatJSON>")
//for each project, putDataInTemplate data:entries, template: content inside tags
var replaced string
//for _, entry := range entries {
children, _ := jsonData.S().Children()
for _, child := range children {
var entry dataEntry
replaced = replaced + replaceEntry(extracted, entry, child, elemName)
}
fragmentLines := getLines(replaced)
fragmentLines = deleteArrayElementsWithString(fragmentLines, "konstrui-repeatJSON")
//afegir fragment al newContent, substituint el fragment original
lines := getLines(templateContent)
p := locateStringInArray(lines, "konstrui-repeatJSON")
lines = deleteLinesBetween(lines, p[0], p[1])
lines = addElementsToArrayPosition(lines, fragmentLines, p[0])
templateContent = concatStringsWithJumps(lines)
}
return templateContent
}
func konstruiRepeatJSON(templateContent string) string {
for strings.Contains(templateContent, "<konstrui-repeatJSON") {
tlines := getLines(templateContent)
tp := locateStringInArray(tlines, "konstrui-repeatJSON")
dataPath, _ := getTagParameters(tlines[tp[0]], "konstrui-repeatJSON", "repeatJSON", "nil")
dataPath = strings.Replace(dataPath, "\n", "", -1)
entries, jsonData := getDataFromJson(rawFolderPath + "/" + dataPath)
templateContent = konstruiRepeatJSONPartTwo(templateContent, entries, jsonData, "")
}
return templateContent
}
func konstruiRepeatElem(templateContent string, entry dataEntry, jsonData *gabs.Container) string {
for strings.Contains(templateContent, "<konstrui-repeatElem") {
tlines := getLines(templateContent)
tp := locateStringInArray(tlines, "konstrui-repeatElem")
elemName, _ := getTagParameters(tlines[tp[0]], "konstrui-repeatElem", "repeatElem", "nil")
extracted := extractText(templateContent, "<konstrui-repeatElem", "</konstrui-repeatElem>")
fragmentLines := getLines(extracted)
fragmentLines = deleteArrayElementsWithString(fragmentLines, "konstrui-repeatElem")
f := concatStringsWithJumps(fragmentLines)
children, _ := jsonData.S(elemName).Children()
var replaced string
for _, child := range children {
//fmt.Println(child)
//fmt.Println(child.Data().(string))
replacedElem := strings.Replace(f, "{{"+elemName+"}}", child.Data().(string), -1)
replaced = replaced + replacedElem
}
fragmentLines = getLines(replaced)
//fmt.Println(replaced)
/*lines := getLines(templateContent)
p := locateStringInArray(lines, "konstrui-repeatElem")*/
tlines = deleteLinesBetween(tlines, tp[0], tp[1])
tlines = addElementsToArrayPosition(tlines, fragmentLines, tp[0])
templateContent = concatStringsWithJumps(tlines)
}
return templateContent
}
func konstruiSimpleVars(template string, entries []dataEntry, jsonData *gabs.Container) string {
//now, replace simple templating variables {{vars}}
/*for _, entry := range entries {
template = replaceEntry(template, entry, jsonData, "")
}*/
/*children, _ := jsonData.S().Children()
for _, child := range children {
var entry dataEntry
fmt.Println("aaaaa")
fmt.Println(child)
template = replaceEntry(template, entry, child, "")
}
*/
var entry dataEntry
template = replaceEntry(template, entry, jsonData, "")
return template
}
func konstruiInclude(content string) string {
var result string
if strings.Contains(content, "<konstrui-include") {
lines := getLines(content)
for _, line := range lines {
if strings.Contains(line, "<konstrui-include") {
dataPath, _ := getTagParameters(line, "<konstrui-include", "html", "nil")
dataPath = strings.Replace(dataPath, "\n", "", -1)
htmlInclude := readFile(rawFolderPath + "/" + dataPath)
result = result + htmlInclude
} else {
result = result + line + "\n"
}
}
/*dataPath, _ := getTagParameters(content, "<konstrui-include", "html", "nil")
dataPath = strings.Replace(dataPath, "\n", "", -1)
htmlInclude := readFile(rawFolderPath + "/" + dataPath)
htmlIncludeLines := getLines(htmlInclude)
contentLines := getLines(content)
p := locateStringInArray(contentLines, "<konstrui-include")
fmt.Println(p)
contentLines = deleteLinesBetween(contentLines, p[0], p[0])
contentLines = addElementsToArrayPosition(contentLines, htmlIncludeLines, p[0])
content = concatStringsWithJumps(contentLines)*/
} else {
result = content
}
return result
}
func konstruiTemplate(templateContent string) string {
var result string
lines := getLines(templateContent)
for _, line := range lines {
if strings.Contains(line, "<konstrui-template") && strings.Contains(line, "</konstrui-template>") {
templatePath, data := getTagParameters(line, "konstrui-template", "html", "data")
result = result + useKonstruiTemplate(templatePath, data) + "\n"
} else {
result = result + line + "\n"
}
}
return result
}
func useKonstruiTemplate(templatePath string, dataPath string) string {
filepath := rawFolderPath + "/" + templatePath
templateContent := readFile(filepath)
entries, jsonData := getDataFromJson(rawFolderPath + "/" + dataPath)
generated := konstruiRepeatJSONPartTwo(templateContent, entries, jsonData, "")
generated = konstruiSimpleVars(generated, entries, jsonData)
return generated
}
func getTagParameters(line string, tagname string, param1 string, param2 string) (string, string) {
var param1content string
var param2content string
line = strings.Replace(line, "<"+tagname+" ", "", -1)
line = strings.Replace(line, "></"+tagname+">", "", -1)
attributes := strings.Split(line, " ")
for i := 0; i < len(attributes); i++ {
attSplitted := strings.Split(attributes[i], "=")
if attSplitted[0] == param1 {
param1content = strings.Replace(attSplitted[1], `"`, "", -1)
param1content = strings.Replace(param1content, ">", "", -1)
}
if attSplitted[0] == param2 {
param2content = strings.Replace(attSplitted[1], `"`, "", -1)
param2content = strings.Replace(param2content, ">", "", -1)
}
}
return param1content, param2content
}
func startTemplating(folderPath string, newDir string, konstruiConfig KonstruiConfig) {
//FILES
//do templating for each file in konstruiConfig.Files
//konstrui-template
for i := 0; i < len(konstruiConfig.Files); i++ {
fName := konstruiConfig.Files[i]
fileContent := readFile(folderPath + "/" + fName)
fileContent = konstruiTemplate(fileContent)
generatedPage := konstruiRepeatJSON(fileContent)
generatedPage = konstruiInclude(generatedPage)
generatedPage = konstruiRepeatArray(generatedPage)
writeFile(newDir+"/"+fName, generatedPage)
}
//REPEATPAGES
//do templating for the file pages in konstruiConfig.RepeatPages
c.Cyan("starting to generate Pages to repeat")
for i := 0; i < len(konstruiConfig.RepeatPages); i++ {
pageTemplate, _, jsonData := getHtmlAndDataFromRepeatPages(konstruiConfig.RepeatPages[i])
//for j := 0; j < len(data); j++ {
children, _ := jsonData.S().Children()
for _, child := range children {
var dataArray []dataEntry
var dat dataEntry
//dataArray = append(dataArray, data[j])
generatedPage := konstruiRepeatJSONPartTwo(pageTemplate, dataArray, child, "")
generatedPage = konstruiRepeatElem(generatedPage, dat, child)
generatedPage = konstruiSimpleVars(generatedPage, dataArray, child)
generatedPage = konstruiInclude(generatedPage)
//writeFile(newDir+"/"+data[j]["pageName"]+"Page.html", generatedPage)
pageName, _ := child.Path("pageName").Data().(string)
writeFile(newDir+"/"+pageName+"Page.html", generatedPage)
}
}
//COPYRAW
//copy the konstruiConfig.CopyRaw files without modificate them
for i := 0; i < len(konstruiConfig.CopyRaw); i++ {
fName := konstruiConfig.CopyRaw[i]
c.Yellow(fName)
fileNameSplitted := strings.Split(fName, ".")
if len(fileNameSplitted) > 1 {
//is a file
copyFileRaw(folderPath, fName, newDir)
} else {
//is a directory
c.Red(folderPath + "/" + fName)
copyDirRaw(folderPath, fName, newDir)
}
}
}