TemplateStr-Go

README

TemplateStr-Go

TemplateStr allows to add variable, function, condition and switch in a string.

Install :

go get -u github.com/CheeseGrinder/TemplateStr-Go/templateStr@latest

Import :

import (
    "github.com/CheeseGrinder/TemplateStr-Go/templateStr"
)
// to simplify the types
type VarMap = templateStr.VariableMap
type FuncArray = templateStr.FuncArray

Construtor :

parser := templateStr.New(funcArray, varMap)

• funcArray: is an array of functions passed to the constructor that can be called in the parsed text

  
  

  var funcArray FuncArray = FuncArray{myCustomFunc, otherCustomFunc}
  

• varMap: is a map of variables passed to the constructor that can be used in the parsed text

  
  

  var varMap VarMap = VarMap{
      "foo": "bar",
      "str": "Jame",
      "int": 32,
      "float": 4.2,
      "bool": true,
      "array": []Any{"foo", 42},
      "Map": VarMap{
          "value": "Map in Map",
      },
      "Map1": VarMap{
          "Map2": VarMap{
              "value": "Map in Map in Map",
          },
      },
  }
  

Function :

result, err := parser.Parse(text)

• Parse(text: string) (string, error) : parse all (variable, function, condition and switch)
• ParseVariable(text: string) (string, error) : parse Variable ; ${variableName}
• ParseFunction(text: string) (string, error) : parse Function and Custom Function ; @{functionName}
• ParseCondition(text: string) (string, error) : parse Condition ; #{value1 == value2; trueValue | falseValue}
• ParseSwitch(text: string) (string, error) : parse Switch ; ?{var; value1::#0F0, value2::#00F, ..., _::#000}
• HasOne(text: string) bool : check if there are one syntaxe
• HasVariable(text: string) bool : check if there are any Variable
• HasFunction(text: string) bool : check if there are any Function
• HasCondition(text: string) bool : check if there are any Condition
• HasSwitch(text: string) bool : check if there are any Switch

Exemple Syntaxe :

• Variable

  
  

  The syntax of the Variables is like :

  • ${variable}
  • ${Map.value}
  • ${MasterMap.SecondMap.value. ...}
  • ${variable[0]}
    
    

  If the value does not exist an error is returned

  //Example of parsing | is not code
  
  name = "Jame"
  
  "name is ${name}"
  parse()
  "name is Jame"
  

• Function

  
  

  The syntax of the Function is like :

  • @{function; parameter}
  • @{function}
    
    

  Here is a list of the basic functions available :

  • @{uppercase; variableName}
  • @{uppercaseFirst; variableName}
  • @{lowercase; variableName}
  • @{swapcase; variableName}
  • @{time} HH/mm/ss
  • @{date} DD/MM/YYYY
  • @{dateTime} DD/MM/YYYY HH/mm/ss
    
    

  //Example of parsing | is not code
  
  name = "jame"
  
  "name is @{uppercase; name}"
  parse()
  "name is JAME"
  //=================================
  
  "what time is it ? it's @{time}"
  parse()
  "what time is it ? it's 15:30:29"
  

• Custom Function

  
  

  The syntax of Custom function is the same as the basic functions, they can have 0,1 or more parameters :

  • @{customFunction; param1 param2 variableName ...}
  • @{customFunction}
    
    

  The developer who adds his own function will have to document it

  Syntaxe Typing can be used at the parameter level of custom functions

  For developers :

  • Parameters to be passed in a list/vec/array
  • The custom function must necessarily return a str/string
    
    

  func YourFunction(parameter []Any) string {
  
      //Your code
  
      return string
  }
  

• Condition

  
  

  The syntax of the Condition is like :

  • #{value1 == value2; trueValue | falseValue}
    
    

  comparator:

  • ==
  • !=
  • <= *
  • < *
  • >= *
  • > *
    
    

  * for this comparator the type string and bool are modified :

  • string it's the number of characters that is compared ('text' = 4)
  • bool it's the value in int that is compared (True = 1)

  value1 is compared with value2

  Syntaxe Typing can be used at value1 and value2 level

  //Example of parsing | is not code
  
  name = "Jame"
  
  "Jame is equal to James ? #{name == 'James'; Yes | No}"
  parse()
  "Jame is equal to James ? No"
  

• Switch

  
  

  The syntax of the Switch is like :

  • ?{variableName; value1::#0F0, value2::#00F, ..., _::#000}
  • ?{type/variableName; value1::#0F0, value2::#00F, ..., _::#000}
    
    

  The value of variableName is compared with all the values*, if a values* is equal to the value of variableName then the value after the :: will be returned.
  If no values* matches, the value after _:: is returned

  you can specify the type of variableName, but don't use Syntaxe Typing.
  If the type is specified then all values* will be typed with the same type.

  syntax to specify the type of variableName :

  • str/variableName
  • int/variableName
  • float/variableName
    
    

  //Example of parsing | is not code
  
  name = "Jame"
  yearsOld = 36
  
  "how old is Jame ? ?{name; Jame::42 years old, William::36 years old, _::I don't know}"
  parse()
  "how old is Jame ? 42 years old"
  //=================================
  
  "who at 36 years old ? ?{int/yearsOld; 42::Jame !, 36::William !, _::I don't know}"
  parse()
  "who at 42 years old ? William !"
  

!!! Warning if the syntax is not respected the text will not be parsed

Syntaxe Typing :

Usable only in the custom function parameters and the two condition comparison values

Format	Type	Return	Note
variableName	*	value of variableName	Is the key of the value in the dictionary pass to the constructor
b/True	bool	True	Type the string True as bool
i/123	int	123	Type the string 123 as type int
f/123.4	float	123.4	Type the string 123.4 as type float
"text" or 'text' or `text`	str	text	It just takes what's in quote, not to be interpreted as a variable name
("test", i/56)	slice	[test 56]	Use typing for typed otherwise text will be used as variable name

This function takes as parameters a Bool, Int and String
+ @{MyCustomFunction; b/True i/15 "foo"}
- @{MyCustomFunction; True 15 foo}


+ #{"test" == "test"; Yes | No}
+ #{"56" == i/56; Yes | No}
- #{foo == 56; Yes | No}

More

If you want another example you can look in the test file (template_test.go)

TODO

• : Add exemple
• : Add test