eslint-plugin-greasemonkey 1.0.0 → 1.2.0

package/src/index.js

@@ -1,33 +1,42 @@
-import metaSpacing from './rules/meta-spacing.js'
-import noUnusedGrants from './rules/no-unused-grants.js'
-import noUnusedResources from './rules/no-unused-resources.js'
-import requireMatchingLocalizedFields from './rules/require-matching-localized-fields.js'
-import requireRequiredFields from './rules/require-required-fields.js'
-import validFieldValues from './rules/valid-field-values.js'
-
-const plugin = {
-    rules: {
-        'meta-spacing': metaSpacing,
-        'require-matching-localized-fields': requireMatchingLocalizedFields,
-        'require-required-fields': requireRequiredFields,
-        'valid-field-values': validFieldValues,
-        'no-unused-resources': noUnusedResources,
-        'no-unused-grants': noUnusedGrants
-    }
-}
-
-plugin.configs = {
-    recommended: {
-        plugins: { greasemonkey: plugin },
-        rules: {
-            'greasemonkey/meta-spacing': 'error',
-            'greasemonkey/require-matching-localized-fields': 'error',
-            'greasemonkey/require-required-fields': 'error',
-            'greasemonkey/valid-field-values': 'error',
-            'greasemonkey/no-unused-resources': 'error',
-            'greasemonkey/no-unused-grants': 'error'
-        }
-    }
-}
-
-export default plugin
+import metaSpacing from './rules/meta-spacing.js'
+import noDuplicateKeys from './rules/no-duplicate-keys.js'
+import noUnusedGrants from './rules/no-unused-grants.js'
+import noUnusedResources from './rules/no-unused-resources.js'
+import requireMatchingLocalizedFields from './rules/require-matching-localized-fields.js'
+import requireRequiredFields from './rules/require-required-fields.js'
+import requireUserJsFilename from './rules/require-user-js-filename.js'
+import validFieldValues from './rules/valid-field-values.js'
+import validGrants from './rules/valid-grants.js'
+
+const plugin = {
+    rules: {
+        'meta-spacing': metaSpacing,
+        'no-duplicate-keys': noDuplicateKeys,
+        'no-unused-grants': noUnusedGrants,
+        'no-unused-resources': noUnusedResources,
+        'require-matching-localized-fields': requireMatchingLocalizedFields,
+        'require-required-fields': requireRequiredFields,
+        'require-user-js-filename': requireUserJsFilename,
+        'valid-field-values': validFieldValues,
+        'valid-grants': validGrants
+    }
+}
+
+plugin.configs = {
+    recommended: {
+        plugins: { greasemonkey: plugin },
+        rules: {
+            'greasemonkey/meta-spacing': 'error',
+            'greasemonkey/no-duplicate-keys': 'error',
+            'greasemonkey/no-unused-grants': 'error',
+            'greasemonkey/no-unused-resources': 'error',
+            'greasemonkey/require-matching-localized-fields': 'error',
+            'greasemonkey/require-required-fields': 'error',
+            'greasemonkey/require-user-js-filename': 'error',
+            'greasemonkey/valid-field-values': 'error',
+            'greasemonkey/valid-grants': 'error'
+        }
+    }
+}
+
+export default plugin

package/src/rules/meta-spacing.js

