New: Add line/col information for JSON

packages/hint-babel-config/src/is-valid.ts

@@ -37,12 +37,15 @@ export default class BabelConfigIsValidHint implements IHint {
         };
 
         const invalidSchema = async (fetchEnd: BabelConfigInvalidSchema) => {
-            const { prettifiedErrors, resource } = fetchEnd;
+            const { errors, prettifiedErrors, resource } = fetchEnd;
 
             debug(`parse::babel-config::error::schema received`);
 
-            for (const error of prettifiedErrors) {
-                await context.report(resource, null, error);
+            for (let i = 0; i < errors.length; i++) {
+                const message = prettifiedErrors[i];
+                const location = errors[i].location;
+
+                await context.report(resource, null, message, null, location);
             }
         };
 

packages/hint-babel-config/tests/fixtures/invalid-json/package.json

@@ -1,4 +1 @@
-{
-  "name": 'example',
-  "version": "0.0.1"
-}
+invalidJson

packages/hint-babel-config/tests/is-valid.ts

@@ -19,7 +19,7 @@ const tests: Array<HintLocalTest> = [
     {
         name: `Invalid json file should fail`,
         path: path.join(__dirname, 'fixtures', 'invalid-json', 'package.json'),
-        reports: [{ message: `Unexpected token ' in JSON at position 12` }]
+        reports: [{ message: `Unexpected token i in JSON at position 0` }]
     },
     {
         name: `If package.json doesn't contain "babel" property, it should pass`,
@@ -55,7 +55,7 @@ const tests: Array<HintLocalTest> = [
         name: 'If .babelrc contains an invalid extends, it should fail',
         path: path.join(__dirname, 'fixtures', 'invalid-extends'),
         reports: [
-            { message: `Unexpected token ' in JSON at position 191` }
+            { message: `Unexpected token ' in JSON at position 202` }
         ]
     }
 ];

packages/hint-manifest-app-name/src/hint.ts

@@ -12,11 +12,8 @@
 import { ucs2 } from 'punycode';
 
 import { Category } from 'hint/dist/src/lib/enums/category';
-import { IHint, HintMetadata } from 'hint/dist/src/lib/types';
-import {
-    Manifest,
-    ManifestParsed
-} from '@hint/parser-manifest/dist/src/types';
+import { IHint, HintMetadata, IJSONLocationFunction } from 'hint/dist/src/lib/types';
+import { ManifestParsed } from '@hint/parser-manifest/dist/src/types';
 import { HintContext } from 'hint/dist/src/lib/hint-context';
 import { HintScope } from 'hint/dist/src/lib/enums/hintscope';
 
@@ -46,15 +43,15 @@ export default class ManifestAppNameHint implements IHint {
             }
         };
 
-        const checkIfPropertyValueIsNotEmpty = async (resource: string, content: string, propertyName: string) => {
+        const checkIfPropertyValueIsNotEmpty = async (resource: string, content: string, propertyName: string, getLocation: IJSONLocationFunction) => {
             if (content && (content.trim() === '')) {
-                await context.report(resource, null, `Web app manifest should have non-empty '${propertyName}' property value.`);
+                await context.report(resource, null, `Web app manifest should have non-empty '${propertyName}' property value.`, null, getLocation(propertyName));
             }
         };
 
-        const checkIfPropertyValueIsUnderLimit = async (resource: string, content: string, propertyName: string, shortNameLengthLimit: number) => {
+        const checkIfPropertyValueIsUnderLimit = async (resource: string, content: string, propertyName: string, shortNameLengthLimit: number, getLocation: IJSONLocationFunction) => {
             if (content && (ucs2.decode(content).length > shortNameLengthLimit)) {
-                await context.report(resource, null, `Web app manifest should have '${propertyName}' property value under ${shortNameLengthLimit} characters.`);
+                await context.report(resource, null, `Web app manifest should have '${propertyName}' property value under ${shortNameLengthLimit} characters.`, null, getLocation(propertyName));
 
                 return false;
             }
@@ -63,7 +60,7 @@ export default class ManifestAppNameHint implements IHint {
         };
 
         const validate = async (manifestParsed: ManifestParsed) => {
-            const { parsedContent: manifest, resource }: { parsedContent: Manifest, resource: string } = manifestParsed;
+            const { getLocation, parsedContent: manifest, resource } = manifestParsed;
 
             const name = manifest.name;
 
@@ -100,8 +97,8 @@ export default class ManifestAppNameHint implements IHint {
             const shortNameLengthLimit: number = 12;
 
             await checkIfPropertyExists(resource, name, 'name');
-            await checkIfPropertyValueIsNotEmpty(resource, name, 'name');
-            await checkIfPropertyValueIsUnderLimit(resource, name, 'name', nameLengthLimit);
+            await checkIfPropertyValueIsNotEmpty(resource, name, 'name', getLocation);
+            await checkIfPropertyValueIsUnderLimit(resource, name, 'name', nameLengthLimit, getLocation);
 
             const shortName: string = manifest.short_name;
             const shortNameIsRequired: boolean = name && (name.trim() !== '') && (ucs2.decode(name).length > shortNameLengthLimit);
@@ -118,8 +115,8 @@ export default class ManifestAppNameHint implements IHint {
             }
 
             await checkIfPropertyExists(resource, shortName, 'short_name');
-            await checkIfPropertyValueIsNotEmpty(resource, shortName, 'short_name');
-            await checkIfPropertyValueIsUnderLimit(resource, shortName, 'short_name', shortNameLengthLimit);
+            await checkIfPropertyValueIsNotEmpty(resource, shortName, 'short_name', getLocation);
+            await checkIfPropertyValueIsUnderLimit(resource, shortName, 'short_name', shortNameLengthLimit, getLocation);
         };
 
         context.on('parse::manifest::end', validate);

packages/hint-manifest-is-valid/src/hint.ts

@@ -15,6 +15,7 @@ import { Category } from 'hint/dist/src/lib/enums/category';
 import {
     IAsyncHTMLElement,
     IHint,
+    IJSONLocationFunction,
     HintMetadata
 } from 'hint/dist/src/lib/types';
 import { isSupported } from 'hint/dist/src/lib/utils/caniuse';
@@ -79,7 +80,7 @@ export default class ManifestIsValidHint implements IHint {
                 color.model === 'hwb';
         };
 
-        const checkColors = async (resource: string, element: IAsyncHTMLElement, manifest: Manifest) => {
+        const checkColors = async (resource: string, element: IAsyncHTMLElement, manifest: Manifest, getLocation: IJSONLocationFunction) => {
             const colorProperties = [
                 'background_color',
                 'theme_color'
@@ -96,22 +97,22 @@ export default class ManifestIsValidHint implements IHint {
                 const color = parseColor(normalizedColorValue);
 
                 if (color === null) {
-                    await context.report(resource, element, `Web app manifest should not have invalid value '${colorValue}' for property '${property}'.`);
+                    await context.report(resource, element, `Web app manifest should not have invalid value '${colorValue}' for property '${property}'.`, null, getLocation(property));
 
                     continue;
                 }
 
                 if (isNotSupportedColorValue(color, normalizedColorValue)) {
-                    await context.report(resource, element, `Web app manifest should not have unsupported value '${colorValue}' for property '${property}'.`);
+                    await context.report(resource, element, `Web app manifest should not have unsupported value '${colorValue}' for property '${property}'.`, null, getLocation(property));
                 }
             }
         };
 
-        const checkLang = async (resource: string, element: IAsyncHTMLElement, manifest: Manifest) => {
+        const checkLang = async (resource: string, element: IAsyncHTMLElement, manifest: Manifest, getLocation: IJSONLocationFunction) => {
             const lang = manifest.lang;
 
             if (lang && !bcp47(lang)) {
-                await context.report(resource, element, `Web app manifest should not have invalid value '${manifest.lang}' for property 'lang'.`);
+                await context.report(resource, element, `Web app manifest should not have invalid value '${manifest.lang}' for property 'lang'.`, null, getLocation('lang'));
             }
         };
 
@@ -122,21 +123,25 @@ export default class ManifestIsValidHint implements IHint {
         };
 
         const handleInvalidSchema = async (manifestInvalidSchemaEvent: ManifestInvalidSchema) => {
-            for (const error of manifestInvalidSchemaEvent.prettifiedErrors) {
-                await context.report(manifestInvalidSchemaEvent.resource, manifestInvalidSchemaEvent.element, error);
+            for (let i = 0; i < manifestInvalidSchemaEvent.prettifiedErrors.length; i++) {
+                const error = manifestInvalidSchemaEvent.prettifiedErrors[i];
+                const location = manifestInvalidSchemaEvent.errors[i].location;
+
+                await context.report(manifestInvalidSchemaEvent.resource, manifestInvalidSchemaEvent.element, error, null, location);
             }
         };
 
         const validateOtherProperties = async (manifestParsed: ManifestParsed) => {
             const {
                 element,
+                getLocation,
                 parsedContent: manifest,
                 resource
-            }: { element: IAsyncHTMLElement, parsedContent: Manifest, resource: string } = manifestParsed;
+            } = manifestParsed;
 
             // Additional checks not covered by the schema.
-            await checkLang(resource, element, manifest);
-            await checkColors(resource, element, manifest);
+            await checkLang(resource, element, manifest, getLocation);
+            await checkColors(resource, element, manifest, getLocation);
         };
 
         context.on('parse::manifest::end', validateOtherProperties);

packages/hint-typescript-config/src/helpers/config-checker.ts

@@ -5,7 +5,7 @@ import { HintContext } from 'hint/dist/src/lib/hint-context';
 const configChecker = (property: string, desiredValue: boolean, message: string, context: HintContext) => {
 
     return async (evt: TypeScriptConfigParse): Promise<void> => {
-        const { config, resource } = evt;
+        const { config, getLocation, resource } = evt;
         const properties = property.split('.');
 
         let current = config[properties.shift()];
@@ -15,7 +15,7 @@ const configChecker = (property: string, desiredValue: boolean, message: string,
         }
 
         if (current !== desiredValue) {
-            await context.report(resource, null, message);
+            await context.report(resource, null, message, null, getLocation(property));
         }
     };
 };

packages/hint-typescript-config/src/is-valid.ts

@@ -39,12 +39,15 @@ export default class TypeScriptConfigIsValid implements IHint {
         };
 
         const invalidSchema = async (fetchEnd: TypeScriptConfigInvalidSchema) => {
-            const { prettifiedErrors, resource } = fetchEnd;
+            const { errors, prettifiedErrors, resource } = fetchEnd;
 
             debug(`parse::typescript-config::error::schema received`);
 
-            for (const error of prettifiedErrors) {
-                await context.report(resource, null, error);
+            for (let i = 0; i < errors.length; i++) {
+                const message = prettifiedErrors[i];
+                const location = errors[i].location;
+
+                await context.report(resource, null, message, null, location);
             }
         };
 

packages/hint-typescript-config/src/target.ts

@@ -219,15 +219,15 @@ export default class TypeScriptConfigTarget implements IHint {
         };
 
         const validate = async (evt: TypeScriptConfigParse) => {
-            const { config, resource } = evt;
+            const { config, getLocation, resource } = evt;
             const { targetedBrowsers } = context;
             const target = getConfiguredTarget(config);
             const minimumBrowsers = toMiniumBrowser(targetedBrowsers);
 
             const maxESVersion = getMaxVersion(minimumBrowsers);
 
             if (maxESVersion !== target) {
-                await context.report(resource, null, `Based on your browser configuration your "compilerOptions.target" should be "${maxESVersion}". Current one is "${target}"`);
+                await context.report(resource, null, `Based on your browser configuration your "compilerOptions.target" should be "${maxESVersion}". Current one is "${target}"`, null, getLocation('compilerOptions.target'));
             }
         };
 

packages/hint-typescript-config/tests/fixtures/invalidjson/tsconfig.json

@@ -1,23 +1 @@
-{
-    "compilerOptions": {
-        "alwaysStrict": true,
-        "declaration": true,
-        "inlineSourceMap": true,
-        "lib": [
-            'dom',
-            "dom.iterable",
-            "es2017",
-            "esnext",
-            "esnext.asynciterable"
-        ],
-        "module": "commonjs",
-        "newLine": "lf",
-        "removeComments": false,
-        "target": "esnext"
-    },
-    "exclude": [
-        "dist",
-        "node_modules",
-        "packages"
-    ]
-}
+invalidJson

packages/hint-typescript-config/tests/is-valid.ts

@@ -18,17 +18,23 @@ const tests: Array<HintLocalTest> = [
     {
         name: 'Invalid configuration should fail',
         path: path.join(__dirname, 'fixtures', 'invalidjson'),
-        reports: [{ message: `Unexpected token ' in JSON at position 148` }]
+        reports: [{ message: `Unexpected token i in JSON at position 0` }]
     },
     {
         name: 'Invalid configuration should fail',
         path: path.join(__dirname, 'fixtures', 'invalidschemaenum'),
-        reports: [{ message: `'compilerOptions.lib[3]' should be equal to one of the allowed values 'es5, es6, es2015, es7, es2016, es2017, es2018, esnext, dom, dom.iterable, webworker, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2017.object, es2017.sharedmemory, es2017.typedarrays, esnext.array, esnext.asynciterable, esnext.promise'. Value found 'invalidlib'` }]
+        reports: [{
+            message: `'compilerOptions.lib[3]' should be equal to one of the allowed values 'es5, es6, es2015, es7, es2016, es2017, es2018, esnext, dom, dom.iterable, webworker, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2017.object, es2017.sharedmemory, es2017.typedarrays, esnext.array, esnext.asynciterable, esnext.promise'. Value found 'invalidlib'`,
+            position: { column: 12, line: 9 }
+        }]
     },
     {
         name: 'If schema has additional properties, it should fail',
         path: path.join(__dirname, 'fixtures', 'invalidschemaadditional'),
-        reports: [{ message: `'compilerOptions' should NOT have additional properties. Additional property found 'invalidProperty'.` }]
+        reports: [{
+            message: `'compilerOptions' should NOT have additional properties. Additional property found 'invalidProperty'.`,
+            position: { column: 9, line: 15 }
+        }]
     },
     {
         name: 'If schema has an invalid pattern, it should fail',
@@ -50,7 +56,7 @@ const tests: Array<HintLocalTest> = [
         name: 'If the configuration has an invalid extends, it should fail',
         path: path.join(__dirname, 'fixtures', 'invalid-extends'),
         reports: [
-            { message: `Unexpected token ' in JSON at position 148` }
+            { message: `Unexpected token i in JSON at position 0` }
         ]
     }
 ];

packages/hint/package.json

@@ -24,6 +24,7 @@
     "handlebars": "^4.0.11",
     "is-ci": "^1.2.0",
     "is-svg": "^3.0.0",
+    "jsonc-parser": "^2.0.2",
     "lodash": "^4.17.10",
     "mime-db": "1.35.0",
     "npm-registry-fetch": "^3.8.0",

packages/hint/src/lib/types.ts

@@ -7,6 +7,7 @@ export * from './types/async-html';
 export * from './types/connector';
 export * from './types/events';
 export * from './types/formatters';
+export * from './types/json-parser';
 export * from './types/network';
 export * from './types/problems';
 export * from './types/hints';

packages/hint/src/lib/types/json-parser.ts

@@ -0,0 +1,36 @@
+import { ProblemLocation } from './problems';
+
+export interface IJSONLocationOptions {
+    at?: 'name' | 'value';
+}
+
+/**
+ * Resolve the location of a JSON object path (defaults to property name).
+ * Pass `true` for `atValue` to get the location of the property value instead.
+ */
+export interface IJSONLocationFunction {
+    (path: string, options?: IJSONLocationOptions): ProblemLocation;
+}
+
+/**
+ * Access parsed JSON with location information and scoping options.
+ */
+export interface IJSONResult {
+
+    /**
+     * The raw parsed data (as would be returned by `JSON.parse`).
+     */
+    data: any;
+
+    /**
+     * Resolve the location of a JSON object path (defaults to property name).
+     * Pass `true` for `atValue` to get the location of the property value instead.
+     */
+    getLocation: IJSONLocationFunction;
+
+    /**
+     * Get a `JSONResult` scoped to the specified path as its root.
+     * @param path The path to the new root (e.g. `foo.bar`)
+     */
+    scope(path: string): IJSONResult;
+}

packages/hint/src/lib/types/schema-validation-result.ts

@@ -1,8 +1,13 @@
 import * as ajv from 'ajv';
+import { ProblemLocation } from './problems';
+
+export interface ISchemaValidationError extends ajv.ErrorObject {
+    location?: ProblemLocation;
+}
 
 export type SchemaValidationResult = {
     data: any;
-    errors: Array<ajv.ErrorObject>;
+    errors: Array<ISchemaValidationError>;
     prettifiedErrors: Array<string>;
     valid: boolean;
 };