Code Monkey home page Code Monkey logo

jettoumpletl's Introduction

Umple Modelling Language

Build Status

OS Linux Jenkins Windows Appveyor
Status Jenkins Linux Build status Windows Build status

Description

This is the main project for various Umple subprojects and components.

Umple is a model-oriented programming technology, allowing developers to embed modelling concepts (e.g. UML associations, state machines), patterns, generation templates, and other abstractions in traditional code, and vice versa. It generates high quality code for Java, C++ and PhP (Python in beta), as well as diagrams, metrics and many other artifacts. It can be embeded in the above languages as well as embed them.

The project homepage is located at https://umple.org/

There are a large number of scientific papers about Umple listed at: https://umple.org/publications

Cite the overall project as: Timothy C. Lethbridge, Andrew Forward, Omar Badreddin, Dusan Brestovansky, Miguel Garzon, Hamoud Aljamaan, Sultan Eid, Ahmed Husseini Orabi, Mahmoud Husseini Orabi, Vahdat Abdelzad, Opeyemi Adesina, Aliaa Alghamdi, Abdulaziz Algablan, Amid Zakariapour, "Umple: Model-Driven Development for Open Source and Education", Science of Computer Programming, 2021, https://doi.org/10.1016/j.scico.2021.102665.

Cite latest software release as: University of Ottawa, Umple, https://umple.org/releases https://doi.org/10.5281/zenodo.4677562 DOI

Development Process

Umple is developed in itself, guaranteeing robustness; the most recent version of the compiler must be used to compile itself. See the wiki for development setup: https://umple.org/devsetup

Development follows a model-driven, test-driven, agile, continuous-integration process. Umple is hosted currently on Github at https://umple.org/code . It was first released in 2007. The master was on Google Code from 2011 to mid 2015 and moved to Github in 2015.

Umple has been largely developed as a research project at the University of Ottawa, Canada, by numerous PhD and masters students. Many undergraduates from across Canada and the USA have also contributed through the UCOSP program. See the license file for the list of contributors. https://umple.org/license

Installation and Downloading

Umple does not need necessarily to be downloaded, the following allow you to run it directly in any web browser:

You can download the java jar for command-line use, or the Eclipse plugin:

  • Download page: https://umple.org/dl - Links to the latest official release and continuous builds (command-line, Eclipse, Docker)

To run locally on your machine, Umple needs Java (versions 8 and up although 17 is recommended) installed. It runs on Mac, Linux and Windows.

Usage

Umple is a programming and modeling language with a rich syntax. Full documentation with many examples can be found at

Other Key links

