@vltpkg/query 1.5.0 → 1.6.0

package/test/parser.ts

@@ -1,117 +0,0 @@
-import t from 'tap'
-import postcssSelectorParser from 'postcss-selector-parser'
-import { parse, escapeScopedNamesSlashes } from '../src/parser.ts'
-
-t.test('escapeScopedNamesSlashes', async t => {
-  t.equal(
-    escapeScopedNamesSlashes('#@scope/package'),
-    '#@scope\\/package',
-    'should escape forward slash in #@scope/package pattern',
-  )
-
-  t.equal(
-    escapeScopedNamesSlashes('#@scope-dash-sep/package'),
-    '#@scope-dash-sep\\/package',
-    'should escape forward slash with dashes',
-  )
-
-  t.equal(
-    escapeScopedNamesSlashes('#@scope.dot.sep/package'),
-    '#@scope.dot.sep\\/package',
-    'should escape forward slash with dots',
-  )
-
-  t.equal(
-    escapeScopedNamesSlashes('#@multiple/package #@another/pkg'),
-    '#@multiple\\/package #@another\\/pkg',
-    'should escape multiple instances of the pattern',
-  )
-
-  t.equal(
-    escapeScopedNamesSlashes('#@name/package[attr]'),
-    '#@name\\/package[attr]',
-    'should work with attribute selectors',
-  )
-
-  t.equal(
-    escapeScopedNamesSlashes('#regular #@123/456'),
-    '#regular #@123\\/456',
-    'should work with numeric components',
-  )
-
-  t.equal(
-    escapeScopedNamesSlashes('#regular-selector'),
-    '#regular-selector',
-    'should not modify strings without the specific pattern',
-  )
-
-  t.equal(
-    escapeScopedNamesSlashes('a > b #@xyz/abc'),
-    'a > b #@xyz\\/abc',
-    'should work with combinators',
-  )
-})
-
-t.test('parse', async t => {
-  // Test basic parsing
-  t.ok(parse(':root > *'), 'should parse simple selectors')
-
-  // Compare with direct postcss parser for equivalence (minus the escaping)
-  const simpleSelector = 'div > span'
-  const directAst = postcssSelectorParser().astSync(simpleSelector)
-  const ourAst = parse(simpleSelector)
-
-  t.same(
-    ourAst.toString(),
-    directAst.toString(),
-    'should produce equivalent AST to direct postcss parser',
-  )
-
-  // Test with a selector that needs escaping
-  const selectorWithScoped = '#@scope/package'
-  t.doesNotThrow(
-    () => parse(selectorWithScoped),
-    'should parse selectors with scoped packages without throwing',
-  )
-
-  // Test a complex selector
-  const complexSelector = 'a > #@scope/pkg.class:pseudo[attr=val]'
-  t.ok(
-    parse(complexSelector),
-    'should parse complex selectors with scoped packages',
-  )
-
-  t.ok(parse(':root > :v(2.0.0)'), 'should parse dots in parameters')
-  t.ok(
-    parse(':root > :v("2.0.0")'),
-    'should parse dots in string parameters',
-  )
-
-  const res: any[] = []
-  parse(':v(>2)').walk(node => {
-    res.push({
-      type: node.type,
-      source: node.source,
-      ...(node.value ? { value: node.value } : undefined),
-    })
-  })
-  t.matchSnapshot(
-    res,
-    'should clean up usage of combinators params in pseudo selectors that accept only string values',
-  )
-
-  res.length = 0
-  parse(
-    ':root > :v(>1 >2 >3):not(:v(2.0.0-pre+build0.13adsfa1)) > published(<=2024-01-01T11:11:11.111Z) :severity(>=0):score( > 0.9)',
-  ).walk(node => {
-    res.push({
-      type: node.type,
-      source: node.source,
-      ...(node.value ? { value: node.value } : undefined),
-    })
-  })
-  t.matchSnapshot(
-    res,
-    'should clean up usage of multiple pseudo selectors requiring cleaning up',
-  )
-})

package/test/pseudo/abandoned.ts

