ts2famix 2.0.0 → 2.0.1

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

@@ -0,0 +1,50 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { StructuralEntity } from "./structural_entity";
+import { ContainerEntity } from "./container_entity";
+import { Entity } from "./entity";
+
+export class Access extends Entity {
+
+    private _accessor!: ContainerEntity;
+    private _variable!: StructuralEntity;
+    private _isWrite!: boolean;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Access", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("accessor", this.accessor);
+        exporter.addProperty("variable", this.variable);
+        exporter.addProperty("isWrite", this.isWrite);
+    }
+
+    get accessor(): ContainerEntity {
+        return this._accessor;
+    }
+
+    set accessor(accessor: ContainerEntity) {
+        this._accessor = accessor;
+        accessor.addAccess(this);
+    }
+
+    get variable(): StructuralEntity {
+        return this._variable;
+    }
+
+    set variable(variable: StructuralEntity) {
+        this._variable = variable;
+        variable.addIncomingAccess(this);
+    }
+
+    get isWrite(): boolean {
+        return this._isWrite;
+    }
+
+    set isWrite(isWrite: boolean) {
+        this._isWrite = isWrite;
+    }
+}

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

@@ -0,0 +1,39 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { NamedEntity } from "./named_entity";
+import { Type } from "./type";
+
+export class Alias extends NamedEntity {
+
+    private _parentEntity!: NamedEntity;
+    private _aliasedEntity!: Type;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Alias", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("parentType", this.parentEntity);
+        exporter.addProperty("aliasedEntity", this.aliasedEntity);
+    }
+
+    get parentEntity(): NamedEntity {
+        return this._parentEntity;
+    }
+
+    set parentEntity(parentEntity: NamedEntity) {
+        this._parentEntity = parentEntity;
+        parentEntity.addAlias(this);
+    }
+
+    get aliasedEntity(): Type {
+        return this._aliasedEntity;
+    }
+
+    set aliasedEntity(aliasedEntity: Type) {
+        this._aliasedEntity = aliasedEntity;
+        aliasedEntity.addTypeAlias(this);
+    }
+}

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

@@ -0,0 +1,97 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+import { ContainerEntity } from "./container_entity";
+import { Parameter } from "./parameter";
+import { Invocation } from "./invocation";
+import { ParameterType } from "./parameter_type";
+
+export class BehavioralEntity extends ContainerEntity {
+
+    private _signature!: string;
+    private _parameters: Set<Parameter> = new Set();
+
+    public addParameter(parameter: Parameter): void {
+        if (!this._parameters.has(parameter)) {
+            this._parameters.add(parameter);
+            parameter.parentEntity = this;
+        }
+    }
+
+    private _numberOfParameters!: number;
+    private _incomingInvocations: Set<Invocation> = new Set();
+
+    public addIncomingInvocation(incomingInvocation: Invocation): void {
+        if (!this._incomingInvocations.has(incomingInvocation)) {
+            this._incomingInvocations.add(incomingInvocation);
+            incomingInvocation.addCandidate(this);
+        }
+    }
+
+    private _declaredType!: Type;
+    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();
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("BehavioralEntity", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("signature", this.signature);
+        exporter.addProperty("parameters", this.parameters);
+        exporter.addProperty("numberOfParameters", this.numberOfParameters);
+        exporter.addProperty("incomingInvocations", this.incomingInvocations);
+        exporter.addProperty("declaredType", this.declaredType);
+        /* don't add the property here, since it doesn't apply to all subclasses */
+        //    exporter.addProperty("genericParameters", this.getGenericParameters());
+    }
+
+    get signature(): string {
+        return this._signature;
+    }
+
+    set signature(signature: string) {
+        this._signature = signature;
+    }
+
+    get parameters(): Set<Parameter> {
+        return this._parameters;
+    }
+
+    get numberOfParameters(): number {
+        return this._numberOfParameters;
+    }
+
+    set numberOfParameters(numberOfParameters: number) {
+        this._numberOfParameters = numberOfParameters;
+    }
+
+    get incomingInvocations(): Set<Invocation> {
+        return this._incomingInvocations;
+    }
+
+    get declaredType(): Type {
+        return this._declaredType;
+    }
+
+    set declaredType(declaredType: Type) {
+        this._declaredType = declaredType;
+        declaredType.addBehavioralEntityWithDeclaredType(this);
+    }
+
+    get genericParameters(): Set<ParameterType> {
+        return this._genericParameters;
+    }
+}

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

@@ -0,0 +1,85 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+import { Method } from "./method";
+import { Property } from "./property";
+import { Inheritance } from "./inheritance";
+
+export class Class extends Type {
+
+    private _isAbstract!: boolean;
+    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("Class", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("isAbstract", this.isAbstract);
+        exporter.addProperty("attributes", this.properties); // Moose (10) codes them as attributes
+        exporter.addProperty("methods", this.methods);
+        exporter.addProperty("superInheritances", this.superInheritances);
+        exporter.addProperty("subInheritances", this.subInheritances);
+    }
+
+    get isAbstract(): boolean {
+        return this._isAbstract;
+    }
+
+    set isAbstract(isAbstract: boolean) {
+        this._isAbstract = isAbstract;
+    }
+
+    get properties(): Set<Property> {
+        return this._properties;
+    }
+
+    get methods(): Set<Method> {
+        return this._methods;
+    }
+
+    get superInheritances(): Set<Inheritance> {
+        return this._superInheritances;
+    }
+
+    get subInheritances(): Set<Inheritance> {
+        return this._subInheritances;
+    }
+}

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

@@ -0,0 +1,47 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { SourcedEntity } from "./sourced_entity";
+
+export class Comment extends SourcedEntity {
+
+  private _isJSDoc!: boolean;
+  private _container!: SourcedEntity;
+  private _content!: string;
+
+  public getJSON(): string {
+    const json: FamixJSONExporter = new FamixJSONExporter("Comment", this);
+    this.addPropertiesToExporter(json);
+    return json.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("isJSDoc", this.isJSDoc);
+    exporter.addProperty("commentedEntity", this.container);
+    exporter.addProperty("content", this.content);
+  }
+
+    get isJSDoc(): boolean {
+        return this._isJSDoc;
+    }
+
+    set isJSDoc(isJSDoc: boolean) {
+        this._isJSDoc = isJSDoc;
+    }
+
+    get container(): SourcedEntity {
+        return this._container;
+    }
+
+    set container(container: SourcedEntity) {
+        this._container = container;
+        container.addComment(this);
+    }
+
+    get content(): string {
+        return this._content;
+    }
+
+    set content(content: string) {
+        this._content = content;
+    }
+}

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

@@ -12,7 +12,6 @@ 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";
@@ -33,11 +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 "./arrowFunction";
+export { ArrowFunction } from "./arrow_function";
 export { ParametricArrowFunction } from "./parametric_arrow_function";
-export { ParameterConcretisation } from "./parameterConcretisation";
+export { ParameterConcretisation } from "./parameter_concretisation";