@platformos/platformos-check-common 0.0.7 → 0.0.9

package/src/test/MockFileSystem.spec.ts

@@ -7,20 +7,21 @@ describe('MockFileSystem', () => {
 
   beforeEach(() => {
     fs = new MockFileSystem({
-      'layout/theme.liquid': 'theme.liquid content',
-      'layout/password.liquid': 'password.liquid content',
+      'app/views/layouts/layout.liquid': 'layout.liquid content',
+      'app/views/layouts/password.liquid': 'password.liquid content',
       'app/views/partials/product-card.liquid': 'product-card.liquid content',
       'app/views/partials/product-variant.liquid': 'product-variant.liquid content',
-      'sections/section.liquid': 'section.liquid content',
       'assets/js/foo.js': 'foo.js content',
       'assets/js/bar.js': 'bar.js content',
-      'assets/theme.js': 'theme.js content',
+      'assets/app.js': 'app.js content',
     });
   });
 
   describe('readFile', () => {
     it('returns the content of existing files', async () => {
-      expect(await fs.readFile('file:/layout/theme.liquid')).toBe('theme.liquid content');
+      expect(await fs.readFile('file:/app/views/layouts/layout.liquid')).toBe(
+        'layout.liquid content',
+      );
       expect(await fs.readFile('file:/assets/js/foo.js')).toBe('foo.js content');
     });
 
@@ -31,10 +32,10 @@ describe('MockFileSystem', () => {
 
   describe('readDirectory', () => {
     it('returns the list of files in a leaf', async () => {
-      const result = await fs.readDirectory('file:/layout');
+      const result = await fs.readDirectory('file:/app/views/layouts');
       expect(result).to.eql([
-        ['file:/layout/theme.liquid', FileType.File],
-        ['file:/layout/password.liquid', FileType.File],
+        ['file:/app/views/layouts/layout.liquid', FileType.File],
+        ['file:/app/views/layouts/password.liquid', FileType.File],
       ]);
     });
 
@@ -42,16 +43,14 @@ describe('MockFileSystem', () => {
       const result = await fs.readDirectory('file:/assets');
       expect(result).to.eql([
         ['file:/assets/js', FileType.Directory],
-        ['file:/assets/theme.js', FileType.File],
+        ['file:/assets/app.js', FileType.File],
       ]);
     });
 
     it('returns the list of files and directories at the root', async () => {
       const result = await fs.readDirectory('file:/');
       expect(result).to.eql([
-        ['file:/layout', FileType.Directory],
         ['file:/app', FileType.Directory],
-        ['file:/sections', FileType.Directory],
         ['file:/assets', FileType.Directory],
       ]);
     });

package/src/test/MockFileSystem.ts

@@ -1,7 +1,7 @@
 import { AbstractFileSystem, FileStat, FileTuple, FileType } from '@platformos/platformos-common';
 import { deepGet } from '../utils';
 import { normalize, relative } from '../path';
-import { MockTheme } from './MockTheme';
+import { MockApp } from './MockApp';
 import * as path from '../path';
 
 interface FileTree {
@@ -12,7 +12,7 @@ export class MockFileSystem implements AbstractFileSystem {
   private rootUri: string;
 
   constructor(
-    private mockTheme: MockTheme,
+    private mockApp: MockApp,
     rootUri = 'file:///',
   ) {
     this.rootUri = normalize(rootUri);
@@ -20,10 +20,10 @@ export class MockFileSystem implements AbstractFileSystem {
 
   async readFile(uri: string): Promise<string> {
     const relativePath = this.rootRelative(uri);
-    if (this.mockTheme[relativePath] === undefined) {
+    if (this.mockApp[relativePath] === undefined) {
       throw new Error('File not found');
     } else {
-      return this.mockTheme[relativePath];
+      return this.mockApp[relativePath];
     }
   }
 
@@ -50,7 +50,7 @@ export class MockFileSystem implements AbstractFileSystem {
 
   async stat(uri: string): Promise<FileStat> {
     const relativePath = this.rootRelative(uri);
-    const source = this.mockTheme[relativePath];
+    const source = this.mockApp[relativePath];
     if (source) {
       return {
         type: FileType.File,
@@ -71,7 +71,7 @@ export class MockFileSystem implements AbstractFileSystem {
 
   private get fileTree(): FileTree {
     const result: FileTree = {};
-    for (const [relativePath, source] of Object.entries(this.mockTheme)) {
+    for (const [relativePath, source] of Object.entries(this.mockApp)) {
       const segments = relativePath.split('/');
       let current = result;
       for (let i = 0; i < segments.length - 1; i++) {

package/src/test/contain-offense.spec.ts

@@ -7,7 +7,10 @@ const rootUri = 'file:///';
 describe('Module: containOffense', () => {
   const offenses: Offense[] = [
     buildOffense(`The translation for 'hello.world' is missing`, 'locales/en.json'),
-    buildOffense(`'app/views/partials/missing.liquid' does not exist`, 'layout/theme.liquid'),
+    buildOffense(
+      `'app/views/partials/missing.liquid' does not exist`,
+      'app/views/layouts/layout.liquid',
+    ),
   ];
 
   describe('with string assertions', () => {
@@ -29,12 +32,17 @@ describe('Module: containOffense', () => {
 
     it(`should not contain the Offense when their messages match but absolute paths don't match`, () => {
       expect(offenses).to.not.containOffense(
-        buildOffense(`The translation for 'hello.world' is missing`, 'layout/password.liquid'),
+        buildOffense(
+          `The translation for 'hello.world' is missing`,
+          'app/views/layouts/password.liquid',
+        ),
       );
     });
 
     it(`should not contain the Offense when their absolute paths match but messages don't match`, () => {
-      expect(offenses).to.not.containOffense(buildOffense('!!!', 'layout/theme.liquid'));
+      expect(offenses).to.not.containOffense(
+        buildOffense('!!!', 'app/views/layouts/layout.liquid'),
+      );
     });
 
     it(`should not contain the Offense when their absolute paths and messages don't match`, () => {

package/src/test/index.ts

@@ -1,3 +1,3 @@
 export * from './MockFileSystem';
-export * from './MockTheme';
+export * from './MockApp';
 export * from './test-helper';

package/src/test/test-helper.ts

@@ -10,44 +10,39 @@ import {
   Dependencies,
   extractDocDefinition,
   FixApplicator,
-  isBlock,
-  isSection,
   JSONCorrector,
   JSONSourceCode,
   LiquidSourceCode,
   Offense,
   recommended,
-  SectionSchema,
   SourceCodeType,
   StringCorrector,
-  Theme,
-  ThemeBlockSchema,
-  toSchema,
+  App,
   toSourceCode,
+  YAMLSourceCode,
 } from '../index';
 import * as path from '../path';
 import { MockFileSystem } from './MockFileSystem';
-import { MockTheme } from './MockTheme';
+import { MockApp } from './MockApp';
 
 export { JSONCorrector, StringCorrector };
 
 const rootUri = path.normalize('file:/');
 
-export function getTheme(themeDesc: MockTheme): Theme {
-  return Object.entries(themeDesc)
+export function getApp(appDesc: MockApp): App {
+  return Object.entries(appDesc)
     .map(([relativePath, source]) => toSourceCode(toUri(relativePath), source))
-    .filter((x): x is LiquidSourceCode | JSONSourceCode => x !== undefined);
+    .filter((x): x is LiquidSourceCode | JSONSourceCode | YAMLSourceCode => x !== undefined);
 }
 
 export async function check(
-  themeDesc: MockTheme,
+  appDesc: MockApp,
   checks: CheckDefinition[] = recommended,
   mockDependencies: Partial<Dependencies> = {},
   checkSettings: ChecksSettings = {},
 ): Promise<Offense[]> {
-  const theme = getTheme(themeDesc);
+  const app = getApp(appDesc);
   const config: Config = {
-    context: 'theme',
     settings: { ...checkSettings },
     checks,
     rootUri,
@@ -56,95 +51,27 @@ export async function check(
     },
   };
 
-  const sections = new Map(
-    theme
-      .filter((source) => isSection(source.uri))
-      .map((source) => [path.basename(source.uri, '.liquid'), source]),
-  );
-  const blocks = new Map(
-    theme
-      .filter((source) => isBlock(source.uri))
-      .map((source) => [path.basename(source.uri, '.liquid'), source]),
-  );
-
-  /**
-   * Schemas are assumed to be valid in tests, hijack
-   * getBlockSchema/getSectionSchema with overrides when you want to test
-   * something otherwise
-   */
-  const isValidSchema = async () => true;
-
   const defaultMockDependencies: Dependencies = {
-    fs: new MockFileSystem({ '.theme-check.yml': '', ...themeDesc }),
-    async getBlockSchema(name) {
-      const block = blocks.get(name);
-      if (!block) return undefined;
-      return toSchema(config.context, block.uri, block, isValidSchema) as Promise<
-        ThemeBlockSchema | undefined
-      >;
-    },
-    async getSectionSchema(name) {
-      const section = sections.get(name);
-      if (!section) return undefined;
-      return toSchema(config.context, section.uri, section, isValidSchema) as Promise<
-        SectionSchema | undefined
-      >;
-    },
+    fs: new MockFileSystem({ '.platformos-check.yml': '', ...appDesc }),
     async getDocDefinition(relativePath) {
-      const file = theme.find((file) => file.uri.endsWith(relativePath));
+      const file = app.find((file) => file.uri.endsWith(relativePath));
       if (!file || !isLiquidHtmlNode(file.ast)) {
         return undefined;
       }
       return extractDocDefinition(file.uri, file.ast);
     },
-    themeDocset: {
+    platformosDocset: {
       async graphQL() {
         return null;
       },
       async filters() {
         return [
           { name: 'item_count_for_variant' },
-          { name: 'link_to_type' },
-          { name: 'link_to_vendor' },
           { name: 'append' },
           { name: 'upcase' },
           { name: 'downcase' },
-          { name: 'color_to_rgb' },
-          {
-            name: 'hex_to_rgba',
-            deprecated: true,
-            deprecation_reason: '`hex_to_rgba` has been replaced by [`color_to_rgb`](/do...',
-          },
-          {
-            name: 'currency_selector',
-            deprecated: true,
-            deprecation_reason: 'Deprecated without a direct replacement because the [cur...',
-          },
-          {
-            name: 'article_img_url',
-            deprecated: true,
-            deprecation_reason: '`article_img_url` has been replaced by [`image_url`](/d...',
-          },
-          {
-            name: 'collection_img_url',
-            deprecated: true,
-            deprecation_reason: '`collection_img_url` has been replaced by [`image_url`](...',
-          },
-          {
-            name: 'img_tag',
-            deprecated: true,
-            deprecation_reason: '`img_tag` has been replaced by [`image_tag`](/docs/api/...',
-          },
-          {
-            name: 'img_url',
-            deprecated: true,
-            deprecation_reason: '`img_url` has been replaced by [`image_url`](/docs/api/...',
-          },
-          {
-            name: 'product_img_url',
-            deprecated: true,
-            deprecation_reason: '`product_img_url` has been replaced by [`image_url`](/d...',
-          },
+          { name: 'parameterize' },
+          { name: 'slugify' },
         ];
       },
       async objects() {
@@ -169,17 +96,9 @@ export async function check(
             },
           },
           {
-            name: 'section',
-            access: {
-              global: false,
-              parents: [],
-              template: [],
-            },
-          },
-          {
-            name: 'block',
+            name: 'context',
             access: {
-              global: false,
+              global: true,
               parents: [],
               template: [],
             },
@@ -192,30 +111,6 @@ export async function check(
               template: [],
             },
           },
-          {
-            name: 'predictive_search',
-            access: {
-              global: false,
-              parents: [],
-              template: [],
-            },
-          },
-          {
-            name: 'recommendations',
-            access: {
-              global: false,
-              parents: [],
-              template: [],
-            },
-          },
-          {
-            name: 'comment',
-            access: {
-              global: false,
-              parents: [],
-              template: [],
-            },
-          },
         ];
       },
       async liquidDrops() {
@@ -224,13 +119,10 @@ export async function check(
       async tags() {
         return [];
       },
-      async systemTranslations() {
-        return { 'shopify.sentence.words_connector': ', ' };
-      },
     },
   };
 
-  return coreCheck(theme, config, { ...defaultMockDependencies, ...mockDependencies });
+  return coreCheck(app, config, { ...defaultMockDependencies, ...mockDependencies });
 }
 
 export async function runLiquidCheck(
@@ -238,10 +130,10 @@ export async function runLiquidCheck(
   sourceCode: string,
   fileName: string = 'file.liquid',
   mockDependencies: Partial<Dependencies> = {},
-  existingThemeFiles?: MockTheme,
+  existingAppFiles?: MockApp,
 ): Promise<Offense[]> {
   const offenses = await check(
-    { ...existingThemeFiles, [fileName]: sourceCode },
+    { ...existingAppFiles, [fileName]: sourceCode },
     [checkDef],
     mockDependencies,
   );
@@ -258,40 +150,47 @@ export async function runJSONCheck(
   return offenses.filter((offense) => offense.uri === path.join(rootUri, fileName));
 }
 
-export async function autofix(themeDesc: MockTheme, offenses: Offense[]) {
-  const theme = getTheme(themeDesc);
-  const fixed = { ...themeDesc };
+export async function runYAMLCheck(
+  checkDef: CheckDefinition<SourceCodeType.YAML>,
+  sourceCode: string,
+  fileName: string = 'file.yml',
+  mockDependencies: Partial<Dependencies> = {},
+): Promise<Offense[]> {
+  const offenses = await check({ [fileName]: sourceCode }, [checkDef], mockDependencies);
+  return offenses.filter((offense) => offense.uri === path.join(rootUri, fileName));
+}
+
+export async function autofix(appDesc: MockApp, offenses: Offense[]) {
+  const app = getApp(appDesc);
+  const fixed = { ...appDesc };
 
   const stringApplicator: FixApplicator = async (sourceCode, fixes) => {
     fixed[asRelative(sourceCode.uri)] = applyFixToString(sourceCode.source, fixes);
   };
 
-  await coreAutofix(theme, offenses, stringApplicator);
+  await coreAutofix(app, offenses, stringApplicator);
 
   return fixed;
 }
 
-export function applyFix(
-  themeDescOrSource: MockTheme | string,
-  offense: Offense,
-): string | undefined {
+export function applyFix(appDescOrSource: MockApp | string, offense: Offense): string | undefined {
   const source =
-    typeof themeDescOrSource === 'string'
-      ? themeDescOrSource
-      : themeDescOrSource[asRelative(offense.uri)];
+    typeof appDescOrSource === 'string'
+      ? appDescOrSource
+      : appDescOrSource[asRelative(offense.uri)];
   const corrector = createCorrector(offense.type, source);
   offense.fix?.(corrector as any);
   return applyFixToString(source, corrector.fix);
 }
 
 export function applySuggestions(
-  themeDescOrSource: MockTheme | string,
+  appDescOrSource: MockApp | string,
   offense: Offense,
 ): undefined | string[] {
   const source =
-    typeof themeDescOrSource === 'string'
-      ? themeDescOrSource
-      : themeDescOrSource[asRelative(offense.uri)];
+    typeof appDescOrSource === 'string'
+      ? appDescOrSource
+      : appDescOrSource[asRelative(offense.uri)];
   return offense.suggest?.map((suggestion) => {
     const corrector = createCorrector(offense.type, source);
     suggestion.fix(corrector as any);
@@ -299,12 +198,11 @@ export function applySuggestions(
   });
 }
 
-export function highlightedOffenses(themeOrSource: MockTheme | string, offenses: Offense[]) {
-  const theme =
-    typeof themeOrSource === 'string' ? { 'file.liquid': themeOrSource } : themeOrSource;
+export function highlightedOffenses(appOrSource: MockApp | string, offenses: Offense[]) {
+  const app = typeof appOrSource === 'string' ? { 'file.liquid': appOrSource } : appOrSource;
   return offenses.map((offense) => {
     const relativePath = path.relative(offense.uri, rootUri);
-    const source = theme[relativePath];
+    const source = app[relativePath];
     const {
       start: { index: startIndex },
       end: { index: endIndex },

package/src/to-source-code.ts

@@ -1,6 +1,7 @@
 import { toLiquidHtmlAST } from '@platformos/liquid-html-parser';
 
 import { toJSONNode } from './jsonc/parse';
+import { toYAMLNode } from './yaml/parse';
 import * as path from './path';
 import {
   GraphQLDocumentNode,
@@ -9,6 +10,7 @@ import {
   JSONSourceCode,
   LiquidSourceCode,
   SourceCodeType,
+  YAMLSourceCode,
 } from './types';
 import { asError } from './utils/error';
 
@@ -28,6 +30,14 @@ export function toJSONAST(source: string): JSONNode | Error {
   }
 }
 
+export function toYAMLAST(source: string): JSONNode | Error {
+  try {
+    return toYAMLNode(source);
+  } catch (error) {
+    return asError(error);
+  }
+}
+
 export function toGraphQLAST(source: string): GraphQLDocumentNode | Error {
   try {
     return {
@@ -43,9 +53,10 @@ export function toSourceCode(
   uri: string,
   source: string,
   version?: number,
-): LiquidSourceCode | JSONSourceCode | GraphQLSourceCode {
+): LiquidSourceCode | JSONSourceCode | GraphQLSourceCode | YAMLSourceCode {
   const isLiquid = uri.endsWith('.liquid');
   const isGraphQL = uri.endsWith('.graphql');
+  const isYAML = uri.endsWith('.yml') || uri.endsWith('.yaml');
 
   if (isLiquid) {
     return {
@@ -63,6 +74,14 @@ export function toSourceCode(
       ast: toGraphQLAST(source),
       version,
     };
+  } else if (isYAML) {
+    return {
+      uri: path.normalize(uri),
+      source,
+      type: SourceCodeType.YAML,
+      ast: toYAMLAST(source),
+      version,
+    };
   } else {
     return {
       uri: path.normalize(uri),

package/src/types/{theme-liquid-docs.ts → platformos-liquid-docs.ts}

@@ -1,29 +1,24 @@
-import { Mode, Translations } from '..';
-
 /**
- * Shopify themes docset.
+ * platformOS Liquid docset.
  */
-export interface ThemeDocset {
+export interface PlatformOSDocset {
   /** Whether it was augmented prior to being passed. */
   isAugmented?: boolean;
 
-  /** Returns Liquid filters available on themes. */
+  /** Returns Liquid filters available in platformOS. */
   filters(): Promise<FilterEntry[]>;
 
-  /** Returns objects (or Liquid variables) available on themes. */
+  /** Returns objects (or Liquid variables) available in platformOS. */
   objects(): Promise<ObjectEntry[]>;
 
-  /** Returns objects (excluding global variables, hidden objects, and deprecated objects) available on themes. */
+  /** Returns objects (excluding global variables, hidden objects, and deprecated objects) available in platformOS. */
   liquidDrops(): Promise<ObjectEntry[]>;
 
-  /** Returns Liquid tags available on themes. */
+  /** Returns Liquid tags available in platformOS. */
   tags(): Promise<TagEntry[]>;
 
   /** Returns graphql root query */
   graphQL(): Promise<string | null>;
-
-  /** Returns system translations available on themes. */
-  systemTranslations(): Promise<Translations>;
 }
 
 /** A URI that will uniquely describe the schema */
@@ -45,10 +40,10 @@ export interface SchemaDefinition {
   fileMatch?: string[];
 }
 
-/** Source of JSON schemas for themes. */
+/** Source of JSON schemas for the app. */
 export interface JsonValidationSet {
   /** All relevant SchemaDefinitions. */
-  schemas: (mode: Mode) => Promise<SchemaDefinition[]>;
+  schemas: () => Promise<SchemaDefinition[]>;
 }
 
 export interface DocsetEntry {