zonefence 0.0.8 → 0.0.9

package/README.ja.md

@@ -152,6 +152,86 @@ src/
 
 `scope.apply: self` を指定すると、そのルールは自フォルダのみに適用され、子フォルダには継承されません。
 
+## ディレクトリパターン（コロケーション対応）
+
+ページごとに `containers/`、`presenters/` などのディレクトリを配置するコロケーションパターンを使用している場合、`directoryPatterns` を定義することで、`zonefence.yaml` を各ディレクトリに重複して配置せずにルールを自動適用できます。
+
+### ディレクトリ構造の例
+
+```
+src/
+├── pages/
+│   ├── zonefence.yaml      ← ここにdirectoryPatternsを定義
+│   ├── home/
+│   │   ├── containers/     ← パターンマッチ（pagesのスコープ内）
+│   │   └── presenters/     ← パターンマッチ
+│   └── settings/
+│       ├── containers/     ← パターンマッチ
+│       └── presenters/     ← パターンマッチ
+└── api/
+    └── containers/         ← マッチしない（pagesのスコープ外）
+```
+
+### 設定例
+
+```yaml
+# src/pages/zonefence.yaml
+version: 1
+description: "Pages層のルール"
+
+directoryPatterns:
+  - pattern: "**/containers"
+    config:
+      description: "Container層"
+      imports:
+        allow:
+          - from: "../presenters/**"
+          - from: "../hooks/**"
+        deny:
+          - from: "../containers/**"
+            message: "Containerは兄弟Containerからimportしてはいけません"
+
+  - pattern: "**/presenters"
+    config:
+      imports:
+        allow:
+          - from: "./**"
+          - from: "@/ui/**"
+        deny:
+          - from: "../containers/**"
+            message: "PresenterはContainerからimportしてはいけません"
+
+scope:
+  exclude:
+    - "**/*.test.tsx"
+```
+
+### パターンオプション
+
+| オプション | 説明 | デフォルト |
+|-----------|------|-----------|
+| `pattern` | マッチするディレクトリのglobパターン（zonefence.yamlの位置からの相対パス） | 必須 |
+| `config.description` | マッチしたディレクトリの説明 | - |
+| `config.imports` | マッチしたディレクトリのimportルール | - |
+| `config.mergeStrategy` | `"merge"`（他のルールと結合）または `"override"`（置換） | `"merge"` |
+| `priority` | 複数パターンがマッチした場合、優先度が高い方が先に適用される | `0` |
+
+### パターン書式
+
+| パターン | マッチ例（`pages/zonefence.yaml`から） |
+|---------|---------------------------------------|
+| `**/containers` | `pages/home/containers`, `pages/settings/containers`, `pages/a/b/containers` |
+| `*/presenters` | `pages/home/presenters`（直下の子のみ） |
+| `home/containers` | `pages/home/containers`（完全一致） |
+
+### 優先順位
+
+複数のルールがディレクトリに適用される場合：
+
+1. **ディレクトリ固有の `zonefence.yaml`**（最優先）
+2. **パターンルール**（`priority`値順、次に具体性順）
+3. **親ディレクトリからの継承**（最低優先）
+
 ## エラー出力例
 
 ```

package/README.md

@@ -152,6 +152,86 @@ src/
 
 With `scope.apply: self`, the rule applies only to the current folder and is not inherited by child folders.
 
+## Directory Patterns (Colocation Support)
+
+For projects using colocation patterns (e.g., `containers/`, `presenters/` directories under each page), you can define `directoryPatterns` to apply rules automatically to matching directories without duplicating `zonefence.yaml` files.
+
+### Example Structure
+
+```
+src/
+├── pages/
+│   ├── zonefence.yaml      ← Define directoryPatterns here
+│   ├── home/
+│   │   ├── containers/     ← Pattern matches (within pages scope)
+│   │   └── presenters/     ← Pattern matches
+│   └── settings/
+│       ├── containers/     ← Pattern matches
+│       └── presenters/     ← Pattern matches
+└── api/
+    └── containers/         ← Does NOT match (outside pages scope)
+```
+
+### Configuration
+
+```yaml
+# src/pages/zonefence.yaml
+version: 1
+description: "Pages layer rules"
+
+directoryPatterns:
+  - pattern: "**/containers"
+    config:
+      description: "Container layer"
+      imports:
+        allow:
+          - from: "../presenters/**"
+          - from: "../hooks/**"
+        deny:
+          - from: "../containers/**"
+            message: "Containers should not import from sibling containers"
+
+  - pattern: "**/presenters"
+    config:
+      imports:
+        allow:
+          - from: "./**"
+          - from: "@/ui/**"
+        deny:
+          - from: "../containers/**"
+            message: "Presenters should not import from containers"
+
+scope:
+  exclude:
+    - "**/*.test.tsx"
+```
+
+### Pattern Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `pattern` | Glob pattern to match directories (relative to the zonefence.yaml location) | Required |
+| `config.description` | Description for matched directories | - |
+| `config.imports` | Import rules for matched directories | - |
+| `config.mergeStrategy` | `"merge"` (combine with other rules) or `"override"` (replace) | `"merge"` |
+| `priority` | Higher priority patterns are applied first (when multiple patterns match) | `0` |
+
+### Pattern Syntax
+
+| Pattern | Matches (from `pages/zonefence.yaml`) |
+|---------|---------------------------------------|
+| `**/containers` | `pages/home/containers`, `pages/settings/containers`, `pages/a/b/containers` |
+| `*/presenters` | `pages/home/presenters` (direct children only) |
+| `home/containers` | `pages/home/containers` (exact path) |
+
+### Priority Order
+
+When multiple rules apply to a directory:
+
+1. **Directory's own `zonefence.yaml`** (highest priority)
+2. **Pattern rules** (sorted by `priority` value, then by specificity)
+3. **Parent directory inheritance** (lowest priority)
+
 ## Error Output Example
 
 ```

