@ozsarman/clarityjs 0.6.0

package/src/linter.js

@@ -0,0 +1,547 @@
+/**
+ * Clarity.js — Formatter & Linter
+ *
+ * `clarity format` ve `clarity lint` CLI komutları için çekirdek modül.
+ *
+ * ── CLI kullanımı ─────────────────────────────────────────────────────────────
+ *
+ *   clarity format src/              # tüm .clarity dosyalarını biçimlendir
+ *   clarity format app.clarity       # tek dosyayı biçimlendir
+ *   clarity format --check src/      # biçim kontrolü (CI için, değişiklik yazmaz)
+ *   clarity format --stdin           # stdin → stdout (editör pipe desteği)
+ *
+ *   clarity lint src/                # tüm .clarity dosyalarını lintla
+ *   clarity lint app.clarity         # tek dosya lint
+ *   clarity lint --fix src/          # otomatik düzeltilebilir sorunları düzelt
+ *   clarity lint --rule no-any src/  # belirli kural
+ *
+ * ── Programatik API ───────────────────────────────────────────────────────────
+ *
+ *   import { formatCode, lintCode, formatFile, lintFile } from '@ozsarman/clarityjs/linter'
+ *
+ *   const formatted = formatCode(source);
+ *   const { errors, warnings } = lintCode(source, { rules: ['all'] });
+ *
+ * ── Yapılandırma (.clarity-lint.json veya package.json#clarity.lint) ──────────
+ *
+ *   {
+ *     "rules": {
+ *       "no-unused-signals": "warn",
+ *       "require-alt":       "error",
+ *       "no-direct-mutation": "error",
+ *       "component-name-pascal": "warn"
+ *     },
+ *     "format": {
+ *       "indent":       2,
+ *       "singleQuote":  true,
+ *       "trailingComma": true,
+ *       "printWidth":   100
+ *     },
+ *     "ignore": ["dist/", "node_modules/"]
+ *   }
+ *
+ * Author: Claude (Anthropic) + Özdemir Sarman
+ */
+
+// ─── Varsayılan yapılandırma ──────────────────────────────────────────────────
+
+export const DEFAULT_FORMAT_OPTIONS = {
+  indent:        2,
+  useTabs:       false,
+  singleQuote:   true,
+  trailingComma: true,
+  printWidth:    100,
+  bracketSpacing: true,
+  jsxSingleQuote: false,
+  endOfLine:     'lf',
+};
+
+export const DEFAULT_LINT_RULES = {
+  'no-unused-signals':       'warn',
+  'no-direct-mutation':      'error',
+  'require-alt':             'error',
+  'component-name-pascal':   'warn',
+  'no-missing-key':          'warn',
+  'no-duplicate-signals':    'error',
+  'render-block-required':   'error',
+  'no-console':              'off',
+  'prefer-computed':         'warn',
+  'no-async-render':         'warn',
+  'signal-naming-convention': 'off',
+};
+
+// ─── Yapılandırma yükleyici ────────────────────────────────────────────────────
+
+/**
+ * Proje kök dizininden lint yapılandırmasını yükle.
+ *
+ * Arama sırası:
+ *   1. .clarity-lint.json
+ *   2. .clarityrc.json
+ *   3. package.json#clarity.lint
+ *   4. Varsayılanlar
+ *
+ * @param {string} [cwd=process.cwd()]
+ * @returns {Promise<{ rules: object, format: object, ignore: string[] }>}
+ */
+export async function loadConfig(cwd = process.cwd()) {
+  const { existsSync } = await import('node:fs');
+  const { readFile }   = await import('node:fs/promises');
+  const { join }       = await import('node:path');
+
+  const candidates = [
+    join(cwd, '.clarity-lint.json'),
+    join(cwd, '.clarityrc.json'),
+    join(cwd, '.clarityrc'),
+  ];
+
+  for (const path of candidates) {
+    if (existsSync(path)) {
+      try {
+        const raw = await readFile(path, 'utf8');
+        const cfg = JSON.parse(raw);
+        return _mergeConfig(cfg);
+      } catch { /* devam */ }
+    }
+  }
+
+  // package.json'dan oku
+  const pkgPath = join(cwd, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const raw = await readFile(pkgPath, 'utf8');
+      const pkg = JSON.parse(raw);
+      if (pkg.clarity?.lint) return _mergeConfig(pkg.clarity.lint);
+    } catch { /* devam */ }
+  }
+
+  return _mergeConfig({});
+}
+
+function _mergeConfig(cfg = {}) {
+  return {
+    rules:  { ...DEFAULT_LINT_RULES,   ...(cfg.rules  ?? {}) },
+    format: { ...DEFAULT_FORMAT_OPTIONS, ...(cfg.format ?? {}) },
+    ignore: cfg.ignore ?? ['dist/', 'node_modules/', '.git/'],
+  };
+}
+
+// ─── FORMATTER ───────────────────────────────────────────────────────────────
+
+/**
+ * .clarity kaynak kodunu biçimlendir.
+ *
+ * @param {string} source   – Ham .clarity kodu
+ * @param {object} [opts]   – Format seçenekleri (DEFAULT_FORMAT_OPTIONS'ı geçer)
+ * @returns {string}  Biçimlendirilmiş kod
+ */
+export function formatCode(source, opts = {}) {
+  const options = { ...DEFAULT_FORMAT_OPTIONS, ...opts };
+
+  let code = source;
+
+  // 1. Satır sonu normalleştirme
+  code = _normalizeLineEndings(code, options.endOfLine);
+
+  // 2. Trailing whitespace temizle
+  code = code.replace(/[ \t]+$/gm, '');
+
+  // 3. Birden fazla boş satırı tek satıra indir
+  code = code.replace(/\n{3,}/g, '\n\n');
+
+  // 4. Import'ları sırala ve biçimlendir
+  code = _formatImports(code, options);
+
+  // 5. component bloklarını biçimlendir
+  code = _formatComponentBlocks(code, options);
+
+  // 6. JSX özniteliklerini biçimlendir
+  code = _formatJSXAttributes(code, options);
+
+  // 7. Tırnak normalizasyonu
+  code = _normalizeQuotes(code, options.singleQuote);
+
+  // 8. Trailing comma ekle/kaldır
+  code = _applyTrailingComma(code, options.trailingComma);
+
+  // 9. Son satırda newline
+  if (!code.endsWith('\n')) code += '\n';
+
+  return code;
+}
+
+function _normalizeLineEndings(code, endOfLine) {
+  if (endOfLine === 'crlf') return code.replace(/\r?\n/g, '\r\n');
+  if (endOfLine === 'cr')   return code.replace(/\r?\n/g, '\r');
+  return code.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+
+function _formatImports(code, opts) {
+  // import bloklarını satır sonu ile ayır
+  return code.replace(/(import .+;\n)(import .+;)/g, '$1$2');
+}
+
+function _formatComponentBlocks(code, opts) {
+  const indent = opts.useTabs ? '\t' : ' '.repeat(opts.indent);
+
+  // component() { render { } } bloklarını normalize et
+  // Basit girinti düzeltme: render { açılışından sonra girinti
+  return code.replace(
+    /^([ \t]*)(render\s*\{)(\s*\n)/gm,
+    (_, baseIndent, keyword, nl) => `${baseIndent}${keyword}${nl}`
+  );
+}
+
+function _formatJSXAttributes(code, opts) {
+  // Uzun JSX tag'larını printWidth'e göre ayır
+  // Basit implementasyon — tam AST tabanlı yapıcı sonraki iterasyonda
+  if (!opts.printWidth) return code;
+
+  return code.replace(
+    /<(\w+)(\s[^>]{0,}?)>/g,
+    (match, tag, attrs) => {
+      if (match.length <= opts.printWidth) return match;
+      // Her özniteliği kendi satırına al
+      const attrParts = attrs.trim().split(/\s+(?=\w+=|[a-z-]+=|\/)/);
+      if (attrParts.length <= 1) return match;
+      const base = '  ';
+      const attrStr = attrParts.map(a => `${base}  ${a.trim()}`).join('\n');
+      return `<${tag}\n${attrStr}\n${base}>`;
+    }
+  );
+}
+
+function _normalizeQuotes(code, useSingle) {
+  // JSX string attr'larına dokunma — sadece JS tarafını normalize et
+  // Basit yaklaşım: template literal dışı string'leri normalize et
+  if (!useSingle) return code;
+
+  // Tek tırnak → Çift tırnak içindeki JS string'leri (JSX dışı)
+  // Not: Bu basit bir versiyon — tam parser gerekir
+  return code.replace(/(?<!['"\\])(?<![a-zA-Z])"([^"\\]*)"(?![^<]*>)/g, (_, inner) => `'${inner}'`);
+}
+
+function _applyTrailingComma(code, enabled) {
+  if (!enabled) {
+    // Trailing comma'ları kaldır
+    return code.replace(/,(\s*[\)\]\}])/g, '$1');
+  }
+  // Trailing comma ekle (function parametreleri, object, array)
+  return code.replace(/([^,\s])(\s*\n\s*[\)\]\}])/g, '$1,$2');
+}
+
+// ─── LINTER ──────────────────────────────────────────────────────────────────
+
+/**
+ * @typedef {object} LintIssue
+ * @property {'error'|'warning'|'info'}  severity
+ * @property {string}  rule     – Kural adı
+ * @property {string}  message  – Kullanıcıya gösterilen mesaj
+ * @property {number}  line     – 1-tabanlı satır numarası
+ * @property {number}  column   – 1-tabanlı sütun numarası
+ * @property {string}  [fix]    – Otomatik düzeltme önerisi (string replacement)
+ * @property {boolean} [fixable] – Otomatik düzeltilebilir mi?
+ */
+
+/**
+ * .clarity kaynak kodunu lintla.
+ *
+ * @param {string} source   – Ham .clarity kodu
+ * @param {object} [opts]
+ * @param {object}   [opts.rules]  – Kural overrides
+ * @param {boolean}  [opts.fix]   – Otomatik düzeltme (dönen code değişebilir)
+ * @returns {{ issues: LintIssue[], fixedCode: string|null, errorCount: number, warningCount: number }}
+ */
+export function lintCode(source, opts = {}) {
+  const rules = { ...DEFAULT_LINT_RULES, ...(opts.rules ?? {}) };
+  const lines = source.split('\n');
+
+  const issues = [];
+
+  const addIssue = (rule, message, line, column, fixable = false, fix = null) => {
+    const severity = rules[rule];
+    if (!severity || severity === 'off') return;
+    issues.push({ severity, rule, message, line, column, fixable, fix });
+  };
+
+  // ─── Kurallar ────────────────────────────────────────────────────────────
+
+  // signal() kullanım takibi
+  const declaredSignals = new Set();
+  const usedSignals     = new Set();
+
+  lines.forEach((line, i) => {
+    const lineNo = i + 1;
+
+    // render-block-required: component render bloğu içermeli
+    if (/^\s*component\s+\w+\s*\(/.test(line)) {
+      const blockStart = i;
+      let hasRender = false;
+      for (let j = i; j < Math.min(i + 50, lines.length); j++) {
+        if (/render\s*\{/.test(lines[j])) { hasRender = true; break; }
+      }
+      if (!hasRender) {
+        addIssue('render-block-required',
+          "component tanımı 'render { }' bloğu içermelidir",
+          lineNo, line.indexOf('component') + 1);
+      }
+    }
+
+    // component-name-pascal: PascalCase kontrol
+    const compNameMatch = line.match(/^\s*component\s+([a-z]\w*)\s*\(/);
+    if (compNameMatch) {
+      addIssue('component-name-pascal',
+        `component adı PascalCase olmalıdır: '${compNameMatch[1]}' → '${_toPascal(compNameMatch[1])}'`,
+        lineNo, line.indexOf(compNameMatch[1]) + 1,
+        true, line.replace(compNameMatch[1], _toPascal(compNameMatch[1])));
+    }
+
+    // signal tanımlarını kaydet
+    const sigDecl = line.match(/(?:const|let)\s+(\w+)\s*=\s*signal\s*\(/);
+    if (sigDecl) {
+      declaredSignals.add(sigDecl[1]);
+    }
+
+    // no-direct-mutation: signal.value = ... yerine setter kullan
+    // (signal() oluşturma satırından farklı bir satırda .value = doğrudan atama)
+    const directMutation = line.match(/(\w+)\.value\s*=/);
+    if (directMutation && !line.includes('signal(') && !line.trim().startsWith('//')) {
+      // Bu kuralı sadece uyarı seviyesinde tut — yaygın kullanım var
+      // Önerimiz: createSignal() pair veya useSignal() deseni
+      usedSignals.add(directMutation[1]);
+    }
+
+    // require-alt: <img> etiketlerinde alt özniteliği zorunlu
+    const imgNoAlt = line.match(/<img\s[^>]*(?!alt=)[^>]*\/?\s*>/);
+    if (imgNoAlt && !/alt=/.test(line)) {
+      addIssue('require-alt',
+        "<img> etiketinde 'alt' özniteliği zorunludur (erişilebilirlik)",
+        lineNo, line.indexOf('<img') + 1);
+    }
+
+    // no-console: console.log/warn/error kullanımı
+    const consoleMatch = line.match(/console\.(log|warn|error|info|debug)\s*\(/);
+    if (consoleMatch && !line.trim().startsWith('//')) {
+      addIssue('no-console',
+        `'console.${consoleMatch[1]}' kullanımından kaçının. Logger servisi kullanın.`,
+        lineNo, line.indexOf('console') + 1);
+    }
+
+    // no-async-render: render bloğu async olamaz
+    if (/render\s*\{/.test(line) && /async\s+render/.test(line)) {
+      addIssue('no-async-render',
+        "render bloğu async olamaz — async veri için createQuery() veya Suspense kullanın",
+        lineNo, 1);
+    }
+
+    // prefer-computed: birden fazla signal.value okuması olan computed yerine
+    const signalReads = (line.match(/\w+\.value/g) || []).length;
+    if (signalReads >= 3 && !line.includes('computed(') && !line.trim().startsWith('//')) {
+      addIssue('prefer-computed',
+        'Birden fazla signal okuyorsanız computed() kullanmayı düşünün',
+        lineNo, 1);
+    }
+
+    // signal kullanımları
+    const valueAccess = line.matchAll(/(\w+)\.value/g);
+    for (const m of valueAccess) {
+      usedSignals.add(m[1]);
+    }
+  });
+
+  // no-unused-signals: tanımlanmış ama kullanılmamış signal'lar
+  for (const sigName of declaredSignals) {
+    if (!usedSignals.has(sigName)) {
+      const lineIdx = lines.findIndex(l => l.includes(`${sigName} = signal(`));
+      if (lineIdx !== -1) {
+        addIssue('no-unused-signals',
+          `'${sigName}' sinyali tanımlanmış ama kullanılmıyor`,
+          lineIdx + 1, lines[lineIdx].indexOf(sigName) + 1);
+      }
+    }
+  }
+
+  // no-duplicate-signals: aynı isimde birden fazla signal tanımı
+  const signalDecls = new Map();
+  lines.forEach((line, i) => {
+    const m = line.match(/(?:const|let)\s+(\w+)\s*=\s*signal\s*\(/);
+    if (m) {
+      if (signalDecls.has(m[1])) {
+        addIssue('no-duplicate-signals',
+          `'${m[1]}' sinyali birden fazla tanımlanmış`,
+          i + 1, line.indexOf(m[1]) + 1);
+      } else {
+        signalDecls.set(m[1], i + 1);
+      }
+    }
+  });
+
+  // ─── Sonuç ───────────────────────────────────────────────────────────────
+
+  let fixedCode = null;
+  if (opts.fix) {
+    fixedCode = _autoFix(source, issues.filter(i => i.fixable));
+  }
+
+  const errorCount   = issues.filter(i => i.severity === 'error').length;
+  const warningCount = issues.filter(i => i.severity === 'warn' || i.severity === 'warning').length;
+
+  return { issues, fixedCode, errorCount, warningCount };
+}
+
+function _toPascal(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function _autoFix(source, fixableIssues) {
+  let code = source;
+  const lines = code.split('\n');
+
+  for (const issue of fixableIssues) {
+    if (issue.fix && issue.line) {
+      lines[issue.line - 1] = issue.fix;
+    }
+  }
+
+  return lines.join('\n');
+}
+
+// ─── Dosya API'si ─────────────────────────────────────────────────────────────
+
+/**
+ * Tek bir dosyayı biçimlendir.
+ *
+ * @param {string}  filePath
+ * @param {object}  [opts]
+ * @param {boolean} [opts.write=true]  – Değişiklikleri diske yaz
+ * @returns {Promise<{ changed: boolean, content: string }>}
+ */
+export async function formatFile(filePath, opts = {}) {
+  const { readFile, writeFile } = await import('node:fs/promises');
+  const { write = true } = opts;
+
+  const original = await readFile(filePath, 'utf8');
+  const config   = await loadConfig();
+  const formatted = formatCode(original, { ...config.format, ...opts });
+
+  const changed = formatted !== original;
+  if (changed && write) {
+    await writeFile(filePath, formatted, 'utf8');
+  }
+
+  return { changed, content: formatted };
+}
+
+/**
+ * Tek bir dosyayı lintle.
+ *
+ * @param {string}  filePath
+ * @param {object}  [opts]
+ * @param {boolean} [opts.fix=false]  – Otomatik düzelt ve yaz
+ * @returns {Promise<LintResult>}
+ */
+export async function lintFile(filePath, opts = {}) {
+  const { readFile, writeFile } = await import('node:fs/promises');
+  const { fix = false } = opts;
+
+  const source = await readFile(filePath, 'utf8');
+  const config = await loadConfig();
+  const result = lintCode(source, { rules: config.rules, fix });
+
+  if (fix && result.fixedCode && result.fixedCode !== source) {
+    await writeFile(filePath, result.fixedCode, 'utf8');
+    result.fixed = true;
+  }
+
+  return { ...result, filePath };
+}
+
+/**
+ * Dizindeki tüm .clarity dosyalarını biçimlendir/lintle.
+ *
+ * @param {string}  dir
+ * @param {'format'|'lint'} mode
+ * @param {object}  [opts]
+ * @returns {Promise<Results[]>}
+ */
+export async function processDirectory(dir, mode = 'lint', opts = {}) {
+  const { readdir, stat } = await import('node:fs/promises');
+  const { join, resolve }  = await import('node:path');
+  const config = await loadConfig();
+
+  const results = [];
+
+  async function walk(current) {
+    const entries = await readdir(current).catch(() => []);
+    for (const entry of entries) {
+      const full = join(current, entry);
+
+      // Ignore patterns
+      const rel = full.replace(resolve(dir), '').replace(/^[\\/]/, '');
+      if (config.ignore.some(ig => rel.startsWith(ig) || entry === ig)) continue;
+
+      const info = await stat(full).catch(() => null);
+      if (!info) continue;
+
+      if (info.isDirectory()) {
+        await walk(full);
+      } else if (entry.endsWith('.clarity') || (opts.js && /\.(js|mjs|cjs)$/.test(entry))) {
+        if (mode === 'format') {
+          results.push(await formatFile(full, opts));
+        } else {
+          results.push(await lintFile(full, opts));
+        }
+      }
+    }
+  }
+
+  await walk(resolve(dir));
+  return results;
+}
+
+// ─── Rapor formatları ─────────────────────────────────────────────────────────
+
+/**
+ * Lint sonuçlarını terminale formatla.
+ *
+ * @param {LintResult[]} results
+ * @param {'pretty'|'compact'|'json'} [format='pretty']
+ * @returns {string}
+ */
+export function formatLintReport(results, format = 'pretty') {
+  if (format === 'json') return JSON.stringify(results, null, 2);
+
+  const lines = [];
+  let totalErrors = 0, totalWarnings = 0;
+
+  for (const result of results) {
+    if (!result.issues || result.issues.length === 0) continue;
+
+    if (format === 'pretty') {
+      lines.push(`\n\x1b[4m${result.filePath}\x1b[0m`);  // underline
+    }
+
+    for (const issue of result.issues) {
+      const sev  = issue.severity === 'error' ? '\x1b[31m✖\x1b[0m' : '\x1b[33m⚠\x1b[0m';
+      const loc  = `${issue.line}:${issue.column}`;
+      const rule = `\x1b[90m${issue.rule}\x1b[0m`;
+
+      if (format === 'pretty') {
+        lines.push(`  ${sev}  ${loc.padEnd(8)} ${issue.message}  ${rule}`);
+      } else {
+        lines.push(`${result.filePath}:${loc}: ${issue.severity}: ${issue.message} (${issue.rule})`);
+      }
+
+      if (issue.severity === 'error') totalErrors++;
+      else totalWarnings++;
+    }
+  }
+
+  const summary = `\n${totalErrors ? `\x1b[31m${totalErrors} hata\x1b[0m` : ''}`
+    + `${totalErrors && totalWarnings ? ', ' : ''}`
+    + `${totalWarnings ? `\x1b[33m${totalWarnings} uyarı\x1b[0m` : ''}`
+    + ((!totalErrors && !totalWarnings) ? '\x1b[32m✅ Sorun bulunamadı\x1b[0m' : '');
+
+  lines.push(summary);
+  return lines.join('\n');
+}