@@ -1,47 +1,51 @@
-import { extractMetadata } from '../utils.js'
-
-const reLeadingWhitespace = /^\s*/
-
-export default {
-    meta: {
-        type: 'layout',
-        docs: {
-            description: 'Align metadata values to the column after the longest key',
-            category: 'Stylistic Issues',
-            recommended: true
-        },
-        fixable: 'whitespace',
-        schema: [{ type: 'number', description: 'Minimum spaces after the longest key (default 3)' }],
-        defaultOptions: [3],
-        messages: { misaligned: 'Metadata values should be aligned at column {{column}}' }
-    },
-
-    create(context) {
-        const minSpaces = context.options[0] ?? 3
-        return {
-            Program() {
-                const sourceCode = context.sourceCode,
-                      metaEntries = extractMetadata(sourceCode)
-                if (!metaEntries.length) return
-                const longestKey = metaEntries.reduce((max, entry) => Math.max(max, entry.key.length), 0),
-                      targetColumn = longestKey + minSpaces +4
-                for (const entry of metaEntries) {
-                    const keyLen = entry.key.length,
-                          commentText = sourceCode.getText(entry.comment),
-                          actualSpaces = commentText.split(entry.key)[1].match(reLeadingWhitespace)[0].length,
-                          desiredSpaces = targetColumn - keyLen -4
-                    if (actualSpaces != desiredSpaces)
-                        context.report({
-                            node: entry.comment, messageId: 'misaligned', data: { column: targetColumn },
-                            fix(fixer) {
-                                const keyIdx = commentText.indexOf(entry.key) + entry.key.length,
-                                      rest = commentText.slice(keyIdx).replace(reLeadingWhitespace, ''),
-                                      fixedText = commentText.slice(0, keyIdx) + ' '.repeat(desiredSpaces) + rest
-                                return fixer.replaceText(entry.comment, fixedText)
-                            }
-                        })
-                }
-            }
-        }
-    }
-}
+import { extractMetadata } from '../utils.js'
+
+const re = { leadingWhitespace: /^\s*/, whitespace: /\s+/ }
+
+export default {
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Align metadata values to the column after the longest key',
+            category: 'Stylistic Issues',
+            recommended: true
+        },
+        fixable: 'whitespace',
+        schema: [{ type: 'number', description: 'Minimum spaces after the longest key (default 3)' }],
+        defaultOptions: [3],
+        messages: { misaligned: 'Metadata values should be aligned at column {{column}}' }
+    },
+
+    create(context) {
+        const minSpaces = context.options[0] ?? 3
+        return {
+            Program() {
+                const sourceCode = context.sourceCode,
+                      metaEntries = extractMetadata(sourceCode)
+                if (!metaEntries.length) return
+                let targetCol = metaEntries.reduce((max, entry) => Math.max(max, entry.key.length), 0) + minSpaces +4
+                for (const entry of metaEntries)
+                    if (entry.key == 'resource') {
+                        const name = entry.value.trim().split(re.whitespace)[0],
+                              requiredCol = 4 + entry.key.length +1 + name.length + minSpaces
+                        if (requiredCol > targetCol) targetCol = requiredCol
+                    }
+                for (const entry of metaEntries) {
+                    const commentText = sourceCode.getText(entry.comment),
+                          keyIdx = commentText.indexOf(entry.key) + entry.key.length,
+                          parts = entry.value.trim().split(re.whitespace),
+                          named = entry.key == 'resource' && parts.length >= 2,
+                          prefix = named ? ` ${parts[0]} ` : '',
+                          suffix = named ? parts.slice(1).join(' ') : entry.value.trim(),
+                          fixedText = commentText.slice(0, keyIdx) + prefix
+                                    + ' '.repeat(targetCol - keyIdx - prefix.length) + suffix
+                    if (commentText !== fixedText)
+                        context.report({
+                            node: entry.comment, messageId: 'misaligned', data: { column: targetCol },
+                            fix(fixer) { return fixer.replaceText(entry.comment, fixedText) }
+                        })
+                }
+            }
+        }
+    }
+}

package/src/rules/no-duplicate-keys.js

