ts2famix 1.4.1 → 2.0.1

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

@@ -0,0 +1,40 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Entity } from "./entity";
+import { ParametricClass } from "./parametric_class";
+import { ParametricFunction } from "./parametric_function";
+import { ParametricInterface } from "./parametric_interface";
+import { ParametricMethod } from "./parametric_method";
+
+export class Concretisation extends Entity {
+
+    private _genericEntity!: ParametricClass | ParametricInterface | ParametricFunction | ParametricMethod;
+    private _concreteEntity!: ParametricClass | ParametricInterface | ParametricFunction | ParametricMethod;  // is this correct?
+
+    public getJSON(): string {
+      const json: FamixJSONExporter = new FamixJSONExporter("Concretisation", this);
+      this.addPropertiesToExporter(json);
+      return json.getJSON();
+    }
+  
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+      super.addPropertiesToExporter(exporter);
+      exporter.addProperty("genericEntity", this.genericEntity);
+      exporter.addProperty("concreteEntity", this.concreteEntity);
+    }
+
+    get genericEntity() {
+        return this._genericEntity;
+    }
+
+    set genericEntity(genericEntity: ParametricClass | ParametricInterface | ParametricFunction | ParametricMethod) {
+        this._genericEntity = genericEntity;
+    }
+
+    get concreteEntity() {
+        return this._concreteEntity;
+    }
+
+    set concreteEntity(concreteEntity: ParametricClass | ParametricInterface | ParametricFunction | ParametricMethod) {
+        this._concreteEntity = concreteEntity;
+    }
+}

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

