@rcrsr/rill-cli 0.6.0

package/tests/check/rules/collections.test.ts

@@ -0,0 +1,380 @@
+/**
+ * Collection Operator Rules Tests
+ * Verify conventions for each, map, fold, and filter operators.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parse } from '@rcrsr/rill';
+import { validateScript } from '../../../src/check/validator.js';
+import type { CheckConfig } from '../../../src/check/types.js';
+
+// ============================================================
+// TEST HELPERS
+// ============================================================
+
+/**
+ * Create a config with specific rule enabled.
+ */
+function createConfig(ruleCode: string): CheckConfig {
+  return {
+    rules: { [ruleCode]: 'on' },
+    severity: {},
+  };
+}
+
+/**
+ * Validate source and extract diagnostic messages.
+ */
+function getDiagnostics(source: string, ruleCode: string): string[] {
+  const ast = parse(source);
+  const diagnostics = validateScript(ast, source, createConfig(ruleCode));
+  return diagnostics.map((d) => d.message);
+}
+
+/**
+ * Validate source and check for violations.
+ */
+function hasViolations(source: string, ruleCode: string): boolean {
+  const ast = parse(source);
+  const diagnostics = validateScript(ast, source, createConfig(ruleCode));
+  return diagnostics.length > 0;
+}
+
+/**
+ * Validate source and get severity levels.
+ */
+function getSeverities(source: string, ruleCode: string): string[] {
+  const ast = parse(source);
+  const diagnostics = validateScript(ast, source, createConfig(ruleCode));
+  return diagnostics.map((d) => d.severity);
+}
+
+// ============================================================
+// BREAK_IN_PARALLEL TESTS
+// ============================================================
+
+describe('BREAK_IN_PARALLEL', () => {
+  const rule = 'BREAK_IN_PARALLEL';
+
+  it('detects break in map', () => {
+    const source = `
+      [1, 2, 3] -> map {
+        ($ == 2) ? break
+        $ * 2
+      }
+    `;
+    expect(hasViolations(source, rule)).toBe(true);
+
+    const messages = getDiagnostics(source, rule);
+    expect(messages[0]).toContain("Break not allowed in 'map'");
+    expect(messages[0]).toContain('parallel operator');
+  });
+
+  it('detects break in filter', () => {
+    const source = `
+      [1, 2, 3] -> filter {
+        ($ > 2) ? break
+        $ > 1
+      }
+    `;
+    expect(hasViolations(source, rule)).toBe(true);
+
+    const messages = getDiagnostics(source, rule);
+    expect(messages[0]).toContain("Break not allowed in 'filter'");
+  });
+
+  it('detects break in nested conditional within map', () => {
+    const source = `
+      [1, 2, 3] -> map {
+        ($ == 2) ? {
+          break
+        } ! {
+          $ * 2
+        }
+      }
+    `;
+    expect(hasViolations(source, rule)).toBe(true);
+  });
+
+  it('detects break in pipe chain terminator within map', () => {
+    const source = `
+      [1, 2, 3] -> map {
+        $ -> break
+      }
+    `;
+    expect(hasViolations(source, rule)).toBe(true);
+  });
+
+  it('allows map without break', () => {
+    const source = `
+      [1, 2, 3] -> map { $ * 2 }
+    `;
+    expect(hasViolations(source, rule)).toBe(false);
+  });
+
+  it('allows filter without break', () => {
+    const source = `
+      [1, 2, 3] -> filter { $ > 1 }
+    `;
+    expect(hasViolations(source, rule)).toBe(false);
+  });
+
+  it('returns error severity', () => {
+    const source = `
+      [1, 2, 3] -> map {
+        ($ == 2) ? break
+        $ * 2
+      }
+    `;
+    const severities = getSeverities(source, rule);
+    expect(severities[0]).toBe('error');
+  });
+});
+
+// ============================================================
+// PREFER_MAP TESTS
+// ============================================================
+
+describe('PREFER_MAP', () => {
+  const rule = 'PREFER_MAP';
+
+  it('suggests map for each without accumulator', () => {
+    const source = `
+      [1, 2, 3] -> each { $ * 2 }
+    `;
+    expect(hasViolations(source, rule)).toBe(true);
+
+    const messages = getDiagnostics(source, rule);
+    expect(messages[0]).toContain("Consider using 'map'");
+    expect(messages[0]).toContain('pure transformations');
+  });
+
+  it('allows each with accumulator initialization', () => {
+    const source = `
+      [1, 2, 3] -> each(0) { $@ + $ }
+    `;
+    expect(hasViolations(source, rule)).toBe(false);
+  });
+
+  it('allows each with closure having accumulator parameter', () => {
+    const source = `
+      [1, 2, 3] -> each |x, acc = 0| ($acc + $x)
+    `;
+    expect(hasViolations(source, rule)).toBe(false);
+  });
+
+  it('returns info severity', () => {
+    const source = `
+      [1, 2, 3] -> each { $ * 2 }
+    `;
+    const severities = getSeverities(source, rule);
+    expect(severities[0]).toBe('info');
+  });
+});
+
+// ============================================================
+// FOLD_INTERMEDIATES TESTS
+// ============================================================
+
+describe('FOLD_INTERMEDIATES', () => {
+  const rule = 'FOLD_INTERMEDIATES';
+
+  it('is a placeholder rule (no violations yet)', () => {
+    const source = `
+      [1, 2, 3] -> fold(0) { $@ + $ }
+    `;
+    // Placeholder - no implementation yet
+    expect(hasViolations(source, rule)).toBe(false);
+  });
+
+  it('does not flag each with accumulator', () => {
+    const source = `
+      [1, 2, 3] -> each(0) { $@ + $ }
+    `;
+    expect(hasViolations(source, rule)).toBe(false);
+  });
+});
+
+// ============================================================
+// FILTER_NEGATION TESTS
+// ============================================================
+
+describe('FILTER_NEGATION', () => {
+  const rule = 'FILTER_NEGATION';
+
+  it('warns about filter with .empty method (likely unintended)', () => {
+    const source = `
+      ["", "a", "b"] -> filter .empty
+    `;
+    expect(hasViolations(source, rule)).toBe(true);
+
+    const messages = getDiagnostics(source, rule);
+    expect(messages[0]).toContain("Filter with '.empty' likely unintended");
+    expect(messages[0]).toContain('filter (!.empty)');
+  });
+
+  it('allows filter with other methods', () => {
+    const source = `
+      ["a", "b", "c"] -> filter .upper
+    `;
+    // Only .empty triggers warning for now
+    expect(hasViolations(source, rule)).toBe(false);
+  });
+
+  it('allows filter with grouped negation', () => {
+    const source = `
+      ["", "a", "b"] -> filter (!.empty)
+    `;
+    expect(hasViolations(source, rule)).toBe(false);
+  });
+
+  it('allows filter with block containing complex logic', () => {
+    const source = `
+      ["", "a", "b"] -> filter { !$.empty }
+    `;
+    // Block form doesn't trigger shorthand warning
+    expect(hasViolations(source, rule)).toBe(false);
+  });
+
+  it('returns warning severity', () => {
+    const source = `
+      ["", "a", "b"] -> filter .empty
+    `;
+    const severities = getSeverities(source, rule);
+    expect(severities[0]).toBe('warning');
+  });
+});
+
+// ============================================================
+// METHOD_SHORTHAND TESTS
+// ============================================================
+
+describe('METHOD_SHORTHAND', () => {
+  const rule = 'METHOD_SHORTHAND';
+
+  it('suggests shorthand for map with block wrapping method', () => {
+    const source = `
+      ["hello", "world"] -> map { $.upper() }
+    `;
+    expect(hasViolations(source, rule)).toBe(true);
+
+    const messages = getDiagnostics(source, rule);
+    expect(messages[0]).toContain("Prefer method shorthand '.upper'");
+    expect(messages[0]).toContain('{ $.upper() }');
+  });
+
+  it('suggests shorthand for each with block wrapping method', () => {
+    const source = `
+      [1, 2, 3] -> each { $.str() }
+    `;
+    expect(hasViolations(source, rule)).toBe(true);
+
+    const messages = getDiagnostics(source, rule);
+    expect(messages[0]).toContain("Prefer method shorthand '.str'");
+  });
+
+  it('suggests shorthand for filter with block wrapping method', () => {
+    const source = `
+      ["", "a", "b"] -> filter { $.empty() }
+    `;
+    expect(hasViolations(source, rule)).toBe(true);
+  });
+
+  it('suggests shorthand for fold with block wrapping method', () => {
+    const source = `
+      ["a", "b"] -> fold("") { $.upper() }
+    `;
+    // Note: This detects the pattern even though fold typically needs
+    // accumulator logic. This is a valid detection - if user writes
+    // { $.upper() }, the suggestion to use .upper shorthand is correct.
+    expect(hasViolations(source, rule)).toBe(true);
+  });
+
+  it('allows direct method shorthand', () => {
+    const source = `
+      ["hello", "world"] -> map .upper
+    `;
+    expect(hasViolations(source, rule)).toBe(false);
+  });
+
+  it('allows blocks with complex logic', () => {
+    const source = `
+      [1, 2, 3] -> map {
+        ($ > 2) ? "big" ! "small"
+      }
+    `;
+    expect(hasViolations(source, rule)).toBe(false);
+  });
+
+  it('allows blocks with multiple statements', () => {
+    const source = `
+      [1, 2, 3] -> map {
+        $ * 2 => $doubled
+        $doubled + 1
+      }
+    `;
+    expect(hasViolations(source, rule)).toBe(false);
+  });
+
+  it('returns info severity', () => {
+    const source = `
+      ["hello"] -> map { $.upper() }
+    `;
+    const severities = getSeverities(source, rule);
+    expect(severities[0]).toBe('info');
+  });
+});
+
+// ============================================================
+// INTEGRATION TESTS
+// ============================================================
+
+describe('Collection Rules Integration', () => {
+  it('detects multiple violations in same script', () => {
+    const source = `
+      [1, 2, 3] -> each { $ * 2 }
+      [1, 2, 3] -> map {
+        ($ == 2) ? break
+        $ * 2
+      }
+    `;
+
+    const ast = parse(source);
+    const config: CheckConfig = {
+      rules: {
+        PREFER_MAP: 'on',
+        BREAK_IN_PARALLEL: 'on',
+      },
+      severity: {},
+    };
+
+    const diagnostics = validateScript(ast, source, config);
+    expect(diagnostics.length).toBeGreaterThanOrEqual(2);
+
+    const codes = diagnostics.map((d) => d.code);
+    expect(codes).toContain('PREFER_MAP');
+    expect(codes).toContain('BREAK_IN_PARALLEL');
+  });
+
+  it('respects rule configuration', () => {
+    const source = `
+      [1, 2, 3] -> each { $ * 2 }
+    `;
+
+    // Rule off
+    const configOff: CheckConfig = {
+      rules: { PREFER_MAP: 'off' },
+      severity: {},
+    };
+    const diagnosticsOff = validateScript(parse(source), source, configOff);
+    expect(diagnosticsOff.length).toBe(0);
+
+    // Rule on
+    const configOn: CheckConfig = {
+      rules: { PREFER_MAP: 'on' },
+      severity: {},
+    };
+    const diagnosticsOn = validateScript(parse(source), source, configOn);
+    expect(diagnosticsOn.length).toBeGreaterThan(0);
+  });
+});

