@vltpkg/query 1.5.0 → 1.6.0

package/test/attribute.ts

@@ -1,273 +0,0 @@
-import { joinDepIDTuple } from '@vltpkg/dep-id'
-import type { EdgeLike, NodeLike } from '@vltpkg/types'
-import type { Attribute } from 'postcss-selector-parser'
-import t from 'tap'
-import {
-  attribute,
-  filterAttributes,
-  getManifestPropertyValues,
-} from '../src/attribute.ts'
-import {
-  getMissingNodeGraph,
-  getSimpleGraph,
-} from './fixtures/graph.ts'
-import {
-  copyGraphSelectionState,
-  getGraphSelectionState,
-  selectorFixture,
-} from './fixtures/selector.ts'
-import type { TestCase } from './fixtures/types.ts'
-import type {
-  GraphSelectionState,
-  ParserState,
-} from '../src/types.ts'
-
-type ManifestLike = Record<string, any>
-
-const testAttr = selectorFixture(attribute)
-
-t.test('attribute', async t => {
-  const simpleGraph = getSimpleGraph()
-  const all: GraphSelectionState = {
-    edges: new Set<EdgeLike>(simpleGraph.edges),
-    nodes: new Set<NodeLike>(simpleGraph.nodes.values()),
-  }
-  const b = getGraphSelectionState(simpleGraph, 'b')
-  const empty: GraphSelectionState = {
-    edges: new Set(),
-    nodes: new Set(),
-  }
-
-  const queryToExpected = new Set<TestCase>([
-    [
-      '[version="1.0.0"]',
-      all,
-      ['my-project', 'a', 'c', 'd', 'e', 'f', '@x/y'],
-    ], // attribute matches all
-    [
-      '[name]',
-      all,
-      ['my-project', 'a', 'b', 'c', 'd', 'e', 'f', '@x/y'],
-    ], // attribute has any content
-    ['[nonexistingattribute]', all, []], // non existing attribute
-    ['[name="@x/y"]', all, ['@x/y']], // attribute matches scoped quoted
-    ['[name^=m]', all, ['my-project']], // attribute starts with value
-    ['[name^="m"]', all, ['my-project']], // attribute starts with value
-    ['[name^=@x]', all, ['@x/y']], // attribute starts with scope
-    ['[name^="@x"]', all, ['@x/y']], // attribute starts with scope
-    ['[name$=project]', all, ['my-project']], // attribute ends with value
-    ['[name$="project"]', all, ['my-project']], // attribute ends with value
-    ['[name~=project]', all, ['my-project']], // attribute contains word
-    ['[name~="project"]', all, ['my-project']], // attribute contains word
-    ['[name~=notfound]', all, []], // attribute contains not found
-    ['[name~="notfound"]', all, []], // attribute contains not found
-    ['[name*=pro]', all, ['my-project']], // attribute contains string
-    ['[name*="pro"]', all, ['my-project']], // attribute contains string
-    ['[name|=my]', all, ['my-project']], // attribute starts with hyphened string
-    ['[name|="my"]', all, ['my-project']], // attribute starts with hyphened string
-    ['[name|="a"]', all, ['a']], // also matches on exact match
-    ['[name="A"]', all, []], // case sensitive by default
-    ['[name="A" i]', all, ['a']], // case insensitive flag
-    ['[name="A" s]', all, []], // case insensitive flag
-    ['[name="a"]', empty, []], // no matches if starting from empty partial
-    ['[name="a"]', b, []], // no matches if node can't be find in partial
-    ['[name="b"]', b, ['b']], // matches single node found
-    ['[keywords=something]', all, ['c']], // matches item in array prop
-    ['[keywords=missing]', all, []], // can not match missing item in array
-  ])
-  const initial = {
-    edges: new Set(all.edges),
-    nodes: new Set(all.nodes),
-  }
-  for (const [query, partial, expected] of queryToExpected) {
-    const res = await testAttr(
-      query,
-      initial,
-      copyGraphSelectionState(partial),
-    )
-    t.strictSame(
-      res.nodes.map(i => i.name),
-      expected,
-      `query > "${query}"`,
-    )
-    t.matchSnapshot(
-      {
-        edges: res.edges.map(i => i.name).sort(),
-        nodes: res.nodes.map(i => i.name).sort(),
-      },
-      `query > "${query}"`,
-    )
-  }
-
-  await t.test('missing node', async t => {
-    const missingNodeGraph = getMissingNodeGraph()
-    const all: GraphSelectionState = {
-      edges: new Set<EdgeLike>(missingNodeGraph.edges),
-      nodes: new Set<NodeLike>(missingNodeGraph.nodes.values()),
-    }
-    const queryToExpected = new Set<TestCase>([
-      ['[name]', all, ['node-missing-project']], // root node has a name
-      ['[name=a]', all, []], // can't match missing node
-    ])
-    const initial = copyGraphSelectionState(all)
-    for (const [query, partial, expected] of queryToExpected) {
-      const res = await testAttr(
-        query,
-        initial,
-        copyGraphSelectionState(partial),
-      )
-      t.strictSame(
-        res.nodes.map(i => i.name),
-        expected,
-        `query > "${query}"`,
-      )
-      t.matchSnapshot(
-        {
-          edges: res.edges.map(i => i.name).sort(),
-          nodes: res.nodes.map(i => i.name).sort(),
-        },
-        `query > "${query}"`,
-      )
-    }
-  })
-})
-
-t.test('bad selector type', async t => {
-  await t.rejects(
-    testAttr(':dev'),
-    /Mismatching query node/,
-    'should throw an error',
-  )
-})
-
-t.test('bad operator', async t => {
-  await t.rejects(
-    testAttr('[name==foo]'),
-    {
-      message: 'Unsupported attribute operator: =',
-      cause: {
-        code: 'EQUERY',
-        found: '[name==foo]',
-        validOptions: ['=', '^=', '$=', '~=', '*=', '|='],
-      },
-    },
-    'should throw an error',
-  )
-})
-
-t.test('bad operator [loose mode]', async t => {
-  await t.resolves(
-    testAttr('[name==foo]', undefined, undefined, true),
-    'should resolve with no error',
-  )
-})
-
-t.test(
-  'unquotted scoped names are not supported by the parser',
-  async t => {
-    await t.rejects(
-      testAttr('[name=@x/y]'),
-      /Unexpected "\/" found./,
-      'should throw an error',
-    )
-  },
-)
-
-t.test('getManifestPropertyValues', async t => {
-  const simpleGraph = getSimpleGraph()
-  const b = simpleGraph.nodes.get(
-    joinDepIDTuple(['registry', '', 'b@1.0.0']),
-  )!
-
-  t.strictSame(
-    getManifestPropertyValues(
-      b,
-      ['scripts', 'postinstall'],
-      'postinstall',
-    ),
-    ['postinstall'],
-    'should return the postinstall script value',
-  )
-
-  t.strictSame(
-    getManifestPropertyValues(b, ['contributors'], 'contributors'),
-    ['[object Object]'],
-    'should return a stringified object value',
-  )
-
-  t.strictSame(
-    getManifestPropertyValues(b, ['contributors', 'name'], 'name'),
-    ['Ruy Adorno'],
-    'should return the value from a array-nested object',
-  )
-
-  b.manifest = { foo: 1 } as ManifestLike
-  t.strictSame(
-    getManifestPropertyValues(b, ['foo'], 'foo'),
-    ['1'],
-    'should return values as strings',
-  )
-
-  b.manifest = { keywords: [undefined, 'foo'] } as ManifestLike
-  t.strictSame(
-    getManifestPropertyValues(b, ['keywords'], 'keywords'),
-    ['', 'foo'],
-    'should turn falsy values into empty strings',
-  )
-
-  b.manifest = 'bad manifest' as unknown as ManifestLike
-  t.strictSame(
-    getManifestPropertyValues(b, ['name'], 'name'),
-    undefined,
-    'should not return results from a bad manifest',
-  )
-
-  delete b.manifest
-  t.strictSame(
-    getManifestPropertyValues(b, ['name'], 'name'),
-    undefined,
-    'should not return results from a missing manifest',
-  )
-})
-
-t.test('filterAttributes', async t => {
-  const simpleGraph = getSimpleGraph()
-  const all: GraphSelectionState = {
-    edges: new Set<EdgeLike>(simpleGraph.edges),
-    nodes: new Set<NodeLike>(simpleGraph.nodes.values()),
-  }
-  const state = {
-    cancellable: async () => {},
-    collect: {
-      edges: new Set<EdgeLike>(),
-      nodes: new Set<NodeLike>(),
-    },
-    comment: '',
-    current: { type: 'attribute', value: 'postinstall' } as Attribute,
-    initial: copyGraphSelectionState(all),
-    partial: all,
-    loose: false,
-    importers: simpleGraph.importers,
-    hostContexts: new Map(),
-    walk: async (state: ParserState) => state,
-    retries: 0,
-    securityArchive: undefined,
-    signal: new AbortController().signal,
-    specificity: { idCounter: 0, commonCounter: 0 },
-  }
-  filterAttributes(
-    state,
-    (attr: string) => !!attr,
-    'postinstall',
-    'scripts',
-    false,
-    ['scripts', 'postinstall'],
-  )
-  t.matchSnapshot(
-    {
-      edges: [...state.partial.edges].map(i => i.name).sort(),
-      nodes: [...state.partial.nodes].map(i => i.name).sort(),
-    },
-    'should have filtered out nodes with postinstall script only',
-  )
-})

