First init
diff --git a/termmapper.go b/termmapper.go
new file mode 100644
index 0000000..b2d41fe
--- /dev/null
+++ b/termmapper.go
@@ -0,0 +1,454 @@
+package termmapper
+
+/*
+$( => PUNCT PunctType=Brck ``, '', *RRB*, *LRB*, -
+$, => PUNCT PunctType=Comm ,
+$. => PUNCT PunctType=Peri ., :, ?, ;, !
+ADJA => ADJ _ neuen, neue, deutschen, ersten, anderen
+ADJD => ADJ Variant=Short gut, rund, knapp, deutlich, möglich
+ADV => ADV _ auch, nur, noch, so, aber
+APPO => ADP AdpType=Post zufolge, nach, gegenüber, wegen, über
+APPR => ADP AdpType=Prep in, von, mit, für, auf
+APPRART => ADP AdpType=Prep|PronType=Art im, am, zum, zur, vom
+APZR => ADP AdpType=Circ an, hinaus, aus, her, heraus
+ART => DET PronType=Art der, die, den, des, das
+CARD => NUM NumType=Card 000, zwei, drei, vier, fünf
+FM => X Foreign=Yes New, of, de, Times, the
+ITJ => INTJ _ naja, Ach, äh, Na, piep
+KOKOM => CCONJ ConjType=Comp als, wie, denn, wir
+KON => CCONJ _ und, oder, sondern, sowie, aber
+KOUI => SCONJ _ um, ohne, statt, anstatt, Ums
+KOUS => SCONJ _ daß, wenn, weil, ob, als
+NE => PROPN _ SPD, Deutschland, USA, dpa, Bonn
+NN => NOUN _ Prozent, Mark, Millionen, November, Jahren
+PAV => ADV PronType=Dem
+PDAT => DET PronType=Dem dieser, diese, diesem, dieses, diesen
+PDS => PRON PronType=Dem das, dies, die, diese, der
+PIAT => DET PronType=Ind,Neg,Tot keine, mehr, alle, kein, beiden
+PIDAT => DET AdjType=Pdt|PronType=Ind,Neg,Tot
+PIS => PRON PronType=Ind,Neg,Tot man, allem, nichts, alles, mehr
+PPER => PRON PronType=Prs es, sie, er, wir, ich
+PPOSAT => DET Poss=Yes|PronType=Prs ihre, seine, seiner, ihrer, ihren
+PPOSS => PRON Poss=Yes|PronType=Prs ihren, Seinen, seinem, unsrigen, meiner
+PRELAT => DET PronType=Rel deren, dessen, die
+PRELS => PRON PronType=Rel die, der, das, dem, denen
+PRF => PRON PronType=Prs|Reflex=Yes sich, uns, mich, mir, dich
+PTKA => PART _ zu, am, allzu, Um
+PTKANT => PART PartType=Res nein, ja, bitte, Gewiß, Also
+PTKNEG => PART Polarity=Neg nicht
+PTKVZ => ADP PartType=Vbp an, aus, ab, vor, auf
+PTKZU => PART PartType=Inf zu, zur, zum
+PWAT => DET PronType=Int welche, welchen, welcher, wie, welchem
+PWAV => ADV PronType=Int wie, wo, warum, wobei, wonach
+PWS => PRON PronType=Int was, wer, wem, wen, welches
+TRUNC => X Hyph=Yes Staats-, Industrie-, Finanz-, Öl-, Lohn-
+VAFIN => AUX Mood=Ind|VerbForm=Fin ist, hat, wird, sind, sei
+VAIMP => AUX Mood=Imp|VerbForm=Fin Seid, werde, Sei
+VAINF => AUX VerbForm=Inf werden, sein, haben, worden, Dabeisein
+VAPP => AUX Aspect=Perf|VerbForm=Part worden, gewesen, geworden, gehabt, werden
+VMFIN => VERB Mood=Ind|VerbForm=Fin|VerbType=Mod kann, soll, will, muß, sollen
+VMINF => VERB VerbForm=Inf|VerbType=Mod können, müssen, wollen, dürfen, sollen
+VMPP => VERB Aspect=Perf|VerbForm=Part|VerbType=Mod gewollt
+VVFIN => VERB Mood=Ind|VerbForm=Fin sagte, gibt, geht, steht, kommt
+VVIMP => VERB Mood=Imp|VerbForm=Fin siehe, sprich, schauen, Sagen, gestehe
+VVINF => VERB VerbForm=Inf machen, lassen, bleiben, geben, bringen
+VVIZU => VERB VerbForm=Inf einzusetzen, durchzusetzen, aufzunehmen, abzubauen, umzusetzen
+VVPP => VERB Aspect=Perf|VerbForm=Part gemacht, getötet, gefordert, gegeben, gestellt
+XY => X _ dpa, ap, afp, rtr, wb
+*/
+
+import (
+ "strconv"
+ "strings"
+
+ "github.com/rs/zerolog/log"
+ "github.com/tidwall/gjson"
+ "github.com/tidwall/sjson"
+)
+
+/*
+import (
+ "encoding/json"
+ "fmt"
+ "log"
+ "strings"
+)
+
+var mapping = map[string]string{
+ "$(":"PUNCT",
+}
+
+// Recursive function to turn the UPos query into a STTS query
+func koralRewriteUpos2Stts(koralquery interface{}) interface{} {
+ switch v := koralquery.(type) {
+ case map[string]interface{}:
+ // Check for '@type' key and act accordingly
+ if typ, ok := v["@type"].(string); ok {
+ switch typ {
+ case "koral:term":
+
+ // Modify the key to use STTS
+// This may require to turn object into a koral:token with terms like:
+
+
+ if key, ok := v["key"].(string); ok {
+ v["key"] = "hallo-" + key
+ }
+ case "operation":
+ // Handle the 'operators' key by recursively modifying each operator
+ if operators, ok := v["operators"].([]interface{}); ok {
+ for i, operator := range operators {
+ operators[i] = modifyJSON(operator)
+ }
+ v["operators"] = operators
+ }
+ }
+ }
+ // Recursively modify any nested maps
+ for k, val := range v {
+ v[k] = modifyJSON(val)
+ }
+ return v
+ case []interface{}:
+ // Recursively modify elements of arrays
+ for i, item := range v {
+ v[i] = modifyJSON(item)
+ }
+ return v
+ }
+ return koralquery
+}
+
+func main() {
+ // Sample JSON input string
+ jsonStr := `{
+ "@type": "operation",
+ "operators": [
+ {
+ "@type": "term",
+ "key": "example1"
+ },
+ {
+ "@type": "term",
+ "key": "example2"
+ },
+ {
+ "@type": "operation",
+ "operators": [
+ {
+ "@type": "term",
+ "key": "nested"
+ }
+ ]
+ }
+ ]
+ }`
+
+ // Parse the JSON string into a generic interface{}
+ var data interface{}
+ err := json.Unmarshal([]byte(jsonStr), &data)
+ if err != nil {
+ log.Fatal("Error unmarshaling JSON:", err)
+ }
+
+ // Modify the JSON structure recursively
+ modifiedData := modifyJSON(data)
+
+ // Marshal the modified data back into a JSON string
+ modifiedJSON, err := json.MarshalIndent(modifiedData, "", " ")
+ if err != nil {
+ log.Fatal("Error marshaling JSON:", err)
+ }
+
+ // Output the modified JSON string
+ fmt.Println(string(modifiedJSON))
+}
+
+
+
+func turnupostostts(json string, targetFoundry string, targetLayer string) {
+ if targetLayer == "" {
+ targetLayer = "p"
+ }
+
+ ldType := "@type"
+
+ if ldType == "koral:span" {
+ next
+ }
+ if ldType == "koral:term" {
+ if foundry == if layer === key -> rewrite
+ }
+
+ // Iterate through the query and whenever a term is requested without a foundry, and without a layser or layer p,
+ // change the key following the mapping
+
+
+}
+
+func addupostooutput(json string, reffoundry string, foundry string) {
+ // https://universaldependencies.org/tagset-conversion/de-stts-uposf.html
+ // Iterate through all matches and add to all xml snippets a line of foundry
+
+}
+
+*/
+
+func Hui() string {
+ return "test"
+}
+
+func Map2(json []byte) string {
+ /*
+ result := gjson.GetBytes(json, "query")
+ var raw []byte
+ if result.Index > 0 {
+ raw = json[result.Index:result.Index+len(result.Raw)]
+ } else {
+ raw = []byte(result.Raw)
+ }
+
+ if result.IsObject() {
+ koralType := gjson.GetBytes(raw, "@type").String()
+ switch koralType {
+ case "koral:term":
+
+ }
+ }
+ */
+
+ koralObj := gjson.ParseBytes(json)
+
+ switch koralObj.Get("@type").String() {
+ case "koral:term":
+ {
+ if koralObj.Get("value").String() == "KOKOM" {
+ // TODO: Turn this in a token, if it isn't already!
+ newJson, _ := sjson.Set(string(json), "value", "CCONJ")
+ return newJson
+ }
+ }
+
+ case "koral:operation":
+ {
+
+ }
+
+ }
+ /*
+
+ var raw []byte
+ if result.Index > 0 {
+ raw = json[result.Index:result.Index+len(result.Raw)]
+ } else {
+ raw = []byte(result.Raw)
+ }
+ */
+ return "jj"
+}
+
+// token writes a token to the string builder
+func token(strBuilder *strings.Builder, foundry string, layer string, keys []string) {
+ strBuilder.WriteString(`{"@type":"koral:token","wrap":`)
+ if len(keys) > 1 {
+ termGroup(strBuilder, foundry, layer, keys)
+ } else {
+ term(strBuilder, foundry, layer, keys[0], true)
+ }
+ strBuilder.WriteString(`}`)
+}
+
+// termGroup writes a termGroup to the string builder
+func termGroup(strBuilder *strings.Builder, foundry string, layer string, keys []string) {
+ strBuilder.WriteString(`{"@type":"koral:termGroup","relation":"relation:and","operation":"operation:and","operands":[`)
+ for i, key := range keys {
+ term(strBuilder, foundry, layer, key, true) // temporary
+ if i < len(keys)-1 {
+ strBuilder.WriteString(",")
+ }
+ }
+ strBuilder.WriteString(`]}`)
+}
+
+// term writes a term to the string builder
+func term(strBuilder *strings.Builder, foundry string, layer string, key string, match bool) {
+
+ // TODO: May have ne!!!!
+ strBuilder.WriteString(`{"@type":"koral:term","match":"match:`)
+ if match {
+ strBuilder.WriteString("eq")
+ } else {
+ strBuilder.WriteString("ne")
+ }
+ strBuilder.WriteString(`","foundry":"`)
+ strBuilder.WriteString(foundry)
+ strBuilder.WriteString(`","layer":"`)
+ strBuilder.WriteString(layer)
+ strBuilder.WriteString(`","key":"`)
+ strBuilder.WriteString(key)
+ strBuilder.WriteString(`"}`)
+}
+
+func flatten() {
+
+ // if a termGroup isan operand in a termGroup with the same relation/operation:
+ // flatten the termGroup into the parent termGroup
+
+ // if a termGroup has only a single term, remove the group
+}
+
+func replaceWrappedTerm(jsonString string, foundry string, layer string, key string) string {
+ var err error
+ jsonString, err = sjson.Set(jsonString, "foundry", foundry)
+ if err != nil {
+ log.Error().Err(err).Msg("Error setting foundry")
+ }
+ jsonString, err = sjson.Set(jsonString, "layer", layer)
+ if err != nil {
+ log.Error().Err(err).Msg("Error setting layer")
+ }
+ jsonString, err = sjson.Set(jsonString, "key", key)
+ if err != nil {
+ log.Error().Err(err).Msg("Error setting key")
+ }
+ return jsonString
+}
+
+func replaceGroupedTerm(jsonString string, op []int, foundry string, layer string, key string) string {
+ var err error
+
+ strInt := "operands." + strconv.Itoa(op[0]) + "."
+ jsonString, err = sjson.Set(jsonString, strInt+"foundry", foundry)
+ if err != nil {
+ log.Error().Err(err).Msg("Error setting foundry")
+ }
+ jsonString, err = sjson.Set(jsonString, strInt+"layer", layer)
+ if err != nil {
+ log.Error().Err(err).Msg("Error setting layer")
+ }
+ jsonString, err = sjson.Set(jsonString, strInt+"key", key)
+ if err != nil {
+ log.Error().Err(err).Msg("Error setting key")
+ }
+
+ if len(op) > 1 {
+ for i := 1; i < len(op); i++ {
+ jsonString, err = sjson.Delete(jsonString, "operands."+strconv.Itoa(op[i]))
+ if err != nil {
+ log.Error().Err(err).Msg("Error deleting operand")
+ }
+ }
+ }
+
+ return jsonString
+}
+
+/*
+func replaceTermWithToken(jsonString string) string {
+ // Replace the term with the token
+ replacedString, err := sjson.Set(jsonString, "wrap.operands.0", token())
+ if err != nil {
+ return jsonString // Return the original string in case of an error
+ }
+ return replacedString
+
+// case1: 1 -> 1 the term is an operand in a termGroup with the same relation/operation
+// case2: 1 -> 1 the term is wrapped
+// case3: 1 -> 1 the term is an operand in a termGroup with a different relation/operation
+// case4: n -> 1 the term is an operand in a termGroup with the same relation/operation
+// case5: n -> 1 the term is wrapped
+// case6: n -> 1 the term is an operand in a termGroup with a different relation/operation
+// case7: 1 -> n the term is an operand in a termGroup with the same relation/operation
+// case8: 1 -> n the term is wrapped
+// case9: 1 -> n the term is an operand in a termGroup with a different relation/operation
+ }
+*/
+
+func Map(jsonStr string) string {
+
+ obj := gjson.Get(jsonStr, "query")
+
+ // value := gjson.Get(json, "name.last")
+
+ /*
+
+ // Modify the JSON structure recursively
+ modifiedData := modifyJSON(ast.NewAny(data))
+
+ // Marshal the modified data back into a JSON string
+ modifiedJSON, err := sonic.MarshalString(modifiedData)
+
+ // Parse the JSON string into a generic interface{}
+ var data interface{}
+
+ err := sonic.UnmarshalString(jsonStr, data)
+
+ if err != nil {
+ log.Fatal("Error unmarshaling JSON:", err)
+ return ""
+ }
+
+
+
+ if err != nil {
+ log.Fatal("Error marshaling JSON:", err)
+ }
+ */
+ // Output the modified JSON string
+ return obj.String() //modifyJSON(obj)
+}
+
+// Recursive function to modify JSON using Sonic library
+//func modifyJSON(data gjson.Result) string {
+
+// Check if data is a map
+// if data.IsObject() {
+/*
+ dataMap := data.Map()
+
+ koralType := dataMap["@type"].String()
+
+ // Look for @type key
+
+ switch koralType {
+ case "koral:term":
+ // Modify the key by adding 'hallo-' prefix
+
+ // sjson.SetRaw(data.String())
+ sjson.Set(data.Path(data.Bytes()), "key", "hallo-"+dataMap["key"].String())
+
+ dataMap["key"] = "hallo-" + dataMap["key"].String()
+ /*
+ if key, found := data.GetString("key"); found {
+ data.Set("key", "hallo-"+key)
+ }
+*/
+/*
+ case "koral:operation":
+ // Handle the 'operators' key by recursively modifying each operator
+ if operators, found := data.GetArray("operators"); found {
+ for i := range operators {
+ operators[i] = modifyJSON(operators[i])
+ }
+ data.Set("operators", operators)
+ }
+ }*/
+/*
+ // Recursively modify any nested objects
+ data.ForEach(func(k string, v sonic.Any) {
+ data.Set(k, modifyJSON(v))
+ })
+*/
+//}
+// Handle arrays by modifying elements recursively
+/*
+ if data.IsArray() {
+ for i := range data.GetArray() {
+ data.Set(i, modifyJSON(data.GetArray()[i]))
+ }
+ }
+*/
+/*
+ return data
+}
+*/