package/tests/check/rules/conditionals.test.ts

@@ -0,0 +1,185 @@
+/**
+ * Conditional Convention Rules Tests
+ * Verify conditional convention enforcement.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parse } from '@rcrsr/rill';
+import { validateScript } from '../../../src/check/validator.js';
+import type { CheckConfig } from '../../../src/check/types.js';
+
+// ============================================================
+// TEST HELPERS
+// ============================================================
+
+/**
+ * Create a config with conditional rules enabled.
+ */
+function createConfig(rules: Record<string, 'on' | 'off'> = {}): CheckConfig {
+  return {
+    rules: {
+      USE_DEFAULT_OPERATOR: 'on',
+      CONDITION_TYPE: 'on',
+      ...rules,
+    },
+    severity: {},
+  };
+}
+
+/**
+ * Validate source and extract diagnostic messages.
+ */
+function getDiagnostics(source: string, config?: CheckConfig): string[] {
+  const ast = parse(source);
+  const diagnostics = validateScript(ast, source, config ?? createConfig());
+  return diagnostics.map((d) => d.message);
+}
+
+/**
+ * Validate source and check for violations.
+ */
+function hasViolations(source: string, config?: CheckConfig): boolean {
+  const ast = parse(source);
+  const diagnostics = validateScript(ast, source, config ?? createConfig());
+  return diagnostics.length > 0;
+}
+
+/**
+ * Validate source and get diagnostic codes.
+ */
+function getCodes(source: string, config?: CheckConfig): string[] {
+  const ast = parse(source);
+  const diagnostics = validateScript(ast, source, config ?? createConfig());
+  return diagnostics.map((d) => d.code);
+}
+
+// ============================================================
+// USE_DEFAULT_OPERATOR TESTS
+// ============================================================
+
+describe('USE_DEFAULT_OPERATOR', () => {
+  const config = createConfig({ CONDITION_TYPE: 'off' });
+
+  it('accepts ?? for default values', () => {
+    expect(hasViolations('$dict.field ?? "default"', config)).toBe(false);
+  });
+
+  it('accepts simple conditionals without .? check', () => {
+    expect(hasViolations('$x > 0 ? "positive" ! "negative"', config)).toBe(
+      false
+    );
+  });
+
+  it('detects verbose default pattern with .? check', () => {
+    const source = '$data.?name ? $data.name ! "unknown"';
+
+    const messages = getDiagnostics(source, config);
+    expect(messages.length).toBeGreaterThan(0);
+    expect(messages[0]).toContain('Use ?? for defaults');
+    expect(messages[0]).toContain('$dict.field ?? "default"');
+  });
+
+  it('accepts conditional without else branch', () => {
+    expect(hasViolations('$data.?field ? "exists"', config)).toBe(false);
+  });
+
+  it('accepts negated conditionals without existence check', () => {
+    // Pattern: value -> ! { body } is a negated conditional, not a default pattern
+    expect(
+      hasViolations(
+        'ccr::file_exists($path) -> ! { ccr::error("...") }',
+        config
+      )
+    ).toBe(false);
+    expect(hasViolations('true -> ! { "not true" }', config)).toBe(false);
+    expect(hasViolations('$ready -> ! { "not ready" }', config)).toBe(false);
+  });
+
+  it('has correct severity and code', () => {
+    const source = '$data.?field ? $data.field ! "default"';
+    const ast = parse(source);
+    const diagnostics = validateScript(ast, source, config);
+
+    expect(diagnostics.length).toBeGreaterThan(0);
+    expect(diagnostics[0]?.code).toBe('USE_DEFAULT_OPERATOR');
+    expect(diagnostics[0]?.severity).toBe('info');
+  });
+});
+
+// ============================================================
+// CONDITION_TYPE TESTS
+// ============================================================
+
+describe('CONDITION_TYPE', () => {
+  const config = createConfig({ USE_DEFAULT_OPERATOR: 'off' });
+
+  it('is currently disabled - accepts all conditionals', () => {
+    // Note: This rule is currently disabled because Rill allows truthy/falsy
+    // semantics in conditionals, and runtime handles type checking.
+    // These tests verify the rule doesn't produce false positives.
+
+    expect(hasViolations('true ? "yes" ! "no"', config)).toBe(false);
+    expect(hasViolations('false ? "yes" ! "no"', config)).toBe(false);
+    expect(hasViolations('$x > 0 ? "positive" ! "negative"', config)).toBe(
+      false
+    );
+    expect(hasViolations('$a == $b ? "equal" ! "different"', config)).toBe(
+      false
+    );
+    expect(hasViolations('$a && $b ? "both" ! "not both"', config)).toBe(false);
+    expect(hasViolations('!$ready ? "not ready" ! "ready"', config)).toBe(
+      false
+    );
+    expect(
+      hasViolations(
+        '"hello" -> .contains("ell") ? "found" ! "not found"',
+        config
+      )
+    ).toBe(false);
+    expect(
+      hasViolations('$val -> :?string ? "is string" ! "not string"', config)
+    ).toBe(false);
+    expect(hasViolations('$data.?field ? "exists" ! "missing"', config)).toBe(
+      false
+    );
+
+    // Currently these don't trigger warnings (rule disabled)
+    expect(hasViolations('"hello" ? "has value" ! "empty"', config)).toBe(
+      false
+    );
+    expect(hasViolations('42 ? "yes" ! "no"', config)).toBe(false);
+    expect(hasViolations('$name ? "has name" ! "no name"', config)).toBe(false);
+  });
+});
+
+// ============================================================
+// INTEGRATION TESTS
+// ============================================================
+
+describe('Conditional rules integration', () => {
+  it('can detect multiple violations in same code', () => {
+    const source = '$data.?field ? $data.field ! "default"';
+
+    const codes = getCodes(source);
+    // Should detect USE_DEFAULT_OPERATOR
+    expect(codes).toContain('USE_DEFAULT_OPERATOR');
+  });
+
+  it('respects rule configuration', () => {
+    const source = '$data.?field ? $data.field ! "default"';
+
+    // With USE_DEFAULT_OPERATOR on
+    const withRule = createConfig({ USE_DEFAULT_OPERATOR: 'on' });
+    expect(hasViolations(source, withRule)).toBe(true);
+
+    // With USE_DEFAULT_OPERATOR off
+    const withoutRule = createConfig({ USE_DEFAULT_OPERATOR: 'off' });
+    expect(hasViolations(source, withoutRule)).toBe(false);
+  });
+
+  it('accepts all conditional forms (CONDITION_TYPE disabled)', () => {
+    const config = createConfig({ USE_DEFAULT_OPERATOR: 'off' });
+    const source = '($x > 0 && $y < 10) || $z == 5 ? "yes" ! "no"';
+    expect(hasViolations(source, config)).toBe(false);
+  });
+});