editorconfig support, fixed docs

Author: NullVoxPopuli

docs/rules/template-block-indentation.md

@@ -36,10 +36,18 @@ Examples of **incorrect** code for this rule:
 </div>
 ```
 
+```hbs
+<div>
+  <p>{{t 'Stuff here!'}}</p>
+</div>
+```
+
 Examples of **correct** code for this rule:
 
 ```hbs
-{{#each foo as |bar|}}{{/each}}
+{{#each foo as |bar|}}
+  {{bar.name}}
+{{/each}}
 ```
 
 ```hbs
@@ -55,3 +63,6 @@ Examples of **correct** code for this rule:
 - Object:
   - `indentation` (integer, default `2`): Number of spaces to indent.
   - `ignoreComments` (boolean, default `false`): Skip indentation checking for comments.
+
+When no option is specified, the rule reads `indent_size` from .editorconfig (if present).
+If no .editorconfig is found, the default is `2` spaces.

lib/rules/template-block-indentation.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { resolveEditorConfig } = require('../utils/editorconfig');
+
 const VOID_TAGS = new Set([
   'area',
   'base',
@@ -162,7 +164,17 @@ module.exports = {
   },
 
   create(context) {
-    const config = parseOptions(context.options[0]);
+    const options = context.options[0];
+    let config;
+    if (options === undefined) {
+      // No explicit config — try .editorconfig for indent_size
+      const filePath = context.filename || context.getFilename();
+      const editorConfig = resolveEditorConfig(filePath);
+      const indent = editorConfig.indent_size;
+      config = { indentation: typeof indent === 'number' ? indent : 2 };
+    } else {
+      config = parseOptions(options);
+    }
     const sourceCode = context.sourceCode;
     const sourceText = sourceCode.getText();
     const sourceLines = sourceText.split('\n');

lib/utils/editorconfig.js

@@ -0,0 +1,160 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Lightweight .editorconfig parser.
+ *
+ * Walks up from `filePath` collecting .editorconfig files, parses their
+ * INI-like sections, and returns the merged properties that apply.
+ *
+ * Only simple glob patterns are supported:
+ *   *            – matches everything
+ *   *.ext        – matches files with that extension
+ *   *.{a,b}      – matches files with extension a or b
+ *   [section]    – literal pattern
+ *
+ * This intentionally does NOT replicate the full editorconfig-core spec
+ * (no ** path globs, no numeric ranges, etc.) because for indent_size
+ * resolution the simple patterns cover virtually all real configs.
+ */
+
+const COMMENT_RE = /^\s*[#;]/;
+const SECTION_RE = /^\s*\[(.+?)]\s*$/;
+const PROPERTY_RE = /^\s*([\w.-]+)\s*=\s*(.*?)\s*$/;
+
+function parseEditorConfig(contents) {
+  const sections = [];
+  let current = { glob: null, props: {} }; // preamble (root, etc.)
+  sections.push(current);
+
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || COMMENT_RE.test(line)) {
+      continue;
+    }
+    const sectionMatch = SECTION_RE.exec(line);
+    if (sectionMatch) {
+      current = { glob: sectionMatch[1], props: {} };
+      sections.push(current);
+      continue;
+    }
+    const propMatch = PROPERTY_RE.exec(line);
+    if (propMatch) {
+      const key = propMatch[1].toLowerCase();
+      let value = propMatch[2].toLowerCase();
+      // Parse numbers and booleans
+      if (/^\d+$/.test(value)) {
+        value = Number(value);
+      } else if (value === 'true') {
+        value = true;
+      } else if (value === 'false') {
+        value = false;
+      }
+      current.props[key] = value;
+    }
+  }
+  return sections;
+}
+
+/**
+ * Tests whether a simple editorconfig glob matches a filename (basename only).
+ */
+function globMatchesFilename(glob, filename) {
+  // Strip leading path separators (editorconfig globs without / apply to basename)
+  if (glob.includes('/')) {
+    // Path-style globs are not supported in this lightweight impl
+    return false;
+  }
+  if (glob === '*') {
+    return true;
+  }
+  // Handle *.{ext1,ext2} and *.ext
+  const braceMatch = /^\*\.{([^}]+)}$/.exec(glob);
+  if (braceMatch) {
+    const extensions = braceMatch[1].split(',').map((e) => e.trim());
+    return extensions.some((ext) => filename.endsWith(`.${ext}`));
+  }
+  if (glob.startsWith('*.')) {
+    const ext = glob.slice(1); // e.g. ".hbs"
+    return filename.endsWith(ext);
+  }
+  // Literal match
+  return filename === glob;
+}
+
+/**
+ * Collect .editorconfig files from `dir` up to the filesystem root,
+ * stopping at a file that declares `root = true`.
+ */
+function collectConfigFiles(dir) {
+  const files = [];
+  let current = dir;
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const configPath = path.join(current, '.editorconfig');
+    try {
+      const contents = fs.readFileSync(configPath, 'utf8');
+      const sections = parseEditorConfig(contents);
+      const isRoot = sections[0] && sections[0].glob === null && sections[0].props.root === true;
+      files.push({ dir: current, sections });
+      if (isRoot) {
+        break;
+      }
+    } catch {
+      // No .editorconfig at this level, keep going
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return files;
+}
+
+/**
+ * Resolve editorconfig properties for a given file path.
+ *
+ * Returns an object like `{ indent_size: 4, indent_style: 'space', ... }`
+ * with only the properties that matched. Returns an empty object if no
+ * .editorconfig is found or no sections match.
+ */
+function resolveEditorConfig(filePath) {
+  const dir = path.dirname(filePath);
+  const filename = path.basename(filePath);
+  const configFiles = collectConfigFiles(dir);
+
+  // Merge: outermost first, innermost wins (same as editorconfig spec)
+  const merged = {};
+  for (let i = configFiles.length - 1; i >= 0; i--) {
+    for (const section of configFiles[i].sections) {
+      if (section.glob === null) {
+        continue; // preamble section (root = true, etc.)
+      }
+      if (globMatchesFilename(section.glob, filename)) {
+        Object.assign(merged, section.props);
+      }
+    }
+  }
+
+  // Apply editorconfig post-processing rules
+  if (merged.indent_style === 'tab' && merged.indent_size === undefined) {
+    merged.indent_size = 'tab';
+  }
+  if (
+    merged.indent_size !== undefined &&
+    merged.tab_width === undefined &&
+    merged.indent_size !== 'tab'
+  ) {
+    merged.tab_width = merged.indent_size;
+  }
+  if (merged.indent_size === 'tab' && merged.tab_width !== undefined) {
+    merged.indent_size = merged.tab_width;
+  }
+
+  return merged;
+}
+
+module.exports = { resolveEditorConfig };

tests/lib/utils/editorconfig-test.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { resolveEditorConfig } = require('../../../lib/utils/editorconfig');
+
+describe('resolveEditorConfig', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'editorconfig-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns empty object when no .editorconfig exists', () => {
+    const filePath = path.join(tmpDir, 'test.hbs');
+    const result = resolveEditorConfig(filePath);
+    expect(result).toEqual({});
+  });
+
+  it('reads indent_size from .editorconfig', () => {
+    fs.writeFileSync(
+      path.join(tmpDir, '.editorconfig'),
+      ['root = true', '', '[*]', 'indent_size = 4'].join('\n')
+    );
+    const filePath = path.join(tmpDir, 'test.hbs');
+    const result = resolveEditorConfig(filePath);
+    expect(result.indent_size).toBe(4);
+  });
+
+  it('matches *.hbs sections', () => {
+    fs.writeFileSync(
+      path.join(tmpDir, '.editorconfig'),
+      ['root = true', '', '[*.hbs]', 'indent_size = 3'].join('\n')
+    );
+    const filePath = path.join(tmpDir, 'test.hbs');
+    const result = resolveEditorConfig(filePath);
+    expect(result.indent_size).toBe(3);
+  });
+
+  it('does not match non-matching glob', () => {
+    fs.writeFileSync(
+      path.join(tmpDir, '.editorconfig'),
+      ['root = true', '', '[*.js]', 'indent_size = 4'].join('\n')
+    );
+    const filePath = path.join(tmpDir, 'test.hbs');
+    const result = resolveEditorConfig(filePath);
+    expect(result.indent_size).toBeUndefined();
+  });
+
+  it('handles brace expansion *.{hbs,gjs}', () => {
+    fs.writeFileSync(
+      path.join(tmpDir, '.editorconfig'),
+      ['root = true', '', '[*.{hbs,gjs}]', 'indent_size = 6'].join('\n')
+    );
+    expect(resolveEditorConfig(path.join(tmpDir, 'test.hbs')).indent_size).toBe(6);
+    expect(resolveEditorConfig(path.join(tmpDir, 'test.gjs')).indent_size).toBe(6);
+    expect(resolveEditorConfig(path.join(tmpDir, 'test.js')).indent_size).toBeUndefined();
+  });
+
+  it('later sections override earlier ones', () => {
+    fs.writeFileSync(
+      path.join(tmpDir, '.editorconfig'),
+      ['root = true', '', '[*]', 'indent_size = 2', '', '[*.hbs]', 'indent_size = 4'].join('\n')
+    );
+    const filePath = path.join(tmpDir, 'test.hbs');
+    const result = resolveEditorConfig(filePath);
+    expect(result.indent_size).toBe(4);
+  });
+
+  it('inner .editorconfig overrides outer', () => {
+    // outer
+    fs.writeFileSync(
+      path.join(tmpDir, '.editorconfig'),
+      ['root = true', '', '[*]', 'indent_size = 2'].join('\n')
+    );
+    // inner dir
+    const innerDir = path.join(tmpDir, 'app');
+    fs.mkdirSync(innerDir);
+    fs.writeFileSync(path.join(innerDir, '.editorconfig'), ['[*]', 'indent_size = 4'].join('\n'));
+    const filePath = path.join(innerDir, 'test.hbs');
+    const result = resolveEditorConfig(filePath);
+    expect(result.indent_size).toBe(4);
+  });
+
+  it('sets indent_size to tab when indent_style is tab and indent_size unset', () => {
+    fs.writeFileSync(
+      path.join(tmpDir, '.editorconfig'),
+      ['root = true', '', '[*]', 'indent_style = tab'].join('\n')
+    );
+    const filePath = path.join(tmpDir, 'test.hbs');
+    const result = resolveEditorConfig(filePath);
+    expect(result.indent_style).toBe('tab');
+    expect(result.indent_size).toBe('tab');
+  });
+
+  it('ignores comments', () => {
+    fs.writeFileSync(
+      path.join(tmpDir, '.editorconfig'),
+      ['root = true', '# a comment', '; another comment', '[*]', 'indent_size = 5'].join('\n')
+    );
+    const filePath = path.join(tmpDir, 'test.hbs');
+    const result = resolveEditorConfig(filePath);
+    expect(result.indent_size).toBe(5);
+  });
+});