ts2famix 2.0.0 → 2.0.1

package/src/lib/famix/model/famix/parametric_class.ts

@@ -0,0 +1,49 @@
+import { Interface } from "./interface";
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Class } from "./class";
+import { ParameterType } from "./parameter_type";
+import { PrimitiveType } from "./primitive_type";
+
+export class ParametricClass extends Class {
+
+    private _genericParameters: Set<ParameterType> = new Set();
+
+    public addGenericParameter(genericParameter: ParameterType): void {
+        if (!this._genericParameters.has(genericParameter)) {
+            this._genericParameters.add(genericParameter);
+            genericParameter.parentGeneric = this;
+        }
+    }
+
+    clearGenericParameters(): void {
+        this._genericParameters.clear();
+    }
+
+    private _concreteParameters: Set<PrimitiveType | Class | Interface> = new Set();
+
+    public addConcreteParameter(concreteParameter: PrimitiveType | Class | Interface): void {
+        if (!this._concreteParameters.has(concreteParameter)) {
+            this._concreteParameters.add(concreteParameter);
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("ParametricClass", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("genericParameters", this.genericParameters);
+        exporter.addProperty("concreteParameters", this.concreteParameters);
+    }
+
+    get genericParameters(): Set<ParameterType> {
+        return this._genericParameters;
+    }
+
+    get concreteParameters(): Set<PrimitiveType | Class | Interface> {
+        return this._concreteParameters;
+    }
+}

package/src/lib/famix/model/famix/parametric_function.ts

@@ -0,0 +1,32 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Class } from "./class";
+import { Function } from "./function";
+import { Interface } from "./interface";
+import { PrimitiveType } from "./primitive_type";
+
+export class ParametricFunction extends Function {
+
+    private _concreteParameters: Set<PrimitiveType | Class | Interface> = new Set();
+
+    public addConcreteParameter(concreteParameter: PrimitiveType | Class | Interface): void {
+        if (!this._concreteParameters.has(concreteParameter)) {
+            this._concreteParameters.add(concreteParameter);
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("ParametricFunction", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("genericParameters", this.genericParameters);
+        exporter.addProperty("concreteParameters", this.concreteParameters);
+    }
+
+    get concreteParameters(): Set<PrimitiveType | Class | Interface> {
+        return this._concreteParameters;
+    }
+}

package/src/lib/famix/model/famix/parametric_interface.ts

@@ -0,0 +1,49 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Class } from "./class";
+import { Interface } from "./interface";
+import { ParameterType } from "./parameter_type";
+import { PrimitiveType } from "./primitive_type";
+
+export class ParametricInterface extends Interface {
+
+    private _genericParameters: Set<ParameterType> = new Set();
+
+    public addGenericParameter(genericParameter: ParameterType): void {
+        if (!this._genericParameters.has(genericParameter)) {
+            this._genericParameters.add(genericParameter);
+            genericParameter.parentGeneric = this;
+        }
+    }
+
+    clearGenericParameters(): void {
+        this._genericParameters.clear();
+    }
+
+    private _concreteParameters: Set<PrimitiveType | Class | Interface> = new Set();
+
+    public addConcreteParameter(concreteParameter: PrimitiveType | Class | Interface): void {
+        if (!this._concreteParameters.has(concreteParameter)) {
+            this._concreteParameters.add(concreteParameter);
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("ParametricInterface", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("genericParameters", this.genericParameters);
+        exporter.addProperty("concreteParameters", this.concreteParameters);
+    }
+
+    get genericParameters(): Set<ParameterType> {
+        return this._genericParameters;
+    }
+
+    get concreteParameters(): Set<PrimitiveType | Class | Interface> {
+        return this._concreteParameters;
+    }
+}

package/src/lib/famix/model/famix/parametric_method.ts

@@ -0,0 +1,32 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Class } from "./class";
+import { Interface } from "./interface";
+import { Method } from "./method";
+import { PrimitiveType } from "./primitive_type";
+
+export class ParametricMethod extends Method {
+
+    private _concreteParameters: Set<PrimitiveType | Class | Interface> = new Set();
+
+    public addConcreteParameter(concreteParameter: PrimitiveType | Class | Interface): void {
+        if (!this._concreteParameters.has(concreteParameter)) {
+            this._concreteParameters.add(concreteParameter);
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("ParametricMethod", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("genericParameters", this.genericParameters);
+        exporter.addProperty("concreteParameters", this.concreteParameters);
+    }
+
+    get concreteParameters(): Set<PrimitiveType | Class | Interface> {
+        return this._concreteParameters;
+    }
+}

package/src/lib/famix/model/famix/primitive_type.ts

@@ -0,0 +1,15 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+
+export class PrimitiveType extends Type {
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("PrimitiveType", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+    }
+}

package/src/lib/famix/model/famix/property.ts

@@ -0,0 +1,94 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Class } from "./class";
+import { Interface } from "./interface";
+import { StructuralEntity } from "./structural_entity";
+
+export type VisibilityTypes = "public" | "private" | "protected" | "";
+
+export class Property extends StructuralEntity {
+
+    private _isClassSide: boolean = false;
+
+    public get readOnly() {
+        return this._readOnly;
+    }
+
+    public set readOnly(value: boolean) {
+        this._readOnly = value;
+    }
+    private _readOnly: boolean = false;
+    private _parentEntity!: Class | Interface;
+
+    public get isDefinitelyAssigned() {
+        return this._isDefinitelyAssigned;
+    }
+
+    public set isDefinitelyAssigned(value: boolean) {
+        this._isDefinitelyAssigned = value;
+    }
+
+    public get isOptional() {
+        return this._isOptional;
+    }
+
+    public set isOptional(value: boolean) {
+        this._isOptional = value;
+    }
+
+    public get isJavaScriptPrivate() {
+        return this._isJavaScriptPrivate;
+    }
+
+    public set isJavaScriptPrivate(value: boolean) {
+        this._isJavaScriptPrivate = value;
+    }
+    private _isDefinitelyAssigned!: boolean;
+
+    private _isOptional!: boolean;
+
+    private _isJavaScriptPrivate!: boolean;
+
+    public get visibility() {
+        return this._visibility;
+    }
+
+    public set visibility(value: VisibilityTypes) {
+        this._visibility = value;
+    }
+
+    private _visibility: VisibilityTypes = "";
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Property", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("readOnly", this.readOnly);
+        exporter.addProperty("isClassSide", this.isClassSide);
+        exporter.addProperty("parentType", this.parentEntity);
+        exporter.addProperty("visibility", this.visibility);
+        exporter.addProperty("isDefinitelyAssigned", this.isDefinitelyAssigned);
+        exporter.addProperty("isOptional", this.isOptional);
+        exporter.addProperty("isJavaScriptPrivate", this.isJavaScriptPrivate);
+    }
+
+    get isClassSide() {
+        return this._isClassSide;
+    }
+
+    set isClassSide(isClassSide: boolean) {
+        this._isClassSide = isClassSide;
+    }
+
+    get parentEntity() {
+        return this._parentEntity;
+    }
+
+    set parentEntity(parentEntity: Class | Interface) {
+        this._parentEntity = parentEntity;
+        parentEntity.addProperty(this);
+    }
+}

package/src/lib/famix/model/famix/reference.ts

@@ -0,0 +1,40 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+import { ContainerEntity } from "./container_entity";
+import { Entity } from "./entity";
+
+export class Reference extends Entity {
+
+    private _source!: ContainerEntity;
+    private _target!: Type;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Reference", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("source", this.source);
+        exporter.addProperty("target", this.target);
+    }
+
+    get source() {
+        return this._source;
+    }
+
+    set source(source: ContainerEntity) {
+        this._source = source;
+        source.addOutgoingReference(this);
+    }
+
+    get target() {
+        return this._target;
+    }
+
+    set target(target: Type) {
+        this._target = target;
+        target.addIncomingReference(this);
+    }
+}

package/src/lib/famix/model/famix/scoping_entity.ts

@@ -0,0 +1,35 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { ContainerEntity } from "./container_entity";
+import { logger } from "../../../../analyze";
+import { Module } from "./module";
+
+export class ScopingEntity extends ContainerEntity {
+
+    private _modules: Set<Module> = new Set();
+
+    public addModule(childModule: Module): void {
+        if (!this._modules.has(childModule)) {
+            logger.debug("Adding module " + childModule.name + " to " + this.name);
+            this._modules.add(childModule);
+            childModule.parentScope = this;
+        } else {
+            logger.debug("Module " + childModule.name + " already added to " + this.name);
+        }
+    }
+
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("ScopingEntity", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        //    exporter.addProperty("namespaces", this.getModules());
+    }
+
+    get modules() {
+        return this._modules;
+    }
+}

package/src/lib/famix/model/famix/script_entity.ts

@@ -0,0 +1,34 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { ScopingEntity } from "./scoping_entity";
+
+export class ScriptEntity extends ScopingEntity {
+
+    private _numberOfLinesOfText!: number;
+    private _numberOfCharacters!: number;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("ScriptEntity", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+    }
+
+    get numberOfLinesOfText() {
+        return this._numberOfLinesOfText;
+    }
+
+    set numberOfLinesOfText(numberOfLinesOfText: number) {
+        this._numberOfLinesOfText = numberOfLinesOfText;
+    }
+
+    get numberOfCharacters() {
+        return this._numberOfCharacters;
+    }
+
+    set numberOfCharacters(numberOfCharacters: number) {
+        this._numberOfCharacters = numberOfCharacters;
+    }
+}

package/src/lib/famix/model/famix/source_anchor.ts

@@ -0,0 +1,30 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Entity } from "./entity";
+import { SourcedEntity } from "./sourced_entity";
+
+export class SourceAnchor extends Entity {
+
+    private _element!: SourcedEntity;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("SourceAnchor", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("element", this.element);
+    }
+
+    get element() {
+        return this._element;
+    }
+
+    set element(element: SourcedEntity) {
+        if (this._element === undefined) {
+            this._element = element;
+            element.sourceAnchor = this;
+        }
+    }
+}

package/src/lib/famix/model/famix/source_language.ts

@@ -0,0 +1,35 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Entity } from "./entity";
+import { SourcedEntity } from "./sourced_entity";
+
+export class SourceLanguage extends Entity {
+
+    private _sourcedEntities: Set<SourcedEntity> = new Set();
+
+    // name of the source language
+    get name(): string {
+        return "TypeScript";
+    }
+
+    public addSourcedEntity(sourcedEntity: SourcedEntity): void {
+        if (!this._sourcedEntities.has(sourcedEntity)) {
+            this._sourcedEntities.add(sourcedEntity);
+            sourcedEntity.declaredSourceLanguage = this;
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("SourceLanguage", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("sourcedEntities", this.sourcedEntities);
+    }
+
+    get sourcedEntities() {
+        return this._sourcedEntities;
+    }
+}

package/src/lib/famix/model/famix/sourced_entity.ts

@@ -0,0 +1,70 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { SourceLanguage } from "./source_language";
+import { Entity } from "./entity";
+import { Comment } from "./comment";
+import { SourceAnchor } from "./source_anchor";
+import { logger } from "../../../../analyze";
+
+export class SourcedEntity extends Entity {
+
+    private _isStub!: boolean;
+    private _sourceAnchor!: SourceAnchor;
+    private _comments: Set<Comment> = new Set();
+
+    public addComment(comment: Comment): void {
+        if (!this._comments.has(comment)) {
+            this._comments.add(comment);
+            comment.container = this;
+        } else {
+            logger.debug("Adding comment that is already in comments: " + comment.getJSON() + " to " + this.getJSON());
+        }
+    }
+
+    private _declaredSourceLanguage!: SourceLanguage;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("SourcedEntity", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("isStub", this.isStub);
+        exporter.addProperty("sourceAnchor", this.sourceAnchor);
+        exporter.addProperty("comments", this.comments);
+        exporter.addProperty("declaredSourceLanguage", this.declaredSourceLanguage);
+    }
+
+    get isStub() {
+        return this._isStub;
+    }
+
+    set isStub(isStub: boolean) {
+        this._isStub = isStub;
+    }
+
+    get sourceAnchor() {
+        return this._sourceAnchor;
+    }
+
+    set sourceAnchor(sourceAnchor: SourceAnchor) {
+        if (this._sourceAnchor === undefined) {
+            this._sourceAnchor = sourceAnchor;
+            sourceAnchor.element = this;
+        }
+    }
+
+    get comments() {
+        return this._comments;
+    }
+
+    get declaredSourceLanguage() {
+        return this._declaredSourceLanguage;
+    }
+
+    set declaredSourceLanguage(declaredSourceLanguage: SourceLanguage) {
+        this._declaredSourceLanguage = declaredSourceLanguage;
+        declaredSourceLanguage.addSourcedEntity(this);
+    }
+}

package/src/lib/famix/model/famix/structural_entity.ts

@@ -0,0 +1,43 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+import { Access } from "./access";
+import { NamedEntity } from "./named_entity";
+
+export class StructuralEntity extends NamedEntity {
+
+    private _incomingAccesses: Set<Access> = new Set();
+
+    public addIncomingAccess(incomingAccess: Access): void {
+        if (!this._incomingAccesses.has(incomingAccess)) {
+            this._incomingAccesses.add(incomingAccess);
+            incomingAccess.variable = this;
+        }
+    }
+
+    private _declaredType!: Type;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("StructuralEntity", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("incomingAccesses", this.incomingAccesses);
+        exporter.addProperty("declaredType", this.declaredType);
+    }
+
+    get incomingAccesses() {
+        return this._incomingAccesses;
+    }
+
+    get declaredType() {
+        return this._declaredType;
+    }
+
+    set declaredType(declaredType: Type) {
+        this._declaredType = declaredType;
+        declaredType.addStructureWithDeclaredType(this);
+    }
+}

package/src/lib/famix/model/famix/type.ts

@@ -0,0 +1,87 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { StructuralEntity } from "./structural_entity";
+import { ContainerEntity } from "./container_entity";
+import { Reference } from "./reference";
+import { BehavioralEntity } from "./behavioral_entity";
+import { Alias } from "./alias";
+
+export class Type extends ContainerEntity {
+
+    private _container!: ContainerEntity;
+    private _typeAliases: Set<Alias> = new Set();
+
+    public addTypeAlias(typeAlias: Alias): void {
+        if (!this._typeAliases.has(typeAlias)) {
+            this._typeAliases.add(typeAlias);
+            typeAlias.aliasedEntity = this;
+        }
+    }
+
+    private _structuresWithDeclaredType: Set<StructuralEntity> = new Set();
+
+    public addStructureWithDeclaredType(structureWithDeclaredType: StructuralEntity): void {
+        if (!this._structuresWithDeclaredType.has(structureWithDeclaredType)) {
+            this._structuresWithDeclaredType.add(structureWithDeclaredType);
+            structureWithDeclaredType.declaredType = this;
+        }
+    }
+
+    private _behavioralEntitiesWithDeclaredType: Set<BehavioralEntity> = new Set();
+
+    public addBehavioralEntityWithDeclaredType(behavioralEntityWithDeclaredType: BehavioralEntity): void {
+        if (!this._behavioralEntitiesWithDeclaredType.has(behavioralEntityWithDeclaredType)) {
+            this._behavioralEntitiesWithDeclaredType.add(behavioralEntityWithDeclaredType);
+            behavioralEntityWithDeclaredType.declaredType = this;
+        }
+    }
+
+    private _incomingReferences: Set<Reference> = new Set();
+
+    public addIncomingReference(incomingReference: Reference): void {
+        if (!this._incomingReferences.has(incomingReference)) {
+            this._incomingReferences.add(incomingReference);
+            incomingReference.target = this;
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Type", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("typeContainer", this.container);
+        /* unsupported properties in MM so far */
+        // exporter.addProperty("typeAliases", this.getTypeAliases());
+        // exporter.addProperty("structuresWithDeclaredType", this.getStructuresWithDeclaredType());
+        // exporter.addProperty("behavioralEntitiesWithDeclaredType", this.getBehavioralEntitiesWithDeclaredType());
+        exporter.addProperty("incomingReferences", this.incomingReferences);
+    }
+
+    get container() {
+        return this._container;
+    }
+
+    set container(container: ContainerEntity) {
+        this._container = container;
+        container.addType(this);
+    }
+
+    get typeAliases() {
+        return this._typeAliases;
+    }
+
+    get structuresWithDeclaredType() {
+        return this._structuresWithDeclaredType;
+    }
+
+    get behavioralEntitiesWithDeclaredType() {
+        return this._behavioralEntitiesWithDeclaredType;
+    }
+
+    get incomingReferences() {
+        return this._incomingReferences;
+    }
+}

package/src/lib/famix/model/famix/variable.ts

@@ -0,0 +1,27 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { ContainerEntity } from "./container_entity";
+import { StructuralEntity } from "./structural_entity";
+
+export class Variable extends StructuralEntity {
+
+    private _parentContainerEntity!: ContainerEntity;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Variable", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("parentBehaviouralEntity", this.parentContainerEntity);
+    }
+
+    get parentContainerEntity() {
+        return this._parentContainerEntity;
+    }
+
+    set parentContainerEntity(parentContainerEntity: ContainerEntity) {
+        this._parentContainerEntity = parentContainerEntity;
+    }
+}