next() — tailwindcss Function Reference

Architecture documentation for the next() function in walk.rs from the tailwindcss codebase.

Function rust RustCore MachineExtractor calls 7 called by 1

Entity Profile

RustCore→ MachineExtractor→ next() — tailwindcss Function Reference

Dependency Diagram

graph TD
  3e24cbbb_d0d2_be5b_ec36_1f076cc42d7f["next()"]
  ca21c5b0_9a8b_3e9e_e91a_c6153afa2996["next()"]
  ca21c5b0_9a8b_3e9e_e91a_c6153afa2996 -->|calls| 3e24cbbb_d0d2_be5b_ec36_1f076cc42d7f
  365169b4_4aeb_e5a8_2cbf_612384e629cc["skip_entry()"]
  3e24cbbb_d0d2_be5b_ec36_1f076cc42d7f -->|calls| 365169b4_4aeb_e5a8_2cbf_612384e629cc
  ca21c5b0_9a8b_3e9e_e91a_c6153afa2996["next()"]
  3e24cbbb_d0d2_be5b_ec36_1f076cc42d7f -->|calls| ca21c5b0_9a8b_3e9e_e91a_c6153afa2996
  a6843842_f355_8b58_6480_56e7a52c15a4["new_stdin()"]
  3e24cbbb_d0d2_be5b_ec36_1f076cc42d7f -->|calls| a6843842_f355_8b58_6480_56e7a52c15a4
  53c4c04f_8ea8_89d6_9869_cc927b86c4b9["add_parents()"]
  3e24cbbb_d0d2_be5b_ec36_1f076cc42d7f -->|calls| 53c4c04f_8ea8_89d6_9869_cc927b86c4b9
  4b4250a8_bde9_e486_7a39_21572b17261f["new_walkdir()"]
  3e24cbbb_d0d2_be5b_ec36_1f076cc42d7f -->|calls| 4b4250a8_bde9_e486_7a39_21572b17261f
  375b58d9_a2fe_75bb_3a9f_2f5574c0532f["is_dir()"]
  3e24cbbb_d0d2_be5b_ec36_1f076cc42d7f -->|calls| 375b58d9_a2fe_75bb_3a9f_2f5574c0532f
  55dd83a4_0144_9917_edad_d9a20af65a76["path()"]
  3e24cbbb_d0d2_be5b_ec36_1f076cc42d7f -->|calls| 55dd83a4_0144_9917_edad_d9a20af65a76
  style 3e24cbbb_d0d2_be5b_ec36_1f076cc42d7f fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

crates/ignore/src/walk.rs lines 1088–1154

    fn next(&mut self) -> Option<Result<DirEntry, Error>> {
        loop {
            let ev = match self.it.as_mut().and_then(|it| it.next()) {
                Some(ev) => ev,
                None => {
                    match self.its.next() {
                        None => return None,
                        Some((_, None)) => {
                            return Some(Ok(DirEntry::new_stdin()));
                        }
                        Some((path, Some(it))) => {
                            self.it = Some(it);
                            if path.is_dir() {
                                let (ig, err) = self.ig_root.add_parents(path);
                                self.ig = ig;
                                if let Some(err) = err {
                                    return Some(Err(err));
                                }
                            } else {
                                self.ig = self.ig_root.clone();
                            }
                        }
                    }
                    continue;
                }
            };
            match ev {
                Err(err) => {
                    return Some(Err(Error::from_walkdir(err)));
                }
                Ok(WalkEvent::Exit) => {
                    self.ig = self.ig.parent().unwrap();
                }
                Ok(WalkEvent::Dir(ent)) => {
                    let mut ent = DirEntry::new_walkdir(ent, None);
                    let should_skip = match self.skip_entry(&ent) {
                        Err(err) => return Some(Err(err)),
                        Ok(should_skip) => should_skip,
                    };
                    if should_skip {
                        self.it.as_mut().unwrap().it.skip_current_dir();
                        // Still need to push this on the stack because
                        // we'll get a WalkEvent::Exit event for this dir.
                        // We don't care if it errors though.
                        let (igtmp, _) = self.ig.add_child(ent.path());
                        self.ig = igtmp;
                        continue;
                    }
                    let (igtmp, err) = self.ig.add_child(ent.path());
                    self.ig = igtmp;
                    ent.err = err;
                    return Some(Ok(ent));
                }
                Ok(WalkEvent::File(ent)) => {
                    let ent = DirEntry::new_walkdir(ent, None);
                    let should_skip = match self.skip_entry(&ent) {
                        Err(err) => return Some(Err(err)),
                        Ok(should_skip) => should_skip,
                    };
                    if should_skip {
                        continue;
                    }
                    return Some(Ok(ent));
                }
            }
        }
    }