move tslint ADF rules in principal repo (#3247)

* move tslint ADF rules in principal repo

* fix style issues

* change pacakge.json position

* update to angular cli 6.0.0

* reorganization package.json

* remove node modules2 folder

* exclude integration

* rollback alfresco-js-api

* solve types problems

* fix pdf test

* fix errors and exclude two tests

* fix e2e

* fix test

* copy all the new packages in node_modules

* fix test

* fix packaging script

* scss issue fix

* move test export in tools

tools/tslint-rules/.gitignore

@@ -0,0 +1,7 @@
+/npm-debug.log
+/.idea
+node_modules
+coverage
+/temp/
+local.log
+/rules/*.js

tools/tslint-rules/.npmignore

@@ -0,0 +1,16 @@
+.idea
+
+coverage/
+node_modules
+temp/
+test/
+
+/.editorconfig
+/.travis.yml
+/gulpfile.js
+/.npmignore
+
+*.tgz
+
+/assets/
+local.log

tools/tslint-rules/README.md

@@ -0,0 +1,36 @@
+# adf-tslint-rules
+
+
+A set of [TSLint](https://github.com/palantir/tslint) rules used on [ADF](https://github.com/Alfresco/alfresco-ng2-components) project.
+
+## Installation
+
+```sh
+ npm install adf-tslint-rules
+```
+
+## Configuration
+
+```javascript
+{
+    "rulesDirectory": [
+        "node_modules/codelyzer",
+        "node_modules/adf-tslint-rules"
+    ],
+    "rules": {
+        "adf-file-name": true,
+        "adf-class-name": true,
+        "adf-no-on-prefix-output-name": true
+    }
+}
+```
+
+Supported Rules
+-----
+
+Rule Name   | Description |
+---------- | ------------ | 
+`adf-file-name` | The name of the File should not start with ADF Alfresco or Activiti prefix | 
+`adf-class-name` | The name of the class should not start with ADF Alfresco or Activiti prefix |
+`adf-no-on-prefix-output-name` | Angular allows for an alternative syntax on-*. If the event itself was prefixed with on this would result in an on-onEvent binding expression |
+|

tools/tslint-rules/adfClassNameRule.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Lint = require("tslint");
+const sprintf_js_1 = require("sprintf-js");
+const walkerFactory_1 = require("codelyzer/walkerFactory/walkerFactory");
+const walkerFn_1 = require("codelyzer/walkerFactory/walkerFn");
+const function_1 = require("codelyzer/util/function");
+class Rule extends Lint.Rules.AbstractRule {
+    static invalidName(className) {
+        var whiteList = ['ActivitiContentComponent', 'ActivitiForm'];
+        var classNameReg = /^(alfresco|activiti|adf|activity)/ig;
+        var classNameMatch = classNameReg.exec(className);
+        var isWhiteListName = whiteList.find((currentWhiteListName) => {
+            return currentWhiteListName === className;
+        });
+        if (classNameMatch && !isWhiteListName) {
+            return true;
+        }
+        return false;
+    }
+    apply(sourceFile) {
+        return this.applyWithWalker(Rule.walkerBuilder(sourceFile, this.getOptions()));
+    }
+}
+Rule.metadata = {
+    ruleName: 'adf-class-name',
+    type: 'maintainability',
+    description: `Enforce consistent name avoid prefix`,
+    descriptionDetails: `See more at https://angular.io/styleguide#style-05-13.`,
+    rationale: `Consistent conventions make it easy to quickly identify class when you search with autocomplete.`,
+    options: null,
+    optionsDescription: "Not configurable.",
+    typescriptOnly: true,
+};
+Rule.FAILURE_STRING = 'The name of the class should not start with ADF Alfresco or Activiti prefix ';
+Rule.walkerBuilder = walkerFn_1.all(walkerFn_1.validateComponent((meta, suffixList) => function_1.Maybe.lift(meta.controller)
+    .fmap(controller => controller.name)
+    .fmap(name => {
+    const className = name.text;
+    if (Rule.invalidName(className)) {
+        return [new walkerFactory_1.Failure(name, sprintf_js_1.sprintf(Rule.FAILURE_STRING + className, className, suffixList))];
+    }
+})));
+exports.Rule = Rule;

tools/tslint-rules/adfClassNameRule.ts

@@ -0,0 +1,61 @@
+import * as Lint from 'tslint';
+import * as ts from 'typescript';
+import { sprintf } from 'sprintf-js';
+import { ComponentMetadata } from 'codelyzer/angular/metadata';
+import { Failure } from 'codelyzer/walkerFactory/walkerFactory';
+import { all, validateComponent } from 'codelyzer/walkerFactory/walkerFn';
+import { Maybe, F2 } from 'codelyzer/util/function';
+import { IOptions } from 'tslint';
+import { NgWalker } from 'codelyzer/angular/ngWalker';
+
+export class Rule extends Lint.Rules.AbstractRule {
+
+    public static metadata: Lint.IRuleMetadata = {
+        ruleName: 'adf-class-name',
+        type: 'maintainability',
+        description: `Enforce consistent name avoid prefix`,
+        descriptionDetails: `See more at https://angular.io/styleguide#style-05-13.`,
+        rationale: `Consistent conventions make it easy to quickly identify class when you search with autocomplete.`,
+        options: null,
+        optionsDescription: "Not configurable.",
+        typescriptOnly: true,
+    };
+
+    public static FAILURE_STRING = 'The name of the class should not start with ADF Alfresco or Activiti prefix ';
+
+    static walkerBuilder: F2<ts.SourceFile, IOptions, NgWalker> =
+        all(
+            validateComponent((meta: ComponentMetadata, suffixList?: string[]) =>
+                Maybe.lift(meta.controller)
+                    .fmap(controller => controller.name)
+                    .fmap(name => {
+                        const className = name.text;
+                        if (Rule.invalidName(className)) {
+                            return [new Failure(name, sprintf(Rule.FAILURE_STRING + className, className, suffixList))];
+                        }
+                    })
+            ));
+
+    static invalidName(className: string): boolean {
+        var whiteList = ['ActivitiContentComponent', 'ActivitiForm'];
+
+        var classNameReg = /^(alfresco|activiti|adf|activity)/ig;
+        var classNameMatch = classNameReg.exec(className);
+
+        var isWhiteListName = whiteList.find((currentWhiteListName) => {
+            return currentWhiteListName === className;
+        });
+
+        if (classNameMatch && !isWhiteListName) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithWalker(
+            Rule.walkerBuilder(sourceFile, this.getOptions())
+        );
+    }
+}

tools/tslint-rules/adfFileNameRule.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Lint = require("tslint");
+class Rule extends Lint.Rules.AbstractRule {
+    apply(sourceFile) {
+        return this.applyWithWalker(new AdfFileName(sourceFile, this.getOptions()));
+    }
+}
+Rule.metadata = {
+    ruleName: 'adf-file-name',
+    type: 'maintainability',
+    description: `Enforce consistent name avoid prefix`,
+    descriptionDetails: `See more at https://angular.io/styleguide#style-05-13.`,
+    rationale: `Consistent conventions make it easy to quickly identify files when you search with autocomplete.`,
+    options: null,
+    optionsDescription: "Not configurable.",
+    typescriptOnly: true,
+};
+Rule.FAILURE_STRING = 'The name of the File should not start with ADF Alfresco or Activiti prefix ';
+exports.Rule = Rule;
+class AdfFileName extends Lint.RuleWalker {
+    visitSourceFile(node) {
+        var whiteList = ['activiti-alfresco.service.ts', 'activiti-alfresco.service.spec.ts',
+            'alfresco-api.service.ts', 'alfresco-api.service.spects'];
+        var fileName = this.getFilename();
+        var fileNameReg = /^(alfresco|activiti|adf|activity)/ig;
+        var filenameMatch = fileNameReg.exec(fileName);
+        var isWhiteListName = whiteList.find((currentWhiteListName) => {
+            return currentWhiteListName === fileName;
+        });
+        if (filenameMatch && !isWhiteListName) {
+            this.addFailure(this.createFailure(node.getStart(), node.getWidth(), Rule.FAILURE_STRING + fileName));
+            super.visitSourceFile(node);
+        }
+    }
+    getFilename() {
+        const filename = this.getSourceFile().fileName;
+        const lastSlash = filename.lastIndexOf('/');
+        if (lastSlash > -1) {
+            return filename.substring(lastSlash + 1);
+        }
+        return filename;
+    }
+}

tools/tslint-rules/adfFileNameRule.ts

@@ -0,0 +1,53 @@
+import * as ts from "typescript";
+import * as Lint from "tslint";
+
+
+export class Rule extends Lint.Rules.AbstractRule {
+    public static metadata: Lint.IRuleMetadata = {
+        ruleName: 'adf-file-name',
+        type: 'maintainability',
+        description: `Enforce consistent name avoid prefix`,
+        descriptionDetails: `See more at https://angular.io/styleguide#style-05-13.`,
+        rationale: `Consistent conventions make it easy to quickly identify files when you search with autocomplete.`,
+        options: null,
+        optionsDescription: "Not configurable.",
+        typescriptOnly: true,
+    };
+
+    public static FAILURE_STRING = 'The name of the File should not start with ADF Alfresco or Activiti prefix ';
+
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithWalker(new AdfFileName(sourceFile, this.getOptions()));
+    }
+}
+
+// The walker takes care of all the work.
+class AdfFileName extends Lint.RuleWalker {
+    public visitSourceFile(node: ts.SourceFile) {
+        var whiteList = ['activiti-alfresco.service.ts', 'activiti-alfresco.service.spec.ts',
+            'alfresco-api.service.ts', 'alfresco-api.service.spects'];
+
+        var fileName = this.getFilename();
+
+        var fileNameReg = /^(alfresco|activiti|adf|activity)/ig;
+        var filenameMatch = fileNameReg.exec(fileName);
+
+        var isWhiteListName = whiteList.find((currentWhiteListName) => {
+            return currentWhiteListName === fileName;
+        });
+
+        if (filenameMatch && !isWhiteListName) {
+            this.addFailure(this.createFailure(node.getStart(), node.getWidth(), Rule.FAILURE_STRING + fileName));
+            super.visitSourceFile(node);
+        }
+    }
+
+    private getFilename(): string {
+        const filename = this.getSourceFile().fileName;
+        const lastSlash = filename.lastIndexOf('/');
+        if (lastSlash > -1) {
+            return filename.substring(lastSlash + 1);
+        }
+        return filename;
+    }
+}

tools/tslint-rules/adfPrefixNameRule.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Lint = require("tslint");
+const sprintf_js_1 = require("sprintf-js");
+const ngWalker_1 = require("codelyzer/angular/ngWalker");
+class Rule extends Lint.Rules.AbstractRule {
+    apply(sourceFile) {
+        return this.applyWithWalker(new ADFOutputPrefixNameRule(sourceFile, this.getOptions()));
+    }
+}
+Rule.metadata = {
+    ruleName: 'adf-prefix-name',
+    type: 'maintainability',
+    description: `Name events without the prefix on`,
+    descriptionDetails: `See more at https://angular.io/guide/styleguide#dont-prefix-output-properties`,
+    rationale: `Angular allows for an alternative syntax on-*. If the event itself was prefixed with on this would result in an on-onEvent binding expression`,
+    options: null,
+    optionsDescription: `Not configurable.`,
+    typescriptOnly: true,
+};
+Rule.FAILURE_STRING = 'In the class "%s", the output ' +
+    'property "%s" should not be prefixed with on';
+exports.Rule = Rule;
+class ADFOutputPrefixNameRule extends ngWalker_1.NgWalker {
+    visitNgOutput(property, output, args) {
+        let className = property.parent.name.text;
+        let memberName = property.name.text;
+        if (memberName && memberName.startsWith('on')) {
+            let failureConfig = [className, memberName];
+            failureConfig.unshift(Rule.FAILURE_STRING);
+            this.addFailure(this.createFailure(property.getStart(), property.getWidth(), sprintf_js_1.sprintf.apply(this, failureConfig)));
+        }
+    }
+}

tools/tslint-rules/adfPrefixNameRule.ts

@@ -0,0 +1,43 @@
+import * as Lint from 'tslint';
+import * as ts from 'typescript';
+import { sprintf } from 'sprintf-js';
+import { NgWalker } from 'codelyzer/angular/ngWalker';
+
+export class Rule extends Lint.Rules.AbstractRule {
+    public static metadata: Lint.IRuleMetadata = {
+        ruleName: 'adf-prefix-name',
+        type: 'maintainability',
+        description: `Name events without the prefix on`,
+        descriptionDetails: `See more at https://angular.io/guide/styleguide#dont-prefix-output-properties`,
+        rationale: `Angular allows for an alternative syntax on-*. If the event itself was prefixed with on this would result in an on-onEvent binding expression`,
+        options: null,
+        optionsDescription: `Not configurable.`,
+        typescriptOnly: true,
+    };
+
+    static FAILURE_STRING: string = 'In the class "%s", the output ' +
+        'property "%s" should not be prefixed with on';
+
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithWalker(
+            new ADFOutputPrefixNameRule(sourceFile,
+                this.getOptions()));
+    }
+}
+
+class ADFOutputPrefixNameRule extends NgWalker {
+    visitNgOutput(property: ts.PropertyDeclaration, output: ts.Decorator, args: string[]) {
+        let className = (<any>property).parent.name.text;
+        let memberName = (<any>property.name).text;
+
+        if (memberName && memberName.startsWith('on')) {
+            let failureConfig: string[] = [className, memberName];
+            failureConfig.unshift(Rule.FAILURE_STRING);
+            this.addFailure(
+                this.createFailure(
+                    property.getStart(),
+                    property.getWidth(),
+                    sprintf.apply(this, failureConfig)));
+        }
+    }
+}

tools/tslint-rules/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var adfClassNameRule_1 = require("./adfClassNameRule");
+exports.ADFClassNameRule = adfClassNameRule_1.Rule;
+var adfFileNameRule_1 = require("./adfFileNameRule");
+exports.ADFComponentSelectorRule = adfFileNameRule_1.Rule;
+var adfPrefixNameRule_1 = require("./adfPrefixNameRule");
+exports.ADFOutputPrefixNameRule = adfPrefixNameRule_1.Rule;

tools/tslint-rules/index.ts

@@ -0,0 +1,3 @@
+export { Rule as ADFClassNameRule } from './adfClassNameRule';
+export { Rule as ADFComponentSelectorRule } from './adfFileNameRule';
+export { Rule as ADFOutputPrefixNameRule } from './adfPrefixNameRule';

tools/tslint-rules/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "adf-tslint-rules",
+  "description": "Custom Rules for the ADF project",
+  "version": "0.0.4",
+  "author": "Alfresco Software, Ltd.",
+  "scripts": {
+    "build": "tsc",
+    "tscv": "tsc --version",
+    "tsc": "tsc",
+    "tsc:watch": "tsc --w"
+  },
+  "contributors": [
+    {
+      "name": "Eugenio Romano",
+      "email": "eugenio.romano@alfresco.com"
+    }
+  ],
+  "devDependencies": {
+    "@angular/compiler": "4.2.3",
+    "@angular/core": "4.2.3",
+    "@types/chai": "3.4.33",
+    "@types/less": "0.0.31",
+    "@types/mocha": "2.2.32",
+    "@types/node": "6.0.41",
+    "@types/node-sass": "3.10.31",
+    "@types/source-map": "0.5.0",
+    "@types/sprintf-js": "0.0.27",
+    "chai": "3.5.0",
+    "chai-spies": "0.7.1",
+    "minimalist": "1.0.0",
+    "mocha": "3.0.2",
+    "node-sass": "3.13.0",
+    "rimraf": "2.5.2",
+    "rxjs": "5.4.1",
+    "ts-node": "1.2.2",
+    "tslint": "5.0.0",
+    "typescript": "2.4.0",
+    "zone.js": "0.8.4",
+    "js-yaml": "3.8.4",
+    "json-stringify-pretty-compact": "1.0.4",
+    "@types/js-yaml": "3.5.31"
+  },
+  "peerDependencies": {
+    "tslint": "5.0.0"
+  },
+  "dependencies": {
+    "app-root-path": "2.0.1",
+    "css-selector-tokenizer": "0.7.0",
+    "cssauron": "1.4.0",
+    "semver-dsl": "1.0.1",
+    "source-map": "0.5.6",
+    "sprintf-js": "1.0.3",
+    "codelyzer": "3.1.2"
+  },
+  "license": "Apache-2.0"
+}

tools/tslint-rules/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": {
+        "experimentalDecorators": true,
+        "target": "es6",
+        "module": "commonjs",
+        "declaration": false,
+        "noImplicitAny": false,
+        "removeComments": true,
+        "lib": ["es6", "es2015", "dom"],
+        "noLib": false,
+        "typeRoots": [
+            "./node_modules/@types",
+            "./node_modules"
+        ],
+        "types": [
+            "mocha",
+            "chai",
+            "node",
+            "sprintf-js"
+        ]
+    }
+}

tools/tslint-rules/tslint.json

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "adf-file-naming": true
+  }
+}