denoland-deno/cli/info.rs

// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.

use crate::colors;
use crate::global_state::GlobalState;
use crate::module_graph::{ModuleGraph, ModuleGraphFile, ModuleGraphLoader};
use crate::ModuleSpecifier;
use crate::Permissions;
use deno_core::error::AnyError;
use serde::ser::Serializer;
use serde::Serialize;
use std::collections::{BTreeMap, HashMap, HashSet};
use std::sync::Arc;

// TODO(bartlomieju): rename
/// Struct containing a module's dependency information.
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ModuleDepInfo {
  module: String,
  local: String,
  file_type: String,
  compiled: Option<String>,
  map: Option<String>,
  dep_count: usize,
  #[serde(skip_serializing)]
  deps: FileInfoDepTree,
  total_size: Option<usize>,
  files: FileInfoDepFlatGraph,
}

impl ModuleDepInfo {
  /// Creates a new `ModuleDepInfo` struct for the module with the provided `ModuleSpecifier`.
  pub async fn new(
    global_state: &Arc<GlobalState>,
    module_specifier: ModuleSpecifier,
  ) -> Result<Self, AnyError> {
    // First load module as if it was to be executed by worker
    // including compilation step
    let mut module_graph_loader = ModuleGraphLoader::new(
      global_state.file_fetcher.clone(),
      global_state.maybe_import_map.clone(),
      Permissions::allow_all(),
      false,
      true,
    );
    module_graph_loader
      .add_to_graph(&module_specifier, None)
      .await?;
    let module_graph = module_graph_loader.get_graph();

    let ts_compiler = &global_state.ts_compiler;
    let file_fetcher = &global_state.file_fetcher;
    let out = file_fetcher
      .fetch_cached_source_file(&module_specifier, Permissions::allow_all())
      .expect("Source file should already be cached");
    let local_filename = out.filename.to_string_lossy().to_string();
    let compiled_filename = ts_compiler
      .get_compiled_source_file(&out.url)
      .ok()
      .map(|file| file.filename.to_string_lossy().to_string());
    let map_filename = ts_compiler
      .get_source_map_file(&module_specifier)
      .ok()
      .map(|file| file.filename.to_string_lossy().to_string());
    let file_type =
      crate::media_type::enum_name_media_type(out.media_type).to_string();

    let deps = FileInfoDepTree::new(&module_graph, &module_specifier);
    let total_size = deps.total_size;
    let dep_count = get_unique_dep_count(&module_graph) - 1;
    let files = FileInfoDepFlatGraph::new(&module_graph);

    let info = Self {
      module: module_specifier.to_string(),
      local: local_filename,
      file_type,
      compiled: compiled_filename,
      map: map_filename,
      dep_count,
      deps,
      total_size,
      files,
    };

    Ok(info)
  }
}

/// Counts the number of dependencies in the graph.
///
/// We are counting only the dependencies that are not http redirects to other files.
fn get_unique_dep_count(graph: &ModuleGraph) -> usize {
  graph.iter().fold(
    0,
    |acc, e| {
      if e.1.redirect.is_none() {
        acc + 1
      } else {
        acc
      }
    },
  )
}

impl std::fmt::Display for ModuleDepInfo {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    f.write_fmt(format_args!("{} {}\n", colors::bold("local:"), self.local))?;
    f.write_fmt(format_args!(
      "{} {}\n",
      colors::bold("type:"),
      self.file_type
    ))?;
    if let Some(ref compiled) = self.compiled {
      f.write_fmt(format_args!(
        "{} {}\n",
        colors::bold("compiled:"),
        compiled
      ))?;
    }
    if let Some(ref map) = self.map {
      f.write_fmt(format_args!("{} {}\n", colors::bold("map:"), map))?;
    }

    f.write_fmt(format_args!(
      "{} {} unique {}\n",
      colors::bold("deps:"),
      self.dep_count,
      colors::gray(&format!(
        "(total {})",
        human_size(self.deps.total_size.unwrap_or(0) as f64),
      ))
    ))?;
    f.write_fmt(format_args!(
      "{} {}\n",
      self.deps.name,
      colors::gray(&format!("({})", human_size(self.deps.size as f64)))
    ))?;

