ST6RI-178 Implement versioned publishing

.github/workflows/build.yml

@@ -0,0 +1,44 @@
+# This workflow will build a Java project with Maven, and cache/restore any dependencies to improve the workflow execution time
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-maven
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Java CI with Maven
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: '**'
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up JDK 17
+      uses: actions/setup-java@v4
+      with:
+        java-version: '17'
+        distribution: 'temurin'
+        cache: maven
+    - name: Build with Maven
+      run: ./mvnw -B clean verify --file pom.xml
+    - name: Publish Test Report
+      uses: mikepenz/action-junit-report@v5
+      if: success() || failure() # always run even if the previous step fails
+      with:
+        report_paths: '**/target/surefire-reports/TEST-*.xml'
+        include_passed: true
+    - name: Verify index generation
+      run: echo $(git diff -- sysml.library/.index.json) | grep -e '^$' || (echo "Library index in the git repository is not up to date. Please re-generate it and push changes to the repository."; exit 1)
+    - name: Publish to Github Packages
+      if: github.event_name != 'pull_request'
+      run: ./mvnw -B deploy -DskipTests=true
+      env:
+        GITHUB_TOKEN: ${{ github.token }} # GITHUB_TOKEN is the default env for the password

kerml/src/examples/KerML Spec Annex A Examples/A-3-8-ChangingFeatureValues.kerml

