Luar-X: extensão e generalização do sistema de processamento de modelos luar

Texto

(1)UNIVERSIDADE FEDERAL DO RIO GRANDE DO NORTE. U NIVERSIDADE F EDERAL DO R IO G RANDE DO N ORTE C ENTRO DE T ECNOLOGIA P ROGRAMA DE P ÓS -G RADUAÇÃO EM E NGENHARIA E LÉTRICA E DE C OMPUTAÇÃO. Luar-X: Extensão e Generalização do Sistema de Processamento de Modelos Luar. Diogo Henrique Duarte Bezerra. Orientador: Prof. Dr. Aquiles Medeiros Filgueira Burlamaqui. Tese de Doutorado apresentada ao Programa de Pós-Graduação em Engenharia Elétrica e de Computação da UFRN (área de concentração: Engenharia de Computação) como parte dos requisitos para obtenção do título de Doutor em Ciências.. Número de ordem do PPgEEC: D168. Natal, RN, Maio de 2016.

(2) Catalogação da Publicação na Fonte Universidade Federal do Rio Grande do Norte - Sistema de Bibliotecas Biblioteca Central Zila Mamede / Setor de Informação e Referência Bezerra, Diogo Henrique Duarte. Luar-X: Extensão e Generalização do Sistema de Processamento de Modelos Luar / Diogo Henrique Duarte Bezerra - Natal, RN, 2016 53f: il. Orientador: Prof. Dr. Aquiles Medeiros Filgueira Burlamaqui. Tese (doutorado) - Universidade Federal do Rio Grande do Norte. Centro de Tecnologia. Programa de Pós-Graduação em Engenharia Elétrica e de Computação. 1. Sistema Luar-X - Tese. 2. Processador de Modelos Luar - Tese. 3. Linguagem XML - Tese. 4. Reúso - Tese. 5. Template - Tese. 6. Autoria Hipermídia Tese. I. Burlamaqui, Aquiles Medeiros Filgueira. II. Título. RN/UF/BCZM. CDU 004.423.25.

(3) Luar-X: Extensão e Generalização do Sistema de Processamento de Modelos Luar. Diogo Henrique Duarte Bezerra. Tese de Doutorado aprovada em 30 de Maio de 2016 pela banca examinadora composta pelos seguintes membros:.

(4) Agradecimentos. O meu sentimento de gratidão por esta tese, fruto de um trabalho de quatro anos, é primeiramente dedicado ao Deus criador de tudo que há. Seus projetos e engenharias nos fascinam cada vez mais que nos aprofundamos na busca por entendê-los. Este trabalho representa o entendimento de um ponto em uma área de estudo dentre tantas outras que permeiam o projeto do nosso universo. Aos meus pais, Altamir e Regineide, agradeço pela educação que me deram, pelo cidadão que sou e por participarem, tendo grande contribuição, neste projeto de vinte sete anos e meio de estudo formal. A tese representa a conclusão deste projeto, juntamente com o recebimento do mais elevado grau acadêmico dos sistemas de ensino superior do país. Ao prof. Aquiles, são nove anos de parceria. Ele foi o responsável por me guiar e inserir no mundo acadêmico, graduação, mestrado e doutorado. Sou muito agradecido pela oportunidade de ter obtido sua orientação em todos momentos até aqui. Por ter acreditado em mim quando no segundo período da graduação, me convidou para participar do projeto TV Mímica e em seguida nos projetos GTMV, GTRM, Luar e Suíte de Testes Ginga. Pelas indicações de estágio na HXD e mestrado no Lavid/UFPB. Por toda paciência e apoio neste período de doutoramento. Aos meus irmãos, Diego e Thiago, pelo apoio e companheirismo durante este período de trabalho e doutoramento, em especial a Diego pelo auxílio nas traduções dos artigos. A minha namorada, Danielle, pelo carinho e paciência durante a fase final do doutoramento. Ao prof. Guido Lemos, pelo conselho de fazer o doutoramento na UFRN ao invés da UNICAMP. Ao prof. Luiz Marcos, por ter me aceitado no PPGEEC como seu orientando no início do doutoramento, pela liderança e permissão de uso dos equipamentos do laboratório NatalNet. Ao Rostand, pelo apoio e parceria no projeto OddCI no início do doutoramento. Aos profs. Artur, Ana e Gustavo, pela parceria, orientações e horas de dedicação ao me ensinar sobre magnetismo no projeto de estruturas de anéis para memórias magnéticas. Aos colegas do Grupo de Magnetismo e Materias Magnéticos, do DFTE, pelo companhei-.

(5) rismo e em especial a Rafaela e o Silas pelos momentos que trabalhamos juntos, muitas horas de simulações e análises. Aos colegas do laboratório TEAM, pelos momentos, em especial ao Daniel e Sebastião pelas muitas conversas sobre tudo. Aos colegas do laboratório NatalNet, pelos anos que passamos juntos, em especial ao Bruno, Renato, Justo, Sarah, Érika e Bianor pela companhia durante este período de doutoramento. A CAPES, pelas bolsas de estudo que recebi durante a maior parte do doutoramento. Ao Instituto de Engenharia da UFMT, pelo período de afastamento das atividades concedidas durante seis meses. Aos demais, que contribuíram direta ou indiretamente para a conclusão deste trabalho..

(6) “O fracasso é a oportunidade de começar de novo com mais inteligência e redobrada vontade.” (Henry Ford).

(7) Resumo. O sistema de processamento de modelos Luar, utilizado na autoria de documentos NCL, possui conceitos de desenvolvimento baseados no reúso de descrições por meio de modelos de documentos. Esses conceitos de desenvolvimento podem ser utilizados na autoria de outros documentos baseados em XML por meio da análise, adequação, projeto e criação de uma nova infraestrutura de reúso baseada no sistema Luar. Esta tese apresenta o sistema de processamento de modelos Luar-X, uma generalização e extensão do sistema de modelos Luar. O Luar-X mantém os conceitos de desenvolvimento do sistema Luar e modifica, adequa e estende a arquitetura do sistema Luar para permitir o desenvolvimento com linguagens baseadas em XML. Os estudos de caso com as linguagens HTML, SVG e NCL mostram a viabilidade dessa nova infraestrutura de reúso que torna o desenvolvimento de aplicações e a descrição de documentos XML ágil. Palavras-chave: Luar-X, Processador de Modelos Luar, Autoria Hipermídia, XML, Reúso, Template..

(8) Abstract. The Luar template processing system used in authoring NCL documents, has development concepts based on reuse of descriptions through document templates. These development concepts can be used in the authorship of other XML-based documents through the analysis, adequacy, design and creation of a new reuse infrastructure based on Luar system. This view shows the processing system of models Luar-X, a generalization and extension Luar model system. The Luar-X keeps the concepts of development of Luar system and he changes, adapts and extends the Luar system architecture to enable development with XML-based languages. The case studies with HTML, SVG and NCL show the feasibility of this new reuse infrastructure, which makes application development and description of agile XML documents. Keywords: Luar-X, Luar Template Engine, Hipermedia Authoring, XML, Reuse, Template..

(9) Sumário. Sumário. i. Lista de Figuras. iii. Lista de Tabelas. iv. Lista de Códigos. v. Lista de Símbolos e Abreviaturas. vi. 1. Introdução 1.1 Motivação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Contribuições . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Organização da Tese . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 1 2 3 3. 2. Fundamentação Teórica 2.1 Sistemas de Processamento de Modelos . . 2.1.1 Modelos . . . . . . . . . . . . . . 2.1.2 Modelo de Dados . . . . . . . . . . 2.1.3 Processador de Modelos . . . . . . 2.1.4 Tipos de Sistemas de Modelos . . . 2.2 Sistema de Processamento de Modelos Luar 2.2.1 Arquitetura . . . . . . . . . . . . . 2.2.2 Linguagem . . . . . . . . . . . . . 2.2.3 Autoria . . . . . . . . . . . . . . . 2.2.4 Biblioteca . . . . . . . . . . . . . .. 3. . . . . . . . . . .. 5 5 6 7 7 7 8 8 9 10 13. Trabalhos Relacionados 3.0.1 eXtensible Stylesheet Language for Transformation . . . . . . . . 3.0.2 Template Attribute Language . . . . . . . . . . . . . . . . . . . . 3.0.3 Python XML Template Language . . . . . . . . . . . . . . . . .. 15 15 15 16. i. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . .. . . . . . . . . . ..

