mt-lang 0.2.0

data/lib/milk_tea/packages/dependency_solver.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class PackageDependencySolverError < StandardError; end
+
+  class PackageDependencySolver
+    Solution = Data.define(:registry_versions)
+
+    State = Data.define(:manifests_by_path, :selected_registry_versions, :processing_stack) do
+      def deep_dup
+        self.class.new(
+          manifests_by_path: manifests_by_path.dup,
+          selected_registry_versions: selected_registry_versions.dup,
+          processing_stack: processing_stack.dup,
+        )
+      end
+    end
+
+    def initialize(source_resolver:, registry_metadata_provider: PackageRegistryMetadataProvider.new, locked_registry_versions: nil)
+      @source_resolver = source_resolver
+      @registry_metadata_provider = registry_metadata_provider
+      @locked_registry_versions = normalize_locked_registry_versions(locked_registry_versions)
+    end
+
+    def solve(path_or_manifest)
+      root_manifest = path_or_manifest.is_a?(PackageManifest::DataView) ? path_or_manifest : PackageManifest.load(path_or_manifest)
+      state = State.new(
+        manifests_by_path: {},
+        selected_registry_versions: {},
+        processing_stack: [],
+      )
+
+      resolved_state = visit_manifest(root_manifest, state, source: @source_resolver.source_for_manifest(root_manifest))
+      Solution.new(registry_versions: resolved_state.selected_registry_versions.transform_values(&:to_s).freeze)
+    rescue PackageManifestError, PackageRegistryMetadataProviderError, PackageSourceResolverError, PackageVersionError => e
+      raise PackageDependencySolverError, e.message
+    end
+
+    private
+
+    def visit_manifest(manifest, state, source:)
+      existing_manifest = state.manifests_by_path[manifest.manifest_path]
+      if existing_manifest
+        return state
+      end
+
+      if state.processing_stack.include?(manifest.manifest_path)
+        cycle_paths = state.processing_stack + [manifest.manifest_path]
+        cycle = cycle_paths.map do |manifest_path|
+          if manifest_path == manifest.manifest_path
+            manifest.package_name
+          else
+            state.manifests_by_path.fetch(manifest_path).package_name
+          end
+        end
+        raise PackageDependencySolverError, "package dependency cycle detected: #{cycle.join(' -> ')}"
+      end
+
+      state.manifests_by_path[manifest.manifest_path] = manifest
+      state.processing_stack << manifest.manifest_path
+      process_dependency_list(manifest.dependencies, parent_manifest: manifest, parent_source: source, state:)
+    ensure
+      state.processing_stack.pop if state&.processing_stack&.last == manifest.manifest_path
+    end
+
+    def process_dependency_list(dependencies, parent_manifest:, parent_source:, state:, index: 0)
+      return state if index >= dependencies.length
+
+      candidate_states = visit_dependency(dependencies[index], parent_manifest:, parent_source:, state:)
+      last_error = nil
+      candidate_states.each do |candidate_state|
+        begin
+          return process_dependency_list(
+            dependencies,
+            parent_manifest:,
+            parent_source:,
+            state: candidate_state,
+            index: index + 1,
+          )
+        rescue PackageDependencySolverError => e
+          last_error = e
+        end
+      end
+
+      raise last_error || PackageDependencySolverError.new(
+        "failed to resolve dependency #{dependencies[index].name} in #{parent_manifest.manifest_path}",
+      )
+    end
+
+    def visit_dependency(dependency, parent_manifest:, parent_source:, state:)
+      if dependency.path || dependency.git
+        branch = state.deep_dup
+        resolved_package = @source_resolver.resolve(dependency, parent_manifest:, parent_source:)
+        return [visit_manifest(resolved_package.manifest, branch, source: resolved_package.source)]
+      end
+
+      if dependency.registry?
+        if dependency.exact_registry_version?
+          branch = state.deep_dup
+          resolved_package = @source_resolver.resolve(dependency, parent_manifest:, parent_source:)
+          return [visit_manifest(resolved_package.manifest, branch, source: resolved_package.source)]
+        end
+
+        return choose_registry_version(dependency, parent_manifest:, parent_source:, state:)
+      end
+
+      raise PackageDependencySolverError,
+            "dependency #{dependency.name} in #{parent_manifest.manifest_path} has no supported source resolver"
+    end
+
+    def choose_registry_version(dependency, parent_manifest:, parent_source:, state:)
+      package_name = dependency.name
+      dependency_key = registry_dependency_key(parent_source:, dependency_name: package_name)
+      candidate_versions = @registry_metadata_provider.available_versions(package_name).select do |candidate_version|
+        dependency.version_req.matches?(candidate_version)
+      end
+
+      locked_version = locked_registry_version_for(dependency_key, package_name)
+      if locked_version
+        candidate_versions = candidate_versions.select { |candidate_version| candidate_version.to_s == locked_version }
+      end
+
+      if candidate_versions.empty?
+        if locked_version
+          raise PackageDependencySolverError,
+                "locked registry version #{locked_version} for #{package_name} in #{parent_manifest.manifest_path} does not satisfy #{dependency.version_req}"
+        end
+
+        raise PackageDependencySolverError,
+              "no registry version for #{package_name} in #{parent_manifest.manifest_path} satisfies #{dependency.version_req}"
+      end
+
+      last_error = nil
+      candidate_states = candidate_versions.filter_map do |candidate_version|
+        branch = state.deep_dup
+        branch.selected_registry_versions[dependency_key] = candidate_version
+        manifest = @registry_metadata_provider.manifest_for(package_name, candidate_version)
+        source = PackageSourceResolver::Source.new(
+          identity: PackageSourceResolver::RegistryIdentity.new(package_name:, version: candidate_version.to_s),
+          local_root: manifest.root_dir,
+        )
+
+        begin
+          visit_manifest(manifest, branch, source:)
+        rescue PackageDependencySolverError => e
+          last_error = e
+          nil
+        end
+      end
+
+      return candidate_states unless candidate_states.empty?
+
+      raise last_error || PackageDependencySolverError.new(
+        "no registry version for #{package_name} in #{parent_manifest.manifest_path} satisfies #{dependency.version_req}",
+      )
+    end
+
+    def registry_dependency_key(parent_source:, dependency_name:)
+      PackageSourceResolver.registry_dependency_key(
+        parent_source_key: PackageSourceResolver.source_key_for_identity(parent_source.identity),
+        dependency_name:,
+      )
+    end
+
+    def locked_registry_version_for(dependency_key, package_name)
+      @locked_registry_versions[dependency_key] || @locked_registry_versions[package_name]
+    end
+
+    def normalize_locked_registry_versions(versions)
+      return {} unless versions
+
+      versions.each_with_object({}) do |(key, version), locked|
+        normalized_key = case key
+                         when PackageSourceResolver::RegistryDependencyKey
+                           PackageSourceResolver.registry_dependency_key(
+                             parent_source_key: key.parent_source_key,
+                             dependency_name: key.dependency_name,
+                           )
+                         when Array
+                           if key.length != 2
+                             raise PackageDependencySolverError,
+                                   "registry dependency key must contain parent manifest path and dependency name"
+                           end
+
+                           PackageSourceResolver.registry_dependency_key(parent_source_key: key[0], dependency_name: key[1])
+                         else
+                           key.to_s
+                         end
+
+        locked[normalized_key] = version.to_s
+      end
+    end
+  end
+end