@@ -0,0 +1,35 @@
+import { extractMetadata } from '../utils.js'
+
+const MULTI_VALUE_KEYS = new Set([
+    'compatible', 'connect', 'description', 'exclude', 'exclude-match', 'grant',
+    'homepageURL', 'include', 'license', 'match', 'require', 'resource', 'supportURL'
+])
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow duplicate metadata keys',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        schema: [],
+        messages: { dupeKey: 'Duplicate @{{key}}' }
+    },
+
+    create(context) {
+        return {
+            Program() {
+                const metaEntries = extractMetadata(context.sourceCode),
+                      seen = new Set()
+                for (const entry of metaEntries) {
+                    const baseKey = entry.key.split(':')[0]
+                    if (!entry.key.includes(':') && MULTI_VALUE_KEYS.has(baseKey)) continue
+                    if (seen.has(entry.key))
+                        context.report({ node: entry.comment, messageId: 'dupeKey', data: { key: entry.key }})
+                    else seen.add(entry.key)
+                }
+            }
+        }
+    }
+}

package/src/rules/no-unused-grants.js

@@ -1,36 +1,33 @@
-import { extractMetadata } from '../utils.js'
-
-export default {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Flag @grant entries whose APIs are never used',
-            category: 'Possible Errors',
-            recommended: true
-        },
-        schema: [],
-        messages: {
-            unusedGrant: 'Unused @grant: "{{grant}}". If used indirectly,'
-                       + ' add // eslint-disable-line greasemonkey/no-unused-grants'
-        }
-    },
-
-    create(context) {
-        const usedIdentifiers = new Set()
-        return {
-            Identifier(node) { usedIdentifiers.add(node.name) },
-            'Program:exit'() {
-                const sourceCode = context.sourceCode,
-                      metaEntries = extractMetadata(sourceCode),
-                      grants = metaEntries.filter(e => e.key == 'grant')
-                if (!grants.length) return
-                for (const grant of grants) {
-                    const grantName = grant.value.trim()
-                    if (['none', 'unsafeWindow'].includes(grantName)) continue
-                    if (!usedIdentifiers.has(grantName))
-                        context.report({ node: grant.comment, messageId: 'unusedGrant', data: { grant: grantName }})
-                }
-            }
-        }
-    }
-}
+import { extractMetadata } from '../utils.js'
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Flag @grant entries whose APIs are never used',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        schema: [],
+        messages: { unusedGrant: 'Unused @grant: "{{grant}}".' }
+    },
+
+    create(context) {
+        const usedIdentifiers = new Set()
+        return {
+            Identifier(node) { usedIdentifiers.add(node.name) },
+            'Program:exit'() {
+                const sourceCode = context.sourceCode,
+                      metaEntries = extractMetadata(sourceCode),
+                      grants = metaEntries.filter(e => e.key == 'grant')
+                if (!grants.length) return
+                for (const grant of grants) {
+                    const grantName = grant.value.trim()
+                    if (['none', 'unsafeWindow'].includes(grantName)) continue
+                    if (!usedIdentifiers.has(grantName))
+                        context.report({ node: grant.comment, messageId: 'unusedGrant', data: { grant: grantName }})
+                }
+            }
+        }
+    }
+}

package/src/rules/no-unused-resources.js