(10) 3.0.4 3.0.5 3.0.6 3.0.7 4. 5. 6. XTemplate 3.0 . . . . . . . . . . . . . . . Template Authoring Language . . . . . . . Sistema de Processamento de Modelos Luar Proposta Luar-X . . . . . . . . . . . . . .. . . . .. 16 17 17 18. . . . . .. 19 21 22 24 25 27. . . . . .. 28 28 28 33 34 35. Conclusões 6.1 Principais Contribuições . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2 Trabalhos Futuros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 37 37 38. Sistema de Processamento de Modelos Luar-X 4.1 Kernel Luar-X . . . . . . . . . . . . . . . . 4.2 Linguagem Luar-X . . . . . . . . . . . . . 4.3 Processamento de Modelos em Lote . . . . 4.4 Plugins . . . . . . . . . . . . . . . . . . . 4.5 Portal Luar-X . . . . . . . . . . . . . . . . Resultados 5.1 Estudos de Caso . . . . . . . 5.1.1 XHTML . . . . . . 5.1.2 SVG . . . . . . . . . 5.1.3 NCL . . . . . . . . 5.1.4 Aplicações Diversas. . . . . .. . . . . .. . . . . .. . . . . .. . . . . .. . . . . .. . . . . .. . . . . .. . . . . .. . . . . .. . . . . .. . . . . .. . . . . .. . . . . .. . . . . .. . . . . .. . . . .. . . . . .. . . . . .. . . . .. . . . . .. . . . . .. . . . .. . . . . .. . . . . .. . . . .. . . . . .. . . . . .. . . . .. . . . . .. . . . . .. . . . .. . . . . .. . . . . .. . . . .. . . . . .. . . . . .. . . . .. . . . . .. . . . . .. . . . .. . . . . .. . . . . .. . . . .. . . . . .. . . . . .. . . . .. . . . . .. . . . . .. Referências bibliográficas. 40. A Informações Adicionais. 44. B XML - eXtensible Markup Language B.0.1 Objetivos principais da linguagem . . . . . . . . . . . . . . . . . B.0.2 Características da linguagem . . . . . . . . . . . . . . . . . . . .. 49 50 50.

(11) Lista de Figuras. 2.1. 2.3 2.4. Elementos básicos e fluxo do sistema de processamento de modelos [Bezerra 2012] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 Elementos básicos e fluxo do sistema de processamento de modelos Luar [Bezerra 2012] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 Elementos básicos e fluxo do Kernel Luar [Bezerra 2012] . . . . . . . . . 9 Informações do modelo SlideShow no GingaCDN [Bezerra 2012] . . . . 14. 4.1 4.2 4.3. Elementos básicos e fluxo do sistema Luar-X . . . . . . . . . . . . . . . Elementos básicos e fluxo do sistema Luar-X . . . . . . . . . . . . . . . Portal Luar-X . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 20 21 27. 5.1 5.2 5.3. Imagem de uma página XHTML com uma tabela simples . . . . . . . . . Imagem de uma página XHTML . . . . . . . . . . . . . . . . . . . . . . Cartão de visita hipotético Luar-X . . . . . . . . . . . . . . . . . . . . .. 29 31 34. 2.2. iii.

(12) Lista de Tabelas. 3.1. Comparação entre os sistemas . . . . . . . . . . . . . . . . . . . . . . .. iv. 18.

(13) Lista de Códigos. 2.1 2.2. Exemplo de código Luar [Bezerra 2012] . . . . . . . . . . . . . . . . . . Exemplo de código Luar para geração de estruturas NCL semelhantes [Bezerra 2012] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3 Descrições de um modelo e seu atributo [Bezerra 2012] . . . . . . . . . . 2.4 Instanciação do modelo SlideShow [Bezerra 2012] . . . . . . . . . . . . 2.5 Trecho de código utilizando modelos componentes [Bezerra 2012] . . . . 4.1 Exemplo de código Luar-X . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Exemplo de definição de um modelo Luar-X . . . . . . . . . . . . . . . . 4.3 Exemplo de definição do código de geração de um modelo Luar-X . . . . 4.4 Código de utilização do modelo componente TableXHTML . . . . . . . . 4.5 Arquivo de configuração . . . . . . . . . . . . . . . . . . . . . . . . . . 4.6 Exemplo de modelo Luar-X de cabeçalho XHTML . . . . . . . . . . . . 4.7 Exemplo de documento Luar-X utilizando modelo . . . . . . . . . . . . . 4.8 Exemplo do uso de um plugin no Luar-X . . . . . . . . . . . . . . . . . . 5.1 Código de uma tabela simples em XHTML . . . . . . . . . . . . . . . . 5.2 Código de utilização do modelo componente LTableXHTML . . . . . . . 5.3 Código de utilização do modelo componente LPersonalWebPageXHTML 5.4 Código de utilização do modelo LLuarCardSVG . . . . . . . . . . . . . 5.5 Exemplo de autoria com a NCL e plugin JavaScript . . . . . . . . . . . . A.1 Descrição gerada pelo modelo completo LPersonalWebPageXHTML . . A.2 Descrição gerada pelo modelo completo LSlideShowNCL-luarx-js . . . . B.1 Exemplo de documento XML . . . . . . . . . . . . . . . . . . . . . . .. v. 10 11 12 12 13 22 23 23 24 24 25 25 26 29 30 32 34 35 44 46 52.

(14) Lista de Símbolos e Abreviaturas. ADLs: Architecture Description Languages AJAX: Asynchronous Javascript and XML Art TVDI: Arcabouço Tecnológico para Desenvolvimento Ágil e Reutilização de Aplicações para TVDI com suporte a Serviços Web CTIC: Coordenadoria de Tecnologia da Informação e Comunicação GingaCDN: Ginga Code Development Network HTML: HyperText Markup Language IBM: International Business Machines IPTV: Internet Protocol Television ISDB-TB: Integrated Services Digital Broadcasting, Terrestrial, Brazilian version ITU-T: ITU Telecommunication Standardization Sector ITU: International Telegraph Union MathML: Mathematical Markup Language NCL: Nested Context Language NCM: Nested Context Model PXTL: Python XML Template Language RDF: Resource Description Framework RDF: Resource Description Framework RNP: Rede Nacional de Pesquisa SDMX: Statistical Data and Metadata eXchange vi.

(15) SGML: Standard Generalized Markup Language SMIL: Synchronized Multimedia Integration Language SPARQL: SPARQL Protocol and RDF Query Language STTL: SPARQL Template Transformation Language SVG: Scalable Vector Graphics TAL: Template Attribute Language TAL: Template Authoring Language TemPSS: Templates and Profiles for Scientific Software TVDI: Televisão Digital Interativa W3C: World Wide Web Consortium XBRL: eXtensible Business Reporting Language XHTML: eXtensible HyperText Markup Language XML: eXtensible Markup Language XPath: XML Path Language XQuery: XML Query XSIL: Extensible Scientific Interchange Language XSL: eXtensible Stylesheet Language XSLT: eXtensible Stylesheet Language for Transformations.

(16) Capítulo 1 Introdução. Atualmente, a tecnologia vem se tornando cada vez mais acessível globalmente e os seus usuários passaram de consumidores à produtores de informações, assumindo um papel ativo na era da informação. A manipulação e o acesso à informação é tratada em grande parte por meio de softwares que estão presentes no cotidiano da sociedade. Esses softwares possuem um desenvolvimento complexo e demandam tempo e trabalho dos programadores, portanto resultam em um custo elevado para a sua criação. Reconhecendo a complexidade de desenvolvimento dos softwares, os pesquisadores e a indústria buscam novos modelos de desenvolvimento, paradigmas de programação, padrões de projetos, linguagens de domínio específico, frameworks e arquiteturas de sistemas com o objetivo de produzir mais em um menor tempo e com o menor custo. O sistema de processamento de modelos Luar [Bezerra et al. 2012] é um exemplo do resultado dessa busca por novos conhecimentos para o desenvolvimento ágil de softwares. Esse sistema foi projetado para a descrição de aplicações em NCL (Nested Context Language) [Soares Neto et al. 2010], a linguagem declarativa do Middleware Ginga[LAVID & Telemidia n.d.] para o ISDB-TB (Integrated Services Digital Broadcasting, Terrestrial, Brazilian version) [SBTVD n.d.]. O Luar baseia-se em técnicas de reúso a partir de modelos de documentos para diminuir a carga de codificação do programador e tornar ágil o processo de desenvolvimento. O Luar é eficaz e cumpre o objetivo para o qual foi projetado. Assim, há possibilidade de sua arquitetura e seus conceitos serem aproveitados para outros sistemas de modelos em linguagens baseadas em XML (eXtensible Markup Language) [W3C 2008]. Este trabalho amplia e generaliza a utilização do sistema Luar ao criar o Luar-X, um novo sistema de processamento de modelos que mantém os conceitos de autoria do sistema Luar e utiliza uma nova arquitetura capaz de suportar qualquer linguagem baseada em XML..

