@yellicode/elements
Version:
The meta model API for Yellicode - an extensible code generator.
242 lines (241 loc) • 9.88 kB
JavaScript
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
import { PackagedElementTransform } from './packaged-element-transform';
import { NameUtility } from '@yellicode/core';
import { ElementTypeUtility } from '../utils';
// Note: using plural words here to avoid using reserved keywords.
/**
* Enumerates which element types to be renamed when performing rename transforms.
*/
export var RenameTargets;
(function (RenameTargets) {
/**
* No elements are renamed.
*/
RenameTargets[RenameTargets["none"] = 0] = "none";
/**
* Classes are renamed.
*/
RenameTargets[RenameTargets["classes"] = 1] = "classes";
/**
* Interfaces are renamed.
*/
RenameTargets[RenameTargets["interfaces"] = 2] = "interfaces";
/**
* Properties are renamed.
*/
RenameTargets[RenameTargets["properties"] = 4] = "properties";
/**
* Operations are renamed.
*/
RenameTargets[RenameTargets["operations"] = 8] = "operations";
/**
* Operation parameters are renamed.
*/
RenameTargets[RenameTargets["parameters"] = 16] = "parameters";
/**
* Enumerations are renamed.
*/
RenameTargets[RenameTargets["enumerations"] = 32] = "enumerations";
/**
* Enumeration literals are renamed.
*/
RenameTargets[RenameTargets["enumerationLiterals"] = 64] = "enumerationLiterals";
/**
* All members are renamed: properties, operations, parameters and enumerationLiterals.
*/
RenameTargets[RenameTargets["allMembers"] = 92] = "allMembers";
/**
* All elements are renamed.
*/
RenameTargets[RenameTargets["all"] = 127] = "all";
})(RenameTargets || (RenameTargets = {}));
/**
* A base class for renaming classes, interfaces, properties, operations parameters, enumerations and enumeration literals.
*/
var RenamingTransform = /** @class */ (function (_super) {
__extends(RenamingTransform, _super);
/**
* Constructor. Creates a new RenamingTransform with the specified targets.
* @param targets Optional: indicates which elements to rename. The default is RenameTargets.all.
*/
function RenamingTransform(targets) {
var _this = _super.call(this) || this;
_this.targets = targets == null ? RenameTargets.all : targets;
return _this;
}
RenamingTransform.prototype.hasTarget = function (target) {
if (this.targets & target)
return true;
else
return false;
};
RenamingTransform.prototype.transformElement = function (element) {
var _this = this;
if (!ElementTypeUtility.isMemberedClassifier(element.elementType))
return;
if (this.hasTarget(RenameTargets.classes) && ElementTypeUtility.isClass(element.elementType)) {
element.name = this.rename(element.name, element);
}
if (this.hasTarget(RenameTargets.interfaces) && ElementTypeUtility.isInterface(element.elementType)) {
element.name = this.rename(element.name, element);
}
// The element has OwnedAttributes and OwnedOperations
var classifier = element;
if (classifier.ownedAttributes != null && this.hasTarget(RenameTargets.properties)) {
classifier.ownedAttributes.forEach(function (att) {
att.name = _this.rename(att.name, att);
});
}
if (classifier.ownedOperations != null) {
classifier.ownedOperations.forEach(function (op) {
if (_this.hasTarget(RenameTargets.operations)) {
op.name = _this.rename(op.name, op);
}
if (_this.hasTarget(RenameTargets.parameters)) {
op.ownedParameters.forEach(function (p) {
p.name = _this.rename(p.name, p);
});
}
});
}
if (ElementTypeUtility.isEnumeration(element.elementType)) {
var enumeration = element;
if (this.hasTarget(RenameTargets.enumerations)) {
enumeration.name = this.rename(enumeration.name, enumeration);
}
if (enumeration.ownedLiterals != null && this.hasTarget(RenameTargets.enumerationLiterals)) {
enumeration.ownedLiterals.forEach(function (literal) {
literal.name = _this.rename(literal.name, literal);
});
}
}
};
return RenamingTransform;
}(PackagedElementTransform));
export { RenamingTransform };
/**
* A transform that capitalizes its rename targets, that is, makes the
* first character uppercase.
*/
var CapitalizingTransform = /** @class */ (function (_super) {
__extends(CapitalizingTransform, _super);
/**
* Constructor. Creates a new CapitalizingTransform with the specified targets.
* @param targets Optional: indicates which elements to rename. The default is RenameTargets.all.
*/
function CapitalizingTransform(targets) {
return _super.call(this, targets) || this;
}
CapitalizingTransform.prototype.rename = function (name, target) {
return NameUtility.capitalize(name);
};
return CapitalizingTransform;
}(RenamingTransform));
export { CapitalizingTransform };
/**
* A transform that uncapitalizes its rename targets, that is, makes the
* first character lowercase.
*/
var UnCapitalizingTransform = /** @class */ (function (_super) {
__extends(UnCapitalizingTransform, _super);
/**
* Constructor. Creates a new UnCapitalizingTransform with the specified targets.
* @param targets Optional: indicates which elements to rename. The default is RenameTargets.all.
*/
function UnCapitalizingTransform(targets) {
return _super.call(this, targets) || this;
}
UnCapitalizingTransform.prototype.rename = function (name, target) {
return NameUtility.unCapitalize(name);
};
return UnCapitalizingTransform;
}(RenamingTransform));
export { UnCapitalizingTransform };
/**
* A transform that converts its rename targets from UpperCamelCase to lowerCamelCase.
*/
var UpperToLowerCamelCaseTransform = /** @class */ (function (_super) {
__extends(UpperToLowerCamelCaseTransform, _super);
/**
* Constructor. Creates a new UpperToLowerCamelCaseTransform with the specified targets.
* @param targets Optional: indicates which elements to rename. The default is RenameTargets.all.
*/
function UpperToLowerCamelCaseTransform(targets) {
return _super.call(this, targets) || this;
}
UpperToLowerCamelCaseTransform.prototype.rename = function (name, target) {
return NameUtility.upperToLowerCamelCase(name);
};
return UpperToLowerCamelCaseTransform;
}(RenamingTransform));
export { UpperToLowerCamelCaseTransform };
/**
* A transform that converts its rename targets from lowerCamelCase to UpperCamelCase.
*/
var LowerToUpperCamelCaseTransform = /** @class */ (function (_super) {
__extends(LowerToUpperCamelCaseTransform, _super);
/**
* Constructor. Creates a new LowerToUpperCamelCaseTransform with the specified targets.
* @param targets Optional: indicates which elements to rename. The default is RenameTargets.all.
*/
function LowerToUpperCamelCaseTransform(targets) {
return _super.call(this, targets) || this;
}
LowerToUpperCamelCaseTransform.prototype.rename = function (name, target) {
return NameUtility.lowerToUpperCamelCase(name);
};
return LowerToUpperCamelCaseTransform;
}(RenamingTransform));
export { LowerToUpperCamelCaseTransform };
/**
* A transform that adds a prefix to its rename targets.
*/
var PrefixingTransform = /** @class */ (function (_super) {
__extends(PrefixingTransform, _super);
/**
* Constructor. Creates a new PrefixingTransform with the specified targets.
* @param targets Optional: indicates which elements to rename. The default is RenameTargets.all.
*/
function PrefixingTransform(targets, prefix) {
var _this = _super.call(this, targets) || this;
_this.prefix = prefix;
return _this;
}
PrefixingTransform.prototype.rename = function (name, target) {
return this.prefix + name;
};
return PrefixingTransform;
}(RenamingTransform));
export { PrefixingTransform };
/**
* A transform that adds a suffix to its rename targets.
*/
var SuffixingTransform = /** @class */ (function (_super) {
__extends(SuffixingTransform, _super);
/**
* Constructor. Creates a new SuffixingTransform with the specified targets.
* @param targets Optional: indicates which elements to rename. The default is RenameTargets.all.
*/
function SuffixingTransform(targets, suffix) {
var _this = _super.call(this, targets) || this;
_this.suffix = suffix;
return _this;
}
SuffixingTransform.prototype.rename = function (name, target) {
return name + this.suffix;
};
return SuffixingTransform;
}(RenamingTransform));
export { SuffixingTransform };