package/test/combinator.ts

@@ -1,175 +0,0 @@
-import t from 'tap'
-import { combinator } from '../src/combinator.ts'
-import { walk } from '../src/index.ts'
-import { getCycleGraph, getSimpleGraph } from './fixtures/graph.ts'
-import {
-  copyGraphSelectionState,
-  getGraphSelectionState,
-  selectorFixture,
-} from './fixtures/selector.ts'
-import type { TestCase } from './fixtures/types.ts'
-import type { EdgeLike, NodeLike } from '@vltpkg/types'
-import type { GraphSelectionState } from '../src/types.ts'
-
-const testCombinator = selectorFixture(combinator)
-
-t.test('combinator', async t => {
-  const simpleGraph = getSimpleGraph()
-  const all: GraphSelectionState = {
-    edges: new Set<EdgeLike>(simpleGraph.edges),
-    nodes: new Set<NodeLike>(simpleGraph.nodes.values()),
-  }
-  const root = {
-    edges: new Set<EdgeLike>(),
-    nodes: new Set<NodeLike>([simpleGraph.mainImporter]),
-  }
-  const b = getGraphSelectionState(simpleGraph, 'b')
-  const d = getGraphSelectionState(simpleGraph, 'd')
-  const bd: GraphSelectionState = {
-    edges: new Set<EdgeLike>([...b.edges, ...d.edges]),
-    nodes: new Set<NodeLike>([...b.nodes, ...d.nodes]),
-  }
-  const e = getGraphSelectionState(simpleGraph, 'e')
-  const f = getGraphSelectionState(simpleGraph, 'f')
-  const empty: GraphSelectionState = {
-    edges: new Set(),
-    nodes: new Set(),
-  }
-  const queryToExpected = new Set<TestCase>([
-    // child combinator
-    ['>', all, ['a', 'b', 'e', '@x/y', 'c', 'd', 'f']], // direct children of all nodes
-    ['>', root, ['a', 'b', 'e', '@x/y']], // from root
-    ['>', d, ['e', 'f']], // from transitive dep
-    ['>', bd, ['c', 'd', 'e', 'f']], // from mutiple deps
-    ['>', e, []], // from node with no deps
-    ['>', empty, []], // from empty nodes
-    // subsequent sibling combinator
-    ['~', all, ['b', 'e', '@x/y', 'a', 'd', 'c', 'f']], // siblings of all nodes
-    ['~', f, ['e']], // leaf node with a sibling
-    ['~', d, ['c']], // transitive node
-    ['~', e, ['a', 'b', '@x/y', 'f']], // node with siblings at multiple locations
-    ['~', root, []], // root has no siblings
-    ['~', empty, []], // sibling of empty nodes
-    // descendent combinator
-    [' ', root, ['a', 'b', 'e', '@x/y', 'c', 'd', 'f']], // from root
-    [' ', f, []], // leaf node
-    [' ', empty, []], // empty list of nodes
-    [' ', d, ['e', 'f']], // transitive node
-    [' ', b, ['c', 'd', 'e', 'f']], // direct dep
-  ])
-  const initial = copyGraphSelectionState(all)
-  for (const [query, partial, expected] of queryToExpected) {
-    const res = await testCombinator(
-      { value: query, type: 'combinator' },
-      initial,
-      copyGraphSelectionState(partial),
-    )
-    t.strictSame(
-      res.nodes.map(i => i.name),
-      expected,
-      `query > "${query}"`,
-    )
-    t.matchSnapshot(
-      {
-        edges: res.edges.map(i => i.name).sort(),
-        nodes: res.nodes.map(i => i.name).sort(),
-      },
-      `query > "${query}"`,
-    )
-  }
-
-  await t.test('cycle', async t => {
-    const cycleGraph = getCycleGraph()
-    const all: GraphSelectionState = {
-      edges: new Set<EdgeLike>(cycleGraph.edges),
-      nodes: new Set<NodeLike>(cycleGraph.nodes.values()),
-    }
-    const root = {
-      edges: new Set<EdgeLike>(),
-      nodes: new Set<NodeLike>([cycleGraph.mainImporter]),
-    }
-    const a = getGraphSelectionState(cycleGraph, 'a')
-    const b = getGraphSelectionState(cycleGraph, 'b')
-    const queryToExpected = new Set<TestCase>([
-      ['>', all, ['a', 'b']], // direct children of all nodes
-      ['>', a, ['b']], // direct children of a
-      ['>', b, ['a']], // direct children of b
-      [' ', root, ['a', 'b']], // descendents of :root
-      [' ', a, ['b', 'a']], // descendents of a
-      [' ', b, ['a', 'b']], // descendents of b
-      ['~', root, []], // siblings of :root
-      ['~', a, []], // siblings of a
-      ['~', b, []], // siblings of b
-    ])
-    const initial = copyGraphSelectionState(all)
-    for (const [query, partial, expected] of queryToExpected) {
-      const result = await testCombinator(
-        { value: query, type: 'combinator' },
-        initial,
-        copyGraphSelectionState(partial),
-      )
-      t.strictSame(
-        result.nodes.map(i => i.name),
-        expected,
-        `query > "${query}"`,
-      )
-      t.matchSnapshot(
-        {
-          edges: result.edges.map(i => i.name).sort(),
-          nodes: result.nodes.map(i => i.name).sort(),
-        },
-        `query > "${query}"`,
-      )
-    }
-  })
-
-  // space between tags are not descendent combinators
-  await t.test('ignore spaces between tags', async t => {
-    const test = selectorFixture(walk)
-    const result = await test(
-      '* { * }',
-      all,
-      copyGraphSelectionState(all),
-    )
-    t.strictSame(
-      result.nodes.map(i => i.name),
-      [...all.nodes].map(i => i.name),
-      'should not treat spaces between tags as descendent combinators',
-    )
-  })
-})
-
-t.test('bad selector type', async t => {
-  await t.rejects(
-    testCombinator(':dev'),
-    /Mismatching query node/,
-    'should throw an error',
-  )
-})
-
-t.test('usnupported combinator', async t => {
-  await t.rejects(
-    testCombinator({ value: '+', type: 'combinator' }),
-    {
-      message: 'Unsupported combinator: +',
-      cause: {
-        code: 'EQUERY',
-        found: '+',
-        validOptions: ['>', '~', ' '],
-      },
-    },
-    'should throw an error',
-  )
-})
-
-t.test('usnupported combinator [loose mode]', async t => {
-  await t.resolves(
-    testCombinator(
-      { value: '+', type: 'combinator' },
-      undefined,
-      undefined,
-      true,
-    ),
-    'should resolve with no error',
-  )
-})