(17) CAPÍTULO 1. INTRODUÇÃO. 1.1. 2. Motivação. A técnica de reúso baseada em modelos vem sendo utilizada por desenvolvedores de diferentes tecnologias. No contexto da TVDI (Televisão Digital Interativa), Santos [Santos & Saade 2010], Neto [Neto et al. 2010] e Bezerra [Bezerra et al. 2012] visam a possibilidade de reúso de estruturas de alguns documentos NCL. Na Web (XHTML - eXtensible Hipertext Markup Language) Vanoirbeek) [Vanoirbeek et al. 2014] também observa o reúso para diferentes tipos de conteúdos, além de sistemas de modelos consolidados como ThymeLeaf [Fernandez 2011], eRuby [Hansson n.d.], Django [Django n.d.], FreeMarker [Foundation 1999] e muitos outros. Na computação científica Cohen [Cohen et al. 2015] desenvolveu uma nova ferramenta, TemPSS (Templates and Profiles for Scientific Software), que faz uso de modelos como técnica de reúso. Ainda existem aplicações para vetoriais descritos em documentos SVG (Scalable Vector Graphics) [W3C 2001] como os projetos Knockout [Sanderson n.d.] e o Nanotemplates [Okunskiy 2015]. Em RDF (Resource Description Framework), Corby [Corby & Faron-Zucker 2015] criou a STTL (SPARQL Template Transformation Language). Na mesma finalidade e de forma universal, para qualquer documento XML, temos a XSLT (XSL for Transformations) [W3C 1999b], parte da XSL (eXtensible Stylesheet Language), recomendada pela W3C (World Wide Web Consortium) [W3C 2004]. Nesse contexto, observamos que existem diversos sistemas de processamento de modelos para linguagens baseadas em XML. Esses sistemas possuem características diferentes de acordo com as suas especificidades e conceitos. O projeto Luar-X foi motivado pela criação de uma arquitetura que suportasse as especificidades de diferentes linguagens XML e trouxesse os conceitos abstratos de modelos componentes e modelos completos, idealizados pelo sistema Luar, para o ecossistema de sistemas de processamento de modelos XML. Os modelos componentes e completos são modelos de composição que tecnicamente são iguais, diferindo em conceitos abstratos e idealizados para auxiliarem as autorias e utilizações de documentos por autores. Os modelos são comumente denominados, no inglês, de Templates. O modelo completo descreve um documento total como uma página Web, uma aplicação para TVDI ou um desenho vetorial. O modelo componente descreve o pedaço de um documento que pode representar, entre outros, um passador de imagens, grupos de botões, tabelas ou consultas de banco de dados. Os modelos componentes precisam, de acordo com as definições de seus autores, se conectarem entre si ou ao documento que está sendo descrito para comporem um documento total..

(18) CAPÍTULO 1. INTRODUÇÃO. 1.2. 3. Contribuições. A principal contribuição deste trabalho é o sistema de processamento de modelos Luar-X, usado para descrição ágil de documentos XML. Esse sistema foi idealizado a partir do trabalho desta tese que iniciou-se com algumas questões de pesquisa apresentadas a seguir: Questões de pesquisa 1. Como fazer uso dos conceitos de modelo componente e modelo completo em sistemas de modelos para linguagens baseadas em XML aplicado ao desenvolvimento ágil? 2. É possível prover uma infraestrutura de reúso capaz de suportar as especificidades das linguagens baseadas em XML e permitir customizações pelo desenvolvedor? 3. A nova infraestrutura de reúso baseada no Luar, mantém ágil a autoria de documentos descritos em XML? As questões de pesquisa permitiram a criação da hipótese descrita a seguir: Hipótese É possível utilizar a técnica de desenvolvimento e reúso baseada em modelos por meio da utilização de modelos implementados pelo sistema Luar para descrição ágil de documentos XML, tornando-a genérica por meio da análise, adequação, projeto e implementação de um sistema de processamento de modelos que mantém os conceitos e estende a sua arquitetura. Para demonstrar tal hipótese, nesta tese realizamos a análise, a adequação, a criação, o projeto, a implementação e a validação do sistema de processamento de modelos Luar-X. Esse sistema mantém os conceitos de autoria do Luar e possui uma nova arquitetura. O novo sistema Luar-X, permite a descrição ágil de documentos XML por meio da técnica de desenvolvimento e reúso baseada em modelos e customizações específicas que o desenvolvedor necessitar.. 1.3. Organização da Tese. Esta tese está estruturada da seguinte forma: O Capítulo 2 discute aspectos conceituais relevantes ao tema desenvolvido, procurando elucidar definições e conceitos necessários.

(19) CAPÍTULO 1. INTRODUÇÃO. 4. ao entendimento do sistema desenvolvido. O Capítulo 3 é um estudo de trabalhos relacionados. O Capítulo 4 discute a concepção do sistema Luar-X. O Capítulo 5 apresenta e discute os resultados obtidos com a construção do Luar-X. Finalmente, o Capítulo 6 apresenta as considerações finais e as perspectivas..

(20) Capítulo 2 Fundamentação Teórica. Neste capítulo serão apresentados os conceitos necessários para o entendimento do trabalho desenvolvido e exposto ao longo deste documento de tese. Esses conceitos estão relacionados aos sistemas de processamento de modelos e o sistema Luar.. 2.1. Sistemas de Processamento de Modelos. Os sistemas de processamento de modelos [Manolescu 2006, Fowler 2003], comumente conhecidos como template engine, são softwares que combinam um ou mais modelos com um modelo de dados e produzem um ou mais documentos como resultados. Esses sistemas realizam o processamento de texto simples e para tal, geralmente, possuem recursos e características como variáveis, funções próprias, substituição de texto, inclusão de arquivo, avaliação condicional e laços. Assim, é comum observar o uso desses softwares para formatos de documentos como as páginas Web e códigos fontes. Atualmente, os processadores de modelos fazem parte de diversos frameworks, linguagens de programação e podem ser utilizados como pré-processadores e filtros. A Figura 2.1 apresenta os elementos básicos e o fluxo dos sistemas de modelos..

(21) CAPÍTULO 2. FUNDAMENTAÇÃO TEÓRICA. Dados. 6. Documento Resultante. Templates. Processador de Templates. Figura 2.1: Elementos básicos e fluxo do sistema de processamento de modelos [Bezerra 2012] Os elementos básicos de um sistema de processamento de modelos são o modelo de dados, o(s) modelo(s), o processador de modelos, a linguagem de modelo e o(s) documento(s) resultante(s). O fluxo do sistema inicia-se com o preenchimento de um ou mais modelos com os dados que seguem para o processador de modelos e são transformados em um ou mais documentos resultantes. O desenvolvimento baseado em modelos apresenta uma grande relevância em situações onde há necessidade de produção em escala, padronização e reúso de documentos. A utilização de modelos permite a separação entre a lógica de negócio e a lógica de apresentação, constantemente observada no contexto Web, e as linguagens de modelos permitem uma lógica restrita quando comparada a linguagens de programação. Assim, em equipes de desenvolvimento Web, por exemplo, os sistemas de modelos livram os webmasters do foco na parte técnica e os permitem focar o trabalho no conteúdo e sua apresentação.. 2.1.1. Modelos. Os modelos são documentos incompletos que os desenvolvedores podem completálos com dados de acordo com o documento final desejado [Parr 2004]. A característica dos modelos, de serem incompletos, tornam o desenvolvimento baseado em modelos flexível e ágil, pois podem ser reusados e modificados de acordo com a necessidade do desenvolvedor, além de permiti-lo focar na descrição de partes específicas do documento. Os modelos são descritos com linguagens de domínio específico, linguagens préexistentes ou linguagens híbridas, que combinam linguagens pré-existentes e linguagens próprias [Manolescu 2006, Fowler 2003]..

