200 lines
6.5 KiB
Python
200 lines
6.5 KiB
Python
from state.devstate import DevState
|
|
from bootstrap.scd import bootstrap_scd
|
|
from framework.conformance import Conformance, render_conformance_check_result
|
|
from concrete_syntax.textual_od import parser, renderer
|
|
from concrete_syntax.common import indent
|
|
from concrete_syntax.plantuml import renderer as plantuml
|
|
from concrete_syntax.plantuml.make_url import make_url
|
|
from util.prompt import yes_no, pause
|
|
|
|
state = DevState()
|
|
|
|
print("Loading meta-meta-model...")
|
|
scd_mmm = bootstrap_scd(state)
|
|
print("OK")
|
|
|
|
print("Is our meta-meta-model a valid class diagram?")
|
|
conf = Conformance(state, scd_mmm, scd_mmm)
|
|
print(render_conformance_check_result(conf.check_nominal()))
|
|
|
|
# If you are curious, you can serialize the meta-meta-model:
|
|
# print("--------------")
|
|
# print(indent(
|
|
# renderer.render_od(state,
|
|
# m_id=scd_mmm,
|
|
# mm_id=scd_mmm),
|
|
# 4))
|
|
# print("--------------")
|
|
|
|
|
|
# Change this:
|
|
woods_mm_cs = """
|
|
Animal:Class {
|
|
# The class Animal is an abstract class:
|
|
abstract = True;
|
|
}
|
|
|
|
# A class without attributes
|
|
# The `abstract` attribute shown above is optional (default: False)
|
|
Bear:Class
|
|
|
|
# Inheritance between two Classes is expressed as follows:
|
|
:Inheritance (Bear -> Animal) # meaning: Bear is an Animal
|
|
|
|
Man:Class {
|
|
# We can define lower and upper cardinalities on Classes
|
|
# (if unspecified, the lower-card is 0, and upper-card is infinity)
|
|
|
|
lower_cardinality = 1; # there must be at least one Man in every model
|
|
upper_cardinality = 2; # there must be at most two Men in every model
|
|
|
|
constraint = ```
|
|
# Python code
|
|
# the last statement must be a boolean expression
|
|
|
|
# When conformance checking, this code will be run for every Man-object.
|
|
# The variable 'this' refers to the current Man-object.
|
|
|
|
# Every man weighs at least '20'
|
|
# (the attribute 'weight' is added further down)
|
|
get_value(get_slot(this, "weight")) > 20
|
|
```;
|
|
}
|
|
# Note that we can only declare the inheritance link after having declared both Man and Animal: We can only refer to earlier objects
|
|
:Inheritance (Man -> Animal) # Man is also an Animal
|
|
|
|
|
|
# BTW, we could also give the Inheritance-link a name, for instance:
|
|
# man_is_animal:Inheritance (Man -> Animal)
|
|
#
|
|
# Likewise, Classes, Associations, ... can also be nameless, for instance:
|
|
# :Class { ... }
|
|
# :Association (Man -> Man) { ... }
|
|
# However, we typically want to give names to classes and associations, because we want to refer to them later.
|
|
|
|
|
|
# We now add an attribute to 'Man'
|
|
# Attributes are not that different from Associations: both are represented by links
|
|
Man_weight:AttributeLink (Man -> Integer) {
|
|
name = "weight"; # mandatory!
|
|
optional = False; # <- meaning: every Man *must* have a weight
|
|
|
|
# We can also define constraints on attributes
|
|
constraint = ```
|
|
# Python code
|
|
# Here, 'this' refers to the LINK that connects a Man-object to an Integer
|
|
tgt = get_target(this) # <- we get the target of the LINK (an Integer-object)
|
|
weight = get_value(tgt) # <- get the Integer-value (e.g., 80)
|
|
weight > 20
|
|
```;
|
|
}
|
|
|
|
# Create an Association from Man to Animal
|
|
afraidOf:Association (Man -> Animal) {
|
|
# An association has the following (optional) attributes:
|
|
# - source_lower_cardinality (default: 0)
|
|
# - source_upper_cardinality (default: infinity)
|
|
# - target_lower_cardinality (default: 0)
|
|
# - target_upper_cardinality (default: infinity)
|
|
|
|
# Every Man is afraid of at least one Animal:
|
|
target_lower_cardinality = 1;
|
|
|
|
# No more than 6 Men are afraid of the same Animal:
|
|
source_upper_cardinality = 6;
|
|
}
|
|
|
|
# Create a GlobalConstraint
|
|
total_weight_small_enough:GlobalConstraint {
|
|
# Note: for GlobalConstraints, there is no 'this'-variable
|
|
constraint = ```
|
|
# Python code
|
|
# compute sum of all weights
|
|
total_weight = 0
|
|
for man_name, man_id in get_all_instances("Man"):
|
|
total_weight += get_value(get_slot(man_id, "weight"))
|
|
|
|
# as usual, the last statement is a boolean expression that we think should be satisfied
|
|
total_weight < 85
|
|
```;
|
|
}
|
|
"""
|
|
|
|
print()
|
|
print("Parsing 'woods' meta-model...")
|
|
woods_mm = parser.parse_od(
|
|
state,
|
|
m_text=woods_mm_cs, # the string of text to parse
|
|
mm=scd_mmm, # the meta-model of class diagrams (= our meta-meta-model)
|
|
)
|
|
print("OK")
|
|
|
|
# As a double-check, you can serialize the parsed model:
|
|
# print("--------------")
|
|
# print(indent(
|
|
# renderer.render_od(state,
|
|
# m_id=woods_mm,
|
|
# mm_id=scd_mmm),
|
|
# 4))
|
|
# print("--------------")
|
|
|
|
print("Is our 'woods' meta-model a valid class diagram?")
|
|
conf = Conformance(state, woods_mm, scd_mmm)
|
|
print(render_conformance_check_result(conf.check_nominal()))
|
|
|
|
# Change this:
|
|
woods_m_cs = """
|
|
george:Man {
|
|
weight = 15;
|
|
}
|
|
billy:Man {
|
|
weight = 100;
|
|
}
|
|
bear1:Bear
|
|
bear2:Bear
|
|
:afraidOf (george -> bear1)
|
|
:afraidOf (george -> bear2)
|
|
:afraidOf (billy -> george)
|
|
"""
|
|
|
|
print()
|
|
print("Parsing 'woods' model...")
|
|
woods_m = parser.parse_od(
|
|
state,
|
|
m_text=woods_m_cs,
|
|
mm=woods_mm, # this time, the meta-model is the previous model we parsed
|
|
)
|
|
print("OK")
|
|
|
|
# As a double-check, you can serialize the parsed model:
|
|
# print("--------------")
|
|
# print(indent(
|
|
# renderer.render_od(state,
|
|
# m_id=woods_m,
|
|
# mm_id=woods_mm),
|
|
# 4))
|
|
# print("--------------")
|
|
|
|
print("Is our model a valid woods-diagram?")
|
|
conf = Conformance(state, woods_m, woods_mm)
|
|
print(render_conformance_check_result(conf.check_nominal()))
|
|
|
|
|
|
print()
|
|
print("==================================")
|
|
if yes_no("Print PlantUML?"):
|
|
print_mm = yes_no(" ▸ Print meta-model?")
|
|
print_m = yes_no(" ▸ Print model?")
|
|
print_conf = print_mm and print_m and yes_no(" ▸ Print conformance links?")
|
|
|
|
uml = ""
|
|
if print_mm:
|
|
uml += plantuml.render_package("Meta-model", plantuml.render_class_diagram(state, woods_mm))
|
|
if print_m:
|
|
uml += plantuml.render_package("Model", plantuml.render_object_diagram(state, woods_m, woods_mm))
|
|
if print_conf:
|
|
uml += plantuml.render_trace_conformance(state, woods_m, woods_mm)
|
|
|
|
print("==================================")
|
|
print(make_url(uml))
|
|
print("==================================")
|