Esta documentación está destinada a modeladores que usan los idiomas de OCL de Object. Aquí se encuentra una documentación detallada para los ingenieros de idiomas que usan o extienden el idioma OCL. Recomendamos que los ingenieros de idiomas lean esta documentación antes de leer la documentación detallada.
ocl Bookshop {
context Shop s inv CustomerPaysBeforeNewOrder: // invariant
forall Customer c in s.customers: // quantifiers available
c.allowedToOrder implies !exists Invoice i in s.invoices:
i.buyer == c && i.moneyPayed < i.invoiceAmount ;
// Method specification for selling a book
context Invoice Stock.sellBook(String iban, int discountPercent, Customer c)
let availableBooks = // set comprehension
{ book | Book book in booksInStock, book.iban == iban }
pre: !availableBooks.isEmpty && // precondition
c.allowedToOrder;
post: let discount = (100 - discountPercent)/100; // postcondition, let
b = result.soldBook // result variable
in
!(b isin booksInStock) &&
booksInStock.size@pre == booksInStock.size + 1 && // @pre
result.invoiceAmount == b.price * discount;
}
Otros ejemplos de expresión (incluidas las commonexpresiones de Monticore):
a + 3*4; // number expressions
a >= b; a < 3; a == "myName"; // equalities
b implies (c && a) || d; // boolean expressions
forall a in S: foo(a) > 3; // quantifiers
exists a in S: foo(a) > 3;
a ?== b; c ?<= d // elvis operators (dealing with optionals)
S.first; S.size; S.addAll(T); // 30 operators for Lists
a in S; S.add(a); // + more for Sets
max(S) > 3; // + more for numbers
La representación textual de OCL se basa principalmente en la definición en [Rum16, Rum17]. El OCL se usa para verificar la corrección de otros modelos. Aquí, el Book y los tipos Customer se definen por un diagrama de clase:
classdiagram Bookshop {
class Book {
String name;
String iban;
double cost;
double price;
}
class Shop;
association [1] Shop -> (invoices) Invoice [*];
association [1] Shop -> (customers) Customer [*];
class Stock {
void addBook(Book b);
Invoice sellBook(Book bookToSell, int discountPercent, Customer buyer);
}
association [1] Stock -> (booksInStock) Book [*];
class Customer {
String name;
String phoneNumber;
int customerNumber;
boolean allowedToOrder;
void payInvoice(double moneyWired, Invoice invoice);
}
class Invoice {
int invoiceNumber;
double invoiceAmount;
double moneyPayed;
}
association [1] Invoice <-> (buyer) Customer [1];
association [1] Invoice <-> (soldBook) Book [1];
}
Esta sección describe la herramienta de línea de comandos del idioma OCL. La herramienta proporciona una funcionalidad típica utilizada al procesar modelos. A este sentido, proporciona funciones para
Los requisitos para construir y usar la herramienta OCL son que (al menos) JDK 8 (JDK 11 y JDK 14 también son oficialmente compatibles con nosotros), GIT y Gradle están instalados y disponibles para su uso en Bash. Si está utilizando Docker, también puede usar el contenedor Docker sin instalar Java, Git o Gradle.
La siguiente subsección describe cómo descargar la herramienta. Luego, este documento describe cómo construir la herramienta a partir de los archivos de origen. Posteriormente, este documento contiene un tutorial para usar la herramienta.
Se puede descargar una versión lista para usar de la herramienta en forma de un archivo JAR ejecutable. Puede usar este enlace de descarga para descargar la herramienta.
Alternativamente, puede descargar la herramienta con wget . El siguiente comando descarga la última versión de la herramienta y la guarda bajo el nombre MCOCL.jar en su directorio de trabajo:
wget "monticore.de/download/MCOCL.jar" -O MCOCL.jar
La última versión de la imagen Docker de las herramientas se puede obtener utilizando
docker pull monticore/ocl
En caso de que esté utilizando Docker, reemplace java -jar MCOCL.jar en lo siguiente por (para Windows PowerShell, Mac Terminal o Linux Bash)
docker run --rm -v ${PWD}:/input -w /input monticore/ocl
o (para la línea de comando de Windows)
docker run --rm -v %CD%:/input -w /input monticore/ocl
Por ejemplo, este comando del paso 2 de este tutorial
java -jar MCOCL.jar -i Example.ocl -pp
se convierte en
docker run --rm -v ${PWD}:/input -w /input monticore/ocl -i Example.ocl -pp
Al usar Docker.
Es posible crear un jar ejecutable de la herramienta a partir de los archivos de origen ubicados en GitHub. A continuación se describe el proceso para construir la herramienta a partir de los archivos de origen utilizando BASH. Para construir un frasco ejecutable con BASH en los archivos de origen disponibles en GitHub, ejecute los siguientes comandos.
Primero, clona el repositorio:
git clone https://github.com/MontiCore/ocl.git
Cambie el directorio al directorio raíz de las fuentes clonadas:
cd OCL
Luego cree el proyecto ejecutando (Información: debe tener instalado Gradle para esto):
gradle build
¡Felicidades! Ahora puede encontrar el archivo jar ejecutable MCOCL.jar en el directorio target/libs (accesible a través de cd target/libs ).
Las secciones anteriores describen cómo obtener un archivo JAR ejecutable (herramienta de línea de comandos OCL). Esta sección proporciona un tutorial para usar la herramienta OCL. Los siguientes ejemplos suponen que nombró localmente la herramienta MCOCL . Si crea la herramienta de las fuentes o usa el comando wget anterior, entonces está bien. Si descargó manualmente la herramienta, entonces debe considerar cambiar el nombre del jar descargado.
Ejecutar el archivo jar sin ninguna opción imprime información de uso del
herramienta a la consola:
$ java -jar MCOCL.jar
usage: OCLTool
-c,--coco <arg> Checks the CoCos for the input. Optional
arguments are:
-c intra to check only the intra-model CoCos,
-c inter checks also inter-model CoCos,
-c type (default) checks all CoCos.
-cd4c,--cd4code Load symbol kinds from CD4C. Shortcut for loading
CDTypeSymbol as TypeSymbol,
CDMethodSignatureSymbol as FunctionSymbol, and
FieldSymbol as VariableSymbol. Furthermore,
warnings about not deserializing
CDAssociationSymbol and CDRoleSymbol will be
ignored.
-d,--dev Specifies whether developer level logging should
be used (default is false)
-fs,--functionSymbol <fqns> Takes the fully qualified name of one or more
symbol kind(s) that should be treated as
FunctionSymbol when deserializing symbol files.
Multiple symbol kinds should be separated by
spaces.
-h,--help Prints this help dialog
-i,--input <files> Processes the list of OCL input artifacts.
Argument list is space separated. CoCos are not
checked automatically (see -c).
-is,--ignoreSymKind <fqns> Takes the fully qualified name of one or more
symbol kind(s) for which no warnings about not
being able to deserialize them shall be printed.
Allows cleaner outputs. Multiple symbol kinds
should be separated by spaces.
-p,--path <directory> Sets the artifact path for imported symbols.
Directory will be searched recursively for files
with the ending ".*sym" (for example ".cdsym" or
".sym"). Defaults to the current folder.
-pp,--prettyprint <files> Prints the OCL model to stdout or the specified
file(s) (optional). Multiple files should be
separated by spaces and will be used in the same
order in which the input files (-i option) are
provided.
-s,--symboltable <files> Stores the symbol tables of the input OCL
artifacts in the specified files. For each input
OCL artifact (-i option) please provide one
output symbol file (using same order in which the
input artifacts are provided) to store its
symbols in. For example, -i x.ocl y.ocl -s
a.oclsym b.oclsym will store the symbols of x.ocl
to a.oclsym and the symbols of y.ocl to b.oclsym.
Arguments are separated by spaces. If no
arguments are given, output is stored to
'target/symbols/{packageName}/{artifactName}.ocls
ym'.
-ts,--typeSymbol <fqns> Takes the fully qualified name of one or more
symbol kind(s) that should be treated as
TypeSymbol when deserializing symbol files.
Multiple symbol kinds should be separated by
spaces.
-vs,--variableSymbol <fqns> Takes the fully qualified name of one or more
symbol kind(s) that should be treated as
VariableSymbol when deserializing symbol files.
Multiple symbol kinds should be separated by
spaces.
Para funcionar correctamente, la herramienta necesita el argumento obligatorio -i,--input <file> , que toma las rutas de archivo de al menos un archivo de entrada que contiene modelos SD. Si no se especifican otros argumentos, la herramienta solo analiza el modelo (s).
Para probar esto, copie el MCOCL.jar en un directorio de su elección. Posteriormente, cree que contenga el siguiente OCL simple:
ocl Example {
}
Guarde el archivo de texto como Example.ocl en el directorio donde se encuentra MCOCL.jar .
Ahora ejecute el siguiente comando:
java -jar MCOCL.jar -i Example.ocl
Puede notar que la herramienta no imprime salida a la consola. Esto significa que la herramienta ha analizado el archivo Example.ocl con éxito.
La herramienta proporciona una impresora bonita para el lenguaje OCL. Se puede usar una impresora bonita, por ejemplo, para corregir el formato de archivos que contienen OCL. Para ejecutar la impresora Pretty, la opción -pp,--prettyprint se puede usar. Usando la opción sin ningún argumento bastante impresas, los modelos contenidos en los archivos de entrada a la consola.
Ejecute el siguiente comando para probar esto:
java -jar MCOCL.jar -i Example.ocl -pp
El comando imprime el modelo bastante impreso contenido en el archivo de entrada a la consola:
ocl Example {
}
Es posible imprimir bastante los modelos contenidos en los archivos de entrada a los archivos de salida. Para esta tarea, es posible proporcionar los nombres de los archivos de salida como argumentos a la opción -pp,--prettyprint . Si se proporcionan argumentos para los archivos de salida, entonces el número de archivos de salida debe ser igual al número de archivos de entrada. El archivo de entrada I-Th está bastante impreso en el archivo de salida I-Th.
Ejecute el siguiente comando para probar esto:
java -jar MCOCL.jar -i Example.ocl -pp Output.ocl
El comando imprime el modelo bastante impreso contenido en el archivo de entrada en el archivo Output.ocl .
Para verificar las condiciones de contexto, se puede usar la opción -c,--coco <arg> . El uso de esta opción sin ningún argumento verifica si el modelo satisface todas las condiciones de contexto.
Si solo está interesado en verificar si un modelo solo satisface un subconjunto de las condiciones de contexto o desea explicar que todas las condiciones de contexto deben verificarse, puede hacerlo también proporcionando uno de los tres argumentos intra , inter y type .
intra ejecuta las condiciones de contexto con respecto a las violaciones de las condiciones de contexto intra-modelo. Estas condiciones de contexto, por ejemplo, verifican las convenciones de nombres.inter ejecuta todas las condiciones de contexto intra-modelo y además verifica si se definen los nombres de tipo en las firmas de constructor.type de argumento ejecuta todas las conidiciones de contexto. Estas condiciones de contexto incluyen verificar si existen tipos y métodos utilizados. El comportamiento al usar el type de argumento es igual al comportamiento predeterminado cuando no se usa argumentos.Ejecute el siguiente comando para probar un ejemplo simple:
java -jar MCOCL.jar -i Example.ocl -c -cd4c
Puede notar que la herramienta no imprime nada en la consola al ejecutar este comando. Esto significa que el modelo satisface todas las condiciones de contexto.
Consideremos ahora un ejemplo más complejo. Recuerde la Bookshop de OCL de la sección An Example Model anterior. Para continuar, copie la representación textual de la Bookshop OCL y guárdela en un archivo Bookshop.ocl en el directorio donde se encuentra el archivo MCOCL.jar . Para esto, necesitará un archivo de símbolos que contenga los símbolos de un diagrama de clase correspondiente a la Bookshop.ocl . Esto se explicará con más detalle en la siguiente sección. Por ahora, simplemente agregue -p src/test/resources/docs/Bookshop/ -cd4c al comando para usar la herramienta Dine la herramienta dónde encontrar el archivo de símbolos preparado para este ejemplo y cómo procesarlo.
Puede verificar los diferentes tipos de condiciones de contexto, utilizando la opción -c,--coco <arg> :
java -jar MCOCL.jar -i Bookshop.ocl -p src/test/resources/docs/Bookshop/ -cd4c -c intra
java -jar MCOCL.jar -i Bookshop.ocl -p src/test/resources/docs/Bookshop/ -cd4c -c inter
java -jar MCOCL.jar -i Bookshop.ocl -p src/test/resources/docs/Bookshop/ -cd4c -c type
Ninguno de estos comandos debe producir salida.
Para ver un error, agregue un error al modelo. Reemplace esta línea en Bookshop.ocl
{ book | Book book in booksInStock, book.iban == iban }
por
{ book2 | Book book in booksInStock, book.iban == iban }
Como book2 no está definido, la herramienta ahora debe imprimir un mensaje de error al verificar los cocos:
$ java -jar MCOCL.jar -i Bookshop.ocl -p src/test/resources/docs/Bookshop/ -cd4c -c
[INFO] DeriveSymTypeOfExpression package suspected
[ERROR] 0xA0309 Bookshop.ocl:<13,12> Could not calculate type of expression "book2" on the left side of SetComprehension
Recuerde deshacer el "error".
En esta sección utilizamos la ruta del símbolo y proporcionamos a la herramienta un archivo de símbolos (tabla de símbolos almacenados) de otro modelo, que contiene la información de tipo necesaria.
Cree un nuevo directorio mytypes en el directorio donde se encuentra la herramienta MCOCL.jar . Por ejemplo, el ejemplo Bookshop.ocl de la primera sección requirió un diagrama de clase que especificó sus tipos de datos. Puede encontrar este archivo de diagrama de clase en src/test/recursos/docs/bookshop/bookshop.cd.
Para usarlo en OCL, primero debe convertirlo en información un archivo de símbolos. El archivo de símbolos Bookshop.sym del diagrama de clases proporciona toda la información de tipo necesaria para usar sus tipos en OCL. Si no desea involucrarse con la herramienta CD en este momento, también puede encontrar el archivo listo para usar en SRC/Test/Resources/Docs/Bookshop/Bookshop.sym. Simplemente cópielo en su carpeta mytypes . De lo contrario, para convertir el diagrama de clase en un archivo de símbolos, debe usar el MCCD.jar del proyecto CD4Analysis y convertir el archivo del diagrama de clases utilizando el siguiente comando:
java -jar MCCD.jar -d false --fieldfromrole navigable -i src/test/resources/docs/Bookshop/Bookshop.cd -s mytypes/Bookshop.sym
El contenido del archivo de símbolos es de menor importancia para usted como usuario del idioma. En caso de que tenga curiosidad y tenga un vistazo al archivo de símbolos: el archivo de símbolos contiene una representación JSON de los símbolos definidos en un modelo. En este caso, el archivo de símbolos contiene información sobre tipos definidos. Por lo general, las herramientas de los idiomas de Monticore generan automáticamente el contenido de estos archivos y usted, como usuario del idioma, no debe preocuparse por sus contenidos.
La ruta que contiene la estructura del directorio que contiene el archivo de símbolos se llama "ruta del símbolo". Si proporcionamos la ruta del símbolo a la herramienta, buscará símbolos en archivos de símbolos, que se almacenan en directorios contenidos en la ruta del símbolo. Entonces, si queremos que la herramienta encuentre nuestro archivo de símbolos, debemos proporcionar la ruta del modelo a la herramienta a través de la opción --path <directory> . Puedes probarlo usando la carpeta mytypes que acabas de crear:
java -jar MCOCL.jar -i Bookshop.ocl --path <SYMBOLPATH> -c type -cd4c
Donde <SYMBOLPATH> es la ruta donde almacenó el archivo de símbolos descargado. En nuestro ejemplo, en caso de que almacene el modelo en el directorio mytypes , ejecute el siguiente comando:
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type -cd4c
Observe que este comando también usa el indicador -cd4c . Para interpretar los Symbolfiles proporcionados a la herramienta OCL, necesita comprender cómo interpretar los símbolos almacenados por la herramienta CD. El indicador -cd4c es una taquigrafía para hacerlo para CD4Code. También puede hacerlo manualmente utilizando las banderas --typeSymbol , --functionSymbol y --variableSymbol seguidos de los tipos de símbolos que deben interpretarse como TypeSymbol , FunctionSymbol y VariableSymbol :
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type --typeSymbol <TYPE_SYMBOL_KINDS> --variableSymbol <VAR_SYMBOL_KINDS> --functionSymbol <FUNC_SYMBOL_KINDS>
donde <TYPE_SYMBOL_KINDS> , <VAR_SYMBOL_KINDS> y <FUNC_SYMBOL_KINDS> son los nombres completamente calificados de los símbolos. En caso de que desee proporcionar múltiples tipos de símbolos, simplemente agréguelos separados por un espacio. En nuestro ejemplo, declarar los símbolos de CD4análisis se vería así:
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type --typeSymbol de.monticore.cdbasis._symboltable.CDTypeSymbol --variableSymbol de.monticore.symbols.oosymbols._symboltable.FieldSymbol --functionSymbol de.monticore.cd4codebasis._symboltable.CDMethodSignatureSymbol
Observe que la herramienta ahora produce muchas advertencias sobre símbolos que no se pueden interpretar. No todos los símbolos de un lenguaje diferente podrían ser interesantes en OCL. Para suprimir estas advertencias involuntarias, puede decir la herramienta OCL para qué tipos de símbolos no desea recibirlas usando la opción --ignoreSymKind <SYM_KINDS_TO_IGNORE> . En nuestro ejemplo, esto se vería así:
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type --typeSymbol de.monticore.cdbasis._symboltable.CDTypeSymbol --variableSymbol de.monticore.symbols.oosymbols._symboltable.FieldSymbol --functionSymbol de.monticore.cd4codebasis._symboltable.CDMethodSignatureSymbol --ignoreSymKind de.monticore.cdassociation._symboltable.CDAssociationSymbol de.monticore.cdassociation._symboltable.CDRoleSymbol
Para el uso diario, esto es un poco complicado. Así que recuerde que la bandera -cd4c puede reducir esto a solo
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type -cd4c
La sección anterior describe cómo cargar símbolos desde un archivo de símbolos existente. Ahora, utilizaremos la herramienta para almacenar un archivo de símbolos para nuestro modelo Bookshop.ocl . El archivo de símbolos almacenado contendrá información sobre los objetos definidos en el archivo OCL. Puede ser importado por otros modelos para usar los símbolos introducidos por estas definiciones de objetos, similar a la forma en que cambiamos el archivo Bookshop.ocl para importar los símbolos contenidos en el símbolo File Bookshop.sym .
El uso de la opción -s,-symboltable <file> construye las tablas de símbolos de los modelos de entrada y las almacena en las rutas de archivo dadas como argumentos. O no se deben proporcionar rutas de archivo o se debe proporcionar exactamente una ruta de archivo para cada modelo de entrada. El archivo de símbolos para el modelo de entrada i-th se almacena en el archivo definido por la ruta del archivo I-th. Si no proporciona ninguna ruta de archivo, la herramienta almacena la tabla de símbolos de cada modelo de entrada en el archivo de símbolos target/symbols/{packageName}/{fileName}.oclsym donde packageName es el nombre del paquete como se especifica en el archivo que contiene El modelo y fileName es el nombre del archivo que contiene el modelo. El archivo se almacena en relación con el directorio de trabajo, es decir, el directorio en el que ejecuta el comando para almacenar los archivos de símbolos. Además, tenga en cuenta que para almacenar los símbolos correctamente, el modelo debe estar bien formado con todos los aspectos y, por lo tanto, todas las condiciones de contexto se verifican de antemano.
Para almacenar el archivo de símbolos de Bookshop.ocl , ejecute el siguiente comando (las verificaciones de condición de contexto implícitas requieren utilizando la opción de ruta del símbolo):
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -cd4c -s
La herramienta produce el target/symbols/docs/Bookshop.oclsym , que ahora puede ser importado por otros modelos, por ejemplo, por modelos que necesitan usar algunos de los objetos definidos en la Bookshop de archivos OCL.
Para almacenar el archivo de símbolos de Bookshop.ocl en el archivo syms/Bookshop.oclsym , por ejemplo, ejecute el siguiente comando (nuevamente, las verificaciones de condición de contexto implícitas requieren utilizando la opción de ruta del símbolo)::
java -jar MCOCL.jar -i Bookshop.ocl -path mytypes -cd4c -s syms/Bookshop.oclsym
¡Felicitaciones, acaba de terminar el tutorial sobre cómo guardar archivos de símbolos SD!