(22) CAPÍTULO 2. FUNDAMENTAÇÃO TEÓRICA. 2.1.2. 7. Modelo de Dados. O modelo de dados é o elemento que permite a customização de um documento gerado pelo processador de modelos. Os dados são definidos pelo desenvolvedor e permitem a customização do modelo, possibilitando o reúso de descrições. Os tipos de dados dependem do documento e dos dados manipulados pelo sistema de modelos. O documento que contém o modelo de dados é pré-formatado, como uma base de dados relacional, um documento XML, uma planilha ou documento com formatação própria, definida pelo sistema de modelos [Manolescu 2006, Fowler 2003].. 2.1.3. Processador de Modelos. Os processadores de modelos são softwares, ou parte de um software, que combinam o(s) modelo(s) com o modelo de dados e produzem um documento ou parte de um documento, com a descrição desejada, como saída. Esses softwares podem ser escritos em diferentes linguagens e possuírem diferentes conceitos de desenvolvimento. Os documentos resultantes, produzidos pelos processadores de modelos, podem ser de diferentes tipos como arquivos de texto, documentos XML, códigos fontes e documentos de descrições [Manolescu 2006, Fowler 2003].. 2.1.4. Tipos de Sistemas de Modelos. Os sistemas de modelos são classificados em três tipos, de acordo com a localização onde a geração dos documentos resultantes são realizadas. Os tipos de sistemas de modelos são: do lado do servidor, do lado cliente, e distribuído. Os sistemas de modelos do lado do servidor possuem processadores de modelos no servidor que geram os documentos de forma dinâmica para os clientes. Os principais exemplos são os sistemas dos frameworks e plataformas Web. Os sistemas de modelos do lado cliente realizam o processamento dos modelos com o software localmente, de forma estática ou dinâmica. Esse tipo de sistema, de geração estática, é mais utilizado para a autoria e descrição de documentos. Os sistemas de geração dinâmica são mais comuns no contexto Web, com a utilização de linguagens de modelos pelos navegadores. Nos sistemas de modelos distribuídos o processamento dos modelos são realizados em múltiplos servidores. Esse tipo de sistema não é muito utilizado, sendo mais comum no ambiente Web. O AJAX (Asynchronous Javascript and XML) [W3C 2005] é um exemplo desse tipo de sistema..

(23) CAPÍTULO 2. FUNDAMENTAÇÃO TEÓRICA. 2.2. 8. Sistema de Processamento de Modelos Luar. O Luar é um sistema de processamento de modelos para documentos NCL, criado com o objetivo de agilizar o desenvolvimento de aplicativos para o ISDB-TB. Nesta seção é apresentado o Luar, sua arquitetura, sua linguagem e os seus conceitos de autoria.. 2.2.1. Arquitetura. A arquitetura do sistema Luar foi concebida para permitir o reuso de descrições em documentos NCL e possibilitar o desenvolvimento ágil de aplicações para TVDI. A Figura 2.2 apresenta os elementos básicos e fluxo do sistema.. Biblioteca de Modelos. Kernel Luar Processador de Modelos. Modelos Luar. Documento. NCL. Scripts de Funções. Documento. Luar. Tratador de Commandos + código Lua. Figura 2.2: Elementos básicos e fluxo do sistema de processamento de modelos Luar [Bezerra 2012] O sistema Luar possui os elementos básicos de um sistema de processamento de modelos padrão e mais alguns elementos para especificidades da infraestrutura de reúso. O fluxo do sistema inicia-se com os autores que usam os modelos Luar e preenchem os dados dos modelos em um documento Luar. Os autores, por meio de comandos e funções do sistema, enviam o documento Luar para o processador de modelos, no Kernel, que combina os modelos e os dados descritos nesse documento e produzem como saída resultante um documento NCL. Os documentos NCL com a inserção de códigos Lua tornam-se documentos Luar que podem ser compostos por outros modelos e seguirem novamente o ciclo do sistema. Os modelos Luar, por padrão, estão na biblioteca de modelos e são baixados pelo Kernel ao serem solicitados por meio de comandos pelos usuários. Os modelos são acessados.

(24) CAPÍTULO 2. FUNDAMENTAÇÃO TEÓRICA. 9. localmente e combinados com os dados descritos no documento Luar na sequência que o processador os encontra. Saída. Processador de Modelos. Processador de Aplicações. Scripts. Tratador de Comandos. Requesições via comandos. Figura 2.3: Elementos básicos e fluxo do Kernel Luar [Bezerra 2012] Na Figura 2.3 podemos observar os elementos básicos do Kernel Luar. A interação no Kernel inicia-se por meio de requisições, por comandos, enviadas pelos usuários. Os comandos estão relacionados com scripts de funções que executam tarefas como listar modelos, listar atributos dos modelos, criar projetos Luar, remover modelos, baixar modelos e gerar documentos NCL. O processador de aplicações é responsável por analisar o documento Luar e gerar a sua descrição NCL. Ao encontrar alguma utilização de modelo na descrição, o processador de aplicações envia a descrição para o processador de modelos que o processa e devolve a descrição correspondente ao modelo. O processador de aplicações ao finalizar sua tarefa, envia a descrição NCL resultado para o seu script correspondente, que salva a descrição em um arquivo NCL. Os modelos completos são manipulados diretamente pelo processador de modelos, sem passar pelo processador de aplicações.. 2.2.2. Linguagem. A linguagem do Luar foi idealizada pensando nos desenvolvedores de aplicações para o Ginga-NCL, que possui Lua como a linguagem de script da NCL. Assim, foi projetado o uso de Lua com NCL por meio de scriptlets, pequenos trechos de código entre as tags delimitadoras <% %>. O aprendizado do Luar é simples para os autores de documentos NCL, pois conhecem a linguagem Lua e não precisam aprender uma nova sintaxe. Os desenvolvedores precisam apenas combinar as duas linguagens por meio da tag delimitadora..

(25) CAPÍTULO 2. FUNDAMENTAÇÃO TEÓRICA. 1 2 3 4 5 6 7 8. 10. </head> </body> <port id="pStart" component="slide1" /> <% for i=1, #slides do print(’<media id="slide’..i..’" src="’..slides[i]..’" descriptor="dSlide" />’) end %>. Código 2.1: Exemplo de código Luar [Bezerra 2012] O Código 2.1 apresenta um exemplo da linguagem Luar. As linhas de um a três possuem códigos NCL. Nas linhas quatro e cinco observamos as tags delimitadoras. As linhas cinco e seis apresentam a definição de uma iteração indo de um até o tamanho da tabela slides. Na linha seis está sendo impressa a tag <media/> de forma dinâmica, de acordo com a quantidade de elementos na tabela slides e usando os valores dos elementos da tabela para o atributo src.. 2.2.3. Autoria. A autoria fazendo uso do sistema Luar pode ser feita de três formas: autoria sem uso de modelos, autoria baseada em modelos completos e autoria utilizando modelos componentes. A autoria sem uso de modelos é realizada quando o autor não têm necessidade de usar modelos, mas possui uma grande quantidade de repetições na descrição NCL que irá realizar. Assim, o autor torna o desenvolvimento ágil ao utilizar a linguagem imperativa Lua para gerar dinamicamente as descrições NCL pretendidas. O Código 2.2 apresenta um exemplo de autoria sem uso de modelos, a geração de cinquenta descrições das tags <link/>..