@@ -1,40 +1,36 @@
-import { extractMetadata } from '../utils.js'
-
-const reWhitespace = /\s+/
-
-export default {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Flag @resource entries that are never referenced directly',
-            category: 'Possible Errors',
-            recommended: true
-        },
-        schema: [],
-        messages: {
-            unusedResource: 'Unused @resource: "{{name}}". If used indirectly,'
-                          + ' add // eslint-disable-line greasemonkey/no-unused-resources'
-        }
-    },
-
-    create(context) {
-        return {
-            Program() {
-                const sourceCode = context.sourceCode,
-                      metaEntries = extractMetadata(sourceCode),
-                      resources = metaEntries.filter(e => e.key == 'resource')
-                if (!resources.length) return
-                const text = sourceCode.getText(),
-                      usedResources = new Set(),
-                      regex = /GM_getResource(?:Text|URL)\s*\(\s*['"]([^'"]+)['"]\s*\)/g
-                let match
-                while ((match = regex.exec(text)) !== null) usedResources.add(match[1])
-                for (const res of resources) {
-                    const name = res.value.split(reWhitespace)[0]
-                    if (!usedResources.has(name))
-                        context.report({ node: res.comment, messageId: 'unusedResource', data: { name }})
-                }
-            }
-        }
-    }
-}
+import { extractMetadata } from '../utils.js'
+
+const re = { resourceGetter: /GM_getResource(?:Text|URL)\s*\(\s*['"]([^'"]+)['"]\s*\)/g, whitespace: /\s+/ }
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Flag @resource entries that are never referenced directly',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        schema: [],
+        messages: { unusedResource: 'Unused @resource: "{{name}}".' }
+    },
+
+    create(context) {
+        return {
+            Program() {
+                const sourceCode = context.sourceCode,
+                      metaEntries = extractMetadata(sourceCode),
+                      resources = metaEntries.filter(e => e.key == 'resource')
+                if (!resources.length) return
+                const text = sourceCode.getText(),
+                      usedResources = new Set()
+                let match
+                while ((match = re.resourceGetter.exec(text)) !== null) usedResources.add(match[1])
+                for (const res of resources) {
+                    const name = res.value.split(re.whitespace)[0]
+                    if (!usedResources.has(name))
+                        context.report({ node: res.comment, messageId: 'unusedResource', data: { name }})
+                }
+            }
+        }
+    }
+}

package/src/rules/require-matching-localized-fields.js

@@ -1,53 +1,53 @@
-import { extractMetadata } from '../utils.js'
-
-export default {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Require matching localized name and description fields',
-            category: 'Possible Errors',
-            recommended: true
-        },
-        schema: [{
-            type: 'object',
-            properties: {
-                ignoreLanguages: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Language codes to ignore (e.g., ["fr", "de"])'
-                }
-            },
-            additionalProperties: false
-        }],
-        defaultOptions: [{}],
-        messages: { missingPair: 'Missing matching @{{missing}} for @{{present}}' }
-    },
-
-    create(context) {
-        const options = context.options[0] || {},
-              ignoreLanguages = options.ignoreLanguages || []
-        return {
-            Program() {
-                const metaEntries = extractMetadata(context.sourceCode),
-                      nameEntries = metaEntries.filter(e => e.key.startsWith('name:')),
-                      descEntries = metaEntries.filter(e => e.key.startsWith('description:')),
-                      nameLangs = new Set(nameEntries.map(e => e.key.split(':')[1])),
-                      descLangs = new Set(descEntries.map(e => e.key.split(':')[1]))
-                for (const lang of nameLangs)
-                    if (!ignoreLanguages.includes(lang) && !descLangs.has(lang))
-                        context.report({
-                            node: nameEntries.find(entry => entry.key == `name:${lang}`).comment,
-                            messageId: 'missingPair',
-                            data: { missing: `description:${lang}`, present: `name:${lang}` }
-                        })
-                for (const lang of descLangs)
-                    if (!ignoreLanguages.includes(lang) && !nameLangs.has(lang))
-                        context.report({
-                            node: descEntries.find(e => e.key == `description:${lang}`).comment,
-                            messageId: 'missingPair',
-                            data: { missing: `name:${lang}`, present: `description:${lang}` }
-                        })
-            }
-        }
-    }
-}
+import { extractMetadata } from '../utils.js'
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require matching localized name and description fields',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        schema: [{
+            type: 'object',
+            properties: {
+                ignoreLanguages: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Language codes to ignore (e.g., ["fr", "de"])'
+                }
+            },
+            additionalProperties: false
+        }],
+        defaultOptions: [{}],
+        messages: { missingPair: 'Missing matching @{{missing}} for @{{present}}' }
+    },
+
+    create(context) {
+        const options = context.options[0] || {},
+              ignoreLanguages = options.ignoreLanguages || []
+        return {
+            Program() {
+                const metaEntries = extractMetadata(context.sourceCode),
+                      nameEntries = metaEntries.filter(e => e.key.startsWith('name:')),
+                      descEntries = metaEntries.filter(e => e.key.startsWith('description:')),
+                      nameLangs = new Set(nameEntries.map(e => e.key.split(':')[1])),
+                      descLangs = new Set(descEntries.map(e => e.key.split(':')[1]))
+                for (const lang of nameLangs)
+                    if (!ignoreLanguages.includes(lang) && !descLangs.has(lang))
+                        context.report({
+                            node: nameEntries.find(entry => entry.key == `name:${lang}`).comment,
+                            messageId: 'missingPair',
+                            data: { missing: `description:${lang}`, present: `name:${lang}` }
+                        })
+                for (const lang of descLangs)
+                    if (!ignoreLanguages.includes(lang) && !nameLangs.has(lang))
+                        context.report({
+                            node: descEntries.find(e => e.key == `description:${lang}`).comment,
+                            messageId: 'missingPair',
+                            data: { missing: `name:${lang}`, present: `description:${lang}` }
+                        })
+            }
+        }
+    }
+}