@@ -0,0 +1,160 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+import { Invocation } from "./invocation";
+import { NamedEntity } from "./named_entity";
+import { Reference } from "./reference";
+import { Access } from "./access";
+import { Function as FamixFunctionEntity } from "./function";
+import { Variable } from "./variable";
+
+export class ContainerEntity extends NamedEntity {
+
+    private _parentContainerEntity!: ContainerEntity;
+    private _childrenContainerEntities: Set<ContainerEntity> = new Set();
+
+    public addChildContainerEntity(childContainerEntity: ContainerEntity): void {
+        if (!this._childrenContainerEntities.has(childContainerEntity)) {
+            this._childrenContainerEntities.add(childContainerEntity);
+            childContainerEntity.parentContainerEntity = this;
+        }
+    }
+
+    private _cyclomaticComplexity!: number;
+    private _numberOfStatements!: number;
+    private _outgoingReferences: Set<Reference> = new Set();
+
+    public addOutgoingReference(outgoingReference: Reference): void {
+        if (!this._outgoingReferences.has(outgoingReference)) {
+            this._outgoingReferences.add(outgoingReference);
+            outgoingReference.source = this;
+        }
+    }
+
+    private _numberOfLinesOfCode!: number;
+    private _outgoingInvocations: Set<Invocation> = new Set();
+
+    public addOutgoingInvocation(outgoingInvocation: Invocation): void {
+        if (!this._outgoingInvocations.has(outgoingInvocation)) {
+            this._outgoingInvocations.add(outgoingInvocation);
+            outgoingInvocation.sender = this;
+        }
+    }
+
+    private _accesses: Set<Access> = new Set();
+
+    public addAccess(access: Access): void {
+        if (!this._accesses.has(access)) {
+            this._accesses.add(access);
+            access.accessor = this;
+        }
+    }
+
+    private childrenTypes: Set<Type> = new Set();
+
+    public addType(childType: Type): void {
+        if (!this.childrenTypes.has(childType)) {
+            this.childrenTypes.add(childType);
+            childType.parentContainerEntity = this;
+        }
+    }
+
+    private childrenFunctions: Set<FamixFunctionEntity> = new Set();
+
+    public addFunction(childFunction: FamixFunctionEntity): void {
+        if (!this.childrenFunctions.has(childFunction)) {
+            this.childrenFunctions.add(childFunction);
+            childFunction.parentContainerEntity = this;
+        }
+    }
+
+    private _variables: Set<Variable> = new Set();
+
+    public addVariable(variable: Variable): void {
+        if (!this._variables.has(variable)) {
+            this._variables.add(variable);
+            variable.parentContainerEntity = this;
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("ContainerEntity", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        //    exporter.addProperty("parentBehaviouralEntity", this.getParentContainerEntity());
+        //    exporter.addProperty("childrenContainerEntities", this.getChildrenContainerEntities());
+        exporter.addProperty("cyclomaticComplexity", this.cyclomaticComplexity);
+        exporter.addProperty("numberOfStatements", this.numberOfStatements);
+        //    exporter.addProperty("outgoingReferences", this.getOutgoingReferences());  /* derived ?*/
+        exporter.addProperty("numberOfLinesOfCode", this.numberOfLinesOfCode);
+        //    exporter.addProperty("outgoingInvocations", this.getOutgoingInvocations());  /* derived ?*/
+        //    exporter.addProperty("accesses", this.getAccesses());  /* derived ?*/
+        exporter.addProperty("types", this.types);
+        exporter.addProperty("functions", this.functions);
+        exporter.addProperty("localVariables", this.variables);
+    }
+
+    get parentContainerEntity() {
+        return this._parentContainerEntity;
+    }
+
+    set parentContainerEntity(parentContainerEntity: ContainerEntity) {
+        this._parentContainerEntity = parentContainerEntity;
+        parentContainerEntity.addChildContainerEntity(this);
+    }
+
+    get childrenContainerEntities(): Set<ContainerEntity> {
+        return this._childrenContainerEntities;
+    }
+
+    get cyclomaticComplexity(): number {
+        return this._cyclomaticComplexity;
+    }
+
+    set cyclomaticComplexity(cyclomaticComplexity: number) {
+        this._cyclomaticComplexity = cyclomaticComplexity;
+    }
+
+    get numberOfStatements(): number {
+        return this._numberOfStatements;
+    }
+
+    set numberOfStatements(numberOfStatements: number) {
+        this._numberOfStatements = numberOfStatements;
+    }
+
+    get outgoingReferences() {
+        return this._outgoingReferences;
+    }
+
+    get numberOfLinesOfCode(): number {
+        return this._numberOfLinesOfCode;
+    }
+
+    set numberOfLinesOfCode(numberOfLinesOfCode: number) {
+        this._numberOfLinesOfCode = numberOfLinesOfCode;
+    }
+
+    get outgoingInvocations() {
+        return this._outgoingInvocations;
+    }
+
+    get accesses() {
+        return this._accesses;
+    }
+
+    get types() {
+        return this.childrenTypes;
+    }
+
+    get functions() {
+        return this.childrenFunctions;
+    }
+
+    get variables() {
+        return this._variables;
+    }
+}

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

@@ -0,0 +1,37 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { NamedEntity } from "./named_entity";
+
+export class Decorator extends NamedEntity {
+
+    private _decoratorExpression!: string;
+    private _decoratedEntity!: NamedEntity;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Decorator", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("expression", this.decoratorExpression);
+        exporter.addProperty("decoratedEntity", this.decoratedEntity);
+    }
+
+    get decoratorExpression(): string {
+        return this._decoratorExpression;
+    }
+
+    set decoratorExpression(decoratorExpression: string) {
+        this._decoratorExpression = decoratorExpression;
+    }
+
+    get decoratedEntity(): NamedEntity {
+        return this._decoratedEntity;
+    }
+
+    set decoratedEntity(decoratedEntity: NamedEntity) {
+        this._decoratedEntity = decoratedEntity;
+        decoratedEntity.addDecorator(this);
+    }
+}

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

@@ -0,0 +1,30 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+import { EnumValue } from "./enum_value";
+
+export class Enum extends Type {
+
+    private _values: Set<EnumValue> = new Set();
+
+    public addValue(value: EnumValue): void {
+        if (!this._values.has(value)) {
+            this._values.add(value);
+            value.parentEntity = this;
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Enum", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("enumValues", this.values);
+    }
+
+    get values() {
+        return this._values;
+    }
+}

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

@@ -0,0 +1,28 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { StructuralEntity } from "./structural_entity";
+import { Enum } from "./enum";
+
+export class EnumValue extends StructuralEntity {
+
+    private _parentEntity!: Enum;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("EnumValue", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("parentEnum", this.parentEntity);
+    }
+
+    get parentEntity(): Enum {
+        return this._parentEntity;
+    }
+
+    set parentEntity(parentEntity: Enum) {
+        this._parentEntity = parentEntity;
+        parentEntity.addValue(this);
+    }
+}

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

@@ -0,0 +1,51 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Entity } from "./entity";
+import { Module } from "./module";
+import { NamedEntity } from "./named_entity";
+
+export class ImportClause extends Entity {
+
+    private _importingEntity!: Module;
+    private _importedEntity!: NamedEntity;
+    private _moduleSpecifier!: string;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("ImportClause", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("importingEntity", this.importingEntity);
+        exporter.addProperty("importedEntity", this.importedEntity);
+        // unknown property below
+        //    exporter.addProperty("moduleSpecifier", this.getModuleSpecifier());
+    }
+
+    get importingEntity(): Module {
+        return this._importingEntity;
+    }
+
+    set importingEntity(importer: Module) {
+        this._importingEntity = importer;
+        importer.addOutgoingImport(this); // opposite
+    }
+
+    get importedEntity(): NamedEntity {
+        return this._importedEntity;
+    }
+
+    set importedEntity(importedEntity: NamedEntity) {
+        this._importedEntity = importedEntity;
+        importedEntity.addIncomingImport(this); // incomingImports in Famix TImportable/TImport
+    }
+
+    get moduleSpecifier(): string {
+        return this._moduleSpecifier;
+    }
+
+    set moduleSpecifier(moduleSpecifier: string) {
+        this._moduleSpecifier = moduleSpecifier;
+    }
+}

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

@@ -1,18 +1,17 @@
 export { Access } from "./access";
 export { Accessor } from "./accessor";
 export { Alias } from "./alias";
-export { Association } from "./association";
 export { BehavioralEntity } from "./behavioral_entity";
 export { Class } from "./class";
 export { Comment } from "./comment";
 export { ContainerEntity } from "./container_entity";
+export { Concretisation } from "./concretisation";
 export { Decorator } from "./decorator";
 export { Entity } from "./entity";
 export { EnumValue } from "./enum_value";
 export { Enum } from "./enum";
 export { Property } from "./property";
 export { Function } from "./function";
-export { ImplicitVariable } from "./implicit_variable";
 export { ImportClause } from "./import_clause";
 export { IndexedFileAnchor } from "./indexed_file_anchor";
 export { Inheritance } from "./inheritance";
@@ -21,12 +20,10 @@ export { Invocation } from "./invocation";
 export { Method } from "./method";
 export { Module } from "./module";
 export { NamedEntity } from "./named_entity";
-export { Namespace } from "./namespace";
 export { ParameterType } from "./parameter_type";
 export { Parameter } from "./parameter";
-export { ParameterizableClass } from "./parameterizable_class";
-export { ParameterizableInterface } from "./parameterizable_interface";
-export { ParameterizedType } from "./parameterized_type";
+export { ParametricClass } from "./parametric_class";
+export { ParametricInterface } from "./parametric_interface";
 export { PrimitiveType } from "./primitive_type";
 export { Reference } from "./reference";
 export { ScopingEntity } from "./scoping_entity";
@@ -35,6 +32,10 @@ export { SourceAnchor } from "./source_anchor";
 export { SourceLanguage } from "./source_language";
 export { SourcedEntity } from "./sourced_entity";
 export { StructuralEntity } from "./structural_entity";
-export { TextAnchor } from "./text_anchor";
 export { Type } from "./type";
 export { Variable } from "./variable";
+export { ParametricFunction } from "./parametric_function";
+export { ParametricMethod } from "./parametric_method";
+export { ArrowFunction } from "./arrow_function";
+export { ParametricArrowFunction } from "./parametric_arrow_function";
+export { ParameterConcretisation } from "./parameter_concretisation";

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

@@ -0,0 +1,46 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { SourceAnchor } from "./source_anchor";
+
+export class IndexedFileAnchor extends SourceAnchor {
+
+  private _startPos!: number;
+  private _endPos!: number;
+  private _fileName!: string;
+
+  public getJSON(): string {
+    const json: FamixJSONExporter = new FamixJSONExporter("IndexedFileAnchor", this);
+    this.addPropertiesToExporter(json);
+    return json.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("startPos", this.startPos);
+    exporter.addProperty("endPos", this.endPos);
+    exporter.addProperty("fileName", this.fileName);
+  }
+
+    get startPos(): number {
+        return this._startPos;
+    }
+
+    set startPos(startPos: number) {
+        this._startPos = startPos;
+    }
+
+    get endPos(): number {
+        return this._endPos;
+    }
+
+    set endPos(endPos: number) {
+        this._endPos = endPos;
+    }
+
+    get fileName(): string {
+        return this._fileName;
+    }
+
+    set fileName(fileName: string) {
+        this._fileName = fileName;
+    }
+}

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

@@ -0,0 +1,40 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Class } from "./class";
+import { Entity } from "./entity";
+import { Interface } from "./interface";
+
+export class Inheritance extends Entity {
+
+    private _superclass!: Class | Interface;
+    private _subclass!: Class | Interface;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Inheritance", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("superclass", this.superclass);
+        exporter.addProperty("subclass", this.subclass);
+    }
+
+    get superclass() {
+        return this._superclass;
+    }
+
+    set superclass(superclass: Class | Interface) {
+        this._superclass = superclass;
+        superclass.addSubInheritance(this);
+    }
+
+    get subclass() {
+        return this._subclass;
+    }
+
+    set subclass(subclass: Class | Interface) {
+        this._subclass = subclass;
+        subclass.addSuperInheritance(this);
+    }
+}

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