(26) CAPÍTULO 2. FUNDAMENTAÇÃO TEÓRICA. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18. 11. <% for i=1, 50 do print( ’<link xconnector="onKeySelectionORStartStop">’ ) print( ’<bind component="seletorroda1op’ .. i .. ’" role="onSelection">’ ) print( ’<bindParam name="keyCode" value="CURSOR_LEFT"/>’ ) print( ’</bind>’ ) print( ’<bind component="seletorroda1op’ .. i .. ’" role="stop"/>’ ) print( ’<bind component="textoroda1op’ .. i .. ’" role="stop"/>’ ) if i > 1 then print( ’<bind component="seletorroda1op’ .. (i-1) .. ’" role="start"/>’ ) print( ’<bind component="textoroda1op’ .. (i-1) .. ’" role="start"/>’ ) else print( ’<bind component="seletorroda1op51" role="start"/>’ ) print( ’<bind component="textoroda1op51" role="start"/>’ ) end print( ’</link>’ ) end %>. Código 2.2: Exemplo de código Luar para geração de estruturas NCL semelhantes [Bezerra 2012] Os modelos completos e componentes são conceitos importantes no sistema Luar, [Bezerra 2012] apresenta as seguintes definições: "Os modelos completos possuem a característica de criar uma aplicação completa apenas com o preenchimento de seus atributos. Ao utilizá-lo o autor ganha o reúso de toda aplicação sem se preocupar com detalhes do desenvolvimento em NCL. Os modelos componentes se caracterizam por serem códigos independentes que podem se relacionar com outros e com as descrições NCL para formarem uma aplicação NCL. O modelo componente também pode gerar uma aplicação NCL, mas oferece apenas algumas funcionalidades.". A autoria usando modelos completos ou componentes dependem da criação dos modelos e do desenvolvimento baseado em modelos, poucos assumem a complexidade de criar um modelo para que muitos usufruam da simplicidade no uso deste. Assim, o desenvolvimento baseado em modelos torna-se ágil. As autorias dos modelos são divididas em duas partes: identificação e codificação. A identificação é realizada entre as tags <%! %>, nela é obrigatório atribuir à variável template uma descrição do modelo, em seguida as variáveis a serem utilizadas pelos autores dos modelos deverão ser identificadas. Os dados de identificação são utilizados pelo autor que usará o modelo para entender como descrevê-lo e qual sua finalidade. A codificação é um processo subjetivo e específico do criador do modelo e deverá ser feita entre as tags <% %>. O Código 2.3 apresenta um exemplo de identificação de modelo..

(27) CAPÍTULO 2. FUNDAMENTAÇÃO TEÓRICA. 1 2 3 4 5 6. 12. <ncl id="slideshow" xmlns="http://www.ncl.org.br/NCL3.0/EDTVProfile"> <%! template="O modelo SlideShow cria um passador de slides..." slides="Este atributo deve ser uma tabela Lua. Nas linhas da tabela devem ser indicadas o caminho das..." %>. Código 2.3: Descrições de um modelo e seu atributo [Bezerra 2012] A autoria utilizando o modelo completo permite o maior nível de reúso proporcionado pelo sistema Luar. O autor necessita atribuir valores as variáveis descritas na identificação do modelo e definir o modelo que está utilizando com a função includeTemplate. Os códigos e definições são realizadas entre os scriptlets Luar. O Código 2.4 apresenta um exemplo do uso de um modelo que gera uma aplicação para TVDI do tipo apresentação de imagens. 1 2 3 4 5 6 7 8. <% slides={ "image1.png", "image2.png", "image3.png" } includeTemplate("SlideShow") %>. Código 2.4: Instanciação do modelo SlideShow [Bezerra 2012] Os modelos componentes, apesar de não serem um componente de software, foram criados baseados nesse conceito da engenharia de software. Os componentes de software são partes de softwares independentes que podem ser reunidos para formarem um sistema [Brown & Short 1997]. Os modelos componentes não geram uma aplicação NCL completa e podem ser utilizados com a autoria sem a utilização de modelos ao comporem funcionalidades desejadas na aplicação. Esse tipo de modelo pode gerar grupo de botões, formulários, teclados virtuais, passadores de imagens e outros. A criação e o uso dos modelos componentes devem levar em consideração a interação entre os modelos componentes e a descrição realizada pelo autor. Em NCL os modelos componentes devem ser tratados como objetos de mídia e terem no mínimo um identificador, a variável id, para que eles possam ser iniciados e encerrados, outras interações devem ser especificadas na identificação do modelo..

(28) CAPÍTULO 2. FUNDAMENTAÇÃO TEÓRICA. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20. 13. <port id="pStart" component="sidebar"/> <% id="sidebar" relative=true leftLS={image="esquerda.png", width=20} rightLS={image="direita.png", width=20} includeComponent("LSidebar") %> <% id="buttonGroup" x=50 y=70 button={} button.width=80 button.height=30 button[1] = {selected="but1.png", unselected="uBut1.png", start="opt1"} button[2] = {selected="but2.png", unselected="uBut2.png", start="opt2"} button[3] = {selected="but3.png", unselected="uBut3.png", start="opt3"} includeComponent("LButtonGroup") %>. Código 2.5: Trecho de código utilizando modelos componentes [Bezerra 2012] O Código 2.5 apresenta os exemplos de utilização de dois componentes, o primeiro gera a descrição de barras laterais e o segundo gera a descrição de um grupo de botões. Na primeira linha observamos a porta que inicia o primeiro objeto de mídia, o identificador do modelo LSidebar, essa linha é um exemplo de como os modelos são tratados como objetos de mídia. As linhas dezesseis, dezessete e dezoito possuem a definição dos botões no modelo LButtonGroup. O atributo start, em todos os botões, define o objeto de mídia que irá iniciar ao ser selecionado o respectivo botão. A interação dos botões foram definidas previamente pelo criador do modelo, um exemplo do cuidado que o criador e o usuário do modelo devem ter.. 2.2.4. Biblioteca. O sistema Luar utiliza o portal GingaCDN como sua biblioteca. O portal é um serviço Web com a função de divulgar e promover as tecnologias relacionadas ao Middleware Ginga e as aplicações para TVDI. Os modelos Luar são disponibilizados no portal como ferramentas. A comunidade de desenvolvedores podem ter acesso aos modelos, baixá-los via navegadores ou kernel e adicioná-los em sua biblioteca local. Os modelos podem ser categorizados, descritos e exemplificados de forma textual, com imagens e por meio de vídeos. Os autores ainda podem qualificar os modelos. A Figura 2.4 apresenta a imagem de um modelo no portal GingaCDN (Ginga Code Development Network)..

(29) CAPÍTULO 2. FUNDAMENTAÇÃO TEÓRICA. Figura 2.4: Informações do modelo SlideShow no GingaCDN [Bezerra 2012]. 14.

(30) Capítulo 3 Trabalhos Relacionados. Este capítulo apresenta uma descrição de linguagens e sistemas para autoria de modelos e documentos XML, a XSLT (eXtensible Stylesheet Language for Transformation), a TAL (Template Attribute Language), a PXTL (Python XML Template Language), a XTemplate 3.0, a TAL (Template Authoring Language) e o Sistema de Processamento de Modelos Luar.. 3.0.1. eXtensible Stylesheet Language for Transformation. A XSLT [W3C 1999b] é uma linguagem de marcação XML destinada a criação de documentos XSL. Os documentos XSL definem a apresentação dos documentos XML nos navegadores e outros aplicativos que têm suporte para tal. Os documentos XSL não alteram o documento XML original e não criam outro documento. O navegador/aplicativo que recebe o documento XML original, como ele foi criado, apresenta-o como o documento XSL determina. A XSLT prevê o uso de modelos com o processamento sendo realizado pelo navegador/aplicativo que recebe o documento XML com código XSLT. A XSLT define o local e o documento XML que será inserido no código XML a ser utilizado pelo navegador/aplicativo.. 3.0.2. Template Attribute Language. A TAL [ZOPE 2010c] é uma linguagem para autoria de modelos com foco na geração de páginas XHTML, que também pode ser usada para XML, dinamicamente. A linguagem tem como objetivo permitir a colaboração e integração entre programadores e designers. TAL incorpora declarações próprias dentro de tags XHTML ou XML válidas que podem ser trabalhadas com ferramentas populares de design..

