Merge pull request #13 from PanJarda/master

Added RiotTagCodeGenerator

CodeGenerators/RiotTagCodeGenerator.js

@@ -0,0 +1,279 @@
+/**
+ * Created by PanJarda on 06-25-2016.
+ */
+
+define(function (require, exports, module) {
+
+	var CodeGenerator = require("CodeGenerators/CodeGenerator").CodeGenerator;
+
+	function RiotTagCodeGenerator(options) {
+
+		this.tabSize = options.indentSpaces || 4;
+		console.log(options)
+		this.comments = options.comments;
+
+	}
+
+	RiotTagCodeGenerator.prototype = new CodeGenerator();
+
+	RiotTagCodeGenerator.prototype.getFileName = function(fileName, withExtension){
+		var extension = "";
+		if (withExtension) {
+			extension = ".tag";
+		}
+		return fileName + extension;
+	};
+
+  RiotTagCodeGenerator.prototype.matchDocPattern = function(node){
+	return(node.replace("\n", "\n*" + this.getTab()) + "\n");
+  }
+
+	RiotTagCodeGenerator.prototype.getMethodDocumentation = function (op) {
+
+		console.log(this.comments)
+
+		if (!this.comments)
+			return ""
+
+		console.log('ahoj')
+
+		var s = ""
+
+		s += "\n" + this.getTab() + "/**\n"
+
+		s += this.getTab() + " * @method " + op.name + "\n"
+
+		if (op.documentation && op.documentation !== "")
+			s += this.getTab() + " * @documentation: " + this.matchDocPattern(op.documentation)
+
+		if (op.specification && op.specification !== "")
+			s += this.getTab() + " * @specification: " + this.matchDocPattern(op.specification)
+
+		s += this.getDocumentationParameters(op);
+		s += this.getTab() + " */\n";
+
+		return s;
+	};
+
+  RiotTagCodeGenerator.prototype.getDocumentationParameters = function(op) {
+
+	var parametersString = "";
+
+	var parametersLength = op.parameters.length;
+
+	for (var p = 0; p < parametersLength; p++) {
+
+	  	var parameter = op.parameters[p];
+
+		switch(parameter.direction){
+			case "return":
+				parametersString += this.getTab() + " * @return ";
+				break;
+
+			case "in":
+				parametersString += this.getTab() + " * @param ";
+				break;
+		}
+
+		parametersString += parameter.name;
+
+		if (parameter.type)
+			parametersString += " {" + parameter.type.toString() + "} "
+
+		parametersString += this.matchDocPattern(parameter.documentation)
+	}
+
+	return parametersString;
+  };
+
+	RiotTagCodeGenerator.prototype.getDependencies = function (elem) {
+
+		if (!elem || !elem.ownedElements || !elem.ownedElements.length) {
+
+			return "";
+		}
+
+		var s = "";
+
+		var ownedElementsLength = elem.ownedElements.length;
+
+		for (var i = 0; i < ownedElementsLength; i++) {
+
+			var ownedElement = elem.ownedElements[i];
+
+			if (ownedElement instanceof type.UMLGeneralization) {
+
+				if (ownedElement.target instanceof type.UMLClass) {
+
+					s += "require('./" + ownedElement.target.name + ".tag')\n";
+				}
+
+			} else if (this.validUMLAssociation(ownedElement)) {
+
+				s += "require('./" + ownedElement.end1.name + ".tag')\n";
+
+			} else if ( ownedElement instanceof type.UMLDependency &&
+					ownedElement.target instanceof type.UMLClass &&
+					ownedElement.target.name){
+
+				s += "require('./" + ownedElement.target.name + ".tag')\n";
+
+			}
+		}
+
+		return s;
+
+	};
+  RiotTagCodeGenerator.prototype.validUMLAssociation = function(elem) {
+
+	return  elem instanceof type.UMLAssociation &&
+		elem.end1 instanceof type.UMLAssociationEnd &&
+		elem.end2 instanceof type.UMLAssociationEnd &&
+		elem.end2.reference instanceof type.UMLClass &&
+		elem.end1.name !== "" &&
+		elem.end2.reference.name !== "";
+  }
+
+	RiotTagCodeGenerator.prototype.getOperation = function (elem, op) {
+
+		var s = "";
+
+		s += this.getMethodDocumentation(op);
+
+		//function name
+		s += this.getTab() + op.name + "(" + this.getOperationParams(op) + ") {";
+
+		//end function
+		if (elem.isAbstract) {
+			s += "\n" + this.getTab() + "throw 'AbstractMethodNotImplementedError';\n\n" + this.getTab() + "}\n\n";
+		} else {
+			s += "\n" + this.getTab() + this.getTab() + "//TODO: Implement Me \n\n" + this.getTab() + "}\n\n";
+		}
+
+		return s;
+	};
+
+	RiotTagCodeGenerator.prototype.getAttributeDefinitions = function (elem) {
+
+		var s = ""
+
+		if (!elem || !elem.attributes || !elem.attributes.length)
+			return s
+
+
+		var tags = elem.ownedElements
+
+		tags.forEach(function(tag) {
+
+			if (this.validUMLAssociation(tag))
+				s += this.getTab() + "<" + tag.end1.name + "/>\n"
+
+		}, this)
+
+
+		var attrs = elem.attributes
+
+		attrs.forEach(function(attr) {
+
+			if (this.comments && (attr.documentation || attr.type)) {
+				s += "\n" + this.getTab() + "/**\n"
+
+				if (attr.documentation)
+					s += this.getTab() + " * " + attr.documentation + "\n"
+
+				if (attr.type)
+					s += this.getTab() + " * @type {" + attr.type.toString() + "}\n"
+
+				s += this.getTab() + " */\n"
+			}
+
+			s += this.getTab() + "this." + attr.name + " = "
+			s += (attr.defaultValue ? attr.defaultValue : 'null') + "\n"
+
+		}, this)
+
+		s += "\n"
+
+		return s;
+
+	};
+
+	RiotTagCodeGenerator.prototype.getInheritance = function (elem) {
+
+		if (!elem || !elem.ownedElements || !elem.ownedElements.length) {
+
+			return "";
+		}
+
+		var s = "";
+
+		for (var i = 0; i < elem.ownedElements.length; i++) {
+
+			if (elem.ownedElements[i] instanceof type.UMLGeneralization) {
+
+				if (elem.ownedElements[i].target instanceof type.UMLClass) {
+
+					s += this.getTab() + "<" + elem.ownedElements[i].target.name + "/>\n";
+				}
+			}
+		}
+
+		s += "\n";
+
+		return s;
+	};
+
+
+    RiotTagCodeGenerator.prototype.getHeader = function (elem) {
+
+    	if (!this.comments) return "";
+
+        var now = new Date();
+        var s = "";
+
+        s += "/**\n";
+        s += " * Generated On: "+ now.getFullYear()+"-"+(now.getMonth()+1)+"-"+now.getDate()+"\n";
+        s += " * Tag: " + elem.name+"\n";
+
+        if(elem.documentation && elem.documentation !== "")
+            s += " * Description: "+elem.documentation.replace("\n", "\n* ")+"\n";
+
+        s += " */\n\n";
+
+        return s;
+
+    };
+
+	RiotTagCodeGenerator.prototype.getClassDefinition = function (elem) {
+
+		var s = "";
+
+		s += this.getDependencies(elem);
+
+		s += "<" + elem.name + ">\n";
+
+		s += this.getInheritance(elem);
+
+		s += this.getAttributeDefinitions(elem);
+
+		s += this.getOperations(elem);
+
+		s += "</" + elem.name + ">\n";
+
+		return s;
+	};
+
+
+	RiotTagCodeGenerator.prototype.generate = function (elem) {
+
+		var s = "";
+
+		s += this.getHeader(elem);
+
+		s += this.getClassDefinition(elem);
+
+		return s;
+	};
+
+	exports.RiotTagCodeGenerator = RiotTagCodeGenerator;
+});