package/src/rules/require-required-fields.js

@@ -1,41 +1,41 @@
-import { extractMetadata } from '../utils.js'
-
-export default {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Require essential metadata fields',
-            category: 'Possible Errors',
-            recommended: true
-        },
-        schema: [{
-            type: 'object',
-            properties: {
-                fields: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Required metadata fields (default: name, namespace, version)'
-                }
-            },
-            additionalProperties: false
-        }],
-        defaultOptions: [{}],
-        messages: { missingField: 'Missing required metadata field: @{{field}}' }
-    },
-
-    create(context) {
-        const options = context.options[0] || {},
-              requiredFields = options.fields || ['name', 'namespace', 'version']
-        return {
-            Program(node) {
-                const metaEntries = extractMetadata(context.sourceCode),
-                      keys = new Set(metaEntries.map(e => e.key))
-                for (const field of requiredFields)
-                    if (!keys.has(field))
-                        context.report({ node, messageId: 'missingField', data: { field }})
-                if (!metaEntries.some(entry => ['include', 'match'].includes(entry.key)))
-                    context.report({ node, messageId: 'missingField', data: { field: 'match or include' }})
-            }
-        }
-    }
-}
+import { extractMetadata } from '../utils.js'
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require essential metadata fields',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        schema: [{
+            type: 'object',
+            properties: {
+                fields: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Required metadata fields (default: name, namespace, version)'
+                }
+            },
+            additionalProperties: false
+        }],
+        defaultOptions: [{}],
+        messages: { missingField: 'Missing required metadata field: @{{field}}' }
+    },
+
+    create(context) {
+        const options = context.options[0] || {},
+              requiredFields = options.fields || ['name', 'namespace', 'version']
+        return {
+            Program(node) {
+                const metaEntries = extractMetadata(context.sourceCode),
+                      keys = new Set(metaEntries.map(e => e.key))
+                for (const field of requiredFields)
+                    if (!keys.has(field))
+                        context.report({ node, messageId: 'missingField', data: { field }})
+                if (!metaEntries.some(entry => ['include', 'match'].includes(entry.key)))
+                    context.report({ node, messageId: 'missingField', data: { field: 'match or include' }})
+            }
+        }
+    }
+}

package/src/rules/require-user-js-filename.js

@@ -0,0 +1,25 @@
+import { extractMetadata } from '../utils.js'
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require that userscript filenames end in ".user.js"',
+            category: 'Possible Errors',
+            recommended: true
+        },
+        schema: [],
+        messages: { requireUserJs: 'Userscript filename should end in ".user.js"' }
+    },
+
+    create(context) {
+        return {
+            Program(node) {
+                const metaEntries = extractMetadata(context.sourceCode)
+                if (!metaEntries.length) return
+                if (!context.filename.endsWith('.user.js'))
+                    context.report({ node, messageId: 'requireUserJs' })
+            }
+        }
+    }
+}