Umple is continuously tested and built on its own Jenkins server (see https://jenkins.umple.org) . It is also built on Appveyor (https://umple.org/appveyor/).

Contributing

License

Umple is licensed under the MIT license. See https://umple.org/license

Credits

All developers of Umple are listed in the license file at https://umple.org/license

Financial support has been received from NSERC and the Ontario Research Fund. IBM supported early development of Umple. Google and Facebook supported student travel during Umple's development.

Contents of the directories

The umple project is split into many smaller subprojects; the folder hierarchy is explained below to better describe the structure.

  • build/

    • Ant build scripts and related information including user manual raw data

  • cruise.umple/ Umple compiler

    • See its own ReadMe.txt for further details
    • See also UmpleTo* below for additional compiler components

  • cruise.umple.eclipse/, cruise.umple.xtext.ui/ Eclipse plugins

  • cruise.umplificator Converting outside code to Umple

    • cruise.umple.validator Validates umple when umplifying

  • cruise.umple.nebula Infrastructure used for real-time C++

  • dev-tools Tooling for Umple developers

  • dist Build produced items, only available after building

    • libs/ Managed build dependencies that umple.jar require to run*
    • cruise.umple/reference User manual
    • qa/ Test reports
    • umple.jar and umple.VERSION.jar Current command-line Compiler
    • umpledocs.VERSION.jar User manual generator
    • umplestats.VERSION.jar Statistics generation
    • umplesync.VERSION.jar UmpleOnline tool to to synchronize graphical form
    • umplerun.VERSION.jar tool to drive input to an umple program
    • vml.VERSION.jar * Extension for variability modeling*
    • umple.unit-test.jar Test Language Compiler
    • umple.mutation.jar Umple Mutant Generator

  • examples/ Developer curated examples

  • externalexamples/ External projects that are used for testing

  • ExternalTextEditorPlugins Plugins for external editors, Notepad++, etc

  • sandbox Small test done before a build to make sure testing and compiling works

  • testbed/, testbed_php/, testbed_ruby/ Test suites for Java, Php and Ruby respectively

  • UmpleToJava/ Code generation for Java

  • UmpleToPhp/ Code generation for Php

  • UmpleToRuby/ Code generation for Ruby

  • UmpleToRTCpp/ *Code generation for C++ *

  • UmpleToSDL/ Code generation to convert Umple to SDL (in early development)

  • UmpleToSql/ Code generation SQL from Umple models

  • UmpleToTest/ Code generation for abstract tests

  • UmpleToTemplate/ Location for templates that could be common to subprojects

  • UmpleTToJunit/ Code Generation for JUnit5 - used by MTL compiler

  • UmpleTToPhpunit/ Code Generation for PhpUnit - used by MTL compiler

  • UmpleTToRubyunit/ Code Generation for RubyUnit - used by MTL compiler

  • umpleonline/ The UmpleOnline web application

    • UmpleOnline allows generation of code from Umple directly in a web browser, and also editing of Umple both graphically and textually. Available at https://try.umple.org

  • Umplificator/ Reverse engineer code to Umple

  • umplificatoronline/ Online tool for converting code to Umple

  • umpleUI/ Projects for the UIGU tooling

    • Projects for generating a UI through UIGU from Umple. These need work to incorporate them into UmpleOnline

  • umplewww/ Core files from the Umple.org web pages

    • Includes items such as the user manual that are moved at build time into the appropriate place

jettoumpletl's People

Contributors

diusrex avatar nava2 avatar timlethbridge avatar vahdat-ab avatar

Stargazers

avatar avatar

Watchers

avatar avatar avatar avatar avatar avatar

Forkers

diusrex

jettoumpletl's Issues

JET Initial Directive can be multi-lined

Currently, the converter only supports having the directive be the first line of the file. JET does allow the directive to be multi-lined, so this should be handled.

Changes would need to be made to TemplateConverter and DirectiveParser for this to work.

Option to remove references to .jet in code block

In many of the Umple templates, like Java's association_set_specialization_reqSuperCode.ump, in the code blocks there are strings with `.jet'.

Since this references to JET could be confusing after conversion to Umple templates is complete, it would be a good idea to add an argument to the converter to remove .jet from strings, or convert it to .ump.

I do not think it would be possible to simply change/remove all references to .jet in code blocks since there could also be packages that contain .jet.

Extra spaces added for code block

In the case where regular text leads into a Code block, it is possible to add additional spaces to the template, in the format:

text....
   // Extraspaces
<% start of code ...

This may happen when the start of a code block from the text is:

text....
   <% start of code ...

This occurs because of the two special cases that can occur with text leading into a code block, both of which will add a newline. Since the text preceding the code block on the same line will be added even if one of the special cases occurs.

This will cause many tests to fail, so I will be adding it after the major refactoring pull request(s).

Extend main template identification

Like the README states, a main template is one which is expected to be compiled into a Java class which will be used. Therefore, a non-main template is one which is just used in other templates.

In the Umple project, all main templates were identified by .jumpjet, while all the regular templates were .jet. So the converter assumes that a file with the extension .jumpjet is a main template, while every other valid jet template is a regular template. However, other projects would likely use other ways to identify main templates.

Rather than force other project authors to adjust their templates, they should be allowed to pass different arguments to identify which templates may be main templates.

Some possible additions would include:

  • All templates
  • No templates (unlikely, but possible if there are multiple directories)
  • Templates that start with a given prefix
  • Templates that have a given suffix (not in their extension)
  • Templates that contain the given substring
  • Templates with a given extension (generalization of the current system)
  • Templates with a given package in their directive

As a further, probably unnecessary extension, it may be possible to use some heuristics to determine if a template is a main or standard template. Some ways to guess that a template is a regular template would be if there are multiple with the same package and class name (in their directive), templates with "Ignore" in their package or class name, etc.

Handle end of file better for PureText

For the JET templates that we used in Umple originally, some ended with a newline, while others didn't. (http://stackoverflow.com/questions/5813311/no-newline-at-end-of-file).

For example, the Java test template files association_AddImmutableUnidirectionalMany.jet does not have a newline at the end, while association_SetOptionalOneToMandatoryMany.jet does. The best way to see the difference is to view them in eclipse, where association_SetOptionalOneToMandatoryMany has a blank line at the end, but association_AddImmutableUnidirectionalMany doesn't. Then, contrast this with looking at them in Github (association_SetOptionalOneToMandatoryMany vs association_AddImmutableUnidirectionalMany

The issue that occurs is that, in JET, the newline at the end of the last line is counted as an additional newline. However, the Java parsing does not differentiate between a final line ending with a newline vs a final line ending with the EOF character. This means that when translating from JET to Umple, there are some inconsistencies between certain files.

This just needs to be handled for PureText parsing, in the special case started by if (line == null && containsOnlySpaces(previousLine)) {. Because of how many files are affected by this, it is possible that the relevant special case should not be kept, or will need to be vastly changed.

Please note that one difficulty with dealing with this issue is how vim (as well as possibly other editors) will automatically insert a newline at the end of the file, while Eclipse will not and instead displays it (so some files will appear to have an additional line at the end of the file).

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.