JSCodeGenerator.js

@@ -15,6 +15,7 @@ define(function (require, exports, module) {
     var MongooseCodeGenerator = require("CodeGenerators/MongooseCodeGenerator").MongooseCodeGenerator;
 	var EmberDSCodeGenerator = require("CodeGenerators/EmberDSCodeGenerator").EmberDSCodeGenerator;
     var ES2015CodeGenerator = require("CodeGenerators/ES2015CodeGenerator").ES2015CodeGenerator;
+    var RiotTagCodeGenerator = require("CodeGenerators/RiotTagCodeGenerator").RiotTagCodeGenerator;
 
     /**
      *
@@ -138,6 +139,10 @@ define(function (require, exports, module) {
 				case "es2015":
                     generator = new ES2015CodeGenerator(options);
                     break;
+                case "riot":
+                    generator = new RiotTagCodeGenerator(options);
+                    break;
+
            }
            console.log(generator);
            return generator;

JavaScriptConfigure.js

@@ -35,7 +35,8 @@ define(function (require, exports, module) {
                 {value: "functional", text: "functional"},
                 {value: "mongoose", text: "mongoose"},
 				{value: "ember", text: "ember"},
-                {value: "es2015", text: "es2015"}],
+                {value: "es2015", text: "es2015"},
+                {value: "riot", text: "riot"}],
             default    : {value: "es2015", text: "es2015"}
         },
         "javascript.gen.indentSpaces": {
@@ -44,6 +45,12 @@ define(function (require, exports, module) {
             type       : "Number",
             default    : 4
         },
+        "javascript.gen.comments": {
+            text       : "Generate comments",
+            description: "Generate comments in JSDoc style.",
+            type       : "Check",
+            default    : false
+        },
         "javascript.gen.generateUnitTests": {
             text       : "Generate Unit Tests",
             description: "Generate unit tests using Mocha unit test framework",