refactor(pkgs): Categorize into `by-name` shards

This might not be the perfect way to organize a package set --
especially if the set is not nearly the size of nixpkgs -- but it is
_at_ least a way of organization.

1 files changed, 0 insertions, 156 deletions

diff --git a/pkgs/sources/lf-make-map/src/mapping/mod.rs b/pkgs/sources/lf-make-map/src/mapping/mod.rs
deleted file mode 100644
index 114fdca0..00000000
--- a/pkgs/sources/lf-make-map/src/mapping/mod.rs
+++ /dev/null
@@ -1,156 +0,0 @@
-use std::{
-    fmt::{Display, Write},
-    hash::Hash,
-};
-
-use log::debug;
-
-pub mod map_tree;
-
-#[derive(Clone, Debug, Eq)]
-pub struct MapKey {
-    pub key: char,
-
-    resolution: usize,
-
-    /// Part of the path, used to derive the key
-    part_path: String,
-}
-
-impl Hash for MapKey {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.key.hash(state)
-    }
-}
-
-impl PartialEq for MapKey {
-    fn eq(&self, other: &Self) -> bool {
-        self.key == other.key
-    }
-}
-
-impl MapKey {
-    pub fn new_from_part_path(part_path: &str, resolution: usize) -> Vec<Self> {
-        let key = Self::part_path_to_key(&part_path, resolution);
-
-        key.chars()
-            .map(|ch| Self {
-                key: ch,
-                resolution,
-                part_path: part_path.to_owned(),
-            })
-            .collect()
-    }
-
-    pub fn new_ones_from_path(path: &str, number_of_chars: usize) -> Vec<Self> {
-        let key: Vec<MapKey> = path
-            .split('/')
-            .map(|part| Self::new_from_part_path(part, number_of_chars))
-            .flatten()
-            .collect();
-
-        debug!(
-            "Generated full MapKeys: '{}' -> '{}'",
-            path,
-            MapKey::display(&key)
-        );
-        key
-    }
-
-    pub fn increment(&self, target_resolution: usize) -> Vec<Self> {
-        let new_resolution = target_resolution;
-
-        // debug!("Incrementing: '{}' ('{}')", &self, &self.part_path);
-
-        let added_chars = if new_resolution < self.part_path.len() {
-            MapKey::part_path_to_key(&self.part_path, new_resolution)
-        } else {
-            let mut generated_chars =
-                MapKey::part_path_to_key(&self.part_path, self.part_path.len());
-
-            generated_chars.extend(
-                (0..(new_resolution - self.part_path.len()))
-                    .into_iter()
-                    .map(|_| self.part_path.chars().last().expect("This will exists")),
-            );
-
-            generated_chars
-        };
-
-        let part_path = self.part_path.clone();
-        let output: Vec<Self> = added_chars
-            .chars()
-            .enumerate()
-            .map(|(res, ch)| MapKey {
-                key: ch,
-                resolution: res + 1,
-                part_path: part_path.clone(),
-            })
-            .collect();
-
-        // debug!("Finished increment: '{}' ('{}')", MapKey::display(&output), output[0].part_path);
-        output
-    }
-
-    pub fn display(values: &[Self]) -> String {
-        values.iter().map(|value| value.key.clone()).collect()
-    }
-    fn part_path_to_key(part: &str, number_of_chars: usize) -> String {
-        fn make(pat: char, part: &str, number_of_chars: usize) -> String {
-            let mut acc = String::new();
-
-            if !part.split(pat).all(|part| part.len() > 0) {
-                panic!(
-                    "\
-Can't turn this path '{}' to a mapping.
-This should not happen, please report the bug!",
-                    part
-                )
-            }
-
-            let mut last_working = None;
-            for i in 0..number_of_chars {
-                for str in part.split(pat) {
-                    if acc.len() != number_of_chars {
-                        acc.push(match str.chars().nth(i) {
-                            Some(ch) => ch,
-                            None => {
-                                if let Some(last) = last_working {
-                                    str.chars().nth(last).expect("This should always exist")
-                                } else {
-                                    last_working = Some(i - 1);
-                                    str.chars().nth(i - 1).expect("This should always exist")
-                                }
-                            }
-                        })
-                    }
-                }
-            }
-
-            acc
-        }
-
-        let value = if part.contains('_') && !part.starts_with('_') && !part.ends_with('_') {
-            make('_', part, number_of_chars)
-        } else if part.contains('-') && !part.starts_with('-') && !part.ends_with('-') {
-            make('-', part, number_of_chars)
-        } else {
-            part.chars().take(number_of_chars).collect::<String>()
-        };
-
-        assert_eq!(
-            value.len(),
-            number_of_chars,
-            "'{}' does not have expected length of: {}",
-            value,
-            number_of_chars
-        );
-        value
-    }
-}
-
-impl Display for MapKey {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_char(self.key)
-    }
-}