data/lib/milk_tea/packages/graph.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class PackageGraphError < StandardError; end
+
+  class PackageGraph
+    Edge = Data.define(:dependency, :node)
+    Node = Data.define(:manifest, :source, :edges)
+
+    def self.load(path, locked: false, source_resolver: PackageSourceResolver.new, registry_metadata_provider: PackageRegistryMetadataProvider.new)
+      return PackageLock.load(path, source_resolver:) if locked
+
+      new(path, source_resolver:, registry_metadata_provider:).load
+    end
+
+    def initialize(path, source_resolver: PackageSourceResolver.new, registry_metadata_provider: PackageRegistryMetadataProvider.new)
+      @path = File.expand_path(path)
+      @source_resolver = source_resolver
+      @graph_source_resolver = source_resolver
+      @registry_metadata_provider = registry_metadata_provider
+      @nodes_by_manifest_path = {}
+      @build_stack = []
+    end
+
+    def load
+      root_manifest = PackageManifest.load(@path)
+      @graph_source_resolver = resolve_graph_source_resolver(root_manifest)
+      build_node(root_manifest, source: @graph_source_resolver.source_for_manifest(root_manifest))
+    end
+
+    def self.render_tree(path, source_resolver: PackageSourceResolver.new, registry_metadata_provider: PackageRegistryMetadataProvider.new)
+      load(path, source_resolver:, registry_metadata_provider:).tree_lines.join("\n")
+    end
+
+    class Node
+      def packages(nodes = [], visited = {})
+        return nodes if visited[manifest.manifest_path]
+
+        visited[manifest.manifest_path] = true
+        nodes << self
+        edges.each do |edge|
+          edge.node&.packages(nodes, visited)
+        end
+        nodes
+      end
+
+      def source_roots(roots = [], visited = {})
+        return roots if visited[manifest.manifest_path]
+
+        visited[manifest.manifest_path] = true
+        roots << manifest.source_root
+        edges.each do |edge|
+          edge.node&.source_roots(roots, visited)
+        end
+        roots
+      end
+
+      def package_for_path(path, matches = [])
+        return nil unless path
+
+        expanded_path = File.expand_path(path)
+        matches << self if package_path?(expanded_path)
+        edges.each do |edge|
+          edge.node&.package_for_path(expanded_path, matches)
+        end
+
+        matches.max_by { |node| node.manifest.root_dir.length }
+      end
+
+      def tree_lines(indent = 0)
+        lines = [("  " * indent) + manifest.package_name]
+        edges.each do |edge|
+          if edge.node
+            lines.concat(edge.node.tree_lines(indent + 1))
+          else
+            lines << (("  " * (indent + 1)) + edge.dependency.name)
+          end
+        end
+        lines
+      end
+
+      private
+
+      def package_path?(path)
+        root_dir = manifest.root_dir
+        path == root_dir || path.start_with?(root_dir + File::SEPARATOR)
+      end
+    end
+
+    private
+
+    def build_node(manifest, source:)
+      existing = @nodes_by_manifest_path[manifest.manifest_path]
+      return existing if existing
+
+      if @build_stack.include?(manifest.manifest_path)
+        cycle_paths = @build_stack + [manifest.manifest_path]
+        cycle_names = cycle_paths.map { |path| package_name_for_manifest_path(path) }
+        raise PackageGraphError, "package dependency cycle detected: #{cycle_names.join(' -> ')}"
+      end
+
+      @build_stack << manifest.manifest_path
+      edges = manifest.dependencies.map do |dependency|
+        resolved_package = @graph_source_resolver.resolve(dependency, parent_manifest: manifest, parent_source: source)
+        edge_node = build_node(resolved_package.manifest, source: resolved_package.source)
+        Edge.new(dependency:, node: edge_node)
+      end
+
+      node = Node.new(manifest:, source:, edges:)
+      @nodes_by_manifest_path[manifest.manifest_path] = node
+      node
+    ensure
+      @build_stack.pop if @build_stack.last == manifest.manifest_path
+    end
+
+    def package_name_for_manifest_path(manifest_path)
+      node = @nodes_by_manifest_path[manifest_path]
+      return node.manifest.package_name if node
+
+      PackageManifest.load(manifest_path).package_name
+    rescue PackageManifestError
+      manifest_path
+    end
+
+    def resolve_graph_source_resolver(root_manifest)
+      return @source_resolver unless @source_resolver.supports_dependency_solving?
+
+      solution = PackageDependencySolver.new(
+        source_resolver: @source_resolver,
+        registry_metadata_provider: @registry_metadata_provider,
+        locked_registry_versions: @source_resolver.resolved_registry_versions,
+      ).solve(root_manifest)
+
+      @source_resolver.with_resolved_registry_versions(solution.registry_versions)
+    rescue PackageDependencySolverError => e
+      raise PackageGraphError, e.message
+    end
+  end
+end