package/dist/cli/index.cjs

@@ -28,7 +28,7 @@ var import_commander = require("commander");
 
 // src/cli/commands/check.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 
 // src/core/import-collector.ts
 function collectImports(project, rootDir) {
@@ -411,6 +411,21 @@ var importRuleSchema = import_zod.z.union([
     message: import_zod.z.string().optional()
   })
 ]);
+var importsSchema = import_zod.z.object({
+  allow: import_zod.z.array(importRuleSchema).optional().default([]),
+  deny: import_zod.z.array(importRuleSchema).optional().default([]),
+  mode: import_zod.z.enum(["allow-first", "deny-first"]).optional().default("allow-first")
+});
+var patternRuleConfigSchema = import_zod.z.object({
+  description: import_zod.z.string().optional(),
+  imports: importsSchema.optional(),
+  mergeStrategy: import_zod.z.enum(["merge", "override"]).optional().default("merge")
+});
+var directoryPatternRuleSchema = import_zod.z.object({
+  pattern: import_zod.z.string(),
+  config: patternRuleConfigSchema,
+  priority: import_zod.z.number().int().optional().default(0)
+});
 var zoneFenceConfigSchema = import_zod.z.object({
   version: import_zod.z.number().int().positive(),
   description: import_zod.z.string().optional(),
@@ -418,11 +433,8 @@ var zoneFenceConfigSchema = import_zod.z.object({
     apply: import_zod.z.enum(["self", "descendants"]).optional().default("descendants"),
     exclude: import_zod.z.array(import_zod.z.string()).optional().default([])
   }).optional().default({}),
-  imports: import_zod.z.object({
-    allow: import_zod.z.array(importRuleSchema).optional().default([]),
-    deny: import_zod.z.array(importRuleSchema).optional().default([]),
-    mode: import_zod.z.enum(["allow-first", "deny-first"]).optional().default("allow-first")
-  }).optional().default({})
+  imports: importsSchema.optional().default({}),
+  directoryPatterns: import_zod.z.array(directoryPatternRuleSchema).optional().default([])
 });
 function parseConfig(data) {
   return zoneFenceConfigSchema.parse(data);
@@ -431,11 +443,17 @@ function parseConfig(data) {
 // src/rules/loader.ts
 var RULE_FILE_NAME = "zonefence.yaml";
 async function loadRulesForDirectory(rootDir) {
+  const result = await loadRulesForDirectoryWithAllDirs(rootDir);
+  return result.rules;
+}
+async function loadRulesForDirectoryWithAllDirs(rootDir) {
   const rules = {};
-  await scanDirectory(rootDir, rootDir, rules);
-  return rules;
+  const allDirectories = [];
+  await scanDirectory(rootDir, rootDir, rules, allDirectories);
+  return { rules, allDirectories };
 }
-async function scanDirectory(currentDir, rootDir, rules) {
+async function scanDirectory(currentDir, rootDir, rules, allDirectories) {
+  allDirectories.push(currentDir);
   const ruleFilePath = import_node_path3.default.join(currentDir, RULE_FILE_NAME);
   if (import_node_fs.default.existsSync(ruleFilePath)) {
     const config = await loadRuleFile(ruleFilePath);
@@ -448,7 +466,7 @@ async function scanDirectory(currentDir, rootDir, rules) {
   for (const entry of entries) {
     if (entry.isDirectory() && !shouldSkipDirectory(entry.name)) {
       const subDir = import_node_path3.default.join(currentDir, entry.name);
-      await scanDirectory(subDir, rootDir, rules);
+      await scanDirectory(subDir, rootDir, rules, allDirectories);
     }
   }
 }
@@ -463,30 +481,138 @@ function shouldSkipDirectory(name) {
 }
 
 // src/rules/resolver.ts
+var import_node_path5 = __toESM(require("path"), 1);
+
+// src/rules/pattern-matcher.ts
 var import_node_path4 = __toESM(require("path"), 1);
+var import_minimatch2 = require("minimatch");
+function matchDirectoryPattern(targetDir, pattern, sourceDir) {
+  const relativePath = import_node_path4.default.relative(sourceDir, targetDir);
+  if (!relativePath || relativePath.startsWith("..") || import_node_path4.default.isAbsolute(relativePath)) {
+    return false;
+  }
+  return (0, import_minimatch2.minimatch)(relativePath, pattern, { dot: false });
+}
+function calculateSpecificity(pattern) {
+  let specificity = 0;
+  const segments = pattern.split("/");
+  for (const segment of segments) {
+    if (segment === "**") {
+      specificity += 1;
+    } else if (segment === "*") {
+      specificity += 5;
+    } else if (segment.includes("*")) {
+      specificity += 8;
+    } else {
+      specificity += 10;
+    }
+  }
+  return specificity;
+}
+function findMatchingPatterns(targetDir, patternSources) {
+  const matches = [];
+  for (const source of patternSources) {
+    for (const rule of source.patterns) {
+      if (matchDirectoryPattern(targetDir, rule.pattern, source.sourceDir)) {
+        matches.push({
+          pattern: rule.pattern,
+          config: rule.config,
+          priority: rule.priority ?? 0,
+          sourceFile: source.sourceFile,
+          specificity: calculateSpecificity(rule.pattern)
+        });
+      }
+    }
+  }
+  matches.sort((a, b) => {
+    if (a.priority !== b.priority) {
+      return b.priority - a.priority;
+    }
+    return b.specificity - a.specificity;
+  });
+  return matches;
+}
+function collectPatternSources(rulesByDirectory) {
+  const sources = [];
+  for (const [directory, { config, ruleFilePath }] of Object.entries(rulesByDirectory)) {
+    if (config.directoryPatterns && config.directoryPatterns.length > 0) {
+      sources.push({
+        sourceFile: ruleFilePath,
+        sourceDir: directory,
+        patterns: config.directoryPatterns
+      });
+    }
+  }
+  return sources;
+}
+
+// src/rules/resolver.ts
 function resolveRules(rulesByDirectory) {
   const resolvedRules = [];
   const directories = Object.keys(rulesByDirectory).sort((a, b) => a.length - b.length);
+  const patternSources = collectPatternSources(rulesByDirectory);
   for (const directory of directories) {
     const { config, ruleFilePath } = rulesByDirectory[directory];
     const parentRules = findParentRules(directory, directories, rulesByDirectory);
-    const mergedConfig = mergeConfigs(parentRules, config);
+    let mergedConfig = mergeConfigs(parentRules, config);
+    const patternMatches = findMatchingPatterns(directory, patternSources);
+    const appliedPatternRules = [];
+    if (patternMatches.length > 0) {
+      let patternConfig = createEmptyConfig(mergedConfig.version);
+      for (const match of [...patternMatches].reverse()) {
+        patternConfig = applyPatternRule(patternConfig, match);
+        appliedPatternRules.unshift({
+          pattern: match.pattern,
+          sourceFile: match.sourceFile,
+          priority: match.priority
+        });
+      }
+      mergedConfig = mergeTwoConfigs(patternConfig, mergedConfig);
+    }
     const excludePatterns = collectExcludePatterns(mergedConfig);
     resolvedRules.push({
       directory,
       ruleFilePath,
       config: mergedConfig,
-      excludePatterns
+      excludePatterns,
+      appliedPatternRules: appliedPatternRules.length > 0 ? appliedPatternRules : void 0
     });
   }
   return resolvedRules;
 }
+function createEmptyConfig(version) {
+  return { version };
+}
+function applyPatternRule(base, match) {
+  const { config } = match;
+  const mergeStrategy = config.mergeStrategy ?? "merge";
+  if (mergeStrategy === "override") {
+    return {
+      ...base,
+      description: config.description ?? base.description,
+      imports: config.imports ? {
+        allow: config.imports.allow ?? [],
+        deny: config.imports.deny ?? [],
+        mode: config.imports.mode ?? base.imports?.mode ?? "allow-first"
+      } : base.imports
+    };
+  }
+  return {
+    ...base,
+    description: config.description ?? base.description,
+    imports: {
+      allow: mergeImportRules(base.imports?.allow, config.imports?.allow),
+      deny: mergeImportRules(base.imports?.deny, config.imports?.deny),
+      mode: config.imports?.mode ?? base.imports?.mode ?? "allow-first"
+    }
+  };
+}
 function findParentRules(directory, allDirectories, rulesByDirectory) {
   const parents = [];
   for (const potentialParent of allDirectories) {
     if (potentialParent === directory) continue;
-    const relative = import_node_path4.default.relative(potentialParent, directory);
-    if (!relative.startsWith("..") && !import_node_path4.default.isAbsolute(relative)) {
+    const relative = import_node_path5.default.relative(potentialParent, directory);
+    if (!relative.startsWith("..") && !import_node_path5.default.isAbsolute(relative)) {
       const parentConfig = rulesByDirectory[potentialParent].config;
       const scopeApply = parentConfig.scope?.apply ?? "descendants";
       if (scopeApply === "descendants") {
@@ -546,12 +672,12 @@ function collectExcludePatterns(config) {
 // src/cli/commands/check.ts
 function findTsConfig(startDir) {
   let dir = startDir;
-  while (dir !== import_node_path5.default.dirname(dir)) {
-    const configPath = import_node_path5.default.join(dir, "tsconfig.json");
+  while (dir !== import_node_path6.default.dirname(dir)) {
+    const configPath = import_node_path6.default.join(dir, "tsconfig.json");
     if (import_node_fs2.default.existsSync(configPath)) {
       return configPath;
     }
-    dir = import_node_path5.default.dirname(dir);
+    dir = import_node_path6.default.dirname(dir);
   }
   return void 0;
 }
@@ -561,20 +687,20 @@ function getPathsMapping(project, rootDir, tsConfigFilePath) {
   if (!originalPaths || !tsConfigFilePath) {
     return originalPaths;
   }
-  const tsConfigDir = import_node_path5.default.dirname(tsConfigFilePath);
+  const tsConfigDir = import_node_path6.default.dirname(tsConfigFilePath);
   const adjustedPaths = {};
   for (const [alias, targets] of Object.entries(originalPaths)) {
     adjustedPaths[alias] = targets.map((target) => {
       const targetWithoutGlob = target.replace(/\*$/, "");
-      const absoluteTarget = import_node_path5.default.resolve(tsConfigDir, targetWithoutGlob);
-      const relativeToRoot = import_node_path5.default.relative(rootDir, absoluteTarget);
+      const absoluteTarget = import_node_path6.default.resolve(tsConfigDir, targetWithoutGlob);
+      const relativeToRoot = import_node_path6.default.relative(rootDir, absoluteTarget);
       return (relativeToRoot || ".") + (target.endsWith("*") ? "/*" : "");
     });
   }
   return adjustedPaths;
 }
 async function checkCommand(targetPath, options) {
-  const absolutePath = import_node_path5.default.resolve(targetPath);
+  const absolutePath = import_node_path6.default.resolve(targetPath);
   console.log(`Checking import boundaries in: ${absolutePath}
 `);
   try {