Resolve "Cleanup parser"

.gitlab-ci.yml

@@ -12,7 +12,7 @@ variables:
 #  # Improve performance with overlayfs.
 #  DOCKER_DRIVER: overlay2
   GRADLE_OPTS: "-Dorg.gradle.daemon=false"
-  TEST_REPORTS: "eraser-base/build/reports/tests/"
+  TEST_REPORTS: "*/build/test-results/**/TEST-*.xml"
   TEST_LOG: "eraser-base/logs/eraser-test.log"
   JACOCO_REPORT: "*/build/reports/jacoco/all-tests/jacoco*Report.xml"
   # settings for influxdb
@@ -55,8 +55,9 @@ test:
     when: always
     paths:
       - $TEST_LOG
-      - $TEST_REPORTS
       - $JACOCO_REPORT
+    reports:
+      junit: $TEST_REPORTS
 
 coverage:
   image: python:3.7.1-alpine

buildSrc/src/main/groovy/eraser.java-common-conventions.gradle

@@ -23,6 +23,10 @@ tasks.named('test') {
   }
 }
 
+tasks.withType(JavaCompile) {
+    options.deprecation = true
+}
+
 task allTests(type: Test, dependsOn: testClasses) {
   description = 'Run every test'
   group = 'verification'

eraser-base/src/main/jastadd/Expression.jrag

@@ -30,4 +30,15 @@ aspect Expression {
   eq Designator.eval() = getItem().getStateAsDouble();
   eq ParenthesizedNumberExpression.eval() = getOperand().eval();
   eq NumberLiteralExpression.eval() = getValue();
+
+  // is-X
+  syn boolean Expression.isLogicalExpression() = false;
+  eq LogicalExpression.isLogicalExpression() = true;
+  syn boolean Expression.isNumberExpression() = false;
+  eq NumberExpression.isNumberExpression() = true;
+  // as-X
+  syn LogicalExpression Expression.asLogicalExpression() = null;
+  eq LogicalExpression.asLogicalExpression() = this;
+  syn NumberExpression Expression.asNumberExpression() = null;
+  eq NumberExpression.asNumberExpression() = this;
 }

eraser-base/src/main/jastadd/Item.jrag

@@ -375,6 +375,8 @@ aspect ItemHandling {
   syn boolean ItemWithDoubleState.isItemWithDoubleState() = true;
   syn boolean Item.isDateTimeItem() = false;
   syn boolean DateTimeItem.isDateTimeItem() = true;
+  syn boolean Item.isActivityItem() = false;
+  syn boolean ActivityItem.isActivityItem() = true;
 
   //--- as$ItemType ---
   // those attributes will raise a ClassCastException if called on the wrong item type. But what else can we do?

eraser-base/src/main/jastadd/LastChanged.jrag

@@ -12,9 +12,7 @@ aspect LastChanged {
     if (lastStateChange == null) {
       return true;
     }
-
     return lastStateChange.toEpochMilli() + (1 / frequency) * 1000 < Instant.now().toEpochMilli();
-
   }
 
 }

eraser-base/src/main/jastadd/ModelStatistics.jrag

 aspect ModelStatistics {
 
-  //--- numChannels ---
-  syn int SmartHomeEntityModel.numChannels() {
-    int sum = 0;
-    for (Thing thing : getThingList()) {
-      sum += thing.getNumChannel();
-    }
-    return sum;
-  }
-
   //--- description ---
   syn String SmartHomeEntityModel.description() = "["
     + this.getNumThingType() + " thing type(s), "
     + this.getNumChannelType() + " channel type(s), "
-    + this.numChannels() + " channel(s), "
+    + this.getNumChannel() + " channel(s), "
     + this.getNumThing() + " thing(s), "
     + this.getNumGroup() + " group(s), "
     + this.items().size() + " item(s)]";

eraser-base/src/main/jastadd/Navigation.jrag

@@ -7,7 +7,27 @@ aspect Navigation {
   //--- items ---
   syn java.util.List<Item> SmartHomeEntityModel.items() {
     java.util.List<Item> result = new java.util.ArrayList<>();
-    addItems(result, getGroupList());
+    getGroupList().forEach(group -> result.addAll(group.items()));
+    result.addAll(unknownGroup().items());
+    return result;
+  }
+  syn java.util.List<Item> Group.items() {
+    java.util.List<Item> result = new java.util.ArrayList<>();
+    getItemList().forEach(item -> result.add(item));
+    getGroupList().forEach(subgroup -> result.addAll(subgroup.items()));
+    return result;
+  }
+
+  //--- groups ---
+  syn java.util.List<Group> SmartHomeEntityModel.groups() {
+    java.util.List<Group> result = new java.util.ArrayList<>();
+    getGroupList().forEach(group -> result.addAll(group.groups()));
+    return result;
+  }
+  syn java.util.List<Group> Group.groups() {
+    java.util.List<Group> result = new java.util.ArrayList<>();
+    getGroupList().forEach(subgroup -> result.addAll(subgroup.groups()));
+    result.add(this);
     return result;
   }
 
@@ -16,9 +36,22 @@ aspect Navigation {
   inh Group Item.enclosingGroup();
   eq Group.getItem().enclosingGroup() = this;
   eq Group.getGroup().enclosingGroup() = this;
+  eq SmartHomeEntityModel.unknownGroup().enclosingGroup() = null;
   eq SmartHomeEntityModel.getGroup().enclosingGroup() = null;
   eq SmartHomeEntityModel.getActivityItem().enclosingGroup() = null;
 
+  //--- containingSmartHomeEntityModel ---
+  inh SmartHomeEntityModel Thing.containingSmartHomeEntityModel();
+  inh SmartHomeEntityModel Group.containingSmartHomeEntityModel();
+  inh SmartHomeEntityModel Item.containingSmartHomeEntityModel();
+  inh SmartHomeEntityModel ThingType.containingSmartHomeEntityModel();
+  inh SmartHomeEntityModel Parameter.containingSmartHomeEntityModel();
+  inh SmartHomeEntityModel ChannelType.containingSmartHomeEntityModel();
+  inh SmartHomeEntityModel Channel.containingSmartHomeEntityModel();
+  inh SmartHomeEntityModel ItemCategory.containingSmartHomeEntityModel();
+  inh SmartHomeEntityModel ChannelCategory.containingSmartHomeEntityModel();
+  eq SmartHomeEntityModel.getChild().containingSmartHomeEntityModel() = this;
+
   //--- relevantFrequencySetting ---
   syn FrequencySetting Group.relevantFrequencySetting() {
     // first, use value defined on group itself, if any
@@ -52,11 +85,6 @@ aspect Navigation {
     return null;
   }
 
-  //--- addItems ---
-  private void SmartHomeEntityModel.addItems(java.util.List<Item> result, JastAddList<Group> groups) {
-    groups.forEach(group -> group.getItemList().forEach(item -> result.add(item)));
-  }
-
   //--- parameters ---
   syn java.util.Set<Parameter> SmartHomeEntityModel.parameters() {
     java.util.Set<Parameter> result = new java.util.TreeSet<>(modelElementComparator());
@@ -71,10 +99,6 @@ aspect Navigation {
     return result;
   }
 
-  //--- containingThing ---
-  inh Thing Channel.containingThing();
-  eq Thing.getChannel().containingThing() = this;
-
   //--- containingNeuralNetwork ---
   inh NeuralNetworkRoot OutputLayer.containingNeuralNetwork();
   eq NeuralNetworkRoot.getOutputLayer().containingNeuralNetwork() = this;
@@ -85,7 +109,7 @@ aspect Navigation {
       return Optional.empty();
     }
     Channel channel = this.getChannel();
-    Thing thing = channel.containingThing();
+    Thing thing = channel.getThing();
     return Optional.of(thing);
   }
 

eraser-base/src/main/jastadd/Printing.jrag

+import java.util.StringJoiner;
+
 aspect Printing {
   syn String ASTNode.prettyPrint() { throw new UnsupportedOperationException(); }
 
@@ -21,9 +23,12 @@ aspect Printing {
     for (Item i : items()) {
       sb.append(i.prettyPrint());
     }
-    for (Group g : getGroupList()) {
+    for (Group g : groups()) {
       sb.append(g.prettyPrint());
     }
+    if (unknownGroup().getNumItem() > 0 ) {
+      sb.append(unknownGroup().prettyPrint());
+    }
     for (ThingType tt : getThingTypeList()) {
       sb.append(tt.prettyPrint());
     }
@@ -45,7 +50,7 @@ aspect Printing {
         .addRequired("id", getID())
         .addNonDefault("label", getLabel())
         .addRequired("type", getType(), ThingType::getID)
-        .addIds("channels", getNumChannel(), getChannelList())
+        .addIds("channels", getChannelList())
         .build();
   }
 
@@ -57,9 +62,7 @@ aspect Printing {
         .addRequired("state", getStateAsString())
         .addOptional("category", hasCategory(), () -> getCategory().getName())
         .addOptional("topic", hasTopic(), () -> getTopic().getTopicString())
-        .addNodes("metaData", getNumMetaData(), getMetaDataList(),
-                  md -> "\"" + md.getKey() + "\":\"" + md.getValue() + "\"",
-                  MemberPrinter.ListBracketType.CURLY)
+        .addOptionalPrettyPrint(getMetaData())
         .build();
   }
 
@@ -77,6 +80,7 @@ aspect Printing {
   eq SwitchItem.prettyPrintType() = "Switch Item" ;
   eq ActivityItem.prettyPrintType() = "Activity Item" ;
   eq DefaultItem.prettyPrintType() = "Item" ;
+  eq ItemPrototype.prettyPrintType() = "!! prototype not converted !!" ;
 
   // special ActivityItem printing. Always omit state.
   eq ActivityItem.prettyPrint() {
@@ -85,12 +89,21 @@ aspect Printing {
         .addNonDefault("label", getLabel())
         .addOptional("category", hasCategory(), () -> getCategory().getName())
         .addOptional("topic", hasTopic(), () -> getTopic().getTopicString())
-        .addNodes("metaData", getNumMetaData(), getMetaDataList(),
-                  md -> "\"" + md.getKey() + "\":\"" + md.getValue() + "\"",
-                  MemberPrinter.ListBracketType.CURLY)
+        .addOptionalPrettyPrint(getMetaData())
         .build();
   }
 
+  // MetaData: metaData={"key": "value", "key": "value"}
+  eq MetaData.prettyPrint() {
+    if (getNumKeyValuePair() == 0) {
+      return "";
+    }
+    StringJoiner sj = new StringJoiner(", ", " metaData={", "}");
+    for (KeyValuePair keyValuePair : getKeyValuePairList()) {
+      sj.add("\"" + keyValuePair.getKey() + "\":\"" + keyValuePair.getValue() + "\"");
+    }
+    return sj.toString();
+  }
 
   // Group: id="" groups=["GROUP_ID", "GROUP_ID"] items=["ITEM_ID", "ITEM_ID"] aggregation=AGG;
   //        AGG either '"agg-name"', or '"agg-name" ("param1", "param2")'
@@ -124,7 +137,7 @@ aspect Printing {
         .addRequired("id", getID())
         .addNonDefault("label", getLabel())
         .addNonDefault("description", getDescription())
-        .addIds("parameters", getNumParameter(), getParameters())
+        .addIds("parameters", getParameters())
         .addIds("channelTypes", getChannelTypes())
         .build();
   }
@@ -154,9 +167,10 @@ aspect Printing {
         .build();
   }
 
+  // ChannelCategory
   syn String DefaultChannelCategory.prettyPrint() = getValue().name();
-
   syn String SimpleChannelCategory.prettyPrint() = getValue();
+  syn String ReferringChannelCategory.prettyPrint() = getChannelCategory().prettyPrint();
 
   // Channel: id="" type="" links=["ITEM_ID", "ITEM_ID"];
   eq Channel.prettyPrint() {

eraser-base/src/main/jastadd/Resolving.jrag

@@ -12,13 +12,11 @@ aspect Resolving {
 
   //--- resolveChannel ---
   syn java.util.Optional<Channel> SmartHomeEntityModel.resolveChannel(String channelId) {
-    for (Thing thing : this.getThingList()) {
-      for (Channel channel : thing.getChannelList()) {
+    for (Channel channel : this.getChannelList()) {
       if (channel.getID().equals(channelId)) {
         return java.util.Optional.of(channel);
       }
     }
-    }
     return java.util.Optional.empty();
   }
 
@@ -32,13 +30,33 @@ aspect Resolving {
     return java.util.Optional.empty();
   }
 
+  //--- resolveDefaultChannelCategory ---
+  syn java.util.Optional<DefaultChannelCategory> SmartHomeEntityModel.resolveDefaultChannelCategory(String name) {
+    for (DefaultChannelCategory dcc : this.defaultChannelCategoryList()) {
+      if (dcc.getValue().name().equals(name)) {
+        return java.util.Optional.of(dcc);
+      }
+    }
+    return java.util.Optional.empty();
+  }
+
+  //--- resolveParameter ---
+  syn java.util.Optional<Parameter> SmartHomeEntityModel.resolveParameter(String parameterId) {
+    for (Parameter parameter : this.getParameterList()) {
+      if (parameter.getID().equals(parameterId)) {
+        return java.util.Optional.of(parameter);
+      }
+    }
+    return java.util.Optional.empty();
+  }
+
   //--- resolveItem ---
   syn java.util.Optional<Item> SmartHomeEntityModel.resolveItem(String itemId) {
     if ("activity".equals(itemId)) {
       return Optional.of(getActivityItem());
     }
     for (Item item : items()) {
-      if (item.getID().equals(itemId)) {
+      if (item.getID().equals(itemId) && !item.isItemPlaceHolder()) {
         return java.util.Optional.of(item);
       }
     }
@@ -108,12 +126,51 @@ aspect Resolving {
   }
 
   // implementing resolving for relations
-  refine RefResolverStubs eq StateSyncGroup.resolveTargetItemByToken(String id, int position) {
+  // _._ -> Item
+  refine RefResolverStubs eq ASTNode.globallyResolveItemByToken(String id) {
     return getRoot().getSmartHomeEntityModel().resolveItem(id).orElseThrow(() -> new RuntimeException("Item '" + id + "' not found!"));
   }
 
+  // _._ -> FrequencySetting
   refine RefResolverStubs eq ASTNode.globallyResolveFrequencySettingByToken(String id) {
     return getRoot().resolveFrequencySetting(id).orElseThrow(() -> new RuntimeException("FrequencySetting '" + id + "' not found!"));
   }
 
+  // Thing.Channel* -> Channel
+  refine RefResolverStubs eq Thing.resolveChannelByToken(String id, int position) {
+    return containingSmartHomeEntityModel().resolveChannel(id).orElseThrow(() -> new RuntimeException("Channel '" + id + "' not found!"));
+  }
+
+  // Thing.Type -> ThingType
+  refine RefResolverStubs eq Thing.resolveTypeByToken(String id) {
+    return containingSmartHomeEntityModel().resolveThingType(id).orElseThrow(() -> new RuntimeException("ThingType '" + id + "' not found!"));
+  }
+
+  // ThingType.Parameter* -> Parameter
+  refine RefResolverStubs eq ThingType.resolveParameterByToken(String id, int position) {
+    return containingSmartHomeEntityModel().resolveParameter(id).orElseThrow(() -> new RuntimeException("Parameter '" + id + "' not found!"));
+  }
+
+  // _._ -> ChannelType
+  refine RefResolverStubs eq ASTNode.globallyResolveChannelTypeByToken(String id) {
+    return getRoot().getSmartHomeEntityModel().resolveChannelType(id).orElseThrow(() -> new RuntimeException("ChannelType '" + id + "' not found!"));
+  }
+
+  // ReferringChannelCategory.ChannelCategory -> DefaultChannelCategory
+  refine RefResolverStubs eq ReferringChannelCategory.resolveChannelCategoryByToken(String id) {
+    return containingSmartHomeEntityModel().resolveDefaultChannelCategory(id).orElseThrow(() -> new RuntimeException("DefaultChannelCategory '" + id + "' not found!"));
+  }
+
+  // Item.Topic? <-> MqttTopic.Item*
+  refine RefResolverStubs eq Item.resolveTopicByToken(String id) {
+    // not an actual resolving, also adds the new mqtt-topic under mqtt-root
+    return getRoot().getMqttRoot().getOrCreateMqttTopic(id);
+  }
+
+  // Item.Category? <-> ItemCategory.Items*
+  refine RefResolverStubs eq Item.resolveCategoryByToken(String id) {
+    // not an actual resolving, also adds the new item-category under containing model
+    return containingSmartHomeEntityModel().getOrCreateCategoryByName(id);
+  }
+
 }

eraser-base/src/main/jastadd/Util.jrag

@@ -34,4 +34,35 @@ aspect Util {
     model.setMachineLearningRoot(new MachineLearningRoot());
     return model;
   }
+  /**
+   * Performs a safe full traversal of the tree using getChild to trigger rewrites
+   */
+  public void ASTNode.doSafeFullTraversal() {
+    for (int i = 0; i < getNumChild(); i++) {
+      ASTNode child = getChild(i);
+      if (child != null) {
+        child.doSafeFullTraversal();
+      }
+    }
+  }
+
+  /**
+   * removes the object from the AST, i.e. removes the reference from its parent to the object
+   *
+   * Please note that any intrinsic non-containment relations to the object are not removed.
+   * @return true, if the object had a parent.
+   */
+  public boolean ASTNode.removeSelf() {
+    if (getParent() == null) {
+      return false;
+    } else {
+      for (int childIndex = 0; childIndex < getParent().numChildren(); childIndex++) {
+        if (getParent().getChild(childIndex) == this) {
+          getParent().removeChild(childIndex);
+          return true;
+        }
+      }
+    }
+    throw new RuntimeException("unable to remove child, because it was not contained in its parent!");
+  }
 }

eraser-base/src/main/jastadd/eraser.flex

@@ -57,7 +57,7 @@ Comment = "//" [^\n\r]+
 "Influx"       { return sym(Terminals.INFLUX); }
 "ML"           { return sym(Terminals.ML); }
 "Rule"         { return sym(Terminals.RULE); }
-"SyncState"    { return sym(Terminals.SYNCSTATE); }
+"SyncState"    { return sym(Terminals.SYNC_STATE); }
 // special items (group already has a token definition)
 "Activity"     { return sym(Terminals.ACTIVITY); }
 "Color"        { return sym(Terminals.COLOR); }

eraser-base/src/main/jastadd/mqtt.jrag

@@ -77,11 +77,16 @@ aspect MQTT {
   refine SmartHomeEntityModel public void SmartHomeEntityModel.addNewItem(Item item) {
     refined(item);
     // update mqtt-topic to new mqtt-root
-    JavaUtils.ifPresentOrElse(
-        getRoot().getMqttRoot().resolveTopicSuffix(item.getTopic().getTopicString()),
-        topic -> item.setTopic(topic),
-        () -> de.tudresden.inf.st.eraser.util.ParserUtils.createMqttTopic(item, item.getTopic().getTopicString(), getRoot())
-    );
+    item.setTopic(getRoot().getMqttRoot().getOrCreateMqttTopic(item.getTopic().getTopicString()));
+  }
+
+  public MqttTopic MqttRoot.getOrCreateMqttTopic(String topicString) {
+    return resolveTopicSuffix(topicString).orElseGet(() -> {
+      MqttTopic result = new MqttTopic();
+      result.setTopicString(topicString);
+      addTopic(result);
+      return result;
+    });
   }
 
 }

eraser-base/src/main/jastadd/shem.jrag

@@ -4,10 +4,73 @@ aspect SmartHomeEntityModel {
   }
 
   public void SmartHomeEntityModel.addNewItem(Item item) {
-    JavaUtils.ifPresentOrElse(
-        resolveGroup(de.tudresden.inf.st.eraser.util.ParserUtils.UNKNOWN_GROUP_NAME),
-        group -> group.addItem(item),
-        () -> de.tudresden.inf.st.eraser.util.ParserUtils.createUnknownGroup(this, Collections.singletonList(item)));
+    unknownGroup().addItem(item);
+  }
+
+  public MetaData MetaData.add(String key, String value) {
+    addKeyValuePair(new KeyValuePair(key, value));
+    return this;
+  }
+
+  syn nta Group SmartHomeEntityModel.unknownGroup() {
+    return new Group().setID("Unknown");
+  }
+
+  syn nta JastAddList<DefaultChannelCategory> SmartHomeEntityModel.defaultChannelCategoryList() {
+    JastAddList<DefaultChannelCategory> result = new JastAddList<>();
+    Arrays.stream(DefaultChannelCategoryValue.values()).sorted().forEach(ccv -> result.add(new DefaultChannelCategory(ccv)));
+    return result;
+  }
+
+  rewrite ItemPrototype {
+    to Item {
+      Item result = getItemWithCorrectType();
+      result.setID(this.getID());
+      result.setLabel(this.getLabel());
+      result.setMetaData(this.getMetaData());
+      if (this.hasTopic()) {
+        result.setTopic(this.getTopic());
+      }
+      if (this.hasCategory()) {
+        result.setCategory(this.getCategory());
+      }
+      if (!result.isActivityItem()) {
+        String state = this.getStateAsString();
+        result.disableSendState();
+        if (state.isEmpty()) {
+          result.setStateToDefault();
+        } else {
+          result.setStateFromString(state);
+        }
+        result.enableSendState();
+      }
+      return result;
+    }
+  }
+
+  // PlaceHolders
+  // ItemPlaceHolder
+  syn Item Item.realItem() = this;
+  eq ItemPlaceHolder.realItem() {
+    return containingSmartHomeEntityModel().resolveItem(getID()).orElseThrow(() -> new RuntimeException("Item '" + getID() + "' not found!"));
+  }
+  eq ItemPlaceHolder.prettyPrintType() = "<placeholder>";
+  syn boolean Item.isItemPlaceHolder() = false;
+  eq ItemPlaceHolder.isItemPlaceHolder() = true;
+
+  // GroupPlaceHolder
+  syn Group Group.realGroup() = this;
+  eq GroupPlaceHolder.realGroup() {
+    return containingSmartHomeEntityModel().resolveGroup(getID()).orElseThrow(() -> new RuntimeException("Group '" + getID() + "' not found!"));
+  }
+
+  public ItemCategory SmartHomeEntityModel.getOrCreateCategoryByName(String categoryName) {
+    return this.resolveItemCategory(categoryName).orElseGet(() -> {
+      ItemCategory result = new ItemCategory();
+      result.setName(categoryName);
+      addItemCategory(result);
+      return result;
+    });
   }
 
 }

eraser-base/src/main/jastadd/shem.relast

 // ----------------    openHAB    ------------------------------
-SmartHomeEntityModel ::= Thing* Group* ThingType* ChannelType* ChannelCategory* ItemCategory* /ActivityItem:Item/ ;
+SmartHomeEntityModel ::= Thing* Group* ThingType* Parameter* ChannelType* Channel* ItemCategory* /ActivityItem:Item/ ;
 
 
 abstract ModelElement ::= <ID:String> ;
 abstract LabelledModelElement : ModelElement ::= <Label:String> ;
 abstract DescribableModelElement : LabelledModelElement ::= <Description:String> ;
 
-ThingType : DescribableModelElement ::= Parameter* ;
+ThingType : DescribableModelElement ::= ;
+rel ThingType.Parameter* -> Parameter ;
 rel ThingType.ChannelType* -> ChannelType ;
 
-Thing : LabelledModelElement ::= Channel* ;
+Thing : LabelledModelElement ::= ;
+rel Thing.Channel* <-> Channel.Thing ;
 rel Thing.Type -> ThingType ;
 
-ChannelType : DescribableModelElement ::= <ItemType:ItemType> <ReadOnly:boolean> ;
-rel ChannelType.ChannelCategory -> ChannelCategory ;
+ChannelType : DescribableModelElement ::= <ItemType:ItemType> <ReadOnly:boolean> ChannelCategory ;
 
 abstract ChannelCategory ;
-DefaultChannelCategory : ChannelCategory ::= <Value:DefaultChannelCategoryValue> ;
+ReferringChannelCategory : ChannelCategory ;
+rel ReferringChannelCategory.ChannelCategory -> DefaultChannelCategory ;
 SimpleChannelCategory : ChannelCategory ::= <Value:String> ;
+DefaultChannelCategory ::= <Value:DefaultChannelCategoryValue> ;
 
 Channel : ModelElement ::= ;
 rel Channel.Type -> ChannelType ;
@@ -26,8 +29,8 @@ rel Channel.LinkedItem* <-> Item.Channel? ;
 Parameter : DescribableModelElement ::= <Type:ParameterValueType> [DefaultValue:ParameterDefaultValue] <Context:String> <Required:boolean> ;
 ParameterDefaultValue ::= <Value:String> ;
 
-abstract Item : LabelledModelElement ::= <_fetched_data:boolean> MetaData:ItemMetaData* /ItemObserver/ /LastChanged/;
-rel Item.Category? -> ItemCategory ;
+abstract Item : LabelledModelElement ::= <_fetched_data:boolean> [MetaData] /ItemObserver/ /LastChanged/;
+rel Item.Category? <-> ItemCategory.Items* ;
 rel Item.FrequencySetting? -> FrequencySetting ;
 
 abstract ItemWithBooleanState : Item ::= <_state:boolean> ;
@@ -46,16 +49,19 @@ StringItem : ItemWithStringState ;
 SwitchItem : ItemWithBooleanState ;
 DefaultItem : ItemWithStringState ;
 ActivityItem : ItemWithDoubleState ;
+ItemPrototype : ItemWithStringState ::= ItemWithCorrectType:Item ;  // only used for parsing
+ItemPlaceHolder : ItemWithStringState ;  // only used for parsing
 
-ItemMetaData ::= <Key:String> <Value:String> ;
+MetaData ::= KeyValuePair* ;
+KeyValuePair ::= <Key:String> <Value:String> ;
 
 ItemCategory ::= <Name:String> ;
 
 LastChanged ::= <Value:Instant> ;
 
-
 Group : LabelledModelElement ::= Group* Item* [AggregationFunction:GroupAggregationFunction] ;
 rel Group.FrequencySetting? -> FrequencySetting ;
+GroupPlaceHolder : Group ;  // only used for parsing
 
 abstract GroupAggregationFunction ;
 SimpleGroupAggregationFunction : GroupAggregationFunction ::= <FunctionName:SimpleGroupAggregationFunctionName> ;

eraser-base/src/main/java/de/tudresden/inf/st/eraser/openhab2/OpenHab2Importer.java

@@ -6,6 +6,7 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.module.SimpleModule;
 import de.tudresden.inf.st.eraser.jastadd.model.*;
 import de.tudresden.inf.st.eraser.openhab2.data.*;
+import de.tudresden.inf.st.eraser.util.JavaUtils;
 import de.tudresden.inf.st.eraser.util.ParserUtils;
 import de.tudresden.inf.st.eraser.util.Tuple;
 import org.apache.logging.log4j.LogManager;
@@ -76,6 +77,9 @@ public class OpenHab2Importer {
       logger.info("Read a total of {} item(s) including groups.", itemList.length);
       update(model, itemList);
 
+      root.treeResolveAll();
+      root.doSafeFullTraversal();
+
       LinkData[] linkList = mapper.readValue(makeURL(linksUrl, hostAndPort), LinkData[].class);
       logger.info("Read a total of {} link(s).", linkList.length);
       update(model, linkList);
@@ -113,13 +117,13 @@ public class OpenHab2Importer {
   private void update(SmartHomeEntityModel model, ChannelTypeData[] channelTypeList) {
     for (ChannelTypeData channelTypeData : channelTypeList) {
       ChannelType channelType = new ChannelType();
+      model.addChannelType(channelType);
       channelType.setID(channelTypeData.UID);
       channelType.setLabel(channelTypeData.label);
       channelType.setDescription(channelTypeData.description);
       maybeSetItemType(channelType, channelTypeData.itemType);
       maybeSetChannelCategory(channelType, channelTypeData.category);
       maybeSetReadOnly(channelType, channelTypeData.stateDescription);
-      model.addChannelType(channelType);
     }
   }
 
@@ -144,17 +148,16 @@ public class OpenHab2Importer {
     if (category == null) {
       return;
     }
-    try {
-      DefaultChannelCategoryValue dccv = DefaultChannelCategoryValue.valueOf(category);
-      channelType.setChannelCategory(new DefaultChannelCategory(dccv));
-    } catch (IllegalArgumentException e) {
+    JavaUtils.ifPresentOrElse(channelType.getRoot().getSmartHomeEntityModel().resolveDefaultChannelCategory(category),
+        dcc -> channelType.setChannelCategory(new ReferringChannelCategory(dcc)),
+        () -> {
           // channel category was not found
           // store in unresolved and only warn once about it
           if (nonDefaultChannelCategories.add(category)) {
             logger.warn("Could not find ChannelCategory for '{}'", category);
           }
           channelType.setChannelCategory(new SimpleChannelCategory(category));
-    }
+        });
   }
 
   private void maybeSetReadOnly(ChannelType channelType, StateDescriptionData stateDescription) {
@@ -177,6 +180,8 @@ public class OpenHab2Importer {
         channel.setID(channelData.uid);
         ifPresent(model.resolveChannelType(channelData.channelTypeUID),
             "channelType", channelData, channel::setType);
+        model.addChannel(channel);
+        // now set relation
         thing.addChannel(channel);
       }
     }
@@ -243,10 +248,12 @@ public class OpenHab2Importer {
         }
         item.enableSendState();
         if (itemData.metadata != null) {
+          MetaData metaData = new MetaData();
+          item.setMetaData(metaData);
           for (Map.Entry<String, MetaDataData> entry : itemData.metadata.entrySet()) {
             logger.debug("Add metadata for namespace {}", entry.getKey());
             for (Map.Entry<String, String> metaDataEntry : entry.getValue().config.entrySet()) {
-              item.addMetaData(new ItemMetaData(metaDataEntry.getKey(), metaDataEntry.getValue()));
+              metaData.add(metaDataEntry.getKey(), metaDataEntry.getValue());
             }
           }
         }
@@ -278,7 +285,7 @@ public class OpenHab2Importer {
       }
     }
     if (!itemsWithoutGroup.isEmpty()) {
-      ParserUtils.createUnknownGroup(model, itemsWithoutGroup);
+      ParserUtils.addToUnknownGroup(model, itemsWithoutGroup);
     }
   }
 

eraser-base/src/main/java/de/tudresden/inf/st/eraser/parser/EraserParserHelper.java

@@ -14,7 +14,8 @@ import java.util.function.BiConsumer;
  *
  * @author rschoene - Initial contribution
  */
-public class EraserParserHelper {
+@Deprecated
+class EraserParserHelper {
   private Logger logger = LogManager.getLogger(EraserParserHelper.class);
 
   private Map<String, ThingType> thingTypeMap = new HashMap<>();
@@ -89,7 +90,7 @@ public class EraserParserHelper {
     } else {
       resolve(itemMap, missingItemForDesignator, Designator::setItem);
     }
-    missingTopicMap.forEach((topic, parts) -> ParserUtils.createMqttTopic(topic, parts, this.root));
+//    missingTopicMap.forEach((item, s) -> item.setMqttTopic(s));
     this.root.getMqttRoot().ensureCorrectPrefixes();
 
     resolveList(channelMap, missingChannelListMap, Thing::addChannel);
@@ -101,7 +102,7 @@ public class EraserParserHelper {
 
 
     createUnknownGroupIfNecessary();
-    createChannelCategories();
+//    createChannelCategories();
     createItemCategories();
 
     if (checkUnusedElements) {
@@ -139,16 +140,10 @@ public class EraserParserHelper {
           sortedDanglingItems.add(item);
         }
       }
-      ParserUtils.createUnknownGroup(this.root.getSmartHomeEntityModel(), sortedDanglingItems);
+      ParserUtils.addToUnknownGroup(this.root.getSmartHomeEntityModel(), sortedDanglingItems);
     }
   }
 
-  private void createChannelCategories() {
-    channelCategoryMap.values().stream().sorted(Comparator.comparing(this::ident)).forEach(
-        cc -> root.getSmartHomeEntityModel().addChannelCategory(cc));
-    channelCategoryMap.clear();
-  }
-
   private void createItemCategories() {
     Map<String, ItemCategory> newCategories = new HashMap<>();
     missingItemCategoryMap.forEach((item, category) ->
@@ -248,21 +243,6 @@ public class EraserParserHelper {
     return ct;
   }
 
-  public ChannelType setChannelCategory(ChannelType ct, String name) {
-    ChannelCategory result = channelCategoryMap.get(name);
-    if (result == null) {
-      try {
-        DefaultChannelCategoryValue dccv = DefaultChannelCategoryValue.valueOf(name);
-        result = new DefaultChannelCategory(dccv);
-      } catch (IllegalArgumentException e) {
-        result = new SimpleChannelCategory(name);
-      }
-      channelCategoryMap.put(name, result);
-    }
-    ct.setChannelCategory(result);
-    return ct;
-  }
-
   public Channel setChannelType(Channel c, String channelTypeName) {
     missingChannelTypeMap.put(c, channelTypeName);
     return c;
@@ -299,17 +279,10 @@ public class EraserParserHelper {
     return item;
   }
 
-  public Item setMetaData(Item item, StringKeyMap metaData) {
-    for (AbstractMap.SimpleEntry<String, String> entry : metaData) {
-      item.addMetaData(new ItemMetaData(entry.getKey(), entry.getValue()));
-    }
-    return item;
-  }
-
   public Item retype(Item itemWithCorrectType, Item prototype) {
     itemWithCorrectType.setID(prototype.getID());
     itemWithCorrectType.setLabel(prototype.getLabel());
-    itemWithCorrectType.setMetaDataList(prototype.getMetaDataList());
+    itemWithCorrectType.setMetaData(prototype.getMetaData());
     itemWithCorrectType.setFrequencySetting(prototype.getFrequencySetting());
     if (!(itemWithCorrectType instanceof ActivityItem)) {
       String state = prototype.getStateAsString();

eraser-base/src/main/java/de/tudresden/inf/st/eraser/util/ParserUtils.java

@@ -8,7 +8,6 @@ import com.fasterxml.jackson.databind.SerializationFeature;
 import de.tudresden.inf.st.eraser.jastadd.model.*;
 import de.tudresden.inf.st.eraser.jastadd.parser.EraserParser;
 import de.tudresden.inf.st.eraser.jastadd.scanner.EraserScanner;
-import de.tudresden.inf.st.eraser.parser.EraserParserHelper;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -26,7 +25,6 @@ import java.util.Objects;
  */
 public class ParserUtils {
 
-  public static final String UNKNOWN_GROUP_NAME = "Unknown";
   private static boolean verboseLoading = false;
   private static final Logger logger = LogManager.getLogger(ParserUtils.class);
   private static final ObjectMapper OBJECT_MAPPER_INSTANCE = new ObjectMapper()
@@ -145,8 +143,7 @@ public class ParserUtils {
 
     EraserScanner scanner = new EraserScanner(reader);
     EraserParser parser = new EraserParser();
-    Root result = (Root) parser.parse(scanner);
-    parser.resolveReferences();
+    Root result = parser.parseRoot(scanner);
     reader.close();
     return result;
   }
@@ -172,31 +169,14 @@ public class ParserUtils {
   }
 
   /**
-   * Create well-known group call "Unknown" and add all dangling items to it.
+   * Add all dangling items to unknown group.
    * @param model         The model to operate on
    * @param danglingItems A list of items to add to the new group
    */
-  public static void createUnknownGroup(SmartHomeEntityModel model, Collection<Item> danglingItems) {
-    Group unknownGroup = new Group();
-    unknownGroup.setID(UNKNOWN_GROUP_NAME);
-    model.addGroup(unknownGroup);
+  public static void addToUnknownGroup(SmartHomeEntityModel model, Collection<Item> danglingItems) {
+    Group unknownGroup = model.unknownGroup();
     danglingItems.forEach(unknownGroup::addItem);
-    logger.info("Created new {}", unknownGroup.prettyPrint().trim());
-  }
-
-  /**
-   * Create a topic for the given topic name and assign it to the given item.
-   * @param item        The item to which the topic will be assigned to
-   * @param topicSuffix The full topic name
-   * @param root        The model to operate on
-   */
-  public static void createMqttTopic(Item item, String topicSuffix, Root root) {
-    item.setTopic(root.getMqttRoot().resolveTopicSuffix(topicSuffix).orElseGet(() -> {
-      MqttTopic result = new MqttTopic();
-      result.setTopicString(topicSuffix);
-      root.getMqttRoot().addTopic(result);
-      return result;
-    }));
+    logger.info("Updated unknown group {}", unknownGroup.prettyPrint().trim());
   }
 
   public static NumberExpression parseNumberExpression(String expression_string) throws IOException, Parser.Exception {
@@ -216,7 +196,6 @@ public class ParserUtils {
   }
 
   private static Expression parseExpression(String expression_string, short alt_goal, Root root) throws IOException, Parser.Exception {
-    EraserParserHelper.setInitialRoot(root);
     StringReader reader = new StringReader(expression_string);
     if (verboseLoading) {
       EraserScanner scanner = new EraserScanner(reader);
@@ -230,13 +209,12 @@ public class ParserUtils {
         e.printStackTrace();
       }
     }
+    EraserParser.setNextInitialRoot(root);
     reader = new StringReader(expression_string);
     EraserScanner scanner = new EraserScanner(reader);
     EraserParser parser = new EraserParser();
-    Expression result = (Expression) parser.parse(scanner, alt_goal);
-    parser.resolveReferences();
+    Expression result = parser.parseExpression(scanner, alt_goal);
     reader.close();
-    EraserParserHelper.setInitialRoot(null);
     return result;
   }
 
@@ -245,8 +223,7 @@ public class ParserUtils {
     StringReader reader = new StringReader(definition);
     EraserScanner scanner = new EraserScanner(reader);
     EraserParser parser = new EraserParser();
-    Root root = (Root) parser.parse(scanner);
-    parser.resolveReferences();
+    Root root = parser.parseRoot(scanner);
     reader.close();
     int size = root.getSmartHomeEntityModel().items().size();
     if (size == 0) {

eraser-base/src/main/java/de/tudresden/inf/st/eraser/util/TestUtils.java

@@ -39,7 +39,9 @@ public class TestUtils {
 
   public static SmartHomeEntityModel createModelWithGroup() {
     Root root = Root.createEmptyRoot();
-    ParserUtils.createUnknownGroup(root.getSmartHomeEntityModel(),new ArrayList<>());
+    Group group0 = new Group();
+    group0.setID("Group0");
+    root.getSmartHomeEntityModel().addGroup(group0);
 
     return root.getSmartHomeEntityModel();
   }

eraser-base/src/test/java/de/tudresden/inf/st/eraser/MarshallingTests.java

 package de.tudresden.inf.st.eraser;
 
+import de.tudresden.inf.st.eraser.jastadd.parser.EraserParser;
 import de.tudresden.inf.st.eraser.jastadd_test.core.TestConfiguration;
 import de.tudresden.inf.st.eraser.jastadd_test.core.TestProperties;
 import de.tudresden.inf.st.eraser.jastadd_test.core.TestRunner;
 import de.tudresden.inf.st.eraser.jastadd_test.core.Util;
-import de.tudresden.inf.st.eraser.parser.EraserParserHelper;
 import de.tudresden.inf.st.eraser.util.ParserUtils;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -25,7 +25,7 @@ public class MarshallingTests {
   @ParameterizedTest
   @MethodSource("getTests")
   public void runTest(TestConfiguration unitTest) throws Exception {
-    EraserParserHelper.setCheckUnusedElements(false);
+    EraserParser.setCheckUnusedElements(false);
     ParserUtils.setVerboseLoading(false);
     TestRunner.runTest(unitTest);
   }