View source

<multilang>
@en <!--English-->
The WML(Web Mind Language) is based on NLP(Natural Language Processing) concepts, an area of computer science which studies the integration between machine languages and the human(natural) languages.<br>
WML is the first language considered a [[Lignuagem_de_Programação_Discreta|discrete programming language]], and for that reason, it seems very similar to natural languages, such as Portuguese, English, Spanish, etc., by following a few specific rules of syntax.<br>

==Sintax==
On its sintax, the WML uses as default the conceptual model of relations and entities of databases.<br>
This way, coding in WML means being very close to the conceptual analysis of a software project.<br>
Based on ER models, you are provided with a platform that creates entities and relations in the WML syntax.<br>
in your WML, each entity will be a table and every relation will have rules and optimization applied.<br>
The code written in WML is self-explanatory, in other words, the logic and the structure of your system are generated in a "natural" form, as if you were describing your system.<br>
Each command is identified by the use of a period(.) or the charactere ";" in the end.<br>

After abstracting the knowledge of the system through this semi-natural code, Mind's engine will be able to generate:
* Relational Data Base structure
* Object Oriented Structure
* Diagrams and documentation
* HTML forms (views)
* Many other outputs, as you configure plugins and modules<br><br>

Following an example of its basic syntax in english:<br>
 each '''<font style='color:red'>teacher</font>''' '''<font style='color:blue'>has</font>''' 1 <font style='color:gray'>or</font> n '''<font style='color:red'>student</font>'''.
