ts2famix 1.4.1 → 2.0.1

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

@@ -0,0 +1,89 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { BehavioralEntity } from "./behavioral_entity";
+import { Class } from "./class";
+import { Interface } from "./interface";
+
+export class Method extends BehavioralEntity {
+
+  private _parentEntity!: Class | Interface;
+  private _kind!: string;
+  private _isAbstract!: boolean;
+  private _isClassSide!: boolean;
+  private _isPrivate!: boolean;
+  private _isPublic!: boolean;
+  private _isProtected!: boolean;
+
+  public getJSON(): string {
+    const json: FamixJSONExporter = new FamixJSONExporter("Method", this);
+    this.addPropertiesToExporter(json);
+    return json.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("parentType", this.parentEntity);
+    exporter.addProperty("kind", this.kind);
+    exporter.addProperty("isAbstract", this.isAbstract);
+    exporter.addProperty("isClassSide", this.isClassSide);
+    exporter.addProperty("isPrivate", this.isPrivate);
+    exporter.addProperty("isPublic", this.isPublic);
+    exporter.addProperty("isProtected", this.isProtected);
+  }
+
+    get parentEntity() {
+        return this._parentEntity;
+    }
+
+    set parentEntity(parentEntity: Class | Interface) {
+        this._parentEntity = parentEntity;
+        parentEntity.addMethod(this);
+    }
+
+    get kind() {
+        return this._kind;
+    }
+
+    set kind(kind: string) {
+        this._kind = kind;
+    }
+
+    get isAbstract() {
+        return this._isAbstract;
+    }
+
+    set isAbstract(isAbstract: boolean) {
+        this._isAbstract = isAbstract;
+    }
+
+    get isClassSide() {
+        return this._isClassSide;
+    }
+
+    set isClassSide(isClassSide: boolean) {
+        this._isClassSide = isClassSide;
+    }
+
+    get isPrivate() {
+        return this._isPrivate;
+    }
+
+    set isPrivate(isPrivate: boolean) {
+        this._isPrivate = isPrivate;
+    }
+
+    get isPublic() {
+        return this._isPublic;
+    }
+
+    set isPublic(isPublic: boolean) {
+        this._isPublic = isPublic;
+    }
+
+    get isProtected() {
+        return this._isProtected;
+    }
+
+    set isProtected(isProtected: boolean) {
+        this._isProtected = isProtected;
+    }
+}

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