@@ -0,0 +1,75 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+import { Method } from "./method";
+import { Property } from "./property";
+import { Inheritance } from "./inheritance";
+
+export class Interface extends Type {
+
+    private _properties: Set<Property> = new Set();
+
+    public addProperty(property: Property): void {
+        if (!this._properties.has(property)) {
+            this._properties.add(property);
+            property.parentEntity = this;
+        }
+    }
+
+    private _methods: Set<Method> = new Set();
+
+    public addMethod(method: Method): void {
+        if (!this._methods.has(method)) {
+            this._methods.add(method);
+            method.parentEntity = this;
+        }
+    }
+
+    private _superInheritances: Set<Inheritance> = new Set();
+
+    public addSuperInheritance(superInheritance: Inheritance): void {
+        if (!this._superInheritances.has(superInheritance)) {
+            this._superInheritances.add(superInheritance);
+            superInheritance.subclass = this;
+        }
+    }
+
+    private _subInheritances: Set<Inheritance> = new Set();
+
+    public addSubInheritance(subInheritance: Inheritance): void {
+        if (!this._subInheritances.has(subInheritance)) {
+            this._subInheritances.add(subInheritance);
+            subInheritance.superclass = this;
+        }
+    }
+
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Interface", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("attributes", this.properties);
+        exporter.addProperty("methods", this.methods);
+        exporter.addProperty("superInheritances", this.superInheritances);
+        exporter.addProperty("subInheritances", this.subInheritances);
+    }
+
+    get properties() {
+        return this._properties;
+    }
+
+    get methods() {
+        return this._methods;
+    }
+
+    get superInheritances() {
+        return this._superInheritances;
+    }
+
+    get subInheritances() {
+        return this._subInheritances;
+    }
+}

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