With this code, the Mind's engine will interpret this:<br><br>
<span style='border:dashed 1px;padding:3px'>'''<font style='color:red'>teacher</font>''' and '''<font style='color:red'>student</font>'''</span> as [[#Entidades|Entities]]<br><br>
<span style='border:dashed 1px;padding:3px'>'''<font style='color:blue'>has</font>'''</span> as a verb keyword, a link<br><br>
<span style='border:dashed 1px;padding:3px'>1 <font style='color:gray'>and</font> n</span> as the relation<br><br>

==Entities==
Making an analogy with the traditional software development and WML, entities may be either Tables in a database or a Class, in an OO system.<br>
In the example, we'll have 2 tables in our database: teacher and student.<br>
These tables will have a 1 to many relation (to each teacher, we will have 1 or n student)<br>
TheWebMind will take care of database keys and relations.
The image under this text shows the ER diagram generated by the exemplified code:
<br>
[[File:teacher_student.jpg]]
 The following code was used for this example:
 1. student has many teacher.
 2. and each teacher has one or many student.
 3. we also know that student has a name:char(60, needed).
 4. every teacher has a name:character(60, not null) too.
 5. we might consider: every student has a mother.

WML identifies the entities in the code using the [[Mind-Natural-Entities-1.0|Mind-Natural-Entities 1.0]] algorithm.<br>
Use the character "#" to indicate when an entity must be abstract, as treated by the module. It's enough to define it only once to set it as an abstract entity.

 person is a #human.<br/>human has height:real(5.2).

Human will become an abstract entity.

==Attributes==
TheWebMind can identify attributes by using the [[Mind-Natural-Attributes-1.0|Mind-Natural-Attributes-1.0]] algorithm.
Remember, this identification is based on the selected and loaded configuration file or develop the project into theWebMind. This file might change due to the interaction with different languages or dialects, traditions, etc. These files may be changed by the developer and we're working on "teaching" theWebMind new things as it gets used, then, it will be able to learn and to adapt itself to the developers who use it.

*Types and instructions
There is a sintax to identify attributes in entities. This sintax looks for a verb in your expression, an element followed by ":", and then a valid identifier. After this, there must be a "( )" with an specification about the attribute in between the parentheses.

 E.g.:
 student has name:varchar(60, needed).

Notice that the details about this attribute are separated by commas, one after the other inside the parentheses. There is not an specific order to them.
Name will be an attribute tht the entity student has, this will be not null, of type varchar with the size 60.

*Comments
You can set comments to properties by using double forward slash in the end of the line, like a normal one-line comment:
 student has name:varchar(60, needed) // the name of they student.

"the name of they student" will be the comment. Depending on the module you choose to generate the project, it may be used like aliases or labels to fields. Not only for comments in your database (if your chosen database supports it) or inside theWebMind.

*Masks
You can also specify a mask to each attribute. This parameter must be inside "[ ]". If your mask uses either "[" or "]" These should be escaped with a "\".

 E.g.:
 student has birthday:date(8, [99/99/9999]).

 '''NOTE''': This mask will be shown to you from theWebMind and will be passed to the chosen module, but theWebMind<br>will NOT use it or check it.
 To know how the chosen module works with masks and what patterns it expects you to use, check its documentation.
 The modules can use this mask either to validate on the server-side before saving any data into your database, or even to validade fields
 on the client-site before submiting forms, using JavaScrit, for example. It depends on the way the module uses this mask.

*Attribute options

We can specify different options to an attribute. The module can generate codes to verify them before saving or show only the valid options on the client-side.
The sintax:
 {optionValue=Label of this optione|secondOptionValue=Label of this other option}

We use "|" to separate each option, while the "=" character tells what the option value is and what is the text to be shown.

 E.g.:
 student has sex:char(1, {F=Female|M=Male}).

Here, the values "F" and "M" will be sent to database, while Female and Male will be the options your client will see. Thus, the module can implement a validation to accept ONLY these two options before saving it into the database.

*Default values

TheWebMind identifies default values simply by the use of ". It also can be escaped with "\" if necessary.
 E.g.:
 subscriber has name:text(-1, "anonymous").

Here, anonymous will be saved everytime the field is null.
 Tip: we can use a number less than 0 to indicate infinite fields, if the chosen database accepts it, like the fieldtype text.

If you want to use a method your DBMS offers, or to set a value which is NOT a string as a default value, you can use the keyword "Exec:", exactly like this (case sensitive).
 E.g.:
 student has subscribing_date:date("Exec:now()").

In this case, when the field subscribing_date is null the function "now()" will be called '''in the database'''.
We can also do that with numbers:
 Student has age:integer("Exec:0").

The number 0 will be the default value.
Note that the Exec: command must me exactly like it it. It must be the first word and it is case sensitive.
If you use " Exec:" or "exec:", the default value will be handled as a string.
We can set an attribute as hidden, or to be handled differently by the module. To do so, we use the "#" character before the name of each attribute.
 student has #email:varchar(200).

==Subtypes==
Sometimes we need to use the same type and features in many different attributes of entities and we don't want it to be a new entity. For these cases, we indicate the creation of subtypes.
 "A subtype has the scope of a type with its features in a neutral form, to be re-used easily."
The specification of a subtype is the use of a "$" in the begining of it, followed by a valid signature of an attribute.
 E.g.:
 $sex:char(1, not null, {F=Female|M=Male}).

We can use it as a valid type without the "$" on it.
 Example of use:
 student has sex:sex().
 teacher has sex:sex().
 worker has sex_definition:sex().

The three entities above have separately an attribute of type char with size 1, needed and with the two pre-defined options.

==Aggregation==
The Mind2.0 engine uses a file with information about the language(idiom) to understand the code. Based on that, there are two special types of relation, the "belongs" and "obligations". They are especially identified by affirmative verbs or for probabilities, like "is", "may be" or "may have".

Obligation is used when an entity refers to another to be rendered as such. For example:
 person is a human.

In this case, the module will recieve the information that these two entities in the database are the same entity in a OO universe. Then, the class person will extend the class human inheriting all its properties and methods.
Depending on the module you've chosen the class human may be set as abstract, once person is now a more usable class.
Meanwhile, entities that belong to others will be simple extentions of them.
 E.g.:
 person may be a teacher.
 person might be a student.

Now, both teacher and student will extend person, but person does not need to be one of them.
In the database, what we see is an aggregation.

==Teaching theWebMind==
The webMind can learn with the developer, that is one of the premises the Discrete programming language must to match.
The way theWebMind can learn with you is asking you about details, details you used and it couldn't recognize.
To do so, Mind will ask you for new verbs, quantifiers or types that it didn't know.
At the debug panel, you can see all the notices, steps, warnings and errors theWebMind found during the "compilation" of your instructions. There you will see all the warnings, in which theWebmind may be asking you something. By clicking the little "engine" icon in the right side of the message, you'll see the possibilities you have to help theWebMind how to understand what you need. With this, Mind will learn this to the next times, do not need to ask you about them.
[[File:adding-verb-thewebmind.png]]

<!--Portugues-->
@pt A Web-Mind-Language(WML) é uma linguagem baseada no conceito NLP(Natural Language Processing), que é um campo da ciência da computação que se preocupa com a interação entre linguagens de computadores e humanas(naturais).
A linguagem se assemelha muito com a natural(português, inglês, espanhol, etc.), apenas seguindo algumas regras de sintaxe.
Este padrão, chamamos de [[Linguagem de Programação Discreta|Linguagem de Programação Discreta]].
Cada instrução é identificada pelo uso de um ponto(.) ou pelo sinal ";" no final do comando.

==Sintaxe==
Em sua sintaxe a WML utiliza como padrão o modelo conceitual de entidade e relacionamento em um banco de dados.<br>
Desta maneira, escrever em WML significa estar muito próximo a análise conceitual de um projeto de software.<br>
Sendo baseada no modelo ER, nada mais comum que a WML suporte a criação de entidades e relacionamentos em sua sintaxe.<br>
Para a WML cada entidade resultará em uma tabela, e cada relacionamento será aplicado de forma normalizada.<br>
O código escrito em WML é auto explicativo, ou seja, toda a lógica do negócio é transferida para o código de forma natural, como se estivéssemos "falando" sobre o sistema em questão.<br>
Após absorver a inteligência que lhe foi passada através do código natural, o interpretador estará apto a gerar:
*Base Relacional de Banco de Dados
*Estrutura orientada a objetos
*Mapeamento objeto-relacional
*Diagramas
*API de desenvolvimento
*Formulários HTML
*Documentação <br><br>

Abaixo segue um exemplo da sintaxe básica em português:<br>
 cada '''<font style='color:red'>professor</font>''' '''<font style='color:blue'>tem</font>''' 1 <font style='color:gray'>ou</font> n '''<font style='color:red'>aluno</font>'''.
Com este trecho de código sendo interpretado teríamos a seguinte situação:<br><br>
<span style='border:dashed 1px;padding:3px'>'''<font style='color:red'>professor</font>''' e '''<font style='color:red'>aluno</font>'''</span> como [[#Entidades|Entidades]]<br><br>
<span style='border:dashed 1px;padding:3px'>'''<font style='color:blue'>tem</font>'''</span> como Palavra-chave de ligação<br><br>
<span style='border:dashed 1px;padding:3px'>1 <font style='color:gray'>ou</font> n</span> como Relação<br><br>

==Entidades==
Fazendo uma analogia ao desenvolvimento de software tradicional, para a WML entidades podem ser Tabelas em um banco de dados, ou Classes em um sistema orientado à objetos.<br>
Utilizando mesmo exemplo descrito acima,teríamos 2 tabelas em um banco de dados: Professor e Aluno.<br>
Estas tabelas teriam a cardinalidade de 1 para n, ou seja, cada professor possui 1 ou n alunos.<br>
Vale lembrar que não é necessário especificar as chaves de tabelas, o próprio Mind deverá se encarregar disto.
Abaixo, a figura ilustra um modelo ER gerado por este código:
<br><br>

[[File:professor_aluno.png]]
<br>
A WML identifica entidades no código através do algorítmo [[Mind-Natural-Entities-1.0|Mind-Natural-Entities 1.0]].<br>

Use o caractere "#" para indicar alguma entidade que deva ser abstrata, quando tratada pelo módulo. Basta indicar com este caractere <b>uma única</b> vez, para definir a entidade como abstrata.
 pessoa é um #humano<br/>humano tem altura:real(5.2).

humano será tratado como uma entidade abstrata.

==Atributos==
A identificação de atributos no Mind se dá por meio do algorítimo [[Mind-Natural-Attributes-1.0|Mind-Natural-Attributes-1.0]].
Lembrando que a identificação de tipos e parâmetros é baseada no arquivo de configuração selecionado para o desenvolvimento, o qual varia diretamente conforme o idioma, tomaremos neste caso, como exemplo o Portugues, que é um dos idiomas que vem por padrão na distribuição do Mind 2.0 (pt-BR). Este arquivo pode ser alterado pelos próprios desenvolvedores ou responsáveis pelo desenvolvimento em tempo de uso.

Um Atributo em uma entidade é basicamente identificado por meio de uma sintaxe padrão. Esta sintaxe espera por um verbo na expressão, e um elemento seguido pelo caractere ":", seguido por um identificador válido do idioma selecionado, tendo entre "( )" os valores mais específicos do atributo.
Ex.:
 aluno tem nome:caractere(60, obrigatório).

Note que as características mais íntimas do atributão estão separadas por ",", identificadas dentro dos parênteses, e para tal, <b>não ha uma órdem específica</b>.
Nome tornar-se-á o atributo agregado à entidade aluno. Será um campo ou varíavel do tipo char, com tamanho de 60 caracteres, e será um campo obrigatório, ou seja, not null na base de dados, e conforme o módulo selecionado para gerar os arquivos e classes, um campo filtrado.

Podemos ainda acrescentar comentários à atributos, da seguinte maneira:
 aluno tem nome:caractere(60, obrigatório) // nome do respectivo aluno.

"nome do respectivo aluno" será o comentário que, caso o SGBD adotado suporte comentários, será salvo diretamente no banco, senão, estará disponível para o módulo, caso o mesmo queira usa-lo como label em formulários ou em comentários no próprio código a ser gerado.

Ha também a especificação de uma máscara para o atributo. Tal parâmetro deve ser informado entre colchetes "[ ]". Caso a máscara contenha um colchete, use o caractere "\" para escapar o mesmo.
Ex.:
 aluno tem cpf:caractere(14, [000.000.000-00]).

Note que, esta máscara será informada na inteligência gerada pelo Mind2.0 como a máscara a ser aplicada neste campo, mas o próprio Mind não se encarregará de usá-la, o módulo sim. O módulo será informado sobre esta máscara, e poderá aplicá-la de diversas formas, para tal, é indicado ver na documentação do módulo selecionado, qual o padrão de máscaras adotado, pois o mesmo pode usar a máscara tanto como uma expressão regular para validar formulários submetidos quanto como uma máscara propriamente tida, usada via js para campos de digitação.

Identificando opções, para o atributo:
O mind compreenderá que determinado atributo somente aceitará valores específicos, caso a seguinte sintaxe seja obedecida, entre os parâmetros.

 {valorDaOpção=Texto da opção|valorDaSegundaOpção=Texto da segunda opção}

Usamos "|" para separar cada opção, enquanto o sinal de "=" indica o valor real da opção, e seu texto para exibição.

Vejamos um exemplo:
 aluno tem sexo:char(1, {F=Feminino|M=Masculino}).

Neste exemplo, os valores "F" ou "M" serão salvos no banco, enquanto o módulo se encarregará de exibir apenas as opções "Feminino" e "Masculino" na tela. O módulo pode, inclusive, fazer uma fvalidação por estes valores antes de uma inserção ou update.

Valores default, são identificados simplesmente pelo uso de aspas duplas ", também podendo ser escapadas com "\" caso necessário.
 aluno tem nome:caractere variante(60, "João").

Neste caso, o nome padrão será <b>João</b>.
Algumas vezes sabemos que o SGBD selecionado oferece alguma funcção específica que queremos usar no valor default, para estes casos, existe uma palavra chave, "Exec:".
Use o comando "Exec:" para apontar um valor default como executável, e não como uma simples string. Strings serão tratadas para que não haja uma execução.
Segue um exemplo:
 aluno tem data_de_cadastro:data("Exec:now()").

SGBDs que aceitarem o comando now() receberam o mesmo, como valor default, e não apenas uma string.
Podemos fazer o mesmo com valores inteiros:
 aluno tem idade:inteiro("Exec:0").

Acabamos de especificar o valor default de idade do aluno, para o inteiro "0".

Note que o comando Exec: deve ser usado precisamente desta forma, sendo o PRIMEIRO comando na string, e tendo a primeira letra maiúscula.
Usando " Exec:" ou "exec:", o valor default será tratado como string.

Para indicar um atributo como hidden, ao ser enviado para o módulo, use o caractere "#" no inicio do nome do atributo.
 aluno tem #matricula:inteiro().

==Sub Tipos==
Algumas vezes precisamos usar um mesmo tipo de dado pra diversas entidades, como CPF, idade, nome, UF, entre ouros.
Nestes casos, aconselhamos o uso de subtipos.

Definição:
 "Um subtipo engloba características específicas de forma neutra, a fim de ser reaproveitado."

A identificação de um subtipo é dada a partir de um "$" no início da instrução, seguido pela identificação válida de um atributo.
Ex.:
$sexo:char(1, obrigatório, {F=Feminino|M=Masculino}).

Assim, criamos o subtipo "sexo", que trata-se de um charactere de tamanho 1, not null, que tem duas opções válidas.

Para usarmos um subtipo, basta que apontemos o mesmo como tipo de determinado atributo, assim:
 aluno tem sexo:sexo()<br>professor tem sexo:sexo().

Acabamos de especificar toda a instrução a respeito do sexo, para ambas as entidades, poupando digitação.
Neste exemplo, o que se ganha é pouco, mas imagine um uso de UFs.
 endereço tem estado:varchar(40, {RS=Rio Grande do Sul|SP=São Paulo|RJ=Rio de Janeiro}).

E se quiséssemos usar todos os estados? Acabaria sendo algo inviável. Assim, podemos usar:
 $uf:varchar(40, {RS=Rio Grande do Sul|SP=São Paulo|RJ=Rio de Janeiro}).

e
 endereço_comercial tem estado:uf().
 endereço_residencial tem estado:uf().

Claro, logicamente, no exemplo acima, acabaríamos transformando UF em uma nova entidade.


==Derivação e Especialização==
Estes são detalhes quase sutis, a respeito deste padrão. O algorítimo do Mind2.0 trabalha apoiado num arquivo de configurações referente ao idioma selecionado, o qual possui alguns identificadores específicos para isto. São chamados de "belongs" e "obligations". São identificados, principalmente, por alguns verbos específicos, como "é", "são" ou "pode ser", "pode ter".

Obligation é quando uma determinada entidade refere-se a outra de forma a se tornar ela. Por exemplo:
 pessoa é um humano.

Neste caso, o módulo poderá interpretar que pessoa e humano são a mesma coisa, ou que pessoa esteja na verdade, extendento humano, passando a ter assim, todas as características de humano. Humano torna-se-a uma classe abstrata, pois pessoa passa a ocupar uma posição mais usual, com os dados de humano.

Enquanto que, entidades que pertencem a outras (belongs) serão apenas extenções da primeira.
 pessoa pode ser jurídica.<br/>pessoa pode ser física.

Neste exemplom nós teremos as tres entidades, sendo que tanto jurídica quando física estarão extendendo a pessoa, e na base dedados, o que veremos será uma especialização, onde tanto jurídica quanto física estarão apontando para pessoa.