(31) CAPÍTULO 3. TRABALHOS RELACIONADOS. 16. A linguagem possui um mecanismo de extensão denominado METAL (Macro Expansion Template Attribute Language) [ZOPE 2010b] que a complementa e permite a reutilização de código de outros modelos. A METAL permite ao desenvolvedor definir e utilizar macros que podem possuir slots. Ao se utilizar uma macro o conteúdo variável pode ser especificado por um slot. A princípio, a TAL foi criada para o ZOPE (Z Object Publishing Environment) [ZOPE 2010a], um servidor de aplicações web de código aberto escrito na linguagem Python, mas outros projetos também fizeram uso dela e a implementaram em diferentes linguagens como Python, C#, JavaScript, Java, Perl, Perl 6, PHP e XSL.. 3.0.3. Python XML Template Language. A PXTL [Clover 2010] é uma linguagem que permite o uso de XML com código Python, similar ao Luar que permite uso de XML com Lua. Assim, a PXTL permite embutir código Python nos documentos XML para controlar a geração e transformação dos conteúdos dos documentos. Os elementos são condicionais, iteradores, submodelos e importações. Os atributos são os condicionais, de alterações e atributo raiz. Esta linguagem possui um processador de modelos, seguindo a arquitetura padrão de um sistema de processamento de modelos como apresentado no Capítulo 2. A PXTL especifica ainda elementos (tags) e atributos próprios como opção para o desenvolvedor fazer uso. Apesar de ser um sistema de modelos destinado a documentos XML, a PXTL tem como principal uso os documentos XHTML.. 3.0.4. XTemplate 3.0. A linguagem XTemplate 3.0 é uma linguagem inspirada em ADLs (Architecture Description Languages) [Clements 1996] que foi criada para definir modelos de composição e facilitar a autoria de programas descritos com a NCL 3.0 [Soares et al. 2010]. A XTemplate 3.0 torna possível a criação de modelos, denominados templates de composição. Esses templates de composição descrevem genericamente todo o conteúdo de um contexto NCL. Na autoria, o desenvolvedor apenas indica os elementos que utilizará. Segundo [Santos & Saade 2009], a XTemplate funcionaria como se estivesse criando um documento NCL com “buracos” que seriam preenchidos posteriormente pelos autores. A linguagem XTemplate 3.0 foi criada com o objeto de gerar facilidades para um autor de documentos NCL. O autor deve possuir conhecimento em XPath (XML Path.

(32) CAPÍTULO 3. TRABALHOS RELACIONADOS. 17. Language) [W3C 1999a] e XSLT [W3C 1999b] como pré-requisito para utilizar essa linguagem. O sistema de modelos da linguagem XTemplate 3.0 possui uma biblioteca para criação de bases de modelos que permite o compartilhamento dos modelos entre os desenvolvedores [Santos & Saade 2010]. Os documentos NCL completos, que foram gerados a partir do processamento de documentos XTemplate 3.0, deverão ser executados pelo Middleware Ginga.. 3.0.5. Template Authoring Language. A TAL (Template Authoring Language) é uma linguagem criada para definição de modelos de documentos hipermídia. Essa linguagem é declarativa, modular e trabalha de forma independente da linguagem de autoria alvo. A TAL é uma evolução da XTemplate 3.0 e permite que autores mais especializados especifiquem modelos de documentos para que outros autores menos especializados criem novos documentos de forma simples, rápida e livre de erros [Neto et al. 2010]. A linguagem TAL também foi projetada para evitar o uso de notações fora de contexto do modelo conceitual e do nível de abstração da linguagem. Essa característica a torna possível de ser empregada na autoria de outras linguagens declarativas, diferentemente da XTemplate 3.0 [Neto et al. 2010].. 3.0.6. Sistema de Processamento de Modelos Luar. O Sistema de Processamento de Modelos Luar foi criado para a autoria de documentos NCL baseada no reúso de modelos. O Luar permite usar a linguagem Lua com as descrições NCL para a criação dos modelos. Essa característica traz simplicidade no desenvolvimento e facilidade na aprendizagem dos programadores que desenvolvem aplicações para o Middleware Ginga, pois a linguagem de script do Ginga-NCL é Lua. O Sistema Luar possui dois conceitos de modelos para o processo de autoria, os modelos completos e os modelos componentes. O modelo completo descreve um documento total como uma página Web, uma aplicação para TVDI ou um desenho vetorial. O modelo componente descreve o pedaço de um documento que pode representar, entre outros, um passador de imagens, grupos de botões, tabelas ou consultas de banco de dados. Os modelos componentes precisam, de acordo com as definições de seus autores, se conectarem entre si ou ao documento que está sendo descrito para comporem um documento total. O Luar possui um processador e uma biblioteca de modelos. A biblioteca é responsável por agregar, manter coleções e compartilhar os modelos entre a comunidade de.

(33) CAPÍTULO 3. TRABALHOS RELACIONADOS. 18. desenvolvedores.. 3.0.7. Proposta Luar-X. O sistema de processamento de modelos Luar-X provê uma infraestrutura de reúso para o desenvolvimento baseado em modelos por engenheiros de software. O Luar-X mantém o uso dos conceitos de modelo completo e componente do Sistema Luar, mas modifica a linguagem de autoria. A linguagem de autoria do Luar-X por padrão é Lua, mas pode ser qualquer linguagem imperativa combinada com XML, isso é possível por meio de plugins. A combinação das linguagens simplifica o desenvolvimento de modelos XML, pois as notações já são conhecidas na comunidade de desenvolvedores, e permite a criação dos modelos generalizando e simplificando o desenvolvimento destes. A PXTL faz uso dessa abordagem de combinar linguagens ao utilizar a linguagem Python juntamente com a XML, sendo uma abordagem semelhante ao Luar-X. O sistema Luar-X se mostra uma ferramenta de reúso promissora e completa. Nele é possível encontrar características que outros sistemas possuem como as bibliotecas de modelos, que também são encontradas na XTemplate, e o modo de processar modelos, similar a PXTL. Os plugins também são uma característica importante, não encontrada no Luar, pois permitirão customizações e darão maior uso a ferramenta. As linguagens XSLT, XTemplate, Template Authoring Language e Template Attribute Language diferem do Luar-X ao definirem uma sintaxe própria. A XSLT, XTemplate e Template Attribute Language usam notações fora do contexto do modelo conceitual e abstração da linguagem alvo, dificultando a aprendizagem de uso por parte do desenvolvedor. A seguir, é apresentado na Tabela 3.1 um resumo das principais características de cada uma das linguagens ou sistemas de modelos apresentados. Conceito de Reuso Biblioteca Linguagem Open Source Plugins. XSLT Modelo Não possui Própria Sim Não. TAL Modelo Não possui Própria Sim Não. PXTL Modelo Não possui Python Sim Não. XTemplate 3.0 Modelo Própria Própria Sim Não. TAL Modelo Não possui Própria Sim Não. Luar Completo e Componente Portal Ginga-CDN Lua Sim Não. Tabela 3.1: Comparação entre os sistemas. Luar-X Completo e Componente Própria Múltiplas Sim Sim.

(34) Capítulo 4 Sistema de Processamento de Modelos Luar-X. O sistema Luar-X é o melhoramento, extensão e generalização do sistema de modelos Luar para qualquer linguagem baseada em XML. O Luar-X modificou a sintaxe, a biblioteca, permitiu o processamento em lote de modelos e incluiu a possibilidade de plugins para customização do próprio sistema. Os plugins são uma poderosa característica do Luar-X, pois possibilitam e aumentam as funcionalidades nesse sistema, como por exemplo, o uso de diferentes linguagens combinadas com a XML para autoria dos documentos Luar-X. A linguagem Lua foi mantida como padrão no sistema Luar-X. Os conceitos de modelos completos e componentes e a forma de interação do usuário com o sistema também permaneceram. A Figura 4.1 apresenta os elementos básicos e fluxo do sistema de modelos Luar-X..

(35) CAPÍTULO 4. SISTEMA DE PROCESSAMENTO DE MODELOS LUAR-X. 20. Kernel Luar-X Plugins Biblioteca de Modelos. Repositório. de Plugins. Processador Luar-X Modelos Luar-X. Documentos. XML. Scripts de Funções. Documentos. Luar-X. Tratador de Commandos + código Luar-X. Figura 4.1: Elementos básicos e fluxo do sistema Luar-X Os elementos básicos e o fluxo do sistema Luar-X são os mesmos elementos e fluxos do modelo genérico de um sistema de processamento de modelos, como apresentado na Figura 2.1. O sistema Luar-X possui quatro partes: o kernel, a biblioteca de modelos, a linguagem e o repositório de plugins. A linguagem é apresentada na Figura 4.1 por meio dos modelos e dos documentos Luar-X. O fluxo do sistema inicia-se com o desenvolvimento de uma aplicação que fará uso de modelos. Os modelos são mantidos em coleções na biblioteca. O sistema Luar-X pode processar um único documento Luar-X ou um lote de documentos, contendo os dados para compor o modelo, que são enviados para o kernel. Os comandos executam funções específicas do sistema e são utilizados para interação com o kernel. O kernel tem a responsabilidade de fazer o processamento dos modelos por meio do processador LuarX. Após o processamento é gerado o documento XML a partir do modelo e dos dados recebidos pelo processador. No processamento, caso detectado, pode ser usado algum plugin para tratamento de uma especificidade do documento. O documento XML tornase um documento Luar-X ao ser inserido o código Luar-X. Essa característica é útil para que o desenvolvedor utilize mais modelos ou processe novamente o código XML, caso seja necessário. A linguagem Luar-X manteve os conceitos de modelos completos e componentes, mas utiliza outros scriptlets e tags delimitadoras para fazer a combinação de linguagem imperativa e a XML..

