harn-vm 0.5.63

Async bytecode virtual machine for the Harn programming language
Documentation 
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

/// metadata_namespace.
pub fn metadata_namespace(dir, namespace) {
  return metadata_resolve(dir, namespace) ?? {}
}

/// metadata_local_namespace.
pub fn metadata_local_namespace(dir, namespace) {
  let normalized = if dir == "" { "." } else { dir }
  for entry in metadata_entries(namespace) {
    if entry.dir == normalized {
      return entry.local ?? {}
    }
  }
  return {}
}

/// project_inventory.
pub fn project_inventory(namespace) {
  return {
    entries: metadata_entries(namespace),
    status: metadata_status(namespace),
  }
}

/// project_root_package.
pub fn project_root_package() -> string {
  var root_package = ""
  let root_enrichment = metadata_get("", "enrichment")
  if root_enrichment?.rootPackageName {
    root_package = root_enrichment?.rootPackageName
  }
  if !root_package {
    let src_enrichment = metadata_get("src", "enrichment")
    if src_enrichment?.rootPackageName {
      root_package = src_enrichment?.rootPackageName
    }
  }
  if !root_package {
    let project_root = project_root() ?? ""
    let pyproject = read_file(project_root + "/pyproject.toml")
    if pyproject {
      for line in pyproject.split("\n") {
        let trimmed = line.trim()
        if trimmed.starts_with("name") && trimmed.contains("=") {
          let quoted = trimmed.split("\"")
          if quoted?.count ?? 0 >= 2 {
            root_package = quoted[1]
            break
          }
          let single_quoted = trimmed.split("'")
          if single_quoted?.count ?? 0 >= 2 {
            root_package = single_quoted[1]
            break
          }
        }
      }
    }
  }
  if !root_package {
    let project_root = project_root() ?? ""
    let package_json = read_file(project_root + "/package.json")
    if package_json {
      for line in package_json.split("\n") {
        let trimmed = line.trim()
        if trimmed.starts_with("\"name\"") {
          let parts = trimmed.split("\"")
          if parts?.count ?? 0 >= 4 {
            root_package = parts[3]
            break
          }
        }
      }
    }
  }
  if !root_package {
    let project_root = project_root() ?? ""
    let go_mod = read_file(project_root + "/go.mod")
    if go_mod {
      for line in go_mod.split("\n") {
        let trimmed = line.trim()
        if trimmed.starts_with("module ") {
          let module_path = trimmed.replace("module ", "")
          let parts = module_path.split("/")
          if parts?.count ?? 0 > 0 {
            root_package = parts[parts?.count ?? 0 - 1]
            break
          }
        }
      }
    }
  }
  if !root_package {
    let project_root = project_root() ?? ""
    let cargo_toml = read_file(project_root + "/Cargo.toml")
    if cargo_toml {
      for line in cargo_toml.split("\n") {
        let trimmed = line.trim()
        if trimmed.starts_with("name") && trimmed.contains("=") {
          let parts = trimmed.split("\"")
          if parts?.count ?? 0 >= 2 {
            root_package = parts[1]
            break
          }
        }
      }
    }
  }
  return root_package
}

/// project_scan.
pub fn project_scan(path, options) {
  return scan_directory(path, options)
}

/// project_scan_paths.
pub fn project_scan_paths(path, options) {
  var paths = []
  for entry in project_scan(path, options) {
    paths = paths + [entry.path]
  }
  return paths
}

/// project_stale.
pub fn project_stale(namespace) {
  return metadata_status(namespace).stale
}

/// project_stale_dirs.
pub fn project_stale_dirs(namespace) {
  let stale = project_stale(namespace)
  var dirs = []
  for dir in stale.tier1 {
    dirs = dirs + [dir]
  }
  for dir in stale.tier2 {
    dirs = dirs + [dir]
  }
  return dirs
}

/// project_requires_refresh.
pub fn project_requires_refresh(namespace) {
  let status = metadata_status(namespace)
  if status.stale.any_stale {
    return true
  }
  for _dir in status.missing_structure_hash {
    return true
  }
  for _dir in status.missing_content_hash {
    return true
  }
  return false
}