farmfe_core 2.1.0

Core types and data structures for farm.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use farmfe_utils::relative;
use relative_path::RelativePath;
use serde_json::{Map, Value};

#[derive(Debug, Clone)]
pub enum SideEffects {
  Bool(bool),
  Array(Vec<globset::GlobMatcher>),
}

impl Default for SideEffects {
  fn default() -> Self {
    Self::Bool(false)
  }
}

/// package json info that farm used.
/// **Note**: if you want to use the field that not defined here, you can deserialize raw and get the raw package.json [serde_json::Value]
#[derive(Debug, Clone, Default)]
pub struct PackageJsonInfo {
  pub name: Option<String>,
  pub version: Option<String>,

  parsed_side_effects: Option<SideEffects>,
  raw: Option<String>,
  raw_map: Option<Map<String, Value>>,
  /// the directory this package.json belongs to
  dir: Option<String>,
}

impl PackageJsonInfo {
  pub fn new(name: Option<String>, version: Option<String>) -> Self {
    Self {
      name,
      version,
      parsed_side_effects: None,
      raw: None,
      raw_map: None,
      dir: None,
    }
  }

  pub fn set_raw(&mut self, raw: String) {
    self.raw = Some(raw);
  }

  pub fn raw(&self) -> &String {
    self.raw.as_ref().unwrap()
  }

  pub fn set_raw_map(&mut self, raw_map: Map<String, Value>) {
    self.raw_map = Some(raw_map);
  }

  pub fn raw_map(&self) -> &Map<String, Value> {
    self.raw_map.as_ref().unwrap()
  }

  pub fn set_dir(&mut self, dir: String) {
    self.dir = Some(dir);
  }

  pub fn dir(&self) -> &String {
    self.dir.as_ref().unwrap()
  }

  /// parse the package.json and get parsed sideEffects info
  /// this method should be called after set_raw and set_dir
  pub fn parse(&mut self) {
    let package_value: serde_json::Map<String, Value> = serde_json::from_str(self.raw()).unwrap();

    self.analyze_parsed_side_effects(&package_value);
  }

  pub fn side_effects(&self) -> Option<&SideEffects> {
    self.parsed_side_effects.as_ref()
  }

  fn analyze_parsed_side_effects(&mut self, package_value: &serde_json::Map<String, Value>) {
    self.parsed_side_effects = if let Some(side_effects) = package_value.get("sideEffects") {
      if let Value::Bool(b) = side_effects {
        Some(SideEffects::Bool(*b))
      } else if let Value::Array(arr) = side_effects {
        let mut res = vec![];

        for item in arr {
          if let Value::String(str) = item {
            res.push(str.to_string());
          }
        }

        Some(SideEffects::Array(
          res
            .into_iter()
            .filter_map(|s| {
              let abs_path = RelativePath::new(&s).to_logical_path(self.dir());
              if let Ok(r) = globset::Glob::new(&relative(self.dir(), &abs_path.to_string_lossy()))
              {
                Some(r.compile_matcher())
              } else {
                None
              }
            })
            .collect::<Vec<_>>(),
        ))
      } else {
        // unknown side effects config, treat it as None
        None
      }
    } else {
      None
    };
  }
}