tla-sbuilder 0.1.0

data/mustache/state_type_invariant-infrastructure-service.mustache

@@ -0,0 +1,49 @@
+(******************************************************************
+{{META.desc}}
+ - modelData {{META.modelData}}
+ - template  {{META.template}}
+
+******************************************************************)
+
+(*
+   Type invariants for infrastructure service return values.
+
+
+   All fields in 'responses' state variable store a record [ status |-> ... , response |-> ... ]
+
+*)
+
+{{!
+
+    iterate infrastructureServices
+
+    - output: <interface_name> |-> Nil, 
+
+
+}}{{#infrastructureServices}}InfrastructureService_TypeInvariant_{{interface_name}} == responses.{{>name_process.mustache}}.response \in { Nil }{{!
+
+    iterate response definitions
+}}{{#response_definitions}}{{!
+        end of response definitions
+}} \union {{namespace}}{{type}}{{/response_definitions}}{{!
+
+    end of intefaces
+    
+}} 
+
+
+\* Type invariant for infrastructure service return values
+
+{{/infrastructureServices}}{{!
+
+   Iterate infrastructureServices again to create call
+
+}}InfrastructureService_TypeInvariant == TRUE {{#infrastructureServices}}
+                                  /\ InfrastructureService_TypeInvariant_{{interface_name}}{{/infrastructureServices}}
+
+{{!
+
+    Composise-services enabled: end
+
+}}
+

data/mustache/state_type_invariant.mustache

@@ -0,0 +1,17 @@
+{{!
+
+   state_type_constraint: type invariant operator for a varibale
+
+}}
+
+
+(******************************************************************
+Type invariants:  {{META.desc}}
+ - modelData {{META.modelData}}
+ - template  {{META.template}}
+******************************************************************)
+
+{{#variables}}
+{{>name_type_invariant.mustache}} == \A entry \in {{>name_variable.mustache}}: entry \in {{>name_interface_type.mustache}}
+{{/variables}}
+

data/mustache/state_type_invariant_cfg.mustache

@@ -0,0 +1,18 @@
+{{!
+
+   state_type_constraint_invariant.mustache: invarint in configuration
+
+
+}}
+
+
+(******************************************************************
+ Activate Type invariants: {{META.desc}}
+ - modelData {{META.modelData}}
+ - template  {{META.template}}
+ ******************************************************************)
+
+
+{{#variables}}
+INVARIANT {{>name_type_invariant.mustache}}
+{{/variables}}

data/mustache/state_variables.mustache

@@ -0,0 +1,20 @@
+{{!
+
+   state_variables: state variables parser
+
+
+}}
+
+(******************************************************************
+State varibles: {{META.desc}}
+ - modelData {{META.modelData}}
+ - template  {{META.template}}
+******************************************************************)
+
+
+{{#variables}}
+       {{>name_variable.mustache}} = {};   \* of type {{>name_interface_type.mustache}}
+{{/variables}}
+
+
+

data/mustache/tla/const_def.mustache

@@ -0,0 +1,5 @@
+(* Magic values *)
+
+CONSTANTS WildCard        \* bind to any value
+CONSTANTS Nil             \* no value
+

data/mustache/tla/const_run.mustache

@@ -0,0 +1,3 @@
+(* Execution environment *)
+
+CONSTANTS Steps           \* Sequence process/parameter records

data/mustache/tla/macro-infrastructure-service.mustache

@@ -0,0 +1,14 @@
+(******************************************************************
+{{META.desc}}
+ - modelData {{META.modelData}}
+ - template  {{META.template}}
+******************************************************************)
+
+\* set 'status' with 'response' for 'operation'  into state variable 'responses'
+macro InfrastructureServiceReturn( operation, status, response ) {
+
+      \* update field for 'operation' in 'responses' variable  with record [ status |-> s , response |-> r ] 
+      responses[InterfaceOperation2ProcessName(operation)] := InfrastructureServiceResponse( status, response );
+}
+
+

data/mustache/tla/macro_run.mustache

@@ -0,0 +1,40 @@
+    (***********************************************************************
+     Macros to control process execution && time
+     ***********************************************************************)
+    macro tick() {
+          now := TickNext( now ); \* now := now + 1;
+    }
+    
+    macro enable( s ) {
+      (* head in sequence 'steps' enable processes *)
+      \* await Len( steps ) # 0 /\ ProcessEnabled( steps, s );
+      await ProcessEnabled( steps, s );
+      
+      (* process entered, remove head from sequence 'steps' *)
+      step  := ProcessRunning( steps ); \* Head( steps );
+      step_parameter  := ProcessParameter( steps );
+      \* steps := ProcessesToRun( steps ); \* Tail( steps );
+
+      (* Reset infrastructure service responses on process entry *)
+      responses := InfrastructureServiceInit;
+
+      (* time advances by one tick for each process step *)
+      tick();
+      \* debug( s );
+    }
+
+    (*  Remove currently running prosess from head of 'step'.
+    
+	Calling this macro enables next process to take turn.
+        If a process comprises several steps, this results
+	processes runing parallel, unless 'process_done' is
+	called in the end of the process.
+    
+    *)
+    
+    macro process_done( s ) {
+        steps := ProcessesToRun( steps ); \* Tail( steps );
+    }
+
+    
+    

data/mustache/tla/module_footer.mustache

@@ -0,0 +1,2 @@
+
+=============================================================================

data/mustache/tla/module_header.mustache

@@ -0,0 +1,9 @@
+Model version: {{META.model_version}}
+Generator version: {{META.version}}
+Generation timestemp: {{META.timestamp}}
+
+
+------------------------------ MODULE model ------------------------------
+
+EXTENDS TLC, FiniteSets, Sequences, Naturals
+

data/mustache/tla/operator_run.mustache

@@ -0,0 +1,8 @@
+(* Override in extending model *)
+
+ProcessEnabled( stepdefs, s ) == FALSE
+ProcessRunning( stepdefs )    == {}     \* Head( stepdefs )
+ProcessParameter( stepdefs )  == {}     \* Head( stepdefs )
+ProcessesToRun( stepdefs )    == {}     \* Tail( stepdefs )
+
+TickNext( t )   == t + 1                \* advance time (when process start)

data/mustache/tla/operators-infrastructure-service.mustache

@@ -0,0 +1,12 @@
+(******************************************************************
+{{META.desc}}
+ - modelData {{META.modelData}}
+ - template  {{META.template}}
+******************************************************************)
+
+\* return response for 'operation' from 'responses' state variable
+InfrastructureServiceGetResponse( operation ) == responses[InterfaceOperation2ProcessName(operation)].response
+
+\* return status for 'operation' from 'responses' state variable
+InfrastructureServiceGetStatus( operation ) == responses[InterfaceOperation2ProcessName(operation)].status
+

data/mustache/tla/plc_define_footer.mustache

@@ -0,0 +1 @@
+    } \* define

data/mustache/tla/plc_define_header.mustache

@@ -0,0 +1 @@
+    define {

data/mustache/tla/plc_define_run.mustache

@@ -0,0 +1,59 @@
+       
+       (* 
+           Current time in state variable now gets ticked
+           when process starts.
+       *)
+       currentTime == now
+
+     (*
+        Variable step_parameter' contains a record with field 'bindSet', which
+        contains a set with input for the process. If 'bindSet' is 'Nil' return
+        whole 'inputSet'
+     *)
+     ProcessParameterInput( inputSet ) == IF (CHOOSE s \in step_parameter': TRUE).bindSet = Nil
+                                            THEN inputSet
+					    ELSE (CHOOSE s \in step_parameter': TRUE).bindSet
+
+     (* All record fields in 'bindDef' must bind with corresponding fields in 'inputParam' *)
+     \* ProcessParameterEnablesTst( inputParam, bindDefs ) == \A key \in  { k \in DOMAIN bindDefs : k # "_key" }:  bindDefs[key] = inputParam[key] 
+
+     (*
+       ProcessParameterEnables: 'inputParam' satisfies 'bindDefs'
+
+       - all 'normal' field in 'bindDefs' are found in 'inputParam'
+       - and all subrecords  can be validated recursively using 'ProcessParameterEnables' using a the set in field '_key'
+       - and each record in the set in field '_rows' validates at least one row in 'inputParam'
+          -- cardinality of inputParam[key] = cardinality _row.set
+
+       
+     
+       Recurse one level down  in 'inputParam' using keys 'bindDefs._key.key'.
+       Recursion is done only if 'bindDefs' defines field '_key'.
+
+       Should be implemented using recursion, but at the time of writing this comment could not make it work.
+
+     *)
+     RECURSIVE ProcessParameterEnables( _, _ )
+     ProcessParameterEnables( inputParam, bindDefs ) == ( \A key \in  { k \in DOMAIN bindDefs : k # "_key" /\ k # "_rows" }:  bindDefs[key] = inputParam[key]  )
+                   /\ ( \A reckey \in { k \in DOMAIN bindDefs : k = "_key"  }: \A r \in bindDefs[reckey] : ProcessParameterEnables( inputParam[r.key], r.rec ) )
+                   /\ ( \A reckey \in { k \in DOMAIN bindDefs : k = "_rows" }: \A r \in bindDefs[reckey] : 
+                      Cardinality( r.set ) = Cardinality( inputParam[r.key] ) /\  \A bDef \in r.set: \E ip \in inputParam[r.key]: ProcessParameterEnables( ip, bDef ) 
+	           )
+
+
+    (* ProcessParameterBind operator
+       
+       Bind 'inputParam' for the process currently being executed with values in 'step_parameter'.
+
+       Bind to inputParameter allowed if one the following matches
+           - step parameter WildCard
+           - process parameter = WildCard
+           - predicate 'ProcessParameterEnables' resolves TRUE for some paramter set in 'step_parameter'
+	   
+       *)
+     ProcessParameterBind( inputParam ) == step_parameter' = WildCard 
+                       \/ { processEnabledInStep \in step_parameter' : 
+                              processEnabledInStep.process = step' 
+                              /\ ( processEnabledInStep.bindRule = WildCard 
+                                   \/ ProcessParameterEnables( inputParam, processEnabledInStep.bindRule ) )   } # {}
+          

data/mustache/tla/plc_footer.mustache

@@ -0,0 +1,2 @@
+} \* end of algorithm
+*)

data/mustache/tla/plc_header.mustache

@@ -0,0 +1,2 @@
+(* 
+--algorithm model {

data/mustache/tla/plc_run_state.mustache

@@ -0,0 +1,12 @@
+(******************************************************************
+{{META.desc}}
+ - modelData {{META.modelData}}
+ - template  {{META.template}}
+ ******************************************************************)
+
+variables
+       steps             = Steps; \* sequence of [ { process |-> {}, parameter |-> {} }]
+       step              = Nil;   \* processes currently enabled
+       step_parameter    = {};    \* paramter binding for currently enabled processes
+       now               = 0;     \* current time
+          

data/mustache/tla/plc_tail.mustache

@@ -0,0 +1,8 @@
+    fair process ( tail="Tail") {
+        tail_wait: await( Len(steps) = 0 );
+        step           := "Tail";
+        step_parameter := {};
+        tail: while( TRUE ) {
+           skip;
+        }
+    }

data/mustache/tla/plc_translation.mustache

@@ -0,0 +1,2 @@
+\* BEGIN TRANSLATION
+\* END TRANSLATION

data/resources/schema/json_schema/draft-04.json

@@ -0,0 +1,150 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}