@@ -1,98 +0,0 @@
-import t from 'tap'
-import { joinDepIDTuple } from '@vltpkg/dep-id'
-import { asSecurityArchiveLike } from '@vltpkg/security-archive'
-import { getSimpleGraph } from '../fixtures/graph.ts'
-import type { ParserState } from '../../src/types.ts'
-import { parse } from '../../src/parser.ts'
-import { abandoned } from '../../src/pseudo/abandoned.ts'
-
-t.test('selects packages with an abandoned alert', async t => {
-  const getState = (query: string, graph = getSimpleGraph()) => {
-    const ast = parse(query)
-    const current = ast.first.first
-    const state: ParserState = {
-      comment: '',
-      current,
-      initial: {
-        edges: new Set(graph.edges.values()),
-        nodes: new Set(graph.nodes.values()),
-      },
-      partial: {
-        edges: new Set(graph.edges.values()),
-        nodes: new Set(graph.nodes.values()),
-      },
-      collect: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      cancellable: async () => {},
-      walk: async i => i,
-      securityArchive: asSecurityArchiveLike(
-        new Map([
-          [
-            joinDepIDTuple(['registry', '', 'e@1.0.0']),
-            { alerts: [{ type: 'missingAuthor' }] },
-          ],
-        ]),
-      ),
-      importers: new Set(graph.importers),
-      retries: 0,
-      signal: new AbortController().signal,
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  await t.test(
-    'filter out any node that does not have the alert',
-    async t => {
-      const res = await abandoned(getState(':abandoned'))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['e'],
-        'should select only abandoned packages',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name),
-        edges: [...res.partial.edges].map(e => e.name),
-      })
-    },
-  )
-})
-
-t.test('missing security archive', async t => {
-  const getState = (query: string) => {
-    const ast = parse(query)
-    const current = ast.first.first
-    const state: ParserState = {
-      comment: '',
-      current,
-      initial: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      partial: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      collect: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      cancellable: async () => {},
-      walk: async i => i,
-      securityArchive: undefined,
-      importers: new Set(),
-      retries: 0,
-      signal: new AbortController().signal,
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  await t.rejects(
-    abandoned(getState(':abandoned')),
-    { message: /Missing security archive/ },
-    'should throw an error',
-  )
-})

package/test/pseudo/attr.ts

@@ -1,298 +0,0 @@
-import t from 'tap'
-import postcssSelectorParser from 'postcss-selector-parser'
-import type { ParserState } from '../../src/types.ts'
-import { attr } from '../../src/pseudo/attr.ts'
-import { getSimpleGraph } from '../fixtures/graph.ts'
-
-t.test('selects packages based on attribute properties', async t => {
-  const getState = (query: string, graph = getSimpleGraph()) => {
-    const ast = postcssSelectorParser().astSync(query)
-    const current = ast.first.first
-    const state: ParserState = {
-      comment: '',
-      current,
-      initial: {
-        edges: new Set(graph.edges.values()),
-        nodes: new Set(graph.nodes.values()),
-      },
-      partial: {
-        edges: new Set(graph.edges.values()),
-        nodes: new Set(graph.nodes.values()),
-      },
-      collect: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      cancellable: async () => {},
-      walk: async i => i,
-      securityArchive: undefined,
-      importers: new Set(graph.importers),
-      retries: 0,
-      signal: new AbortController().signal,
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  await t.test('selects nodes with a specific attribute', async t => {
-    // Based on the getSimpleGraph fixture, only package 'b' has 'scripts' property
-    const res = await attr(getState(':attr([scripts])'))
-    t.strictSame(
-      [...res.partial.nodes].map(n => n.name),
-      ['b'],
-      'should select only package with scripts property',
-    )
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => n.name).sort(),
-      edges: [...res.partial.edges].map(e => e.name).sort(),
-    })
-  })
-
-  await t.test(
-    'selects nodes with a specific attribute value',
-    async t => {
-      // In getSimpleGraph, only package 'd' has private=true
-      const res = await attr(getState(':attr([private=true])'))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['d'],
-        'should select only package with private=true',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'selects nodes with nested attribute paths',
-    async t => {
-      // Package 'b' has a nested scripts.postinstall property
-      const res = await attr(
-        getState(':attr(scripts, [postinstall])'),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['b'],
-        'should select packages with nested attributes',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'selects nodes with nested attribute value',
-    async t => {
-      // Package 'b' has a nested scripts.test="test" property
-      const res = await attr(getState(':attr(scripts, [test=test])'))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['b'],
-        'should select packages with specific nested attribute values',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'supports quoted strings for property names',
-    async t => {
-      // Package 'b' has a nested scripts.test="test" property using quoted strings
-      const res = await attr(
-        getState(':attr("scripts", [test=test])'),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['b'],
-        'should select packages with quoted property name',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'supports multiple quoted strings for nested properties',
-    async t => {
-      // Package 'd' has a deeply nested structure with a.b[].c.d="foo" using quoted strings
-      const res = await attr(
-        getState(':attr("a", "b", "c", [d=foo])'),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['d'],
-        'should select packages with deeply nested attributes using quoted strings',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'supports mixed quoted and unquoted property names',
-    async t => {
-      // Package 'd' has a deeply nested structure mixing quoted and unquoted property names
-      const res = await attr(getState(':attr("a", b, "c", [d=foo])'))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['d'],
-        'should select packages with mixed quoted and unquoted property names',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'selects nodes with complex nested attributes',
-    async t => {
-      // Package 'd' has a deeply nested structure with a.b[].c.d="foo"
-      const res = await attr(getState(':attr(a, b, c, [d=foo])'))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['d'],
-        'should select packages with deeply nested attributes',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'selects nodes with array value attributes',
-    async t => {
-      // Package 'c' has keywords=['something', 'someother']
-      const res = await attr(getState(':attr([keywords=something])'))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['c'],
-        'should select packages with array value attributes',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'selects nodes with complex nested object in arrays',
-    async t => {
-      // Package 'b' has contributors array with objects
-      const res = await attr(
-        getState(':attr(contributors, [name^=Ruy])'),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['b'],
-        'should select packages with objects in arrays by attribute',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'returns no nodes for non-existent attribute',
-    async t => {
-      const res = await attr(getState(':attr([nonexistent])'))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        [],
-        'should return no nodes when attribute does not exist',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name),
-        edges: [...res.partial.edges].map(e => e.name),
-      })
-    },
-  )
-
-  await t.test(
-    'returns no nodes for non-existent nested attribute',
-    async t => {
-      const res = await attr(
-        getState(':attr(scripts, [nonexistent])'),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        [],
-        'should return no nodes when nested attribute does not exist',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name),
-        edges: [...res.partial.edges].map(e => e.name),
-      })
-    },
-  )
-
-  await t.test('handles attribute operator matching', async t => {
-    // Test starts-with operator
-    const startsWithRes = await attr(getState(':attr([version^=1])'))
-    t.strictSame(
-      [...startsWithRes.partial.nodes].map(n => n.name).sort(),
-      ['a', 'c', 'd', 'e', 'f', '@x/y', 'my-project'].sort(),
-      'should match attributes with starts-with operator',
-    )
-
-    // Test ends-with operator
-    const endsWithRes = await attr(getState(':attr([version$=0])'))
-    t.strictSame(
-      [...endsWithRes.partial.nodes].map(n => n.name).sort(),
-      ['@x/y', 'a', 'b', 'c', 'd', 'e', 'f', 'my-project'].sort(),
-      'should match attributes with ends-with operator',
-    )
-
-    t.matchSnapshot({
-      startsWith: [...startsWithRes.partial.nodes]
-        .map(n => n.name)
-        .sort(),
-      endsWith: [...endsWithRes.partial.nodes]
-        .map(n => n.name)
-        .sort(),
-    })
-  })
-
-  await t.test('handles an empty partial state', async t => {
-    // Create a state with empty partial nodes
-    const state = getState(':attr([scripts])')
-    state.partial.nodes.clear()
-    state.partial.edges.clear()
-
-    const res = await attr(state)
-    t.strictSame(
-      [...res.partial.nodes].map(n => n.name),
-      [],
-      'should return empty array when starting with empty partial state',
-    )
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => n.name),
-      edges: [...res.partial.edges].map(e => e.name),
-    })
-  })
-
-  await t.test('invalid parameter handling', async t => {
-    await t.rejects(
-      attr(getState(':attr(>)')),
-      /Failed to parse :attr selector/,
-      'should throw error for invalid parameters',
-    )
-  })
-})