refactor(rules): consolidate imports and add contributing guide 🦖

- Add CONTRIBUTING.md documentation file
- Reduce code duplication across rule implementations
- Refactor all rule files to use namespace imports
- Replace named imports with namespace imports for better organization

Author: NeaByteLab

CONTRIBUTING.md

@@ -0,0 +1,138 @@
+# Contributing to @neabyte/deno-lint
+
+Thank you for your interest in contributing to this Deno lint plugin collection!
+
+## Development Setup
+
+1. **Prerequisites**: Deno 2.2.0+
+2. **Clone the repository**
+3. **Run tests**: `deno task test`
+4. **Check code**: `deno task check`
+
+## Adding New Rules
+
+### 1. Create Rule Implementation
+
+Create a new file in `src/rules/` following the naming convention `RuleName.ts`:
+
+```typescript
+import type * as types from '@interfaces/index.ts'
+import * as utils from '@utils/index.ts'
+
+/**
+ * Lint rule for [rule description].
+ */
+export const yourRuleNameRule = {
+  /**
+   * Creates the lint rule implementation.
+   * @param context - The Deno lint context for reporting issues and fixes
+   * @returns Object containing visitor functions for AST node types
+   */
+  create(context: types.LintContext): Record<string, (node: types.DenoASTNode) => void> {
+    return {
+      /**
+       * Visitor function for [node type].
+       * @param node - The AST node representing a [node type]
+       */
+      YourNodeType(node: types.DenoASTNode): void {
+        if (!utils.isYourNodeType(node)) {
+          return
+        }
+        // Rule logic here
+        context.report({
+          node,
+          message: 'Your rule message',
+          fix: fixer => fixer.replaceText(node, 'fixed code') // optional
+        })
+      }
+    }
+  }
+}
+```
+
+### 2. Export Rule
+
+Add your rule to `src/rules/index.ts`:
+
+```typescript
+export * from '@rules/YourRuleName.ts'
+```
+
+### 3. Register Rule
+
+Add your rule to `src/index.ts`:
+
+```typescript
+const plugin: LintPlugin = {
+  name: 'deno-lint',
+  rules: {
+    // ... existing rules
+    'your-rule-name': rules.yourRuleNameRule
+  }
+}
+```
+
+### 4. Write Tests
+
+Create tests in `tests/rules/YourRuleName.ts`:
+
+```typescript
+import { runnerTest, verifyAutoFix } from '@tests/index.ts'
+
+const rulesId = 'deno-lint/your-rule-name'
+
+Deno.test('your-rule-name (should trigger)', () => runnerTest(rulesId, 'problematic code', 1))
+
+Deno.test('your-rule-name (should not trigger)', () => runnerTest(rulesId, 'valid code', 0))
+
+Deno.test('verify auto-fix', () =>
+  verifyAutoFix(rulesId, 'code to fix', 'expected fixed code', 'description')
+)
+```
+
+### 5. Add Documentation
+
+Create an example file in `examples/your-rule-name.md` with:
+
+- Rule description
+- Examples of violations
+- Examples of correct usage
+- Auto-fix examples (if applicable)
+
+## Code Style
+
+- Follow the project's TypeScript configuration
+- Use JSDoc comments for functions and exports
+- Prefer explicit type annotations
+- Use arrow functions for callbacks
+- Follow the existing naming conventions
+- Use utility functions from `@utils/index.ts` when available
+- Include comprehensive test coverage with both positive and negative cases
+- **Import all types using namespace imports from `@interfaces/index.ts`** (may not be 100% complete yet) - if you find missing types, add them following the existing style
+
+## Testing
+
+- All rules must have comprehensive tests
+- Test both positive and negative cases
+- Include auto-fix tests when applicable
+- Run `deno task test` before submitting
+
+## Submitting Changes
+
+1. Ensure all tests pass: `deno task test`
+2. Run code checks: `deno task check`
+3. Create a pull request with a clear description
+4. Reference any related issues
+
+## Rule Guidelines
+
+- **Do not duplicate existing Deno lint features** - Check [Deno's built-in rules](./development/DENO-RULES.md) before creating new ones
+- Rules should be focused and specific
+- Provide helpful error messages
+- Include auto-fixes when possible
+- Consider performance implications
+- Follow Deno's lint plugin conventions
+
+## Questions?
+
+Feel free to open an issue for questions about contributing or rule implementation.

src/rules/AsyncFunctionNaming.ts

@@ -1,10 +1,5 @@
-import type { DenoASTNode, LintContext } from '@interfaces/index.ts'
-import {
-  createAddSuffixFix,
-  followsAsyncNamingConvention,
-  getFunctionName,
-  isAsyncFunction
-} from '@utils/index.ts'
+import type * as types from '@interfaces/index.ts'
+import * as utils from '@utils/index.ts'
 
 /**
  * Lint rule for enforcing async function naming conventions.
@@ -15,20 +10,20 @@ export const asyncFunctionNamingRule = {
    * @param context - The Deno lint context for reporting issues and fixes
    * @returns Object containing visitor functions for AST node types
    */
-  create(context: LintContext): Record<string, (node: DenoASTNode) => void> {
+  create(context: types.LintContext): Record<string, (node: types.DenoASTNode) => void> {
     return {
       /**
        * Visitor function for function declarations.
        * @param node - The AST node representing a function declaration
        */
-      FunctionDeclaration(node: DenoASTNode): void {
-        if (isAsyncFunction(node) && !followsAsyncNamingConvention(node, 'Async')) {
-          const functionName = getFunctionName(node)
+      FunctionDeclaration(node: types.DenoASTNode): void {
+        if (utils.isAsyncFunction(node) && !utils.followsAsyncNamingConvention(node, 'Async')) {
+          const functionName = utils.getFunctionName(node)
           if (functionName) {
             context.report({
               node,
               message: "Async functions should be named with 'Async' suffix",
-              fix: createAddSuffixFix(context, node, 'Async')
+              fix: utils.createAddSuffixFix(context, node, 'Async')
             })
           }
         }

src/rules/ExplicitParameterTypes.ts

@@ -1,16 +1,5 @@
-import type { DenoASTNode, LintContext, LintFixer, ParameterNode } from '@interfaces/index.ts'
-import {
-  createAddDefaultTypeFix,
-  createAddDestructuredTypeFix,
-  createAddParameterTypeFix,
-  createAddRestTypeFix,
-  getParameterName,
-  hasParameterType,
-  isArrowFunctionExpression,
-  isFunctionDeclaration,
-  isFunctionExpression,
-  isMethodDefinition
-} from '@utils/index.ts'
+import type * as types from '@interfaces/index.ts'
+import * as utils from '@utils/index.ts'
 
 /**
  * Checks all parameters in a function for explicit type annotations.
@@ -19,13 +8,13 @@ import {
  * @param params - Array of parameter nodes to check
  */
 function checkParameters(
-  context: LintContext,
-  node: DenoASTNode,
-  params: Array<ParameterNode>
+  context: types.LintContext,
+  node: types.DenoASTNode,
+  params: Array<types.ParameterNode>
 ): void {
-  params.forEach((param: ParameterNode) => {
-    if (!hasParameterType(param)) {
-      const paramName = getParameterName(param)
+  params.forEach((param: types.ParameterNode) => {
+    if (!utils.hasParameterType(param)) {
+      const paramName = utils.getParameterName(param)
       const message = paramName
         ? `Parameter '${paramName}' must have explicit type annotation`
         : 'Parameter must have explicit type annotation'
@@ -46,21 +35,21 @@ function checkParameters(
  * @returns The appropriate fix function
  */
 function getFixFunction(
-  context: LintContext,
-  node: DenoASTNode,
-  param: ParameterNode
-): (fixer: LintFixer) => unknown {
+  context: types.LintContext,
+  node: types.DenoASTNode,
+  param: types.ParameterNode
+): (fixer: types.LintFixer) => unknown {
   switch (param.type) {
     case 'AssignmentPattern':
-      return createAddDefaultTypeFix(context, node)
+      return utils.createAddDefaultTypeFix(context, node)
     case 'Identifier':
-      return createAddParameterTypeFix(context, node, param.name || 'param')
+      return utils.createAddParameterTypeFix(context, node, param.name || 'param')
     case 'ObjectPattern':
-      return createAddDestructuredTypeFix(context, node)
+      return utils.createAddDestructuredTypeFix(context, node)
     case 'RestElement':
-      return createAddRestTypeFix(context, node)
+      return utils.createAddRestTypeFix(context, node)
     default:
-      return createAddParameterTypeFix(context, node, 'param')
+      return utils.createAddParameterTypeFix(context, node, 'param')
   }
 }
 
@@ -73,14 +62,14 @@ export const explicitParameterTypesRule = {
    * @param context - The Deno lint context for reporting issues and fixes
    * @returns Object containing visitor functions for AST node types
    */
-  create(context: LintContext): Record<string, (node: DenoASTNode) => void> {
+  create(context: types.LintContext): Record<string, (node: types.DenoASTNode) => void> {
     return {
       /**
        * Visitor function for arrow function expressions.
        * @param node - The AST node representing an arrow function expression
        */
-      ArrowFunctionExpression(node: DenoASTNode): void {
-        if (!isArrowFunctionExpression(node)) {
+      ArrowFunctionExpression(node: types.DenoASTNode): void {
+        if (!utils.isArrowFunctionExpression(node)) {
           return
         }
         checkParameters(context, node, node.params)
@@ -89,8 +78,8 @@ export const explicitParameterTypesRule = {
        * Visitor function for function declarations.
        * @param node - The AST node representing a function declaration
        */
-      FunctionDeclaration(node: DenoASTNode): void {
-        if (!isFunctionDeclaration(node)) {
+      FunctionDeclaration(node: types.DenoASTNode): void {
+        if (!utils.isFunctionDeclaration(node)) {
           return
         }
         checkParameters(context, node, node.params)
@@ -99,11 +88,11 @@ export const explicitParameterTypesRule = {
        * Visitor function for function expressions.
        * @param node - The AST node representing a function expression
        */
-      FunctionExpression(node: DenoASTNode): void {
-        if (!isFunctionExpression(node)) {
+      FunctionExpression(node: types.DenoASTNode): void {
+        if (!utils.isFunctionExpression(node)) {
           return
         }
-        if (node.parent && isMethodDefinition(node.parent as DenoASTNode)) {
+        if (node.parent && utils.isMethodDefinition(node.parent as types.DenoASTNode)) {
           return
         }
         checkParameters(context, node, node.params)
@@ -112,8 +101,8 @@ export const explicitParameterTypesRule = {
        * Visitor function for method definitions.
        * @param node - The AST node representing a method definition
        */
-      MethodDefinition(node: DenoASTNode): void {
-        if (!isMethodDefinition(node)) {
+      MethodDefinition(node: types.DenoASTNode): void {
+        if (!utils.isMethodDefinition(node)) {
           return
         }
         checkParameters(context, node, node.value.params)

src/rules/ExplicitReturnTypes.ts

@@ -1,10 +1,5 @@
-import type { DenoASTNode, LintContext } from '@interfaces/index.ts'
-import {
-  createAddReturnTypeFix,
-  hasReturnType,
-  inferReturnType,
-  isFunctionDeclaration
-} from '@utils/index.ts'
+import type * as types from '@interfaces/index.ts'
+import * as utils from '@utils/index.ts'
 
 /**
  * Lint rule for enforcing explicit return type annotations.
@@ -15,22 +10,22 @@ export const explicitReturnTypesRule = {
    * @param context - The Deno lint context for reporting issues and fixes
    * @returns Object containing visitor functions for AST node types
    */
-  create(context: LintContext): Record<string, (node: DenoASTNode) => void> {
+  create(context: types.LintContext): Record<string, (node: types.DenoASTNode) => void> {
     return {
       /**
        * Visitor function for function declarations.
        * @param node - The AST node representing a function declaration
        */
-      FunctionDeclaration(node: DenoASTNode): void {
-        if (!isFunctionDeclaration(node)) {
+      FunctionDeclaration(node: types.DenoASTNode): void {
+        if (!utils.isFunctionDeclaration(node)) {
           return
         }
-        if (!hasReturnType(node)) {
-          const returnType = inferReturnType(node, context)
+        if (!utils.hasReturnType(node)) {
+          const returnType = utils.inferReturnType(node, context)
           context.report({
             node,
             message: 'Function must have explicit return type annotation',
-            fix: createAddReturnTypeFix(context, node, returnType)
+            fix: utils.createAddReturnTypeFix(context, node, returnType)
           })
         }
       }

src/rules/PreferArrayEvery.ts

@@ -1,5 +1,5 @@
-import type { DenoASTNode, LintContext } from '@interfaces/index.ts'
-import { canReplaceWithArrayMethod, createArrayMethodFix, isForStatement } from '@utils/index.ts'
+import type * as types from '@interfaces/index.ts'
+import * as utils from '@utils/index.ts'
 
 /**
  * Lint rule for preferring Array.every() over manual for loops.
@@ -10,21 +10,21 @@ export const preferArrayEveryRule = {
    * @param context - The Deno lint context for reporting issues and fixes
    * @returns Object containing visitor functions for AST node types
    */
-  create(context: LintContext): Record<string, (node: DenoASTNode) => void> {
+  create(context: types.LintContext): Record<string, (node: types.DenoASTNode) => void> {
     return {
       /**
        * Visitor function for for statements.
        * @param node - The AST node representing a for statement
        */
-      ForStatement(node: DenoASTNode): void {
-        if (!isForStatement(node)) {
+      ForStatement(node: types.DenoASTNode): void {
+        if (!utils.isForStatement(node)) {
           return
         }
-        if (canReplaceWithArrayMethod(node, 'every')) {
+        if (utils.canReplaceWithArrayMethod(node, 'every')) {
           context.report({
             node,
             message: 'Prefer Array.every() over manual for loops that return false',
-            fix: createArrayMethodFix(context, node, 'every')
+            fix: utils.createArrayMethodFix(context, node, 'every')
           })
         }
       }