Simple prompt implemented

core/context/base.py

@@ -17,6 +17,10 @@ class Context(ABC):
     def __exit__(self):
         pass
 
+    @abstractmethod
+    def exposed_methods(self):
+        pass
+
     @abstractmethod
     def instantiate(self, type_name: String, instance_name: String):
         pass

core/context/generic.py

@@ -5,6 +5,7 @@ from core.context.bottom import BottomContext
 
 
 class GenericContext(Context):
+
     def __init__(self, state: State, model: Element, metamodel: Element):
         super().__init__(state, model, metamodel)
         self.bottom = BottomContext(state, model)
@@ -15,13 +16,24 @@ class GenericContext(Context):
     def __exit__(self):
         pass
 
+    def exposed_methods(self):
+        yield from [
+            self.instantiate,
+            self.instantiate_value,
+            self.instantiate_link,
+            self.retype_element,
+            self.list_elements,
+            self.delete_element,
+            self.verify,
+        ]
+
     def _type_exists(self, type_name: String, instantiate_link: bool) -> bool:
         metamodel_root = self.state.read_dict(self.metamodel.id, "Model")
         type_element = self.state.read_dict(metamodel_root, type_name.value)
         if type_element is None:
             return False
         else:
-            element_is_edge = self.state.read_edge(type_element) is not None
+            element_is_edge = self.state.read_edge(type_element) != (None, None)
             return element_is_edge == instantiate_link
 
     def instantiate(self, type_name: String, name: String):

core/context/simple_class_diagrams.py

@@ -1,4 +1,4 @@
-from core.element import Element
+from core.element import Element, String, Integer, Boolean
 from state.base import State
 from core.context.generic import GenericContext
 
@@ -7,25 +7,26 @@ class SCDContext(GenericContext):
     def __init__(self, state: State, model: Element, metamodel: Element):
         super().__init__(state, model, metamodel)
 
+    def exposed_methods(self):
+        yield from super().exposed_methods()
+        yield from [
+            self.create_class,
+            self.create_class_attribute,
+            self.create_association,
+            self.create_inheritance
+        ]
 
-def main():
-    from state.devstate import DevState
+    def create_class(self, name: String, lower_cardinality: Integer = Element(), upper_cardinality: Integer = Element()):
+        pass
 
-    s = DevState()
-    scd = SCDContext(s, Element(), Element())
-    bootstrap = scd._bootstrap_scd()
-    model = s.read_dict(bootstrap.id, "Model")
-    x = []
-    for e in s.read_outgoing(model):
-        label_node_edge, = s.read_outgoing(e)
-        _, label_node = s.read_edge(label_node_edge)
-        type_node = s.read_dict(label_node, "Type")
-        x.append(f"{s.read_value(label_node)} : {s.read_value(type_node)}")
-    for t in sorted(x):
-        print(t)
+    def create_class_attribute(self, class_name: String, name: String, optional: Boolean = Element(value=False)):
+        pass
 
-    # s.dump("out/scd.dot", "out/scd.png")
+    def create_association(self, source_class_name: String, target_class_name: String, name: String,
+                           source_lower_cardinality: Integer = Element(), target_lower_cardinality: Integer = Element(),
+                           source_upper_cardinality: Integer = Element(), target_upper_cardinality: Integer = Element()
+                           ):
+        pass
 
-
-if __name__ == '__main__':
-    main()
+    def create_inheritance(self, parent_class_name: String, child_class_name: String):
+        pass

core/manager.py

@@ -6,6 +6,16 @@ class Manager:
     def __init__(self, state: State):
         self.state = state
 
+    def exposed_methods(self):
+        yield from [
+            self.new_model,
+            self.get_model,
+            self.rename_model,
+            self.retype_model,
+            self.delete_model,
+            self.list_models,
+        ]
+
     def new_model(self, name: String, type_model_name: String) -> Element:
         root = self.state.read_root()
         mm_bottom = self.state.read_dict(root, type_model_name.value)