    for (idx, dep) in self.deps.deps.iter().enumerate() {
      print_file_dep_info(&dep, "", idx == self.deps.deps.len() - 1, f)?;
    }

    Ok(())
  }
}

/// A dependency tree of the basic module information.
///
/// Constructed from a `ModuleGraph` and `ModuleSpecifier` that
/// acts as the root of the tree.
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct FileInfoDepTree {
  name: String,
  size: usize,
  total_size: Option<usize>,
  deps: Vec<FileInfoDepTree>,
}

impl FileInfoDepTree {
  /// Create a `FileInfoDepTree` tree from a `ModuleGraph` and the root `ModuleSpecifier`.
  pub fn new(
    module_graph: &ModuleGraph,
    root_specifier: &ModuleSpecifier,
  ) -> Self {
    let mut seen = HashSet::new();
    let mut total_sizes = HashMap::new();

    Self::visit_module(
      &mut seen,
      &mut total_sizes,
      module_graph,
      root_specifier,
    )
  }

  /// Visit modules recursively.
  ///
  /// If currently visited module has not yet been seen it will be annotated with dependencies
  /// and cumulative size of those deps.
  fn visit_module(
    seen: &mut HashSet<String>,
    total_sizes: &mut HashMap<String, usize>,
    graph: &ModuleGraph,
    specifier: &ModuleSpecifier,
  ) -> Self {
    let name = specifier.to_string();
    let never_seen = seen.insert(name.clone());
    let file = get_resolved_file(&graph, &specifier);
    let size = file.size();
    let mut deps = vec![];
    let mut total_size = None;

    if never_seen {
      let mut seen_deps = HashSet::new();
      deps = file
        .imports
        .iter()
        .map(|import| &import.resolved_specifier)
        .filter(|module_specifier| {
          seen_deps.insert(module_specifier.as_str().to_string())
        })
        .map(|specifier| {
          Self::visit_module(seen, total_sizes, graph, specifier)
        })
        .collect::<Vec<_>>();

      total_size = if let Some(total_size) = total_sizes.get(&name) {
        Some(total_size.to_owned())
      } else {
        let total: usize = deps
          .iter()
          .map(|dep| {
            if let Some(total_size) = dep.total_size {
              total_size
            } else {
              0
            }
          })
          .sum();
        let total = size + total;

        total_sizes.insert(name.clone(), total);

        Some(total)
      };
    }

    Self {
      name,
      size,
      total_size,
      deps,
    }
  }
}

/// Flat graph vertex with all shallow dependencies
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct FileInfoVertex {
  size: usize,
  deps: Vec<String>,
}

impl FileInfoVertex {
  /// Creates new `FileInfoVertex` that is a single vertex dependency module
  fn new(size: usize, deps: Vec<String>) -> Self {
    Self { size, deps }
  }
}

struct FileInfoDepFlatGraph(HashMap<String, FileInfoVertex>);

impl FileInfoDepFlatGraph {
  /// Creates new `FileInfoDepFlatGraph`, flat graph of a shallow module dependencies
  ///
  /// Each graph vertex represents unique dependency with its all shallow dependencies
  fn new(module_graph: &ModuleGraph) -> Self {
    let mut inner = HashMap::new();
    module_graph
      .iter()
      .for_each(|(module_name, module_graph_file)| {
        let size = module_graph_file.size();
        let mut deps = Vec::new();
        module_graph_file.imports.iter().for_each(|import| {
          deps.push(import.resolved_specifier.to_string());
        });
        inner.insert(module_name.clone(), FileInfoVertex::new(size, deps));
      });
    Self(inner)
  }
}

impl Serialize for FileInfoDepFlatGraph {
  /// Serializes inner hash map which is ordered by the key
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: Serializer,
  {
    let ordered: BTreeMap<_, _> = self.0.iter().collect();
    ordered.serialize(serializer)
  }
}

