WIP

Author: svetli-n

git-config/src/file/git_config.rs

@@ -153,29 +153,38 @@ impl<'event> GitConfig<'event> {
             .iter()
             .map(|p| PathBuf::from(p.to_str().expect("invalid utf-8 path")))
             .collect();
+        const MAX_DEPTH: u8 = 10;
 
         fn from_paths_req(
             paths: Vec<PathBuf>,
             seen: &mut HashSet<PathBuf>,
             config: &mut GitConfig,
+            depth: u8,
         ) -> Result<(), ParserOrIoError<'static>> {
+            if depth >= MAX_DEPTH {
+                return Ok(());
+            }
             for path in paths.iter() {
                 let other = GitConfig::open(path)?;
-                for (section_id, section_header) in other.section_headers {
+                let mut section_ids: Vec<_> = other.section_headers.keys().collect();
+                section_ids.sort();
+                for section_id in section_ids {
+                    let section_header = &other.section_headers[&section_id];
                     if section_header.name.0 == "include" {
                         let path_values = other.sections[&section_id].values(&Key::from("path"));
                         let mut paths = vec![];
-                        // TODO handle relative and interpolated path
-                        for path in path_values {
-                            let path = PathBuf::from(
-                                std::string::String::from_utf8(path.to_vec()).expect("invalid utf-8 path"),
-                            );
-                            if !seen.contains(&path) {
-                                seen.insert(path.clone());
-                                paths.push(path.clone());
+                        for path_value in path_values {
+                            let interpolated_path = crate::values::Path::from(path_value).interpolate(None).unwrap();
+                            let path = if interpolated_path.is_relative() {
+                                path.parent().unwrap().join(interpolated_path)
+                            } else {
+                                interpolated_path.into()
+                            };
+                            if seen.insert(path.clone()) {
+                                paths.push(path);
                             }
                         }
-                        from_paths_req(paths, seen, config)?;
+                        from_paths_req(paths, seen, config, depth + 1)?;
                     } else {
                         config.push_section(
                             section_header.name.0.to_owned(),
@@ -188,7 +197,7 @@ impl<'event> GitConfig<'event> {
             Ok(())
         }
 
-        from_paths_req(paths, &mut seen, &mut config)?;
+        from_paths_req(paths, &mut seen, &mut config, 0)?;
 
         Ok(config)
     }
@@ -1714,11 +1723,14 @@ mod from_paths {
             r"
             [core]
               a = false
+              sslVerify = true
+              d = 41
             ",
         )
         .expect("Unable to write config file");
 
         let b_path = dir.path().join("b");
+        let relative_b_path = std::path::PathBuf::from("b");
         fs::write(
             b_path.as_path(),
             r"
@@ -1735,12 +1747,15 @@ mod from_paths {
                 r"
             [core]
               c = 12
+              d = 42
             [include]
               path = {}
               path = {}
+            [http]
+	          sslVerify = false
             ",
                 a_path.as_path().to_str().unwrap(),
-                b_path.as_path().to_str().unwrap()
+                relative_b_path.as_path().to_str().unwrap()
             ),
         )
         .expect("Unable to write config file");
@@ -1751,6 +1766,14 @@ mod from_paths {
             config.get_raw_value("core", None, "c"),
             Ok(Cow::<[u8]>::Borrowed(b"12"))
         );
+        assert_eq!(
+            config.get_raw_value("core", None, "d"),
+            Ok(Cow::<[u8]>::Borrowed(b"41"))
+        );
+        assert_eq!(
+            config.get_raw_value("http", None, "sslVerify"),
+            Ok(Cow::<[u8]>::Borrowed(b"false"))
+        );
 
         assert_eq!(
             config.get_raw_value("diff", None, "renames"),
@@ -1770,11 +1793,11 @@ mod from_paths {
         let a_path = dir.path().join("a");
         fs::write(
             a_path.as_path(),
-            r"
+            r#"
             [core]
               a = false
               c = 1
-            ",
+            "#,
         )
         .expect("Unable to write config file");