1 files changed, 0 insertions, 176 deletions
diff --git a/apps/servers/octopus/src/git/tree.rs b/apps/servers/octopus/src/git/tree.rs
deleted file mode 100644
index 5343a57c2463..000000000000
--- a/apps/servers/octopus/src/git/tree.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-//! Tree handling utilities
-//!
-//! The way that libgit2 handles trees is super low-level and overkill
-//! for what we need.  In this module we knock it down a notch or two.
-//!
-//! This code takes a tree returned by
-//! `crate::git::repo::Repo::get_tree()`, and transforms it into a
-//! `TreeData` type that the template engine can render.
-
-use crate::templ_data::repo::{CommitData, FileData, TreeData};
-use git2::{self, ObjectType, TreeWalkMode};
-use std::collections::BTreeMap;
-
-/// A cache of a repository tree
-#[derive(Default, Debug, Clone)]
-pub(crate) struct Tree {
-    inner: BTreeMap<String, TreeNode>,
-}
-
-impl Tree {
-    /// Insert a node into a subtree with it's full path
-    fn insert_to_subtree(&mut self, mut path: Vec<String>, name: String, node: TreeNode) {
-        // If we are given a path, resolve it first
-        let curr = if path.len() > 0 {
-            let rest = path.split_off(1);
-            let mut curr = self.inner.get_mut(&path[0]).unwrap();
-
-            for dir in rest {
-                match curr {
-                    TreeNode::Dir(ref mut d) => {
-                        curr = d.children.inner.get_mut(&dir).unwrap();
-                    }
-                    _ => panic!("Not a tree!"),
-                }
-            }
-
-            match curr {
-                TreeNode::Dir(ref mut d) => &mut d.children,
-                TreeNode::File(_) => panic!("Not a tree!"),
-            }
-        } else {
-            // If no path was given, we assume the root is meant
-            self
-        };
-
-        curr.inner.insert(name, node);
-    }
-
-    /// Walk through the tree and only return filenode objects
-    pub(crate) fn flatten(&self) -> Vec<FileNode> {
-        self.inner.values().fold(vec![], |mut vec, node| {
-            match node {
-                TreeNode::File(f) => vec.push(f.clone()),
-                TreeNode::Dir(d) => vec.append(&mut d.children.flatten()),
-            }
-
-            vec
-        })
-    }
-
-    /// Get all the commits that touch a file
-    pub(crate) fn grab_path_history(&self, mut path: String) -> String {
-        let mut path: Vec<String> = path
-            .split("/")
-            .filter_map(|seg| match seg {
-                "" => None,
-                val => Some(val.into()),
-            })
-            .collect();
-
-        let leaf = if path.len() > 0 {
-            let rest = path.split_off(1);
-            let mut curr = self.inner.get(&path[0]).unwrap();
-
-            for dir in rest {
-                match curr {
-                    TreeNode::Dir(d) => curr = d.children.inner.get(&dir).unwrap(),
-                    TreeNode::File(_) => break, // we reached the leaf
-                }
-            }
-
-            curr
-        } else {
-            panic!("No valid path!");
-        };
-
-        match leaf {
-            TreeNode::File(f) => f.id.clone(),
-            _ => panic!("Not a leaf!"),
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub(crate) enum TreeNode {
-    File(FileNode),
-    Dir(DirNode),
-}
-
-impl TreeNode {
-    fn name(&self) -> String {
-        match self {
-            Self::File(f) => f.name.clone(),
-            Self::Dir(d) => d.name.clone(),
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct FileNode {
-    pub id: String,
-    pub path: Vec<String>,
-    pub name: String,
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct DirNode {
-    pub path: Vec<String>,
-    pub name: String,
-    pub children: Tree,
-}
-
-impl DirNode {
-    fn append(&mut self, node: TreeNode) {
-        self.children.inner.insert(node.name(), node);
-    }
-}
-
-/// Take a series of path-segments and render a tree at that location
-pub(crate) fn parse_tree(tree: git2::Tree, repo: &git2::Repository) -> Tree {
-    let mut root = Tree::default();
-
-    tree.walk(TreeWalkMode::PreOrder, |path, entry| {
-        let path: Vec<String> = path
-            .split("/")
-            .filter_map(|seg| match seg {
-                "" => None,
-                val => Some(val.into()),
-            })
-            .collect();
-        let name = entry.name().unwrap().to_string();
-
-        match entry.kind() {
-            // For every tree in the tree we create a new TreeNode with the path we know about
-            Some(ObjectType::Tree) => {
-                root.insert_to_subtree(
-                    path.clone(),
-                    name.clone(),
-                    TreeNode::Dir(DirNode {
-                        path,
-                        name,
-                        children: Tree::default(),
-                    }),
-                );
-            }
-            // If we encounter a blob, this is a file that we can simply insert into the tree
-            Some(ObjectType::Blob) => {
-                root.insert_to_subtree(
-                    path.clone(),
-                    name.clone(),
-                    TreeNode::File(FileNode {
-                        id: format!("{}", entry.id()),
-                        path,
-                        name,
-                    }),
-                );
-            }
-            _ => {}
-        }
-
-        0
-    })
-    .unwrap();
-
-    root
-}