@platformos/platformos-check-common 0.0.2

package/src/context-utils.ts

@@ -0,0 +1,220 @@
+import { URI, Utils } from 'vscode-uri';
+import { AbstractFileSystem, FileTuple, FileType, UriString } from '@platformos/platformos-common';
+import { parseJSON } from './json';
+import { join } from './path';
+import {
+  MetafieldCategory,
+  MetafieldDefinitionMap,
+  SourceCodeType,
+  Theme,
+  Translations,
+} from './types';
+import { isError } from './utils';
+
+export type FileExists = (uri: string) => Promise<boolean>;
+
+export const makeFileExists = (fs: AbstractFileSystem): FileExists =>
+  async function fileExists(uri: string) {
+    try {
+      await fs.stat(uri);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  };
+
+export const makeFileSize = (fs: AbstractFileSystem) =>
+  async function fileSize(uri: string) {
+    try {
+      const stats = await fs.stat(uri);
+      return stats.size;
+    } catch (error) {
+      return 0;
+    }
+  };
+
+export const makeGetDefaultLocaleFileUri = getDefaultLocaleFileUriFactoryFactory('default.json');
+export const makeGetDefaultSchemaLocaleFileUri =
+  getDefaultLocaleFileUriFactoryFactory('.default.schema.json');
+function getDefaultLocaleFileUriFactoryFactory(postfix = '.default.json') {
+  return function getDefaultLocaleFileUriFactory(fs: AbstractFileSystem) {
+    return (rootUri: string) => getDefaultLocaleFile(fs, rootUri, postfix);
+  };
+}
+
+export const makeGetDefaultLocale = getDefaultLocaleFactoryFactory('.default.json');
+export const makeGetDefaultSchemaLocale = getDefaultLocaleFactoryFactory('.default.schema.json');
+function getDefaultLocaleFactoryFactory(postfix = '.default.json') {
+  return function getDefaultLocaleFactory(fs: AbstractFileSystem, rootUri: string) {
+    return cached(() => getDefaultLocale(fs, rootUri, postfix));
+  };
+}
+
+export const makeGetDefaultTranslations = getDefaultTranslationsFactoryFactory('.default.json');
+export const makeGetDefaultSchemaTranslations =
+  getDefaultTranslationsFactoryFactory('.default.schema.json');
+// prettier-ignore
+function getDefaultTranslationsFactoryFactory(postfix = '.default.json') {
+  return function getDefaultTranslationsFactory(fs: AbstractFileSystem, theme: Theme, rootUri: string) {
+    return cached(() => getDefaultTranslations(fs, theme, rootUri, postfix));
+  };
+}
+
+async function getDefaultLocaleFile(
+  fs: AbstractFileSystem,
+  rootUri: string,
+  postfix = '.default.json',
+) {
+  const files = await fs.readDirectory(join(rootUri, 'locales'));
+  return files.find(([uri]) => uri.endsWith(postfix))?.[0];
+}
+
+async function getDefaultLocale(
+  fs: AbstractFileSystem,
+  rootUri: string,
+  postfix: string,
+): Promise<string> {
+  try {
+    const defaultLocaleFile = await getDefaultLocaleFile(fs, rootUri, postfix);
+    if (!defaultLocaleFile) return 'en';
+    const defaultLocaleFileName = Utils.basename(URI.parse(defaultLocaleFile));
+    return defaultLocaleFileName.split('.')[0];
+  } catch (error) {
+    console.error(error);
+    return 'en';
+  }
+}
+
+async function getDefaultTranslations(
+  fs: AbstractFileSystem,
+  theme: Theme,
+  rootUri: string,
+  postfix: string,
+): Promise<Translations> {
+  try {
+    const bufferTranslations = getDefaultTranslationsFromBuffer(theme, postfix);
+    if (bufferTranslations) return bufferTranslations;
+    const defaultLocaleFile = await getDefaultLocaleFile(fs, rootUri, postfix);
+    if (!defaultLocaleFile) return {};
+    const defaultTranslationsFile = await fs.readFile(defaultLocaleFile);
+    return parseJSON(defaultTranslationsFile, {});
+  } catch (error) {
+    console.error(error);
+    return {};
+  }
+}
+
+/** It might be that you have an open buffer, we prefer translations from there if available */
+function getDefaultTranslationsFromBuffer(theme: Theme, postfix: string): Translations | undefined {
+  const defaultTranslationsSourceCode = theme.find(
+    (sourceCode) =>
+      sourceCode.type === SourceCodeType.JSON &&
+      sourceCode.uri.match(/locales/) &&
+      sourceCode.uri.endsWith(postfix),
+  );
+  if (!defaultTranslationsSourceCode) return undefined;
+  const translations = parseJSON(defaultTranslationsSourceCode.source);
+  if (isError(translations)) return undefined;
+  return translations;
+}
+
+function cached<T>(fn: () => Promise<T>): () => Promise<T>;
+function cached<T>(fn: (...args: any[]) => Promise<T>): (...args: any[]) => Promise<T> {
+  let cachedPromise: Promise<T>;
+  return async (...args) => {
+    if (!cachedPromise) cachedPromise = fn(...args);
+    return cachedPromise;
+  };
+}
+
+export async function recursiveReadDirectory(
+  fs: AbstractFileSystem,
+  uri: string,
+  filter: (fileTuple: FileTuple) => boolean,
+): Promise<UriString[]> {
+  const allFiles = await fs.readDirectory(uri);
+  const files = allFiles.filter((ft) => !isIgnored(ft) && (isDirectory(ft) || filter(ft)));
+
+  const results = await Promise.all(
+    files.map((ft) => {
+      if (isDirectory(ft)) {
+        return recursiveReadDirectory(fs, ft[0], filter);
+      } else {
+        return Promise.resolve([ft[0]]);
+      }
+    }),
+  );
+
+  return results.flat();
+}
+
+export function isDirectory([_, type]: FileTuple) {
+  return type === FileType.Directory;
+}
+
+const ignoredFolders = ['.git', 'node_modules', 'dist', 'build', 'tmp', 'vendor'];
+
+function isIgnored([uri, type]: FileTuple) {
+  return type === FileType.Directory && ignoredFolders.some((folder) => uri.endsWith(folder));
+}
+
+export const FETCHED_METAFIELD_CATEGORIES: MetafieldCategory[] = [
+  'article',
+  'blog',
+  'collection',
+  'company',
+  'company_location',
+  'location',
+  'market',
+  'order',
+  'page',
+  'product',
+  'variant',
+  'shop',
+];
+
+export const makeGetMetafieldDefinitions = (fs: AbstractFileSystem) =>
+  async function (rootUri: string): Promise<MetafieldDefinitionMap> {
+    const definitions = {
+      article: [],
+      blog: [],
+      collection: [],
+      company: [],
+      company_location: [],
+      location: [],
+      market: [],
+      order: [],
+      page: [],
+      product: [],
+      variant: [],
+      shop: [],
+    } as MetafieldDefinitionMap;
+
+    try {
+      const content = await fs.readFile(join(rootUri, '.shopify', 'metafields.json'));
+      const json = parseJSON(content);
+
+      if (isError(json)) return definitions;
+
+      return FETCHED_METAFIELD_CATEGORIES.reduce((definitions, group) => {
+        try {
+          definitions[group] = json[group].map((definition: any) => ({
+            key: definition.key,
+            name: definition.name,
+            namespace: definition.namespace,
+            description: definition.description,
+            type: {
+              category: definition.type.category,
+              name: definition.type.name,
+            },
+          }));
+        } catch (error) {
+          // If there are errors in the file, we ignore it
+        }
+
+        return definitions;
+      }, definitions);
+    } catch (err) {
+      return definitions;
+    }
+  };

package/src/create-safe-check.ts

@@ -0,0 +1,13 @@
+import { Check, SourceCodeType } from './types';
+
+const resolve = () => Promise.resolve(undefined);
+const handleMissingMethod = {
+  get(target: any, prop: string) {
+    if (!(prop in target)) return resolve;
+    return target[prop];
+  },
+};
+
+export function createSafeCheck<S extends SourceCodeType>(check: Partial<Check<S>>): Check<S> {
+  return new Proxy(check, handleMissingMethod);
+}

package/src/disabled-checks/index.spec.ts

@@ -0,0 +1,262 @@
+import { check } from '../test';
+import { Offense } from '..';
+import { describe, it, expect } from 'vitest';
+import { LiquidFilter, RenderMarkup } from './test-checks';
+import { UndefinedObject } from '../checks/undefined-object';
+
+const commentTypes = [
+  (text: string) => `{% # ${text} %}`,
+  (text: string) => `{% comment %}${text}{% endcomment %}`,
+];
+
+function expectLiquidFilterOffense(offenses: Offense[], file: string, assetName: string) {
+  const expectedStart = file.indexOf(`'${assetName}' | random_filter`) + `'${assetName}'`.length;
+  const expectedEnd = expectedStart + ' | random_filter'.length;
+  const foundOffenses = offenses.filter(
+    ({ message, start, end }) =>
+      message === 'Liquid filter can not be used' &&
+      start.index === expectedStart &&
+      end.index === expectedEnd,
+  );
+  expect(foundOffenses).to.have.length(1);
+}
+
+function expectRenderMarkupOffense(offenses: Offense[], templateName: string) {
+  const foundOffenses = offenses.filter(
+    ({ message }) => message === `'${templateName}' can not be rendered`,
+  );
+  expect(foundOffenses).to.have.length(1);
+}
+
+describe('Module: DisabledChecks', () => {
+  const checks = [LiquidFilter, RenderMarkup];
+
+  describe(`Comment variant`, () => {
+    it('should disable checks for the entire document if comment is placed on the first line', async () => {
+      for (const buildComment of commentTypes) {
+        const file = `${buildComment('theme-check-disable LiquidFilter')}
+{% comment %}
+  This is some comment about the file...
+  Adding a comment here should not mess with theme-check-disable
+{% endcomment %}
+{{ 'asset' | random_filter }}
+{% render 'something' %}`;
+
+        const offenses = await check({ 'code.liquid': file }, checks);
+        expect(offenses).to.have.length(1);
+        expectRenderMarkupOffense(offenses, 'something.liquid');
+      }
+    });
+
+    it('should disable all checks even if comment has additional spaces', async () => {
+      for (const buildComment of commentTypes) {
+        const file = `${buildComment('  theme-check-disable     ')}
+{{ 'asset' | random_filter }}
+{% render 'something' %}`;
+
+        const offenses = await check({ 'code.liquid': file }, checks);
+        expect(offenses).to.have.length(0);
+      }
+    });
+
+    it('should disable all checks for a section of the template', async () => {
+      for (const buildComment of commentTypes) {
+        const file = `{{ 'asset-1' | random_filter }}
+{% render 'something-1' %}
+${buildComment('theme-check-disable')}
+{{ 'asset-2' | random_filter }}
+{% render 'something-2' %}
+${buildComment('theme-check-enable')}
+{{ 'asset-3' | random_filter }}`;
+
+        const offenses = await check({ 'code.liquid': file }, checks);
+        expect(offenses).to.have.length(3);
+        expectLiquidFilterOffense(offenses, file, 'asset-1');
+        expectLiquidFilterOffense(offenses, file, 'asset-3');
+        expectRenderMarkupOffense(offenses, 'something-1.liquid');
+      }
+    });
+
+    it('should disable a specific check if check is included in the comment', async () => {
+      for (const buildComment of commentTypes) {
+        const file = `${buildComment('theme-check-disable LiquidFilter')}
+{{ 'asset-1' | random_filter }}
+{% render 'something' %}
+${buildComment('theme-check-enable LiquidFilter')}
+{{ 'asset-2' | random_filter }}`;
+
+        const offenses = await check({ 'code.liquid': file }, checks);
+        expect(offenses).to.have.length(2);
+        expectLiquidFilterOffense(offenses, file, 'asset-2');
+        expectRenderMarkupOffense(offenses, 'something.liquid');
+      }
+    });
+
+    it('should disable multiple checks if checks are separated by a comma (and maybe some spaces)', async () => {
+      for (const buildComment of commentTypes) {
+        const file = `${buildComment('theme-check-disable LiquidFilter, RenderMarkup')}
+{{ 'asset-1' | random_filter }}
+{% render 'something' %}
+${buildComment('theme-check-enable LiquidFilter,RenderMarkup')}
+{{ 'asset-2' | random_filter }}`;
+
+        const offenses = await check({ 'code.liquid': file }, checks);
+        expect(offenses).to.have.length(1);
+        expectLiquidFilterOffense(offenses, file, 'asset-2');
+      }
+    });
+
+    it('should enable specific checks individually', async () => {
+      for (const buildComment of commentTypes) {
+        const file = `${buildComment('theme-check-disable LiquidFilter, RenderMarkup')}
+{{ 'asset-1' | random_filter }}
+{% render 'something-1' %}
+${buildComment('theme-check-enable RenderMarkup')}
+{{ 'asset-2' | random_filter }}
+{% render 'something-2' %}
+${buildComment('theme-check-enable LiquidFilter')}
+{{ 'asset-3' | random_filter }}
+{% render 'something-3' %}`;
+
+        const offenses = await check({ 'code.liquid': file }, checks);
+        expect(offenses).to.have.length(3);
+        expectLiquidFilterOffense(offenses, file, 'asset-3');
+        expectRenderMarkupOffense(offenses, 'something-2.liquid');
+        expectRenderMarkupOffense(offenses, 'something-3.liquid');
+      }
+    });
+
+    describe('Mix of general and specific commands', () => {
+      it('should not reenable specific check when all checks have been disabled before', async () => {
+        for (const buildComment of commentTypes) {
+          const file = `${buildComment('theme-check-disable')}
+{{ 'asset-1' | random_filter }}
+{% render 'something-1' %}
+${buildComment('theme-check-enable RenderMarkup')}
+{{ 'asset-2' | random_filter }}
+{% render 'something-2' %}`;
+          const offenses = await check({ 'code.liquid': file }, checks);
+          expect(offenses).to.have.length(0);
+        }
+      });
+
+      it('should reenable all checks when specific ones have been disabled before', async () => {
+        for (const buildComment of commentTypes) {
+          const file = `${buildComment('theme-check-disable LiquidFilter, RenderMarkup')}
+{{ 'asset-3' | random_filter }}
+{% render 'something-3' %}
+${buildComment('theme-check-enable')}
+{{ 'asset-4' | random_filter }}
+{% render 'something-4' %}`;
+
+          const offenses = await check({ 'code.liquid': file }, checks);
+          expect(offenses).to.have.length(2);
+          expectLiquidFilterOffense(offenses, file, 'asset-4');
+          expectRenderMarkupOffense(offenses, 'something-4.liquid');
+        }
+      });
+    });
+
+    describe('disable next line', () => {
+      it('should disable the next line if there is one', async () => {
+        const file = `{% # theme-check-disable-next-line %}
+{% render 'something' %}
+{% render 'other-thing' %}`;
+
+        const offenses = await check({ 'code.liquid': file }, checks);
+        expect(offenses).to.have.length(1);
+        expectRenderMarkupOffense(offenses, 'other-thing.liquid');
+      });
+
+      it("should not disable the liquid tag's children node if theme check is disabled", async () => {
+        const file = `{% # theme-check-disable-next-line %}
+{% if condition %}
+  {% render 'something' %}
+{% endif %}
+{% render 'other-thing' %}`;
+
+        const offenses = await check({ 'code.liquid': file }, checks);
+        expect(offenses).to.have.length(2);
+        expectRenderMarkupOffense(offenses, 'something.liquid');
+        expectRenderMarkupOffense(offenses, 'other-thing.liquid');
+      });
+
+      it('should disable the next line inside a liquid tag if there is one', async () => {
+        const file = `{% liquid
+  # theme-check-disable-next-line
+  render 'something'
+  render 'other-thing'
+%}`;
+
+        const offenses = await check({ 'code.liquid': file }, checks);
+        expect(offenses).to.have.length(1);
+        expectRenderMarkupOffense(offenses, 'other-thing.liquid');
+      });
+
+      it("should disable the parent node's next node if theme check is disabled as the last child node", async () => {
+        const file = `{% liquid
+  if condition
+    # theme-check-disable-next-line
+  elsif other_condition
+  endif
+%}`;
+
+        const offenses = await check({ 'code.liquid': file }, [UndefinedObject]);
+        expect(offenses).to.have.length(1);
+        expect(offenses).toContainEqual(
+          expect.objectContaining({
+            message: "Unknown object 'condition' used.",
+          }),
+        );
+      });
+
+      it('should not disable any checks if theme-check is disabled at the end', async () => {
+        const file = `{% liquid
+  echo hello
+  echo everyone
+  # theme-check-disable-next-line
+%}`;
+
+        const offenses = await check({ 'code.liquid': file }, [UndefinedObject]);
+        expect(offenses).to.have.length(2);
+        expect(offenses).toContainEqual(
+          expect.objectContaining({
+            message: "Unknown object 'hello' used.",
+          }),
+        );
+        expect(offenses).toContainEqual(
+          expect.objectContaining({
+            message: "Unknown object 'everyone' used.",
+          }),
+        );
+      });
+
+      it('should disable the next line if the content is an HTML tag with liquid', async () => {
+        const file = `{% # theme-check-disable-next-line %}
+<div class="{{ foo }}"></div>
+<div class="{{ bar }}"></div>`;
+
+        const offenses = await check({ 'code.liquid': file }, [UndefinedObject]);
+        expect(offenses).to.have.length(1);
+        expect(offenses).toContainEqual(
+          expect.objectContaining({
+            message: "Unknown object 'bar' used.",
+          }),
+        );
+      });
+
+      it('should not disable the next line if the specified rule does not exist', async () => {
+        const file = `{% # theme-check-disable-next-line FAKE_RULE %}
+<div class="{{ foo }}"></div>`;
+
+        const offenses = await check({ 'code.liquid': file }, [UndefinedObject]);
+        expect(offenses).to.have.length(1);
+        expect(offenses).toContainEqual(
+          expect.objectContaining({
+            message: "Unknown object 'foo' used.",
+          }),
+        );
+      });
+    });
+  });
+});

package/src/disabled-checks/index.ts

@@ -0,0 +1,189 @@
+import { LiquidHtmlNode, LiquidRawTag, LiquidTag, Position } from '@platformos/liquid-html-parser';
+import {
+  LiquidCheckDefinition,
+  LiquidHtmlNodeTypes,
+  Offense,
+  SourceCode,
+  SourceCodeType,
+  UriString,
+} from '../types';
+import { findCurrentNode } from '../visitor';
+import { isError } from '../utils';
+
+type CheckName = string;
+type DisabledChecksMap = Map<UriString, Map<CheckName, { from: number; to?: number }[]>>;
+
+export function createDisabledChecksModule() {
+  const SPECIFIC_CHECK_NOT_DEFINED = '@all';
+  const INLINE_COMMENT_TAG = '#';
+  const disabledChecks: DisabledChecksMap = new Map();
+
+  function determineRanges(
+    file: SourceCode<SourceCodeType.LiquidHtml>,
+    value: string,
+    node: LiquidTag | LiquidRawTag,
+  ) {
+    const [_, command, checksJoined] =
+      value.trim().match(/^(?:theme\-check\-(disable-next-line|disable|enable)) ?(.*)/) || [];
+
+    const checks = checksJoined ? checksJoined.split(/,[ ]*/) : [SPECIFIC_CHECK_NOT_DEFINED];
+
+    checks.forEach((check) => {
+      const disabledRanges = disabledChecks.get(file.uri)!;
+
+      if (command === 'disable-next-line' && !isError(file.ast)) {
+        const nextLinePosition = findNextLinePosition(file.ast, node);
+
+        if (nextLinePosition) {
+          if (!disabledRanges.has(check)) {
+            disabledRanges.set(check, []);
+          }
+          disabledRanges.get(check)!.push({
+            from: nextLinePosition.start,
+            to: nextLinePosition.end,
+          });
+        }
+      }
+
+      if (command === 'disable') {
+        if (!disabledRanges.has(check)) {
+          disabledRanges.set(check, []);
+        }
+        disabledRanges.get(check)!.push({ from: node.position.end });
+      }
+
+      if (command === 'enable') {
+        let disabledRangesForCheck = disabledRanges.get(check);
+        if (disabledRangesForCheck) {
+          disabledRangesForCheck[disabledRangesForCheck.length - 1].to = node.position.start;
+        } else {
+          if (check === SPECIFIC_CHECK_NOT_DEFINED) {
+            for (let ranges of disabledRanges.values()) {
+              for (let range of ranges) {
+                if (!range.to) {
+                  range.to = node.position.start;
+                }
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+
+  const DisabledChecksVisitor: LiquidCheckDefinition = {
+    meta: { schema: {} } as any,
+    create: ({ file }) => ({
+      async onCodePathStart() {
+        disabledChecks.set(file.uri, new Map());
+      },
+
+      async LiquidRawTag(node) {
+        if (node.name !== 'comment') {
+          return;
+        }
+
+        determineRanges(file, node.body.value, node);
+      },
+
+      async LiquidTag(node) {
+        if (typeof node.markup !== 'string' || node.name !== INLINE_COMMENT_TAG) {
+          return;
+        }
+
+        determineRanges(file, node.markup, node);
+      },
+    }),
+  };
+
+  function isDisabled(offense: Offense) {
+    const ranges = [SPECIFIC_CHECK_NOT_DEFINED, offense.check].flatMap((check) => {
+      if (!disabledChecks.has(offense.uri)) {
+        return [];
+      }
+      if (!disabledChecks.get(offense.uri)!.has(check)) {
+        return [];
+      }
+      return disabledChecks.get(offense.uri)!.get(check)!;
+    });
+
+    return ranges.some(
+      (range) => offense.start.index >= range.from && (!range.to || offense.end.index <= range.to),
+    );
+  }
+
+  return {
+    DisabledChecksVisitor,
+    isDisabled,
+  };
+}
+
+export function findNextLinePosition(
+  ast: LiquidHtmlNode,
+  node: LiquidHtmlNode,
+): Position | undefined {
+  const [currentNode, ancestors] = findCurrentNode(ast, node.position.end);
+  const parentNode = ancestors.at(-1);
+  const grandParentNode = ancestors.at(-2);
+
+  let nextNode = getNextNode(parentNode, currentNode);
+  /*
+   * If there is no "next" node, assume they mean the parent block's next node.
+   *
+   * E.g. The following disables check for `elsif` tag
+   *
+   * {% if condition %}
+   *   {% #theme-check-disable-next-line %}
+   * {% elsif other_condition %}
+   *   {{ prouduct }}
+   * {% endif %}
+   *
+   * NOTE: We don't want to do this recursively since it doesn't make sense to go
+   * past 1 depth.
+   */
+  if (!nextNode) {
+    if (parentNode) {
+      nextNode = getNextNode(grandParentNode, parentNode);
+    }
+
+    if (!nextNode) {
+      return;
+    }
+  }
+
+  /*
+   * If the node contains children nodes, we don't want to disable checks for them.
+   * We want to keep it exclusively to the tag itself.
+   */
+  if ('blockStartPosition' in nextNode) {
+    return nextNode.blockStartPosition;
+  }
+
+  return nextNode.position;
+}
+
+function getNextNode(
+  parentNode: LiquidHtmlNode | undefined,
+  node: LiquidHtmlNode,
+): LiquidHtmlNode | undefined {
+  if (!parentNode) {
+    return;
+  }
+
+  let siblingNodes: LiquidHtmlNode[] = [];
+
+  // Could be sibling nodes within a `liquid` tag
+  if (parentNode.type === LiquidHtmlNodeTypes.LiquidTag && Array.isArray(parentNode.markup)) {
+    siblingNodes = parentNode.markup;
+  } else if ('children' in parentNode) {
+    siblingNodes = parentNode.children || [];
+  }
+
+  const currentNodeIdx = siblingNodes.findIndex((c) => c === node);
+
+  if (currentNodeIdx === -1) return;
+
+  const nextNode = siblingNodes.at(currentNodeIdx + 1);
+
+  return nextNode;
+}