Merge pull request #673 from gauge-sh/interface-visibility

Support 'visibility' in interfaces

Author: emdoyle

public/tach-domain-toml-schema.json

@@ -250,6 +250,14 @@
             "items": { "type": "string" },
             "description": "List of regex patterns that match modules which adopt this interface"
           },
+          "visibility": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "default": null,
+            "description": "List of visibility patterns"
+          },
           "data_types": {
             "type": "string",
             "default": "all",

public/tach-toml-schema.json

@@ -180,6 +180,14 @@
             "items": { "type": "string" },
             "description": "List of regex patterns that match modules which adopt this interface"
           },
+          "visibility": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "default": null,
+            "description": "List of visibility patterns"
+          },
           "data_types": {
             "type": "string",
             "default": "all",

python/tach/extension.pyi

@@ -127,6 +127,7 @@ class InterfaceConfig:
     expose: list[str]
     # 'from' in tach.toml
     from_modules: list[str]
+    visibility: list[str] | None
     data_types: InterfaceDataTypes
 
 CacheBackend = Literal["disk"]

python/tests/example/many_features/other_src_root/module5/__init__.py

@@ -0,0 +1 @@
+from module1.api import something

python/tests/example/many_features/other_src_root/module5/tach.domain.toml

@@ -1,5 +1,5 @@
 [root]
-depends_on = []
+depends_on = ["//module1.api"]
 layer = "mid"
 
 [[interfaces]]

python/tests/example/many_features/real_src/module1/tach.domain.toml

@@ -10,9 +10,19 @@ layer = "hightest"
 [[modules]]
 path = "api"
 depends_on = ["**"]
-visibility = ["<domain_root>"]
+visibility = ["<domain_root>", "//module5"]
 layer = "mid"
 
+[[interfaces]]
+expose = [".*"]
+from = ["api"]
+visibility = ["<domain_root>"]
+
+[[interfaces]]
+expose = ["MyAPI"]
+from = ["api"]
+visibility = ["//module5"]
+
 [[modules]]
 path = "submodule1"
 depends_on = []

python/tests/test_check.py

@@ -315,6 +315,12 @@ def test_many_features_example_dir(example_dir, capfd):
             "module3.anything",
             "public interface",
         ),
+        (
+            "[FAIL]",
+            "other_src_root/module5/__init__.py",
+            "module1.api.something",
+            "public interface",
+        ),
     ]
 
     expected_dependencies = [

src/checks/interface.rs

@@ -56,35 +56,35 @@ impl<'a> InterfaceChecker<'a> {
         Ok(self)
     }
 
-    fn check_member(&self, member: &str, module_path: &str) -> InterfaceCheckResult {
+    fn check_member(
+        &self,
+        member: &str,
+        definition_module: &str,
+        usage_module: &str,
+    ) -> InterfaceCheckResult {
         if member.is_empty() {
             return InterfaceCheckResult::TopLevelModule;
         }
 
-        let matching_interfaces = self.interfaces.get_interfaces(module_path);
+        let matching_interfaces = self.interfaces.get_interfaces(definition_module);
 
         if matching_interfaces.is_empty() {
             return InterfaceCheckResult::NoInterfaces;
         }
 
-        let mut is_exposed = false;
         for interface in matching_interfaces {
-            if interface.expose.iter().any(|re| re.is_match(member)) {
-                is_exposed = true;
+            if interface.is_exposed_to(member, usage_module) {
+                return InterfaceCheckResult::Exposed {
+                    type_check_result: self
+                        .type_check_cache
+                        .as_ref()
+                        .map(|cache| cache.get_result(member))
+                        .unwrap_or(TypeCheckResult::Unknown),
+                };
             }
         }
 
-        if !is_exposed {
-            return InterfaceCheckResult::NotExposed;
-        }
-
-        InterfaceCheckResult::Exposed {
-            type_check_result: self
-                .type_check_cache
-                .as_ref()
-                .map(|cache| cache.get_result(member))
-                .unwrap_or(TypeCheckResult::Unknown),
-        }
+        InterfaceCheckResult::NotExposed
     }
 
     fn check_interfaces(
@@ -113,7 +113,11 @@ impl<'a> InterfaceChecker<'a> {
                 .strip_prefix(&dependency_module_config.path)
                 .and_then(|s| s.strip_prefix('.'))
                 .unwrap_or("");
-            let check_result = self.check_member(import_member, &dependency_module_config.path);
+            let check_result = self.check_member(
+                import_member,
+                &dependency_module_config.path,
+                &file_module.module_config().path,
+            );
             match check_result {
                 InterfaceCheckResult::NotExposed => Ok(vec![Diagnostic::new_located_error(
                     file_module.relative_file_path().to_path_buf(),

src/config/domain.rs

@@ -182,6 +182,7 @@ impl Resolvable<InterfaceConfig> for InterfaceConfig {
                     _ => format!("{}.{}", location.mod_path, mod_path),
                 })
                 .collect(),
+            visibility: self.visibility.clone().map(|vis| vis.resolve(location)),
             data_types: self.data_types.clone(),
         }
     }

src/config/interfaces.rs

@@ -43,6 +43,8 @@ pub struct InterfaceConfig {
         skip_serializing_if = "is_default_from_modules"
     )]
     pub from_modules: Vec<String>,
+    #[serde(default)]
+    pub visibility: Option<Vec<String>>,
     #[serde(default, skip_serializing_if = "InterfaceDataTypes::is_default")]
     pub data_types: InterfaceDataTypes,
 }

src/interfaces/compiled.rs

@@ -4,6 +4,7 @@ use regex::Regex;
 #[derive(Debug, Clone)]
 pub struct CompiledInterface {
     pub from_modules: Vec<Regex>,
+    pub visibility: Option<Vec<String>>,
     pub expose: Vec<Regex>,
     pub data_types: InterfaceDataTypes,
 }
@@ -19,6 +20,16 @@ impl CompiledInterface {
         self.expose.iter().any(|regex| regex.is_match(member_name))
     }
 
+    pub fn is_visible_to(&self, module_path: &str) -> bool {
+        self.visibility.as_ref().map_or(true, |visibility| {
+            visibility.iter().any(|v| v == module_path)
+        })
+    }
+
+    pub fn is_exposed_to(&self, member: &str, module_path: &str) -> bool {
+        self.matches_member(member) && self.is_visible_to(module_path)
+    }
+
     pub fn should_type_check(&self, module_path: &str) -> bool {
         self.data_types != InterfaceDataTypes::All && self.matches_module(module_path)
     }
@@ -45,6 +56,7 @@ impl<'a> CompiledInterfaces {
                     .iter()
                     .map(|pattern| Regex::new(&format!("^{}$", pattern)).unwrap())
                     .collect(),
+                visibility: interface.visibility.clone(),
             })
             .collect();
 

src/interfaces/data_types.rs

@@ -333,6 +333,7 @@ mod tests {
         InterfaceConfig {
             expose: vec![".*".to_string()],
             from_modules: vec!["my_module".to_string()],
+            visibility: None,
             data_types: InterfaceDataTypes::Primitive,
         }
     }

src/parsing/config.rs

@@ -71,6 +71,7 @@ fn migrate_strict_mode_to_interfaces(filepath: &Path, config: &mut ProjectConfig
             interfaces.push(InterfaceConfig {
                 expose: interface_members,
                 from_modules: vec![module.path.clone()],
+                visibility: None,
                 data_types: InterfaceDataTypes::All,
             });
         }