MiniLang
2.29
This library is used to store business logic in a simple and yet powerful definition.
A mini script language for PHP. It does three simple tasks.
For example :
when var1>5 and var2>20 then var3=20 // when and then
init var5=20 when var1>5 and var2>20 then var3=var5 // init, when and then
init var5=20 when var1>5 and var2>20 then var3=var5 else var3=var20 // init, when, then and else
when var1>$abc then var3=var5 // $abc is a PHP variable.
Sometimes we need to execute arbitrary code in the basis of "if some value equals to, then we set or execute another code."
In PHP, we could do the next code.
if($condition) {
$variable=1;
}However, this code is executed at runtime. What if we need to execute this code at some specific point?.
We could do the next code:
$script='if($condition) {
$variable=1;
}';
// and later..
eval($script);This solution works (and it only executes if we call the command eval). But it is verbose, prone to error, and it's dangerous.
Our library does the same but safe and clean.
$mini->separate("when condition then variable=1");Installing it using composer:
composer requires eftec/minilang
Creating a new project
use eftecminilangMiniLang;
include "../lib/MiniLang.php"; // or the right path to MiniLang.php
$mini=new MiniLang();
$mini->separate("when field1=1 then field2=2"); // we set the logic of the language but we are not executed it yet.
$mini->separate("when field1=2 then field2=4"); // we set more logic.
$result=['field1'=>1,'field2'=>0]; // used for variables.
$callback=new stdClass(); // used for callbacks if any
$mini->evalAllLogic($callback,$result);
var_dump($result);Another example:
use eftecminilangMiniLang;
include "../lib/MiniLang.php";
$result=['var1'=>'hello'];
$global1="hello";
$mini=new MiniLang(null,$result);
$mini->throwError=false; // if error then we store the errors in $mini->errorLog;
$mini->separate('when var1="hello" then var2="world" '); // if var1 is equals "hello" then var2 is set "world"
$mini->separate('when $global1="hello" then $global2="world" '); // we can also use php variables (global)
$mini->evalAllLogic(false); // false means it continues to evaluate more expressions if any
// (true means that it only evaluates the first expression where "when" is valid)
var_dump($result); // array(2) { ["var1"]=> string(5) "hello" ["var2"]=> string(5) "world" }
var_dump($global2); // string(5) "world"__construct(&$caller,&$dict,array $specialCom=[],$areaName=[],$serviceClass=null)
It reset the previous definitions but the variables, service and areas.
Set a caller object. The caller object it could be a service class with method that they could be called inside the script.
Set a dictionary with the variables used by the system.
It sends an expression to the MiniLang, and it is decomposed in its parts. The script is not executed but parsed.
It evaluates a logic. It returns true or false.
It sets a value or values. It does not consider if WHERE is true or not.
Boolean.
Array of String. if $throwError is false then every error is stored here.
Example:
$this->throwError=false;
$mini->separate("when FIELDDOESNOTEXIST=1 then field2=2");
var_dump($this->errorLog);The syntaxis of the code is separated into four parts. INIT, WHERE (or when), SET (or THEN) and ELSE.
Example:
$mini->separate("when field1=1 then field2=2");It says if field1=1 then we set field2 as 2.
A variable is defined by varname
Example: examples/examplevariable.php
$mini=new MiniLang();
$mini->separate("when field1>0 then field2=3"); // we prepare the language
$variables=['field1'=>1]; // we define regular variables
$callback=new stdClass();
$mini->evalAllLogic($callback,$variables); // we set the variables and run the languageand run the language
var_dump($variables); // field1=1, field2=3A variable could host a PHP object, and it is possible to call and to access the fields inside it.
varname.field
Example of code examples/examplevariable2.php
class MyModel {
var $id=1;
var $value="";
public function __construct($id=0, $value="")
{
$this->id = $id;
$this->value = $value;
}
}
class ClassCaller {
public function Processcaller($arg) {
echo "Caller: setting the variable {$arg->id}<br>";
}
}
class ClassService {
public function ProcessService($arg) {
echo "Service: setting the variable {$arg->id}<br>";
}
}
$mini=new MiniLang([],[],new ClassService());
$mini->separate("when field1.id>0 then
field2.value=3
and field3.processcaller
and processcaller(field3)
and processservice(field3)"); // we prepare the language
$variables=['field1'=>new MyModel(1,"hi")
,'field2'=>new MyModel(2,'')
,'field3'=>new MyModel(3,'')]; // we define regular variables
$callback=new ClassCaller();
$mini->evalAllLogic($callback,$variables,false); // we set the variables and run the languageand run the language
var_dump($variables);A variable could hold an associative/index array, and it is possible to read and to access the elements inside it.
Example:
$mini=new MiniLang(null,
[
'vararray'=>['associindex'=>'hi',0=>'a',1=>'b',2=>'c',3=>'d',4=>'last','a'=>['b'=>['c'=>'nested']]]
]
);vararray.associndex // vararray['associindex'] ('hi')
vararray.4 // vararray[4] 'last'
vararray.123 // it will throw an error (out of index)
vararray.param('a.b.c')) // vararray['a']['b']['c'] ('nested')
param(vararray,'a.b.c')) // vararray['a']['b']['c'] ('nested')
vararray._first // first element ('hi')
vararray._last // last element ('last')
vararray._count // returns the number of elements. (6)Example of code examples/examplevariable_arr.php
class ClassCaller {
public function Processcaller($arg) {
echo "Caller: setting the variable {$arg['id']}<br>";
}
}
class ClassService {
public function ProcessService($arg) {
echo "Service: setting the variable {$arg['id']}<br>";
}
}
$mini=new MiniLang([],[],new ClassService());
$mini->separate("when field1.id>0 then
field2.value=3
and field3.processcaller
and processcaller(field3)
and processservice(field3)");
$variables=['field1'=>['id'=>1,'value'=>3]
,'field2'=>['id'=>2,'value'=>'']
,'field3'=>['id'=>3,'value'=>'']
];
$callback=new ClassCaller();
$mini->evalAllLogic($callback,$variables,false);
var_dump($variables);A global variable takes the values of the PHP ($GLOBAL), so it doesn't need to be defined or set inside the language
Note: For security purpose. global variables defined by PHP as "$_namevar" can't be read or modified. So if you want to protect a global variable, then you can rename it with an underscore as prefix.
Example: If you try to read the variable $_SERVER, then it will return the value of the variable $SERVER which it could be or not defined.
A global variable is defined by
$globalname
$globalname.associndex // $globalname['associindex']
$globalname.4 // $globalname[4]
$globalname.param('a.b.c') // $globalname['a']['b']['c']
param($globalname,'a.b.c') // $globalname['a']['b']['c']Example:
$globalname=30
Example Code: examples/exampleglobal.php
$field1=1; // our global variable
$mini=new MiniLang();
$mini->separate('when $field1>0 then $field1=3'); // we prepare the language
$variables=[]; // local variables
$callback=new stdClass();
$mini->evalAllLogic($callback,$variables); // we set the variables and run the languageand run the language
var_dump($field1); // returns 3| Type | Example |
|---|---|
| Number | 20 |
| string | "hello world", 'hello world' |
| stringp | "my name is {{var}}" |
| function | namefunction(arg,arg) |
set var=20 and var2="hello" and var3="hello {{var}}" and var4=fn()
| Reserved word | Explanation |
|---|---|
| null() | null value |
| false() | false value |
| true() | true value |
| on() | 1 |
| param(var,'l1.l2.l3') | Separates an array (var) into var['l1']['l2']['l3'] |
| off() | 0 |
| undef() | -1 (for undefined) |
| flip() | (special value). It inverts a value ON<->OFF Used as value=flip() |
| now() | returns the current timestamp (integer) |
| timer() | returns the current timestamp (integer) |
| interval() | returns the interval (in seconds) between the last change and now. It uses the field dateLastChange or method dateLastChange() of the callback class |
| fullinterval() | returns the interval (in seconds) between the start of the process and now. It uses the field dateInit or method dateInit() of the callback class |
| contains()/str_contains() | returns true if the text is contained in another text.Example: str_contains(field1,'hi') |
| str_starts_with(), startwith() | returns true if the text starts with another text |
| str_ends_with(),endwith() | returns true if the text ends with another text. |
Example: examples/examplereserved.php
$mini=new MiniLang();
$mini->separate("when true=true then field1=timer()"); // we prepare the language
$variables=['field1'=>1]; // we define regular variables
$callback=new stdClass();
$mini->evalAllLogic($callback,$variables); // we set the variables and run the language
var_dump($variables);Example Timer: examples/examplereservedtimer.php
class ClassWithTimer {
var $dateLastChange;
public function dateInit() {
return time();
}
public function __construct()
{
$this->dateLastChange=time();
}
}
$mini=new MiniLang();
$mini->separate("when true=true then field1=interval() and field2=fullinterval()"); // we prepare the language
$variables=['field1'=>0,'field2'=>0]; // we define regular variables
$callback=new ClassWithTimer();
$mini->evalAllLogic($callback,$variables); // we set the variables and run the language
var_dump($variables);This part of the expression allows setting a value. This expression is usually optional, and it could be omitted.
It is similar to SET, but it is executed before WHERE and no matter if WHERE is valid or not.
init counter=20 where variable1=20 set variable+counter
$mini->separate("init tmp=50 when condition=1 then field1+10"); // set tmp to 50. If condition is 1 then it increases the field1 by 10.This part of the expression adds a condition to the statement.
We can also use "when."
where expression
or
when expression
It's possible to compare more than a condition at the same time by separating by "and" or "or."
where v1=10 and v2=20 or v3<50
where variable1=20 and $variable2=variable3 or function(20)=40
where $field=20 and field2<>40 or field3=40 // sql syntax
where $field==20 && field2!=40 || field3=+40 // PHP syntax
where 1 // it always true
This part of the expression allows setting the value of a variable. It is possible to set more than one variable at the same time by separating by "," or "and."
We can also use the expression "set" or "then"
set expression
or
then expression
This part of the expression is only executed if WHERE is valid
We could set a variable using the next expressions:
This library does not allow complex instruction such as
set variable1=20 and $variable2=variable3 and function(20)=40
$mini->separate("when condition=1 then field1+10"); // if condition is 1 then it increases the field1 by 10.This optional part of the expression allows setting the value of a variable. It is possible to set more than one variable at the same time by separating by "," or "and".
This code is only evaluated if "where" returns false of if ELSE is called manually.
else variable1=20 and $variable2=variable3 and function(20)=40
It is possible to create a loop using the space "loop"
To start a loop, you must write
$this->separate('loop variableloop=variable_with_values');
// where variable_with_values is must contains an array of values
// variableloop._key will contain the key of the loop
// variableloop._value will contain the value of the loop And to end the loop, you must use
$this->separate('loop end');You can escape the loop using the operator "break" in the "set" or "else".
$this->separate('when condition set break else break');Note: Loops are only evaluated when you evaluate all the logic. It does not work with evalLogic() and evalLogic2()
Note: You can't add a condition to a loop, however you can skip a loop assigning an empty array
Example:
$this->separate('loop $row=variable');
$this->separate('loop $row2=variable');
$this->separate('where op=2 then cc=2');
$this->separate('where op=3 then break'); // ends of the first loop
$this->separate('loop end');
$this->separate('loop end')
$obj->evalAllLogic(); It is possible to create a class with the logic created in the language. The goal is to increase the performance of the code.
To generate the class, first we need to write the logic using the method separate2() instead of separate(). It will store the logic inside an array of the instance of the class. You could use the code directly, or you could save inside a class as follows:
// create an instance of MiniLang
$mini=new MiniLang(null);
// the logic goes here
$mini->separate2('when var1="hello" and comp.f=false() then var2="world" '); // if var1 is equals "hello" then var2 is set "world"
// and the generation of the class
$r=$mini->generateClass('ExampleBasicClass','nsexample','ExampleBasicClass.php');It will save a new file called ? ExampleBasicClass.php (you can check the example ? example/genclass/1.examplebasic.php)
With the class generated, you can use this new class instead of MiniLang. Since this class is already compiled, then it is blazing fast. However, if you need to change the logic, then you will need to compile it again. (you can check the example ? example/genclass/2.examplebasic.php and ? example/genclass/ExampleBasicClass.php)
$result=['var1'=>'hello'];
$obj=new ExampleBasicClass(null,$result);
$obj->evalAllLogic(true);The class will look like:
<?php
namespace nsexample;
use eftecminilangMiniLang;
class ExampleBasicClass extends MiniLang {
public $numCode=2; // num of lines of code
public $usingClass=true; // if true then we are using a class (this class)
public function whereRun($lineCode=0) {
// ...
} // end function WhereRun
public function setRun($lineCode=0) {
// ...
} // end function SetRun
public function elseRun($lineCode=0) {
// ...
} // end function ElseRun
public function initRun($lineCode=0) {
// ...
} // end function InitRun
} // end classWhere each method evaluates a part of the expression.
examples/examplebenchmark.php
We call some operations 1000 times.
Medium-Creating a new scripting language on PHP
