Nobody Prefers Margarine
Publish your own packages to the world's most popular software ecosystem with npm Pro.Get started »

commonform-lint

3.0.2 • Public • Published

commonform-lint

find technical errors in Common Forms

var lint = require('commonform-lint')
var assert = require('assert')

lint takes a Common Form argument and returns an array of Common Form Annotations.

Cross-Reference Problems

Broken Cross-References

var message = 'The heading "Indemnity" is referenced, but not used.'
 
assert.deepStrictEqual(
  lint({ content: [ { reference: 'Indemnity' } ] }),
  [
    {
      message: message,
      level: 'error',
      path: [ 'content', 0 ],
      source: 'commonform-lint',
      url: null
    }
  ],
  'returns commonform-annotation noting broken reference'
)
 
assert.deepStrictEqual(
  lint({
    content: [
      { reference: 'Indemnity' },
      { reference: 'Indemnity' }
    ]
  }),
  [
    {
      message: message,
      level: 'error',
      path: [ 'content', 0 ],
      source: 'commonform-lint',
      url: null
    },
    {
      message: message,
      level: 'error',
      path: [ 'content', 1 ],
      source: 'commonform-lint',
      url: null
    }
  ],
  'notes multiple broken references'
)

Unmarked Cross-References

assert.deepStrictEqual(
  lint({
    content: [
      {
        heading: 'Preamble',
        form: { content: [ 'This is a preamble.' ] }
      },
      {
        form: { content: [ 'Nothing important gets said in Preamble.' ] }
      }
    ]
  }),
  [
    {
      message: (
        'The heading "Preamble" is used, ' +
        'but not marked as a reference.'
      ),
      level: 'info',
      path: [ 'content', 1, 'form', 'content', 0 ],
      source: 'commonform-lint',
      url: null
    }
  ],
  'notes unmarked reference'
)

Defined-Term Problems

Conflicting Definitions

assert.deepStrictEqual(
  lint({
    content: [
      { definition: 'Agreement' }, ' ',
      { definition: 'Agreement' }, ' ',
      { definition: 'Consideration' }, ' ',
      { use: 'Agreement' }, ' ',
      { use: 'Agreement' }, ' ',
      { use: 'Consideration' }, ' ',
      { use: 'Consideration' }
    ]
  }),
  [
    {
      message: 'The term "Agreement" is defined more than once.',
      level: 'error',
      path: [ 'content', 0 ],
      source: 'commonform-lint',
      url: null
    },
    {
      message: 'The term "Agreement" is defined more than once.',
      level: 'error',
      path: [ 'content', 2 ],
      source: 'commonform-lint',
      url: null
    }
  ],
  'notes multiple definitions of the same term'
)

Undefined Terms

assert.deepStrictEqual(
  lint({ content: [ { use: 'Agreement' } ] }),
  [
    {
      message: 'The term "Agreement" is used, but not defined.',
      level: 'error',
      path: [ 'content', 0 ],
      source: 'commonform-lint',
      url: null
    }
  ],
  'reports the use of an undefined term'
)
 
assert.deepStrictEqual(
  lint({ content: [ { use: 'Agreement' }, { use: 'Agreement' } ] }),
  [
    {
      message: 'The term "Agreement" is used, but not defined.',
      level: 'error',
      path: [ 'content', 0 ],
      source: 'commonform-lint',
      url: null
    },
    {
      message: 'The term "Agreement" is used, but not defined.',
      level: 'error',
      path: [ 'content', 1 ],
      source: 'commonform-lint',
      url: null
    }
  ],
  'notes multiple uses of an undefined term'
)

Extra Definitions

assert.deepStrictEqual(
  lint({ content: [ { definition: 'Agreement' } ] }),
  [
    {
      message: 'The term "Agreement" is defined, but not used.',
      level: 'warn',
      path: [ 'content', 0 ],
      source: 'commonform-lint',
      url: null
    }
  ],
  'notes use of an unused definition'
)

Terms Used Only Once

assert.deepStrictEqual(
  lint({
    content: [
      { use: 'Agreement' }, ' ',
      { definition: 'Agreement' }
    ]
  }),
  [
    {
      message: 'The defined term "Agreement" is used only once.',
      level: 'info',
      path: [ 'content', 0 ],
      source: 'commonform-lint',
      url: null
    }
  ],
  'notes single use of defined term'
)

Unmarked Defined-Term Uses

assert.deepStrictEqual(
  lint({
    content: [
      {
        form: {
          content: [
            'Defines the term ', { definition: 'Agreement' }, '.'
          ]
        }
      },
      {
        form: {
          content: [
            'Uses the term ', { use: 'Agreement' }, '.'
          ]
        }
      },
      {
        form: {
          content: [
            'Uses the term ', { use: 'Agreement' }, ' again.'
          ]
        }
      },
      {
        form: {
          content: [
            'Uses the term Agreement without marking.'
          ]
        }
      }
    ]
  }),
  [
    {
      message: 'The term "Agreement" is used, but not marked as a defined term.',
      level: 'info',
      path: [ 'content', 3, 'form', 'content', 0 ],
      source: 'commonform-lint',
      url: null
    }
  ],
  'notes unmarked use of defined term'
)
assert.deepStrictEqual(
  lint({
    content: [
      {
        form: {
          content: [
            'Defines the term ', { definition: 'Apple' }, '.'
          ]
        }
      },
      {
        form: {
          content: [
            'Uses the term ', { use: 'Apple' }, '.'
          ]
        }
      },
      {
        form: {
          content: [
            'Uses the term ', { use: 'Apple' }, ' again.'
          ]
        }
      },
      {
        form: {
          content: [
            'Uses Applesauce, which is not a defined term.'
          ]
        }
      }
    ]
  }),
  [],
  'does not note unmarked use of defined term within a longer word'
)

Structurally Sound Forms

assert.deepStrictEqual(
  lint({
    content: [
      { definition: 'Agreement' }, ' ',
      { definition: 'Consideration' }, ' ',
      { use: 'Agreement' }, ' ',
      { use: 'Agreement' }, ' ',
      { use: 'Consideration' }, ' ',
      { use: 'Consideration' }
    ]
  }),
  [/* no annotations */]
)
 
assert.deepStrictEqual(
  lint({
    content: [
      {
        heading: 'Heading',
        form: { content: [ 'test' ] }
      },
      { reference: 'Heading' }, ' ',
      { definition: 'Term' }, ' ',
      { use: 'Term' }, ' ',
      { use: 'Term' }
    ]
  }),
  [/* no annotations */]
)

Install

npm i commonform-lint

DownloadsWeekly Downloads

25

Version

3.0.2

License

BlueOak-1.0.0

Unpacked Size

13.8 kB

Total Files

16

Last publish

Collaborators

  • avatar