Skip to content

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

License

Notifications You must be signed in to change notification settings

CheeseGrinder/TemplateStr-Python

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

30 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

TemplateStr-Python

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

Install :

pip install https://github.com/CheeseGrinder/TemplateStr-Python/archive/vX.X.X.tar.gz

Import :

from templateStr import TemplateStr

Construtor :

parser = TemplateStr(functionList: list, variableDict: dict)
  • functionList: is an list of functions passed to the constructor that can be called in the parsed text
    funcs: list = [meCustomFunc, otherCustomFunc]
  • variableDict: is a dict of variables passed to the constructor that can be used in the parsed text
    varDict: dict = {
        "foo": "bar",
        "str": "Jame",
        "int": 32,
        "float": 4.2,
        "bool": True,
        "list": ["test", 42],
        "Dict": {"value": "Dict in Dict"},
        "Dict1": {"Dict2": {"value": "Dict in Dict in Dict"}},
    }

Function :

parser.parse(text)
  • parse(text: str) -> str : parse all (variable, function, condition and switch)
  • parseVariable(text: str) -> str : parse Variable ; ${variableName}
  • parseFunction(text: str) -> str : parse Function and Custom Function ; @{functionName}
  • parseCondition(text: str) -> str : parse Condition ; #{value1 == value2; trueValue | falseValue}
  • parseSwitch(text: str) -> str : parse Switch ; ?{var; value1::#0F0, value2::#00F, ..., _::#000}
  • hasOne(text: str) -> bool : check if there are one syntaxe
  • hasVariable(text: str) -> bool : check if there are any Variable
  • hasFunction(text: str) -> bool : check if there are any Function
  • hasCondition(text: str) -> bool : check if there are any Condition
  • hasSwitch(text: str) -> 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

    def YourFunction(array: list) -> str:
    
        # Your code
    
        return str
  • 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 !"

Syntaxe Typing :

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) list [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 (test_TemplateStr.py)

TODO

  • : Add exemple
  • : Add test

About

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

Topics

Resources

License

Stars

Watchers

Forks

Languages