Class: MilkTea::ModulePathResolver

Inherits:
Object
  • Object
show all
Defined in:
lib/milk_tea/core/module_path_resolver.rb

Instance Method Summary collapse

Constructor Details

#initialize(module_roots:, platform:, package_graph: nil, source_overrides: nil, package_manifest_cache: nil) ⇒ ModulePathResolver

Returns a new instance of ModulePathResolver.



5
6
7
8
9
10
11
 
# File 'lib/milk_tea/core/module_path_resolver.rb', line 5

def initialize(module_roots:, platform:, package_graph: nil, source_overrides: nil, package_manifest_cache: nil)
  @module_roots = module_roots.map { |root| File.expand_path(root.to_s) }
  @platform = platform
  @package_graph = package_graph
  @source_overrides = source_overrides || {}
  @package_manifest_cache = package_manifest_cache || {}
end

Instance Method Details

#entry_module_namespace_like?(importer_path, importer_module_name) ⇒ Boolean

Returns:

  • (Boolean) 


146
147
148
149
150
 
# File 'lib/milk_tea/core/module_path_resolver.rb', line 146

def entry_module_namespace_like?(importer_path, importer_module_name)
  return false if importer_module_name.include?(".")

  File.basename(importer_path).match?(/\Amain(?:\.(linux|windows|wasm))?\.mt\z/)
end

#import_allowed?(module_name, importer_path, candidate_path) ⇒ Boolean

Returns:

  • (Boolean) 


82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/milk_tea/core/module_path_resolver.rb', line 82

def import_allowed?(module_name, importer_path, candidate_path)
  if @package_graph
    return import_allowed_by_graph?(module_name, importer_path, candidate_path)
  end

  importer_manifest = package_manifest_for_path(importer_path)
  return true unless importer_manifest

  candidate_manifest = package_manifest_for_path(candidate_path)
  return true unless candidate_manifest
  return true if candidate_manifest.manifest_path == importer_manifest.manifest_path

  dependency = importer_manifest.dependencies.find { |entry| entry.name == candidate_manifest.package_name }
  return false unless dependency

  package_namespace_match?(module_name, dependency.name)
end

#import_allowed_by_graph?(module_name, importer_path, candidate_path) ⇒ Boolean

Returns:

  • (Boolean) 


100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/milk_tea/core/module_path_resolver.rb', line 100

def import_allowed_by_graph?(module_name, importer_path, candidate_path)
  importer_package = @package_graph.package_for_path(importer_path)
  return true unless importer_package

  candidate_package = @package_graph.package_for_path(candidate_path)
  return true unless candidate_package
  return true if candidate_package.manifest.manifest_path == importer_package.manifest.manifest_path

  dependency = importer_package.edges.find do |edge|
    edge.node && edge.node.manifest.package_name == candidate_package.manifest.package_name
  end
  return false unless dependency

  package_namespace_match?(module_name, dependency.dependency.name)
end

#namespace_hint_for_missing_module(module_name, importer_path:, importer_module_name:) ⇒ Object 



132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/milk_tea/core/module_path_resolver.rb', line 132

def namespace_hint_for_missing_module(module_name, importer_path:, importer_module_name:)
  return nil unless importer_path && importer_module_name
  return nil unless entry_module_namespace_like?(importer_path, importer_module_name)
  return nil unless module_name.start_with?("#{importer_module_name}.")

  sibling_import = module_name.delete_prefix("#{importer_module_name}.")
  sibling_path = File.join(File.dirname(importer_path), *sibling_import.split(".")) + ".mt"
  resolved_sibling_path = ModuleLoader.resolve_source_path(sibling_path, platform: @platform)
  return nil unless source_path_available?(resolved_sibling_path)

  namespaced_path = File.join(File.dirname(importer_path), importer_module_name, *sibling_import.split(".")) + ".mt"
  "module not found; entry module '#{importer_module_name}' does not create an import namespace for sibling files. Import '#{sibling_import}' instead, or move the module to #{namespaced_path}"