@@ -0,0 +1,65 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { NamedEntity } from "./named_entity";
+import { BehavioralEntity } from "./behavioral_entity";
+import { ContainerEntity } from "./container_entity";
+import { Entity } from "./entity";
+
+export class Invocation extends Entity {
+
+  private _candidates: Set<BehavioralEntity> = new Set();
+
+  public addCandidate(candidate: BehavioralEntity): void {  
+    if (!this._candidates.has(candidate)) {
+      this._candidates.add(candidate);
+      candidate.addIncomingInvocation(this);
+    }
+  }
+
+  private _receiver!: NamedEntity;
+  private _sender!: ContainerEntity;
+  private _signature!: string;
+
+  public getJSON(): string {
+    const json: FamixJSONExporter = new FamixJSONExporter("Invocation", this);
+    this.addPropertiesToExporter(json);
+    return json.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("candidates", this.candidates);
+    exporter.addProperty("receiver", this.receiver);
+    exporter.addProperty("sender", this.sender);
+    exporter.addProperty("signature", this.signature);
+  }
+
+    get candidates() {
+        return this._candidates;
+    }
+
+    get receiver() {
+        return this._receiver;
+    }
+
+    set receiver(receiver: NamedEntity) {
+        this._receiver = receiver;
+        receiver.addReceivedInvocation(this);
+    }
+
+    get sender() {
+        return this._sender;
+    }
+
+    set sender(sender: ContainerEntity) {
+        this._sender = sender;
+        sender.addOutgoingInvocation(this);
+    }
+
+    get signature() {
+        return this._signature;
+    }
+
+    set signature(signature: string) {
+        this._signature = signature;
+    }
+}