ts2famix 1.4.1 → 2.0.1

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

package/src/lib/famix/package.json

@@ -25,4 +25,4 @@
     "tslint": "^5.20.0",
     "typescript": "^3.6.3"
   }
-}
+}

package/src/lib/ts-complex/cyclomatic-service.ts

@@ -12,21 +12,21 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
-import { forEachChild, isIdentifier, SyntaxKind, createSourceFile, ScriptTarget } from 'typescript';
+import { forEachChild, isIdentifier, SyntaxKind, createSourceFile, ScriptTarget, Node, CaseClause, BinaryExpression, FunctionLikeDeclaration } from 'typescript';
 import { isFunctionWithBody } from 'tsutils';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, PathLike, readFileSync } from 'fs';
 
-const getNodeName = (node) => {
+const getNodeName = (node: FunctionLikeDeclaration) => {
   const { name, pos, end } = node;
   const key = name !== undefined && isIdentifier(name) ? name.text : JSON.stringify({ pos, end });
   return key;
 };
 
-const increasesComplexity = (node) => {
+const increasesComplexity = (node: Node) => {
   /* eslint-disable indent */
   switch (node.kind) {
     case SyntaxKind.CaseClause:
-      return node.statements.length > 0;
+      return (node as CaseClause).statements.length > 0;
     case SyntaxKind.CatchClause:
     case SyntaxKind.ConditionalExpression:
     case SyntaxKind.DoStatement:
@@ -38,7 +38,7 @@ const increasesComplexity = (node) => {
       return true;
 
     case SyntaxKind.BinaryExpression:
-      switch (node.operatorToken.kind) {
+      switch ((node as BinaryExpression).operatorToken.kind) {
         case SyntaxKind.BarBarToken:
         case SyntaxKind.AmpersandAmpersandToken:
           return true;
@@ -52,9 +52,9 @@ const increasesComplexity = (node) => {
   /* eslint-enable indent */
 };
 
-const calculateFromSource = (ctx) => {
+const calculateFromSource = (ctx: Node) => {
   let complexity = 0;
-  const output = {};
+  const output: { [key: string]: number } = {};
   forEachChild(ctx, function cb(node) {
     if (isFunctionWithBody(node)) {
       const old = complexity;
@@ -73,11 +73,11 @@ const calculateFromSource = (ctx) => {
   return output;
 };
 
-export const calculate = (filePath) => {
+export const calculate = (filePath: PathLike) => {
   if (!existsSync(filePath)) {
     throw new Error(`File "${filePath}" does not exists`);
   }
   const sourceText = readFileSync(filePath).toString();
-  const source = createSourceFile(filePath, sourceText, ScriptTarget.ES2015);
+  const source = createSourceFile(filePath.toString(), sourceText, ScriptTarget.ES2015);
   return calculateFromSource(source);
 };