From 4b0e5a121be4e834e98dd597be290126d67674a3 Mon Sep 17 00:00:00 2001 From: Shachar Snapiri Date: Sun, 26 Nov 2017 12:22:16 +0200 Subject: [PATCH] Add indexes and events to dragonflow model printer Add the ability to print the events and the indexes of a model in addition to the (already existing) fields. Change-Id: Iffcc7604e0c9426f0b262471b9a9292f7a809ace Partial-Bug: #1734146 --- dragonflow/cli/df_model.py | 147 ++++++++++++++++++++++++++++++------- 1 file changed, 121 insertions(+), 26 deletions(-) diff --git a/dragonflow/cli/df_model.py b/dragonflow/cli/df_model.py index 57af112de..7a1a804db 100644 --- a/dragonflow/cli/df_model.py +++ b/dragonflow/cli/df_model.py @@ -76,6 +76,48 @@ class ModelsPrinter(object): """ pass + def indexes_start(self): + """ + Called once for every model, before all indexes. + Not called if no indexes exist + """ + pass + + def indexes_end(self): + """ + Called once for every model, after all indexes. + Not called if no indexes exist + """ + pass + + @abc.abstractmethod + def handle_index(self, index_name): + """ + Called once for every index in a model. + """ + pass + + def events_start(self): + """ + Called once for every model, before all events. + Not called if no events exist + """ + pass + + def events_end(self): + """ + Called once for every model, after all events. + Not called if no events exist + """ + pass + + @abc.abstractmethod + def handle_event(self, event_name): + """ + Called once for every event in a model. + """ + pass + class PlaintextPrinter(ModelsPrinter): def __init__(self, fh): @@ -101,6 +143,20 @@ class PlaintextPrinter(ModelsPrinter): embedded=', Embedded' if is_embedded else ''), file=self._output) + def indexes_start(self): + print('Indexes', file=self._output) + print('-------', file=self._output) + + def handle_index(self, index_name): + print('{}'.format(index_name), file=self._output) + + def events_start(self): + print('Events', file=self._output) + print('------', file=self._output) + + def handle_event(self, event_name): + print('{}'.format(event_name), file=self._output) + class UMLPrinter(ModelsPrinter): def __init__(self, fh): @@ -111,6 +167,7 @@ class UMLPrinter(ModelsPrinter): def output_start(self): print('@startuml', file=self._output) + print('hide circle', file=self._output) def _output_relations(self): for (dst, src, name, is_single, is_embedded) in self._dependencies: @@ -145,6 +202,18 @@ class UMLPrinter(ModelsPrinter): self._dependencies.add((self._model, type_, name_, is_single, is_embedded)) + def indexes_start(self): + print(' .. Indexes ..', file=self._output) + + def handle_index(self, index_name): + print(' {}'.format(index_name), file=self._output) + + def events_start(self): + print(' == Events ==', file=self._output) + + def handle_event(self, event_name): + print(' {}'.format(event_name), file=self._output) + class DfModelParser(object): def __init__(self, printer): @@ -173,37 +242,63 @@ class DfModelParser(object): else: return field.__name__, None + def _process_field(self, key, field): + if isinstance(field, field_types.ListOfField): + is_single = False + is_embedded = not isinstance(field, + field_types.ReferenceListField) + field_type, restrictions = self._stringify_field_type(field.field) + elif isinstance(field, fields.ListField): + is_single = False + is_embedded = False + field_type, restrictions = self._stringify_field_type( + field.items_types[0]) + if isinstance(field, field_types.EnumListField): + restrictions = list(field._valid_values) + elif isinstance(field, fields.EmbeddedField): + is_single = True + is_embedded = True + field_type, restrictions = self._stringify_field_type( + field.types[0]) + else: + is_single = True + is_embedded = False + field_type, restrictions = self._stringify_field_type(field) + + field_type = re.sub('Field$', '', field_type) + self._printer.handle_field(key, field_type, is_embedded, + is_single, restrictions) + + def _process_fields(self, df_model): + self._printer.fields_start() + for key, field in df_model.iterate_over_fields(): + self._process_field(key, field) + self._printer.fields_end() + + def _process_indexes(self, df_model): + model_indexes = df_model.get_indexes() + if len(model_indexes) > 0: + self._printer.indexes_start() + for key in model_indexes: + self._printer.handle_index(key) + self._printer.indexes_end() + + def _process_events(self, df_model): + model_events = df_model.get_events() + if len(model_events) > 0: + self._printer.events_start() + for event in model_events: + self._printer.handle_event(event) + self._printer.events_end() + def _process_model(self, df_model): model_name = df_model.__name__ self._printer.model_start(model_name) - for key, field in df_model.iterate_over_fields(): - if isinstance(field, field_types.ListOfField): - is_single = False - is_embedded = not isinstance(field, - field_types.ReferenceListField) - field_type, restrictions = self._stringify_field_type( - field.field) - elif isinstance(field, fields.ListField): - is_single = False - is_embedded = False - field_type, restrictions = self._stringify_field_type( - field.items_types[0]) - if isinstance(field, field_types.EnumListField): - restrictions = list(field._valid_values) - elif isinstance(field, fields.EmbeddedField): - is_single = True - is_embedded = True - field_type, restrictions = self._stringify_field_type( - field.types[0]) - else: - is_single = True - is_embedded = False - field_type, restrictions = self._stringify_field_type(field) + self._process_fields(df_model) + self._process_indexes(df_model) + self._process_events(df_model) - field_type = re.sub('Field$', '', field_type) - self._printer.handle_field(key, field_type, is_embedded, - is_single, restrictions) self._printer.model_end(model_name) def parse_models(self):