(36) CAPÍTULO 4. SISTEMA DE PROCESSAMENTO DE MODELOS LUAR-X. 21. A seguir, serão apresentados o kernel, a linguagem, o processamento de modelos em lote, os plugins e a biblioteca de modelos do sistema Luar-X.. 4.1 Kernel Luar-X A Figura 4.2 apresenta com mais detalhes o kernel do sistema Luar-X. Nesta seção, serão detalhados o funcionamento, os elementos e o fluxo da interação desse sistema.. Plugins. Documento XML Resultante. Núcleo. Processador de Modelos. Scripts. Tratador de Comandos. Requisições via comandos. Figura 4.2: Elementos básicos e fluxo do sistema Luar-X A interação com o kernel do Luar-X acontece por meio de linhas de comandos. Os comandos enviados passam pelo tratador de comandos que executa os scripts com a função desejada. A principal função do kernel é de processar o documento Luar-X descrito pelo desenvolvedor. O documento é enviado ao núcleo do processador Luar-X que faz a leitura do documento. No núcleo, na medida que é realizada a leitura do documento, identifica-se na descrição as tarefas a serem realizadas e essas são enviadas aos determinados elementos responsáveis. As tarefas são a de processar modelos, processar descrições genéricas ou executar plugins. O processador de modelos recebe o trecho do documento Luar-X para ser combinado com um modelo, seja ele completo ou componente, e devolve ao núcleo a descrição XML respectiva. O processador ainda realiza o processamento de descrições genéricas, que o desenvolvedor utiliza a linguagem Lua para descrição dinâmica XML..

(37) CAPÍTULO 4. SISTEMA DE PROCESSAMENTO DE MODELOS LUAR-X. 22. O núcleo ao detectar um trecho que solicita um determinado plugin para processá-lo, o envia ao plugin responsável. O plugin realiza o tratamento do trecho e devolve o XML resultante para o núcleo. Ao fim da leitura do documento Luar-X e com as descrições XML resultantes, o núcleo escreve a descrição XML total em um documento XML resultante. O núcleo pode solicitar alternadamente o processamento via processador de modelos ou plugins, de acordo com a ordem que aparecer no documento Luar-X.. 4.2. Linguagem Luar-X. A linguagem do Luar-X foi idealizada a partir da experiência adquirida com o uso da linguagem do sistema Luar. O padrão de linguagem no sistema é a combinação da linguagem Lua com a XML, permitida por meio de scriptlets que são trechos de código entre as tags delimitadoras <? ?>. O Luar-X ainda possui em sua linguagem a definição de mais dois tipos de tags delimitadoras, as tags de definição de modelos <?template ?> e a de uso dos plugins <?plugin ?>. O Código 4.1 mostra o exemplo do Código 2.1 reescrito em Luar-X. 1 2 3 4 5 6 7 8. </head> </body> <port id="pStart" component="slide1" /> <? for i=1, #slides do print(’<media id="slide’..i..’" src="’..slides[i]..’" descriptor="dSlide" />’) end ?>. Código 4.1: Exemplo de código Luar-X O Código 4.2 apresenta um exemplo didático de definição, de um modelo componente de tabela XHTML, com a linguagem do sistema Luar-X. A definição geral do modelo deve ser atribuída a variável template, como na linha dois. As variáveis específicas, que serão usadas pelo modelo, devem ser definidas a seguir como o exemplo da linha quatro..

(38) CAPÍTULO 4. SISTEMA DE PROCESSAMENTO DE MODELOS LUAR-X. 1 2 3 4 5 6 7 8 9 10 11 12 13 14. 23. <?template template = "O modelo LTableXHTML gera uma tabela XHTML simples. As tabelas geradas possuem cabeçalho, linhas e colunas apenas." table = ’Tabela Lua onde deve ser descrita a tabela XHTML conforme o exemplo a seguir: table = { header = {"Linguagem XML","Ano de Criação"}, {"XHTML","2002"}, {"SVG","1999"}, {"NCL","2000"}, {"XSIL","1999"}, {"RDF","1998"}} ’ ?>. Código 4.2: Exemplo de definição de um modelo Luar-X Ao finalizar a definição o modelo deve conter o código de geração criado pelo autor do modelo. O código de geração deve estar entre as tags delimitadoras <? ?>. O Código 4.3 apresenta a continuação do exemplo didático do modelo da tabela XHTML do Código 4.2. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21. <? if table ~= nil then print(’<table border="1">’) if table.header ~= nil then print("<tr>") for i=1, #table.header do print("<th>"..table.header[i].."</th>") end print("</tr>") end for i=1, #table do print("<tr>") for j=1,#table[i] do print("<td>"..table[i][j].."</td>") end print("</tr>") end print("</table>") else print("The table is not defined!") end ?>. Código 4.3: Exemplo de definição do código de geração de um modelo Luar-X A autoria usando modelos é simples, o autor atribui os valores desejados as variáveis definidas na descrição do modelo e usa a função useTemplate() para definir o modelo que está sendo utilizado. O Código 4.4 apresenta um exemplo de uso do modelo didático de tabela XHTML utilizado nesta seção..

(39) CAPÍTULO 4. SISTEMA DE PROCESSAMENTO DE MODELOS LUAR-X. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15. 24. <html> <head><title>Tabela XHTML</title></head> <body> <? table = { header = {"Linguagem XML","Ano de Criação"}, {"XHTML","2002"}, {"SVG","1999"}, {"NCL","2000"}, {"XSIL","1999"}, {"RDF","1998"} } useTemplate(’LTableXHTML’) ?> </body>. Código 4.4: Código de utilização do modelo componente TableXHTML O uso de plugins é uma característica, que permite extensão e flexibilidade paro o sistema de modelos Luar-X. A definição e o uso dos plugins serão apresentados na seção 4.4.. 4.3. Processamento de Modelos em Lote. Uma característica de algumas aplicações descritas em XML é a utilização de mais de um documento com trechos de códigos e características em comum, um exemplo conhecido são as páginas Web descritas em XHTML, que encontramos em diferentes domínios, com o cabeçalho ou rodapé padrão. Assim, para abstrair essas repetições em diferentes documentos tornou-se possível o processamento em lote de documentos XML. O arquivo de configuração (config.lrx), apresentado no Código 4.5, possui uma tabela templateData = { } onde são definidos os atributos em comuns a todo o lote de documentos a serem processados. 1 2 3. templateData = { title = "Exemplo de uso dos dados em lotes de documentos" }. Código 4.5: Arquivo de configuração O Código 4.6 apresenta um exemplo hipotético de um modelo Luar-X para cabeçalhos XHTML. As linhas de um a quatro contém a definição do modelo e as linhas de cinco a seis contém os códigos a serem processados juntamente com os dados..

(40) CAPÍTULO 4. SISTEMA DE PROCESSAMENTO DE MODELOS LUAR-X. 1 2 3 4 5 6 7 8. 25. <?template template="O modelo HeaderXHTML estabelece um título no cabeçalho XHTML" title="Este atributo recebe o nome do título (<title>)" ?> <head> <title><? templateData.title ?></title> </head>. Código 4.6: Exemplo de modelo Luar-X de cabeçalho XHTML No Código 4.7 temos um exemplo da utilização do modelo HeaderXHTML em um documento. A inclusão deste modelo poderia ser usada em todo um lote de documentos Luar-X afim de gerar documentos XHTML com cabeçalhos padronizados. 1 2 3 4 5 6 7 8. <html> <? useTemplate("HeaderXHTML") ?> <body> . . . </body> </html>. Código 4.7: Exemplo de documento Luar-X utilizando modelo. 4.4. Plugins. O sistema Luar-X tem o objetivo de ser uma opção de ferramenta para desenvolvimento ágil de aplicações descritas em XML. Algumas vezes os desenvolvedores precisam tratar as especificidades de cada aplicação, como por exemplo, o uso de folhas de estilo [W3C 2015], JavaScript [W3C 2016], processamento de imagens, linguagens ou outros. Nesse contexto foi projetado o uso de plugins que se integram ao sistema LuarX para tratamento de características específicas em aplicações, com intuito de agilizar o desenvolvimento e evitar o uso de mais ferramentas pelo desenvolvedor. Os plugins são instalados e utilizados por meio das descrições nos documentos LuarX. Foi definido um repositório de plugins on-line e público na Web, onde os desenvolvedores podem submeter e baixar os plugins criados pela comunidade. O acesso ao repositório se dá por meio do Portal Luar-X, que será detalhado na seção 4.5, onde os desenvolvedores podem descrever a funcionalidade do plugin, a versão, qualificá-los e disponibilizar exemplos de uso..