/// Returns a `ModuleGraphFile` associated to the provided `ModuleSpecifier`.
///
/// If the `specifier` is associated with a file that has a populated redirect field,
/// it returns the file associated to the redirect, otherwise the file associated to `specifier`.
fn get_resolved_file<'a>(
  graph: &'a ModuleGraph,
  specifier: &ModuleSpecifier,
) -> &'a ModuleGraphFile {
  // Note(kc): This code is dependent on how we are injecting a dummy ModuleGraphFile
  // into the graph with a "redirect" property.
  let result = graph.get(specifier.as_str()).unwrap();

  if let Some(ref import) = result.redirect {
    graph.get(import).unwrap()
  } else {
    result
  }
}

/// Prints the `FileInfoDepTree` tree to stdout.
fn print_file_dep_info(
  info: &FileInfoDepTree,
  prefix: &str,
  is_last: bool,
  formatter: &mut std::fmt::Formatter<'_>,
) -> std::fmt::Result {
  print_dep(prefix, is_last, info, formatter)?;

  let prefix = &get_new_prefix(prefix, is_last);
  let child_count = info.deps.len();
  for (idx, dep) in info.deps.iter().enumerate() {
    print_file_dep_info(dep, prefix, idx == child_count - 1, formatter)?;
  }

  Ok(())
}

/// Prints a single `FileInfoDepTree` to stdout.
fn print_dep(
  prefix: &str,
  is_last: bool,
  info: &FileInfoDepTree,
  formatter: &mut std::fmt::Formatter<'_>,
) -> std::fmt::Result {
  let has_children = !info.deps.is_empty();

  formatter.write_fmt(format_args!(
    "{} {}{}\n",
    colors::gray(&format!(
      "{}{}─{}",
      prefix,
      get_sibling_connector(is_last),
      get_child_connector(has_children),
    ))
    .to_string(),
    info.name,
    get_formatted_totals(info)
  ))
}

/// Gets the formatted totals for the provided `FileInfoDepTree`.
///
/// If the total size is reported as 0 then an empty string is returned.
fn get_formatted_totals(info: &FileInfoDepTree) -> String {
  if let Some(_total_size) = info.total_size {
    colors::gray(&format!(" ({})", human_size(info.size as f64),)).to_string()
  } else {
    // This dependency has already been displayed somewhere else in the tree.
    colors::gray(" *").to_string()
  }
}

/// Gets the sibling portion of the tree branch.
fn get_sibling_connector(is_last: bool) -> char {
  if is_last {
    '└'
  } else {
    '├'
  }
}

/// Gets the child connector for the branch.
fn get_child_connector(has_children: bool) -> char {
  if has_children {
    '┬'
  } else {
    '─'
  }
}

/// Creates a new prefix for a dependency tree item.
fn get_new_prefix(prefix: &str, is_last: bool) -> String {
  let mut prefix = prefix.to_string();
  if is_last {
    prefix.push(' ');
  } else {
    prefix.push('│');
  }

  prefix.push(' ');
  prefix
}

pub fn human_size(bytse: f64) -> String {
  let negative = if bytse.is_sign_positive() { "" } else { "-" };
  let bytse = bytse.abs();
  let units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
  if bytse < 1_f64 {
    return format!("{}{}{}", negative, bytse, "B");
  }
  let delimiter = 1024_f64;
  let exponent = std::cmp::min(
    (bytse.ln() / delimiter.ln()).floor() as i32,
    (units.len() - 1) as i32,
  );
  let pretty_bytes = format!("{:.2}", bytse / delimiter.powi(exponent))
    .parse::<f64>()
    .unwrap()
    * 1_f64;
  let unit = units[exponent as usize];
  format!("{}{}{}", negative, pretty_bytes, unit)
}

#[cfg(test)]
mod test {
  use super::*;
  use crate::ast::Location;
  use crate::media_type::MediaType;
  use crate::module_graph::ImportDescriptor;
  use deno_core::url::Url;