package/test/error.ts

@@ -1,60 +0,0 @@
-import t from 'tap'
-import { parse } from '@vltpkg/dss-parser'
-import type { PostcssNode } from '@vltpkg/dss-parser'
-import { didYouMean, queryError, selectorText } from '../src/error.ts'
-
-const first = (query: string): PostcssNode => {
-  const node = parse(query, { loose: true }).nodes[0]?.nodes[0]
-  if (!node) throw new Error(`no node parsed for ${query}`)
-  return node
-}
-
-t.test('selectorText', async t => {
-  t.equal(selectorText(first('.dev')), '.dev', 'unescapes')
-  t.equal(selectorText(first('[name%=x]')), '[name%=x]', 'attribute')
-  t.equal(selectorText(first('"foo"')), '"foo"', 'string')
-  t.equal(selectorText(first(':root > *')), ':root', 'pseudo')
-  t.equal(
-    selectorText({ type: 'combinator', value: '+' } as PostcssNode),
-    '+',
-    'falls back to the value of an unparsed node',
-  )
-  t.equal(
-    selectorText({ type: 'combinator' } as PostcssNode),
-    'combinator',
-    'falls back to the type when there is no value',
-  )
-})
-
-t.test('queryError', async t => {
-  const er = queryError('Unsupported selector', first('.dev'), {
-    wanted: ':dev',
-  })
-  t.match(er, {
-    message: 'Unsupported selector',
-    cause: { code: 'EQUERY', found: '.dev', wanted: ':dev' },
-  })
-  t.equal(
-    typeof (er.cause as { found: unknown }).found,
-    'string',
-    'never carries the circular parsed node',
-  )
-})
-
-t.test('didYouMean', async t => {
-  const names = ['dev', 'diff', 'dist', 'prod']
-  t.strictSame(didYouMean('difff', names), ['diff'])
-  t.strictSame(didYouMean('dif', names), ['diff', 'dev', 'dist'])
-  t.strictSame(didYouMean('nope', names), [], 'nothing close enough')
-  t.strictSame(
-    didYouMean('d', names, 0),
-    [],
-    'a zero budget only matches exactly',
-  )
-  t.strictSame(didYouMean('dev', names, 0), ['dev'])
-  t.strictSame(
-    didYouMean('deviation', names),
-    [],
-    'length gap alone rules a candidate out',
-  )
-})