end

#package_manifest_for_path(path) ⇒ Object 



116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/milk_tea/core/module_path_resolver.rb', line 116

def package_manifest_for_path(path)
  return nil unless path

  package_root = ModuleRoots.package_root_for_path(path)
  return nil unless package_root

  manifest_path = File.join(package_root, "package.toml")
  return @package_manifest_cache[manifest_path] if @package_manifest_cache.key?(manifest_path)

  @package_manifest_cache[manifest_path] = PackageManifest.load(path)
end

#package_namespace_match?(module_name, package_name) ⇒ Boolean

Returns:

  • (Boolean) 


128
129
130
 
# File 'lib/milk_tea/core/module_path_resolver.rb', line 128

def package_namespace_match?(module_name, package_name)
  module_name == package_name || module_name.start_with?("#{package_name}.")
end

#resolve_module_path(module_name, importer_path: nil, importer_module_name: nil) ⇒ Object

Raises:



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
 
# File 'lib/milk_tea/core/module_path_resolver.rb', line 13

def resolve_module_path(module_name, importer_path: nil, importer_module_name: nil)
  package_candidate = resolve_package_module_path(module_name, importer_path:)
  return package_candidate if package_candidate

  relative_path = File.join(*module_name.split(".")) + ".mt"
  blocked = false
  candidate = nil
  @module_roots.each do |root|
    path = ModuleLoader.resolve_source_path(File.join(root, relative_path), platform: @platform)
    next unless source_path_available?(path)

    allowed = import_allowed?(module_name, importer_path, path)
    blocked ||= !allowed
    if allowed
      candidate = path
      break
    end
  end
  raise ModuleLoadError.new("package dependency not declared", path: module_name) if blocked
  unless candidate
    message = namespace_hint_for_missing_module(module_name, importer_path:, importer_module_name:) || "module not found"
    raise ModuleLoadError.new(message, path: module_name)
  end
  File.expand_path(candidate)
end

#resolve_package_module_path(module_name, importer_path: nil) ⇒ Object

Raises:



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
 
# File 'lib/milk_tea/core/module_path_resolver.rb', line 44

def resolve_package_module_path(module_name, importer_path: nil)
  return nil unless @package_graph && importer_path

  importer_package = @package_graph.package_for_path(importer_path)
  return nil unless importer_package

  relative_path = File.join(*module_name.split(".")) + ".mt"
  candidates = []
  if package_namespace_match?(module_name, importer_package.manifest.package_name)
    candidates << [
      importer_package.manifest.package_name,
      File.join(importer_package.manifest.source_root, relative_path),
    ]
  end

  importer_package.edges.each do |edge|
    next unless edge.node && package_namespace_match?(module_name, edge.dependency.name)

    candidates << [
      edge.dependency.name,
      File.join(edge.node.manifest.source_root, relative_path),
    ]
  end

  return nil if candidates.empty?

  best_namespace_length = candidates.map { |namespace, _path| namespace.length }.max
  matching_candidates = candidates.select { |namespace, _path| namespace.length == best_namespace_length }
  if matching_candidates.length > 1
    raise ModuleLoadError.new("ambiguous package dependency import", path: module_name)
  end

  resolved_path = ModuleLoader.resolve_source_path(matching_candidates.first.last, platform: @platform)
  raise ModuleLoadError.new("module not found", path: module_name) unless source_path_available?(resolved_path)

  File.expand_path(resolved_path)
end

#source_path_available?(path) ⇒ Boolean

Returns:

  • (Boolean) 


39
40
41
42
 
# File 'lib/milk_tea/core/module_path_resolver.rb', line 39

def source_path_available?(path)
  resolved_path = File.expand_path(path.to_s)
  @source_overrides.key?(resolved_path) || File.file?(resolved_path)
end