(41) CAPÍTULO 4. SISTEMA DE PROCESSAMENTO DE MODELOS LUAR-X. 26. Os plugins são pequenos softwares que recebem uma descrição própria e a tratam devolvendo a descrição para o sistema Luar-X. O plugin deve possuir uma interface Lua, com uma função denominada executePlugin(), que deverá receber a descrição detectada pelo núcleo do sistema Luar-X e retornar a descrição XML resultante do processamento dessa descrição. Assim, é possível o desacoplamento desses plugins com o kernel do sistema Luar-X, proporcionando uma maior flexibilidade e extensão ao sistema como um todo. Uma notável situação de uso dos plugins no sistema Luar-X é a criação de processadores de modelos que fazem uso de outras linguagens imperativas ao invés da linguagem Lua. Esses plugins permitem, em um mesmo documento Luar-X, existir trechos de códigos e definições de modelos em diferentes linguagens. A criação do plugin no sistema Luar-X exige apenas a existência de um arquivo denominado interface.lua no diretório padrão desse plugin. Nesse arquivo, deverá existir a variável description com a descrição e todas as informações necessárias para o desenvolvedor fazer uso do plugin. Essa descrição é uma documentação rápida do plugin para o desenvolvedor. O arquivo também deverá ter a função executePlugin() para o núcleo do kernel Luar-X executar o plugin. A utilização do plugin pelo desenvolvedor é realizada pela escrita do código entre as tags delimitadoras <?plugin ?>. O código escrito entre essas tags é definido pelo desenvolvedor de acordo com a descrição obtida na documentação rápida do plugin e será processado por esse plugin. Entre as tags ainda se faz necessário que o usuário indique o plugin que está sendo utilizando pela função usePlugin(). O Código 4.8 apresenta um exemplo do uso de um plugin que realiza o processamento da combinação da linguagem JavaScript com a XML. 1 2 3 4 5 6 7 8 9. </head> </body> <port id="pStart" component="slide1" /> <?plugin <? usePlugin(’luarx-js_processor’) ?> for(var i=0; i<5; i++){ write(’<media id="slide’+i+’" src="’+slides[i]+’" descriptor="dSlide" />’) } ?>. Código 4.8: Exemplo do uso de um plugin no Luar-X Na criação dos plugins o desenvolvedor possui a liberdade de usar a estrutura do sistema Luar-X, como o arquivo config.lrx, para um acesso global de variáveis. Os plugins podem processar modelos, vídeos, áudio, imagens ou outros arquivos apontados nos links.

(42) CAPÍTULO 4. SISTEMA DE PROCESSAMENTO DE MODELOS LUAR-X. 27. XML. O repositório Luar-X contém os plugins compartilhados que podem ser acessados por toda a comunidade de desenvolvedores. O respositório de plugins e a biblioteca de modelos estão disponíveis no portal Luar-X.. 4.5. Portal Luar-X. O Portal Luar-X é um serviço Web que agrega a biblioteca de modelos e o repositório de plugins. A biblioteca de modelos é responsável por agregar e manter coleções de modelos que são criadas e compartilhadas pelos autores de modelos. A partir desse portal, os autores podem disponibilizar e ter acesso a novos modelos, utilizando-os na autoria de novos documentos XML. O repositório de plugins possui a função de guardar e ser um ponto de compartilhamento e acesso dos plugins desenvolvidos pela comunidade. O Portal permite a divulgação e o acesso a todas as informações e tecnologias relacionadas ao sistema de processamento de modelos Luar-X. No portal é possível categorizar o modelo e o plugin, descrever suas funcionalidades de forma textual ou visual, imagens e vídeos, e mantê-los como coleções. Outros autores podem buscar, visualizar e realizar o download dos modelos pelo portal ou utilizando o kernel Luar-X, que adicionará o modelo ou o plugin em sua biblioteca local. Ainda é possível que os autores qualifiquem os modelos para que a comunidade de autores identifiquem os mais adequados às suas necessidades. LUAR. Diogo Henrique. Luar-X Template Engine. Account | Logout. +. LSlideShow Template Type Template - Complete. Author Diogo Henrique. Category Presenters. Description O template LSlideShow cria um passador de slides. O autor deverá informar apenas as imagens para os slides desejados.. Images Video. Classification. Figura 4.3: Portal Luar-X.

(43) Capítulo 5 Resultados. Neste capítulo são apresentados estudos de caso de utilização do sistema Luar-X com diferentes linguagens baseadas em XML.. 5.1. Estudos de Caso. Os estudos de caso foram realizados com o objetivo de validar o uso do sistema Luar-X com diferentes linguagens baseadas em XML. As linguagens foram escolhidas de acordo com o auxílio no processo de desenvolvimento que o sistema Luar-X pode promover: economia de código; padronização; mecanismo de tradução entre linguagens distintas e diferentes propriedades providas pelos plugins.. 5.1.1. XHTML. A XHTML é uma reformulação da HTML, linguagem de marcação da Web, para seguir as regras XML. Os modelos Luar-X para o XHTML reduzem o esforço repetitivo de codificação em alguns trechos do código, como a criação de tabelas extensas, e podem definir padrões de interface que são reaproveitadas pelo desenvolvedor. O estudo de caso realizado com XHTML consistiu em usar um modelo componente para criação de tabelas e um modelo completo para criação de um página Web completa. A Figura 5.1 apresenta a imagem da página Web com uma tabela simples usada no estudo de caso, o Código 5.1 descreve a tabela..

(44) CAPÍTULO 5. RESULTADOS. 29. Figura 5.1: Imagem de uma página XHTML com uma tabela simples 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26. <table border="1"> <tr> <th> Liguagem XML </th> <th> Ano de Criação </th> </tr> <tr> <td> XHTML </td> <td> 2002 </td> </tr> <tr> <td> SVG </td> <td> 1999 </td> </tr> <tr> <td> NCL </td> <td> 2000 </td> </tr> <tr> <td> XSIL </td> <td> 1999 </td> </tr> <tr> <td> RDF </td> <td> 1998 </td> </tr> </table>. Código 5.1: Código de uma tabela simples em XHTML O Código 5.1 apresenta uma tabela clássica e didática em XHTML. A descrição de uma tabela em XHTML possui muitas repetições. A estrutura de colunas e linhas possui tal característica, chegando a utilizar vinte e seis linhas de código para a descrição de uma tabela com duas colunas e seis linhas. O Código 5.2 apresenta a descrição da mesma tabela ao se utilizar o sistema Luar-X com o modelo componente LTableXHTML..

(45) CAPÍTULO 5. RESULTADOS. 1 2 3 4 5 6 7 8 9 10. 30. table = { header = {"Linguagem XML","Ano de Criação"}, {"XHTML","2002"}, {"SVG","1999"}, {"NCL","2000"}, {"XSIL","1999"}, {"RDF","1998"}, } useTemplate(’LTableXHTML’). Código 5.2: Código de utilização do modelo componente LTableXHTML A utilização do sistema Luar-X para criação da mesma tabela utilizando o modelo componente LTableXHTML é mais legível e ágil do que a codificação puramente em XHTML. A legibilidade se dá pelo uso da linguagem Lua e sua principal estrutura de dados, a tabela. A agilidade é resultado da quantidade de apenas 10 linhas de código para a descrição da tabela XHTML. O estudo realizado mostra que é viável o uso de modelos componentes com XHTML. No estudo de caso em questão, foi desenvolvida ainda uma página Web utilizando o modelo completo. A página foi desenvolvida a partir do modelo LPersonalWebPageXHTML, que cria uma página pessoal..

(46) CAPÍTULO 5. RESULTADOS. Figura 5.2: Imagem de uma página XHTML. 31.