@@ -23,9 +23,9 @@ package ChangingFeatureValuesModelToBeExecuted {
 	}
 
 	struct Product {
-		feature isPainted : Boolean [1] := false;
-		feature isDry : Boolean [1] := true;
-		feature isShipped : Boolean [1] := false;
+		var feature isPainted : Boolean [1] := false;
+		var feature isDry : Boolean [1] := true;
+		var feature isShipped : Boolean [1] := false;
 	}
 
 	behavior Paint {
@@ -80,9 +80,9 @@ package ChangingFeatureValuesExecution {
 	private import FeatureReferencingPerformances::FeatureWritePerformance;
 
 	struct ProductTimeSlice specializes Product {
-		readonly feature redefines isPainted;
-		readonly feature redefines isDry;
-		readonly feature redefines isShipped;
+		feature redefines isPainted;
+		feature redefines isDry;
+		feature redefines isShipped;
 	}
 
 	#atom

kerml/src/examples/Simple Tests/ArgumentResolution.kerml

@@ -5,7 +5,7 @@ package ArgumentResolutionBug {
 
 	behavior B  {
 		in feature x;
-		out feature : A = A(x);
+		out feature : A = new A(x);
 	}
 
 	class C {

kerml/src/examples/Simple Tests/Behaviors.kerml

@@ -8,6 +8,11 @@ package Behaviors {
     }
     behavior B specializes A {
         in x1;
-        out y1;
+        out var y1;
+    }
+    class C {
+        var z = A().y;
+        step a : A;
+        binding z = a.y;
     }
 }

kerml/src/examples/Simple Tests/Expressions.kerml

@@ -56,7 +56,7 @@ package Expressions {
 	bb : Boolean = f.s(1);
 
 	class C {
-		count : ScalarValues::Integer := 0;
+		var count : ScalarValues::Integer := 0;
 	}
 
 	feature obj1 : C;
@@ -70,6 +70,6 @@ package Expressions {
 		feature count : ScalarValues::Integer =  c#(1).count;
 	}
 
-	feature l = L();
+	feature l = new L();
 	feature w1 = w(xx);
 }

kerml/src/examples/Simple Tests/Features.kerml

@@ -49,18 +49,24 @@ package Features {
 		feature guardian[1];
 	}
 
-	classifier RegisteredAsset {
-		composite readonly feature identifier[0..1];
-	}
-
-	classifier Vehicle :> RegisteredAsset {
-		derived feature vin[1] = identifier;	
-	}
-
+    class RegisteredAsset {
+        composite var feature identifier[0..1];
+    }
+
+    classifier Vehicle :> RegisteredAsset {
+        derived var feature vin[1] = identifier;
+
+        var feature v : Vehicle;
+        binding vin = v.vin;
+        var feature w = v.vin;
+
+        feature x = vin;
+        binding x = vin;
+    }
 	feature legalIdentification;
 
 	specialization Redef redefinition LegalRecord::guardian redefines parent;
-	specialization redefinition Vehicle::vin redefines RegisteredAsset::identifier; 
+	specialization redefinition Vehicle::vin redefines RegisteredAsset::identifier;
 
 	redefinition Vehicle::vin redefines legalIdentification; 
 }

kerml/src/examples/Simple Tests/Scoping.kerml

@@ -0,0 +1,40 @@
+package Scoping {
+    package P1 {
+        class A {
+            feature f;
+        }
+        package P2 {
+            class A {
+                feature g;
+            }
+            package P3 {
+                class B :> A {
+                    feature :>> g;
+                }
+            }
+        }
+        package Objects {
+            class Object {
+                feature test1;
+            }
+        }
+        package '$' {
+            class Objects {
+                class Object {
+                    feature test2;
+                }
+            }
+        }
+        package P4 {
+            class C :> Objects::Object {
+                feature :>> test1;
+            }
+            class D :> '$'::Objects::Object {
+                feature :>> test2;
+            }
+            class E :> $::Objects::Object {
+                feature :>> subobjects;
+            }
+        }
+    }
+}

kerml/src/examples/Variable Feature Examples/Enhancements/ExtendedOccurrences.kerml

@@ -0,0 +1,50 @@
+package ExtendedOccurrences {
+    class Interval;
+    class Moment :> Interval;
+    class Timeslice {
+        feature interval : Interval;
+        :>> self : Timeslice;
+    }
+    class Snapshot :> Timeslice {
+        feature moment :>> interval : Moment;
+        :>> self : Snapshot;
+    }
+    class Life :> Timeslice;
+    class ExtendedOccurrence :> Life {
+        :>> timeSlices : Timeslice [1..*];
+        :>> snapshots :> timeSlices : Snapshot [1..*];
+        expr at {
+        	:>> that : Timeslice;
+            in interval : Interval;
+            return result : Timeslice;
+
+            binding result.portionOf = that;
+            binding result.interval = interval;
+        }
+
+        expr while {
+            in timeslice : Timeslice;
+            return result : Timeslice = at(timeslice.interval);
+        }
+
+        var feature activeOccurrences :> Occurrences::occurrences {
+        	connector : Occurrences::HappensDuring from [1] that to [1] self;
+        }
+
+        var feature activeSuboccurrences :> Occurrences::occurrences {
+        	connector : Occurrences::HappensDuring from [1] that to [1] self;
+        }
+
+        // occurrences and performances are abstract package-level features.
+        // It would be nice to put the variable next to them, but they cannot 
+        // be package-level, or featured by Anything. Nevertheless, since
+        // Occurrence is a specialization of Anything, it will have these 
+        // features (might be worth redefining them explicitly), so the
+        // variables can subset them. In the case below, performances will
+        // contain every step in the occurrence, which is the correct domain
+        // for the variable.
+        var feature activePerformances :> Performances::performances {
+        	connector : Occurrences::HappensDuring from [1] that to [1] self;
+        }
+    }
+}

kerml/src/examples/Variable Feature Examples/Enhancements/Moments.kerml

@@ -0,0 +1,39 @@
+package Moments {
+    private import Occurrences::Life;
+    private import Occurrences::Occurrence;
+
+    class Eternity specializes Life {
+        // Nothing before/after or outside.
+        // Could be many of these, see universal below.
+        redefines predecessors [0];
+        redefines successors [0];
+        redefines outsideOfOccurrences [0];
+    }
+
+    class UniversalEternity [1] specializes Eternity {
+      redefines timeSlices: Period;  //Includes life.
+      redefines snapshots : Moment;
+    }
+
+    feature universalEternity : UniversalEternity [1];
+
+    class Period {  //Includes life and snapshots.
+      //↓↓ With UE redef, exactly UE timeslices.
+      redefines timeSliceOf : UniversalEternity [1];
+    }
+
+    class all InstantOccurrence specializes Occurrence {
+        // Probly useful elsewhere, eg, to type snapshots.
+        redefines snapshots [1]; // Or startShot subsets endShot;
+    }                            // Or middleTimeslice [0];
+
+    class Moment specializes Period, InstantOccurrence {
+      //↓↓ With UE redef, exactly UE snapshots.
+      redefines snapshotOf : UniversalEternity [1]; }
+
+    private import Occurrence::spaceTimeCoincidentOccurrences;
+    //UE portion "corresponding" to an occurrence.
+    feature coincidentUEPortion : Occurrence [1] subsets spaceTimeCoincidentOccurrences,
+                                                         universalEternity.portions
+                                                 featured by Occurrence;
+}