Merge pull request #188 from CROSSINGTUD/conditional-events

Add conditional events to predicates

Author: swissiety

.github/workflows/deploy_release.yml

@@ -0,0 +1,44 @@
+name: Deploy CrySL
+
+on:
+  workflow_dispatch:
+
+jobs:
+  deploy-and-release:
+    runs-on: ubuntu-latest
+    name: Deploy CrySL (Release)
+    environment: Deploy
+
+    steps:
+      - name: Checkout source code
+        uses: actions/checkout@v4
+
+      - name: Deploy release version
+        uses: secure-software-engineering/actions/deployment/maven-deployment@develop
+        with:
+          java-distribution: adopt
+          java-version: 17
+          server-id: central
+          server-username: ${{ secrets.SONATYPE_USER }}
+          server-password: ${{ secrets.SONATYPE_PW }}
+          gpg-private-key: ${{ secrets.GPG_PRIVATE_KEY }}
+          gpg-passphrase: ${{ secrets.GPG_PRIVATE_KEY_PASSPHRASE }}
+          mvn-cli-args: '-DskipTests -Pdeployment'
+          deploy-mode: release
+
+      - name: Bump to next SNAPSHOT version
+        uses: secure-software-engineering/actions/deployment/update-snapshot-version@develop
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          source-branch: master
+          target-branch: master
+          snapshot-branch: snapshot-update
+
+      # Steps for GitHub release based on latest tag
+      - name: Get latest tag
+        run: echo "tag=$(git describe --tags --abbrev=0)" >> $GITHUB_ENV
+      - name: Create GitHub release
+        run: |
+          gh release create ${{ env.tag }} --title ${{ env.tag }} --generate-notes
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

CrySLParser/src/main/java/crysl/parsing/CrySLModelReader.java

@@ -222,10 +222,6 @@ public static Collection<CrySLVulnerabilityEntry> toVulnerabilityEntries(EList<S
         return cves.stream().map(CrySLCveEntry::new).collect(Collectors.toList());
     }
 
-    //    private static int parseIntUnderscore(String s) {
-    //        return Integer.parseInt(s.replace("_", "").trim());
-    //    }
-
     public static List<Integer> expandPageRange(PageList list) {
         List<Integer> result = new ArrayList<>();
 
@@ -237,15 +233,13 @@ public static List<Integer> expandPageRange(PageList list) {
             int start = r.getStart();
             if (start <= 0) continue;
 
-            try {
-                int end = r.getEnd();
-                if (end <= 0) {
-                    result.add(start);
-                } else if (end >= start) {
-                    for (int i = start; i <= end; i++) result.add(i);
+            int end = r.getEnd();
+            if (end <= 0) {
+                result.add(start);
+            } else if (end >= start) {
+                for (int i = start; i <= end; i++) {
+                    result.add(i);
                 }
-            } catch (NumberFormatException e) {
-                // ignore or log invalid INTs, consistent with your current code
             }
         }
         return result;
@@ -397,11 +391,12 @@ private Collection<CrySLPredicate> getTimedPredicates(
             if (timed.getAfter() == null) {
                 predicates.add(new CrySLPredicate(null, name, parameters, negate, constraint));
             } else {
-                Collection<StateNode> nodes =
-                        getStatesForMethods(
-                                CrySLReaderUtils.resolveEventToCryslMethods(timed.getAfter()));
+                Collection<CrySLMethod> afterEvents =
+                        CrySLReaderUtils.resolveEventToCryslMethods(timed.getAfter());
+                Collection<StateNode> nodes = getStatesForMethods(afterEvents);
                 predicates.add(
-                        new CrySLCondPredicate(null, name, parameters, negate, nodes, constraint));
+                        new CrySLCondPredicate(
+                                null, name, parameters, negate, afterEvents, nodes, constraint));
             }
         }
         return predicates;

CrySLParser/src/main/java/crysl/rule/CrySLCondPredicate.java

@@ -2,51 +2,62 @@
 
 import java.util.Collection;
 import java.util.List;
+import java.util.Objects;
 
 public class CrySLCondPredicate extends CrySLPredicate {
 
+    private final Collection<CrySLMethod> conditionalEvents;
     private final Collection<StateNode> conditionalNodes;
 
     public CrySLCondPredicate(
             ICrySLPredicateParameter baseObj,
             String name,
             List<ICrySLPredicateParameter> parameters,
             Boolean negated,
+            Collection<CrySLMethod> conditionalEvents,
             Collection<StateNode> nodes) {
-        this(baseObj, name, parameters, negated, nodes, null);
+        this(baseObj, name, parameters, negated, conditionalEvents, nodes, null);
     }
 
     public CrySLCondPredicate(
             ICrySLPredicateParameter baseObj,
             String name,
             List<ICrySLPredicateParameter> parameters,
             Boolean negated,
+            Collection<CrySLMethod> conditionalEvents,
             Collection<StateNode> nodes,
             ISLConstraint constraint) {
         super(baseObj, name, parameters, negated, constraint);
+
+        this.conditionalEvents = conditionalEvents;
         this.conditionalNodes = nodes;
     }
 
-    /**
-     * @return the conditionalMethods
-     */
-    public Collection<StateNode> getConditionalMethods() {
+    public Collection<CrySLMethod> getConditionalEvents() {
+        return conditionalEvents;
+    }
+
+    public Collection<StateNode> getConditionalNodes() {
         return conditionalNodes;
     }
 
     @Override
-    public boolean equals(Object obj) {
-        if (!super.equals(obj)) return false;
-
-        if (!(obj instanceof CrySLCondPredicate)) return false;
-
-        CrySLCondPredicate other = (CrySLCondPredicate) obj;
-        if (!getConditionalMethods().equals(other.getConditionalMethods())) return false;
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        if (!super.equals(o)) return false;
+        CrySLCondPredicate that = (CrySLCondPredicate) o;
+        return Objects.equals(conditionalEvents, that.conditionalEvents)
+                && Objects.equals(conditionalNodes, that.conditionalNodes);
+    }
 
-        return true;
+    @Override
+    public int hashCode() {
+        return Objects.hash(super.hashCode(), conditionalEvents, conditionalNodes);
     }
 
+    @Override
     public String toString() {
-        return super.toString() + " after " + conditionalNodes;
+        return super.toString() + " after " + conditionalEvents + " (" + conditionalNodes + ")";
     }
 }