@@ -0,0 +1,71 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { ImportClause } from "./import_clause";
+import { ScopingEntity } from "./scoping_entity";
+import { ScriptEntity } from "./script_entity";
+
+export class Module extends ScriptEntity {
+
+    public get isAmbient() {
+        return this._isAmbient;
+    }
+
+    public set isAmbient(value: boolean) {
+        this._isAmbient = value;
+    }
+
+    private _isAmbient: boolean = false;
+
+    public get isNamespace() {
+        return this._isNamespace;
+    }
+
+    public set isNamespace(value: boolean) {
+        this._isNamespace = value;
+    }
+    private _isNamespace: boolean = false;
+
+    public get isModule() {
+        return this._isModule;
+    }
+
+    public set isModule(value: boolean) {
+        this._isModule = value;
+    }
+
+    private _isModule: boolean = true;
+
+    private _parentScope!: ScopingEntity;
+    // incomingImports are in NamedEntity
+    private _outgoingImports: Set<ImportClause> = new Set();
+
+    addOutgoingImport(importClause: ImportClause) {
+        if (!this._outgoingImports.has(importClause)) {
+            this._outgoingImports.add(importClause);
+            importClause.importingEntity = this;  // opposite
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Module", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("outgoingImports", this.outgoingImports);
+    }
+
+    get parentScope() {
+        return this._parentScope;
+    }
+
+    set parentScope(parentScope: ScopingEntity) {
+        this._parentScope = parentScope;
+        parentScope.addModule(this);
+    }
+
+    get outgoingImports() {
+        return this._outgoingImports;
+    }
+}

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

@@ -0,0 +1,95 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { SourcedEntity } from "./sourced_entity";
+import { Invocation } from "./invocation";
+import { ImportClause } from "./import_clause";
+import { Alias } from "./alias";
+import { Decorator } from "./decorator";
+
+export class NamedEntity extends SourcedEntity {
+
+    private _fullyQualifiedName!: string;
+    private _receivedInvocations: Set<Invocation> = new Set();
+
+    public addReceivedInvocation(receivedInvocation: Invocation): void {
+        if (!this._receivedInvocations.has(receivedInvocation)) {
+            this._receivedInvocations.add(receivedInvocation);
+            receivedInvocation.receiver = this;
+        }
+    }
+
+    private _incomingImports: Set<ImportClause> = new Set();
+
+    public addIncomingImport(anImport: ImportClause): void {
+        if (!this._incomingImports.has(anImport)) {
+            this._incomingImports.add(anImport);
+            anImport.importedEntity = this;  // opposite
+        }
+    }
+
+    private _name!: string;
+    private _aliases: Set<Alias> = new Set();
+
+    public addAlias(alias: Alias): void {
+        if (!this._aliases.has(alias)) {
+            this._aliases.add(alias);
+            alias.parentEntity = this;
+        }
+    }
+
+    private _decorators: Set<Decorator> = new Set();
+
+    public addDecorator(decorator: Decorator): void {
+        if (!this._decorators.has(decorator)) {
+            this._decorators.add(decorator);
+            decorator.decoratedEntity = this;
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("NamedEntity", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        // exporter.addProperty("fullyQualifiedName", this.getFullyQualifiedName());
+        // exporter.addProperty("incomingInvocations", this.getReceivedInvocations());
+        exporter.addProperty("incomingImports", this.incomingImports);
+        exporter.addProperty("name", this.name);
+        // exporter.addProperty("aliases", this.getAliases());  /* since these generate Unknown property messages */
+        exporter.addProperty("decorators", this.decorators);
+    }
+
+    get fullyQualifiedName() {
+        return this._fullyQualifiedName;
+    }
+
+    set fullyQualifiedName(fullyQualifiedName: string) {
+        this._fullyQualifiedName = fullyQualifiedName;
+    }
+
+    get receivedInvocations() {
+        return this._receivedInvocations;
+    }
+
+    get incomingImports() {
+        return this._incomingImports;
+    }
+
+    get name() {
+        return this._name;
+    }
+
+    set name(name: string) {
+        this._name = name;
+    }
+
+    get aliases() {
+        return this._aliases;
+    }
+
+    get decorators() {
+        return this._decorators;
+    }
+}

package/src/lib/famix/{src/model → model}/famix/parameter.ts

@@ -4,17 +4,7 @@ import { BehavioralEntity } from "./behavioral_entity";
 
 export class Parameter extends StructuralEntity {
 
-  private parentEntity: BehavioralEntity;
-
-  public getParentEntity(): BehavioralEntity {
-    return this.parentEntity;
-  }
-
-  public setParentEntity(parentEntity: BehavioralEntity): void {
-    this.parentEntity = parentEntity;
-    parentEntity.addParameter(this);
-  }
-
+  private _parentEntity!: BehavioralEntity;
 
   public getJSON(): string {
     const json: FamixJSONExporter = new FamixJSONExporter("Parameter", this);
@@ -24,6 +14,15 @@ export class Parameter extends StructuralEntity {
 
   public addPropertiesToExporter(exporter: FamixJSONExporter): void {
     super.addPropertiesToExporter(exporter);
-    exporter.addProperty("parentEntity", this.getParentEntity());
+    exporter.addProperty("parentBehaviouralEntity", this.parentEntity);
   }
+
+    get parentEntity() {
+        return this._parentEntity;
+    }
+
+    set parentEntity(parentEntity: BehavioralEntity) {
+        this._parentEntity = parentEntity;
+        parentEntity.addParameter(this);
+    }
 }

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

@@ -0,0 +1,51 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Concretisation } from "./concretisation";
+import { Entity } from "./entity";
+import { ParameterType } from "./parameter_type";
+import { PrimitiveType } from "./primitive_type";
+
+export class ParameterConcretisation extends Entity {
+
+    private _genericParameter!: ParameterType;
+    private _concreteParameter!: PrimitiveType;
+    private _concretisations: Set<Concretisation> = new Set();
+
+    public addConcretisation(concretisation: Concretisation): void {
+      if (!this._concretisations.has(concretisation)) {
+        this._concretisations.add(concretisation);
+      }
+    }
+  
+    public getJSON(): string {
+      const json: FamixJSONExporter = new FamixJSONExporter("ParameterConcretisation", this);
+      this.addPropertiesToExporter(json);
+      return json.getJSON();
+    }
+  
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+      super.addPropertiesToExporter(exporter);
+      exporter.addProperty("genericEntity", this.genericParameter);
+      exporter.addProperty("concreteEntity", this.concreteParameter);
+      exporter.addProperty("concretisations", this.concretisations);
+    }
+
+    get genericParameter() {
+        return this._genericParameter;
+    }
+
+    set genericParameter(genericEntity: ParameterType) {
+        this._genericParameter = genericEntity;
+    }
+
+    get concreteParameter() {
+        return this._concreteParameter;
+    }
+
+    set concreteParameter(concreteParameter: PrimitiveType) {
+        this._concreteParameter = concreteParameter;
+    }
+
+    get concretisations() {
+        return this._concretisations;
+    }
+}

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

@@ -0,0 +1,58 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+import { ParametricClass } from "./parametric_class";
+import { ParametricInterface } from "./parametric_interface";
+import { Method } from "./method";
+import { Function as FamixFunction } from "./function";
+import { Accessor } from "./accessor";
+import { ParametricMethod } from "./parametric_method";
+import { ParametricFunction } from "./parametric_function";
+import { ArrowFunction } from "./arrow_function";
+import { ParametricArrowFunction } from "./parametric_arrow_function";
+
+export class ParameterType extends Type {
+
+    private _parentGeneric!: ParametricClass | ParametricInterface | Method | ParametricMethod | Accessor | FamixFunction | ParametricFunction | ArrowFunction | ParametricArrowFunction;
+    private _baseType!: Type;
+    private _arguments: Set<Type> = new Set();
+
+    public addArgument(argument: Type): void {
+        if (!this._arguments.has(argument)) {
+            this._arguments.add(argument);
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("ParameterType", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("parentGeneric", this.parentGeneric);
+        exporter.addProperty("baseType", this.baseType);
+        exporter.addProperty("arguments", this.arguments);
+    }
+
+    get parentGeneric() {
+        return this._parentGeneric;
+    }
+
+    set parentGeneric(parentGeneric: ParametricClass | ParametricInterface | Method | ParametricMethod | Accessor | FamixFunction | ParametricFunction | ArrowFunction | ParametricArrowFunction) {
+        this._parentGeneric = parentGeneric;
+        parentGeneric.addGenericParameter(this);
+    }
+
+    get baseType() {
+        return this._baseType;
+    }
+
+    set baseType(baseType: Type) {
+        this._baseType = baseType;
+    }
+
+    get arguments() {
+        return this._arguments;
+    }
+}

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

@@ -0,0 +1,32 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { ArrowFunction } from "./arrow_function";
+import { Class } from "./class";
+import { Interface } from "./interface";
+import { PrimitiveType } from "./primitive_type";
+
+export class ParametricArrowFunction extends ArrowFunction {
+
+    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("ParametricArrowFunction", 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() {
+        return this._concreteParameters;
+    }
+}

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);
+    }
+}