  #[test]
  fn human_size_test() {
    assert_eq!(human_size(16_f64), "16B");
    assert_eq!(human_size((16 * 1024) as f64), "16KB");
    assert_eq!(human_size((16 * 1024 * 1024) as f64), "16MB");
    assert_eq!(human_size(16_f64 * 1024_f64.powf(3.0)), "16GB");
    assert_eq!(human_size(16_f64 * 1024_f64.powf(4.0)), "16TB");
    assert_eq!(human_size(16_f64 * 1024_f64.powf(5.0)), "16PB");
    assert_eq!(human_size(16_f64 * 1024_f64.powf(6.0)), "16EB");
    assert_eq!(human_size(16_f64 * 1024_f64.powf(7.0)), "16ZB");
    assert_eq!(human_size(16_f64 * 1024_f64.powf(8.0)), "16YB");
  }

  #[test]
  fn get_new_prefix_adds_spaces_if_is_last() {
    let prefix = get_new_prefix("", true);

    assert_eq!(prefix, "  ".to_string());
  }

  #[test]
  fn get_new_prefix_adds_a_vertical_bar_if_not_is_last() {
    let prefix = get_new_prefix("", false);

    assert_eq!(prefix, "│ ".to_string());
  }

  fn create_mock_file(
    name: &str,
    imports: Vec<ModuleSpecifier>,
    redirect: Option<ModuleSpecifier>,
  ) -> (ModuleGraphFile, ModuleSpecifier) {
    let spec =
      ModuleSpecifier::from(Url::parse(&format!("http://{}", name)).unwrap());
    let file = ModuleGraphFile {
      filename: "name".to_string(),
      imports: imports
        .iter()
        .map(|import| ImportDescriptor {
          specifier: import.to_string(),
          resolved_specifier: import.clone(),
          resolved_type_directive: None,
          type_directive: None,
          location: Location {
            col: 0,
            filename: "".to_string(),
            line: 0,
          },
        })
        .collect(),
      lib_directives: vec![],
      media_type: MediaType::TypeScript,
      redirect: redirect.map(|x| x.to_string()),
      referenced_files: vec![],
      source_code: "".to_string(),
      specifier: spec.to_string(),
      type_headers: vec![],
      types_directives: vec![],
      version_hash: "".to_string(),
      url: "".to_string(),
    };

    (file, spec)
  }

  #[test]
  fn get_resolved_file_test() {
    let (test_file_redirect, redirect) =
      create_mock_file("test_redirect", vec![], None);
    let (test_file, original) =
      create_mock_file("test", vec![], Some(redirect.clone()));

    let mut graph = ModuleGraph::new();
    graph.insert(original.to_string(), test_file);
    graph.insert(redirect.to_string(), test_file_redirect);

    let file = get_resolved_file(&graph, &original);

    assert_eq!(file.specifier, redirect.to_string());
  }

  #[test]
  fn dependency_count_no_redirects() {
    let (a, aspec) = create_mock_file("a", vec![], None);
    let (b, bspec) = create_mock_file("b", vec![aspec.clone()], None);
    let (c, cspec) = create_mock_file("c", vec![bspec.clone()], None);

    let mut graph = ModuleGraph::new();

    graph.insert(aspec.to_string(), a);
    graph.insert(bspec.to_string(), b);
    graph.insert(cspec.to_string(), c);

    let count = get_unique_dep_count(&graph);

    assert_eq!(graph.len(), count);
  }

  #[test]
  fn dependency_count_with_redirects() {
    let (a, aspec) = create_mock_file("a", vec![], None);
    let (b, bspec) = create_mock_file("b", vec![], Some(aspec.clone()));
    let (c, cspec) = create_mock_file("c", vec![bspec.clone()], None);

    let mut graph = ModuleGraph::new();

    graph.insert(aspec.to_string(), a);
    graph.insert(bspec.to_string(), b);
    graph.insert(cspec.to_string(), c);

    let count = get_unique_dep_count(&graph);

    assert_eq!(graph.len() - 1, count);
  }
}