klenod-build 0.0.1

data/lib/klenod/build/context.rb

@@ -0,0 +1,370 @@
+# frozen_string_literal: true
+
+require "async"
+require "fileutils"
+require "klenod/runtime/bundle_format"
+
+require_relative "graph"
+require_relative "loaded_module"
+require_relative "plugin"
+require_relative "plugins"
+require_relative "config"
+require_relative "asset_compression"
+
+module Klenod
+  module Build
+    AssetWriteResult = Data.define(:written_paths, :removed_paths, :skipped_paths) do
+      def initialize(written_paths = nil, removed_paths = nil, skipped_paths = nil, **keywords)
+        written_paths = keywords.fetch(:written_paths, written_paths)
+        removed_paths = keywords.fetch(:removed_paths, removed_paths)
+        skipped_paths = keywords.fetch(:skipped_paths, skipped_paths || [])
+
+        super(
+          written_paths: written_paths,
+          removed_paths: removed_paths,
+          skipped_paths: skipped_paths
+        )
+      end
+
+      def empty?
+        written_paths.empty? && removed_paths.empty?
+      end
+    end
+
+    AppliedUpdate = Data.define(:event, :entry, :exports, :asset_write_result, :errors) do
+      def success?
+        errors.empty?
+      end
+
+      def failed?
+        !success?
+      end
+
+      def entry_record
+        entry&.record
+      end
+
+      def each_error(&block)
+        return errors.each unless block
+
+        errors.each(&block)
+      end
+
+      def error_messages
+        errors.map { |module_id, error| "#{module_id}: #{error.class}: #{error.message}" }
+      end
+
+      def asset_files_changed?
+        asset_write_result && !asset_write_result.empty?
+      end
+
+      def written_asset_paths
+        asset_write_result&.written_paths || []
+      end
+
+      def removed_asset_paths
+        asset_write_result&.removed_paths || []
+      end
+
+      def skipped_asset_paths
+        asset_write_result&.skipped_paths || []
+      end
+    end
+
+    class Context
+      class DefaultPlugins
+        include Enumerable
+
+        def each(&block)
+          return enum_for(:each) unless block
+
+          Context.default_plugins.each(&block)
+        end
+
+        def to_a
+          Context.default_plugins
+        end
+      end
+
+      DEFAULT_PLUGINS = DefaultPlugins.new.freeze
+
+      def self.default_plugins
+        [
+          Plugins::RubyPlugin.new,
+          Plugins::IntlPlugin.new,
+          Plugins::HamlPlugin.new,
+          Plugins::MarkdownPlugin.new,
+          Plugins::GemImportPlugin.new,
+          Plugins::SvgPlugin.new,
+          Plugins::ImagePlugin.new,
+          Plugins::JsonPlugin.new,
+          Plugins::YamlPlugin.new,
+          Plugins::TomlPlugin.new,
+          Plugins::TextPlugin.new
+        ]
+      end
+
+      def initialize(
+        source_dir:,
+        plugins: DEFAULT_PLUGINS,
+        mode: :development,
+        asset_generation_concurrency: AssetGenerationQueue::DEFAULT_CONCURRENCY,
+        asset_download_concurrency: AssetGenerationQueue::DEFAULT_DOWNLOAD_CONCURRENCY,
+        profiler: nil
+      )
+        @source_dir = source_dir
+        plugins = plugins.to_a if plugins.equal?(DEFAULT_PLUGINS)
+        @plugins = plugins
+        @mode = mode
+        @update_handlers = []
+        @graph =
+          Graph.new(
+            source_dir: source_dir,
+            plugins: plugins,
+            mode: mode,
+            asset_generation_concurrency: asset_generation_concurrency,
+            asset_download_concurrency: asset_download_concurrency,
+            profiler: profiler
+          )
+      end
+
+      attr_reader :graph, :mode
+
+      def evaluate(specifier)
+        @graph.load(specifier)
+      end
+
+      def collect(specifier)
+        loaded(@graph.collect(specifier))
+      end
+
+      def entry(specifier)
+        collect(specifier)
+      end
+
+      def loaded(record_or_module_id)
+        return record_or_module_id if record_or_module_id.is_a?(LoadedModule)
+
+        LoadedModule.new(self, record_or_module_id.respond_to?(:id) ? record_or_module_id.id : record_or_module_id)
+      end
+
+      def build(entrypoints:, output:, assets_dir: nil)
+        bundle = @graph.bundle(entrypoints: entrypoints)
+        assets_dir ? write_assets(assets_dir) : wait_for_assets
+        FileUtils.mkdir_p(File.dirname(output))
+        File.binwrite(output, Runtime::BundleFormat.dump(bundle))
+        bundle
+      end
+
+      def build_executable(entrypoints:, output:, assets_dir: nil)
+        bundle = @graph.bundle(entrypoints: entrypoints)
+        assets_dir ? write_assets(assets_dir) : wait_for_assets
+        FileUtils.mkdir_p(File.dirname(output))
+        File.binwrite(output, executable_bundle_source + Runtime::BundleFormat.dump(bundle))
+        FileUtils.chmod("+x", output)
+        bundle
+      end
+
+      def invalidate_paths(changed_paths, removed_paths: [])
+        @graph.invalidate_paths(changed_paths, removed_paths: removed_paths)
+      end
+
+      def assets
+        @graph.assets
+      end
+
+      def asset(output_path)
+        @graph.asset(output_path)
+      end
+
+      def exports(record_or_module_id)
+        return record_or_module_id.exports if record_or_module_id.is_a?(LoadedModule)
+
+        @graph.exports(record_or_module_id)
+      end
+
+      def evaluated?(record_or_module_id)
+        record_or_module_id = record_or_module_id.id if record_or_module_id.is_a?(LoadedModule)
+        @graph.evaluated?(record_or_module_id)
+      end
+
+      def module_id_for(record_or_module_id)
+        return record_or_module_id.id if record_or_module_id.is_a?(LoadedModule)
+
+        @graph.module_id_for(record_or_module_id)
+      end
+
+      def asset_bytes(output_path, assets_dir: nil)
+        asset = asset(output_path)
+        return asset.bytes unless assets_dir
+
+        path = asset_disk_path(asset.output_path, Pathname.new(assets_dir))
+        write_asset(asset, Pathname.new(assets_dir)) unless File.file?(path)
+        File.binread(path)
+      end
+
+      def assets_for(logical_name)
+        @graph.assets_for(logical_name)
+      end
+
+      def assets_for_module(record_or_module_id, type: nil, content_type: nil, recursive: true)
+        @graph.assets_for_module(module_refs_for_assets(record_or_module_id), type: type, content_type: content_type, recursive: recursive)
+      end
+
+      def asset_references_for_module(record_or_module_id, type: nil, content_type: nil, recursive: true)
+        @graph.asset_references_for_module(module_refs_for_assets(record_or_module_id), type: type, content_type: content_type, recursive: recursive)
+      end
+
+      def each_asset(&block)
+        @graph.each_asset(&block)
+      end
+
+      def wait_for_assets
+        @graph.wait_for_assets
+      end
+
+      def asset_generation_queue
+        @graph.asset_generation_queue
+      end
+
+      def write_assets(assets_dir, &block)
+        assets_root = Pathname.new(assets_dir)
+        results =
+          with_async_task do |task|
+            assets.each_value.map { |asset| task.async { write_asset(asset, assets_root, &block) } }.map(&:wait)
+          end
+
+        asset_write_result(results, removed_paths: [])
+      end
+
+      def write_asset_updates(asset_updates, assets_dir:, &block)
+        assets_root = Pathname.new(assets_dir)
+        removed_paths =
+          asset_updates.filter_map do |update|
+            remove_asset(update.output_path, assets_root) if update.removed?
+          end
+        written_paths =
+          asset_updates.filter_map do |update|
+            write_asset(update.current_asset, assets_root, &block) if update.current_asset
+          end
+
+        asset_write_result(written_paths, removed_paths: removed_paths)
+      end
+
+      def apply_update(event, entry:, assets_dir: nil)
+        return AppliedUpdate.new(event, nil, nil, nil, event.result.errors.freeze) if event.result.errors.any?
+
+        entry = loaded(entry)
+        entry.record
+        asset_write_result = assets_dir && write_asset_updates(event.asset_updates, assets_dir: assets_dir)
+
+        AppliedUpdate.new(
+          event,
+          entry,
+          evaluated?(entry) ? entry.exports : nil,
+          asset_write_result,
+          [].freeze
+        )
+      end
+
+      def on_update(&block)
+        @update_handlers << block
+      end
+
+      def emit_update(event)
+        @update_handlers.each { |handler| handler.call(event) }
+      end
+
+      private
+
+      def executable_bundle_source
+        <<~RUBY.b
+          #!/usr/bin/env ruby
+          # encoding: ASCII-8BIT
+          # frozen_string_literal: true
+
+          require "klenod/runtime"
+
+          Klenod::Runtime.load_executable_bundle(__FILE__).load_entrypoints
+
+          __END__
+        RUBY
+      end
+
+      def write_asset(asset, assets_root, &block)
+        output_path = asset_disk_path(asset.output_path, assets_root)
+        status = asset.write_to(output_path) do |event, event_asset, event_path|
+          block&.call(event, event_asset, event_path)
+        end
+        AssetCompression.write_sidecar(asset, output_path.to_s)
+        block&.call(status, asset, output_path.to_s)
+
+        [status, output_path.to_s]
+      end
+
+      def asset_write_result(results, removed_paths:)
+        written_paths = []
+        skipped_paths = []
+
+        results.each do |status, path|
+          case status
+          when :written then written_paths << path
+          when :skipped then skipped_paths << path
+          else raise ArgumentError, "unknown asset write status: #{status.inspect}"
+          end
+        end
+
+        AssetWriteResult.new(
+          written_paths: written_paths.freeze,
+          removed_paths: removed_paths.freeze,
+          skipped_paths: skipped_paths.freeze
+        )
+      end
+
+      def remove_asset(output_path, assets_root)
+        path = asset_disk_path(output_path, assets_root)
+
+        FileUtils.rm_f(path)
+        AssetCompression.remove_sidecar(path.to_s)
+        path.to_s
+      end
+
+      def with_async_task(&block)
+        task = current_async_task
+        return block.call(task) if task
+
+        with_experimental_warnings_suppressed do
+          Async(&block).wait
+        end
+      end
+
+      def current_async_task
+        Async::Task.current
+      rescue RuntimeError
+        nil
+      end
+
+      def with_experimental_warnings_suppressed
+        enabled = Warning[:experimental]
+        Warning[:experimental] = false
+        yield
+      ensure
+        Warning[:experimental] = enabled
+      end
+
+      def asset_disk_path(output_path, assets_root)
+        assets_root.join(output_path.delete_prefix("/"))
+      end
+
+      def module_refs_for_assets(record_or_module_id)
+        if record_or_module_id.is_a?(Array)
+          record_or_module_id.map { |module_ref| module_ref.is_a?(LoadedModule) ? module_ref.id : module_ref }
+        elsif record_or_module_id.is_a?(LoadedModule)
+          record_or_module_id.id
+        else
+          record_or_module_id
+        end
+      end
+    end
+  end
+end

data/lib/klenod/build/dependency.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Build
+    SourceLocation =
+      Data.define(:path, :line, :column) do
+        def to_s
+          [path, line, column].compact.join(":")
+        end
+      end
+
+    Dependency =
+      Data.define(:id, :specifier, :importer_id, :kind, :loc, :metadata, :eager) do
+        def self.create(specifier:, importer_id:, kind:, loc: nil, metadata: {})
+          new(nil, specifier, importer_id, kind, loc, metadata.freeze, true)
+        end
+      end
+
+    ResolvedDependency = Data.define(:dependency, :module_id, :metadata)
+  end
+end

data/lib/klenod/build/errors.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Klenod
+  class Error < StandardError; end unless const_defined?(:Error, false)
+
+  module Build
+    class Error < Klenod::Error; end
+
+    class ResolveError < Error
+      REASONS = [:incorrect_case, :not_found].freeze
+
+      attr_reader :unresolved_path, :dependency, :importer_id, :reason, :requested_specifier, :suggestions
+
+      def initialize(message = nil, unresolved_path: nil, dependency: nil, importer_id: nil, reason: nil, requested_specifier: nil, suggestions: [])
+        @unresolved_path = unresolved_path
+        @dependency = dependency
+        @importer_id = importer_id
+        @reason = reason
+        @requested_specifier = requested_specifier
+        @suggestions = suggestions.freeze
+
+        super(message || resolution_message)
+      end
+
+      def resolution_failure?
+        REASONS.include?(reason) && requested_specifier
+      end
+
+      def title
+        case reason
+        when :incorrect_case then "Incorrect import path casing"
+        when :not_found then "Module not found"
+        else self.class.name
+        end
+      end
+
+      def source_location
+        dependency&.loc
+      end
+
+      def imported_by
+        if source_location&.line
+          "#{display_importer(source_location.path)}:#{source_location.line}"
+        else
+          display_importer(dependency&.importer_id || importer_id)
+        end
+      end
+
+      def with_resolution_context(dependency:, importer_id:)
+        unless resolution_failure?
+          return self if self.dependency
+
+          return self.class.new(
+            contextual_message(dependency, importer_id),
+            unresolved_path: unresolved_path,
+            dependency: dependency,
+            importer_id: importer_id
+          )
+        end
+
+        replacements = suggestions.map { replacement_specifier(it, dependency) }
+        self.class.new(
+          nil,
+          unresolved_path: unresolved_path,
+          dependency: dependency,
+          importer_id: importer_id,
+          reason: reason,
+          requested_specifier: dependency.specifier.to_s,
+          suggestions: replacements
+        )
+      end
+
+      def with_path_prefix(prefix)
+        return self unless resolution_failure?
+
+        self.class.new(
+          nil,
+          unresolved_path: unresolved_path,
+          dependency: dependency,
+          importer_id: importer_id,
+          reason: reason,
+          requested_specifier: prefixed_path(prefix, requested_specifier),
+          suggestions: suggestions.map { prefixed_path(prefix, it) }
+        )
+      end
+
+      private
+
+      def resolution_message
+        requested = requested_specifier.inspect
+        case reason
+        when :incorrect_case
+          suggestion = suggestions.first
+          suggestion ? "Incorrect case for #{requested}. Use #{suggestion.inspect}." : "Incorrect case for #{requested}."
+        when :not_found
+          message = "Could not resolve #{requested}"
+          return message if suggestions.empty?
+
+          if suggestions.one?
+            "#{message}. Did you mean #{suggestions.first.inspect}?"
+          else
+            "#{message}. Did you mean #{suggestions.map(&:inspect).join(", ")}?"
+          end
+        else
+          "Could not resolve #{requested}"
+        end
+      end
+
+      def display_importer(value)
+        value&.to_s&.delete_prefix("app:/")
+      end
+
+      def contextual_message(dependency, importer_id)
+        details = [
+          "while resolving #{dependency.specifier.inspect}",
+          "for #{importer_id}",
+          "from #{dependency.importer_id || "unknown importer"}"
+        ]
+        details << "kind: #{dependency.kind}" if dependency.kind
+        details << "at #{dependency.loc}" if dependency.loc
+
+        "#{message} (#{details.join(", ")})"
+      end
+
+      def replacement_specifier(suggestion, dependency)
+        canonical = canonical_parts(suggestion)
+        return suggestion unless canonical
+
+        requested_path, query = dependency.specifier.to_s.split("?", 2)
+        replacement =
+          if requested_path.match?(/\A[A-Za-z][A-Za-z0-9+.-]*:/)
+            suggestion
+          elsif requested_path.start_with?("/")
+            "/#{canonical.fetch(:path)}"
+          elsif (importer = canonical_parts(dependency.importer_id.to_s)) && importer.fetch(:root) == canonical.fetch(:root)
+            relative = Pathname.new(canonical.fetch(:path)).relative_path_from(Pathname.new(File.dirname(importer.fetch(:path)))).to_s
+            (requested_path.start_with?("./") && !relative.start_with?(".")) ? "./#{relative}" : relative
+          else
+            canonical.fetch(:path)
+          end
+
+        query ? "#{replacement}?#{query}" : replacement
+      rescue ArgumentError
+        suggestion
+      end
+
+      def canonical_parts(value)
+        case value.to_s
+        when /\A(?<scheme>[A-Za-z][A-Za-z0-9+.-]*):\/\/(?<host>[^\/]+)\/(?<path>.*)\z/
+          {root: "#{$~[:scheme]}://#{$~[:host]}/", path: $~[:path]}
+        when /\A(?<scheme>[A-Za-z][A-Za-z0-9+.-]*):\/(?<path>.*)\z/
+          {root: "#{$~[:scheme]}:/", path: $~[:path]}
+        end
+      end
+
+      def prefixed_path(prefix, value)
+        return value if value.to_s.match?(/\A[A-Za-z][A-Za-z0-9+.-]*:/)
+
+        "#{prefix}#{value}"
+      end
+    end
+
+    class DynamicImportError < Error; end
+    class UnsupportedFileError < Error; end
+
+    class ImportCycleError < Error
+      attr_reader :cycle
+
+      def initialize(cycle)
+        @cycle = cycle.freeze
+        super("Import cycle detected: #{cycle.join(" -> ")}")
+      end
+    end
+  end
+end

data/lib/klenod/build/filesystem_resolver.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+
+require_relative "errors"
+
+module Klenod
+  module Build
+    class FilesystemResolver
+      MAX_CORRECTIONS = 3
+
+      PathMatch = Data.define(:path, :case_mismatch)
+
+      def initialize(root:, extensions: [], path_prefix: nil)
+        @root = Pathname.new(root).expand_path
+        @extensions = extensions.freeze
+        @path_prefix = path_prefix.to_s
+      end
+
+      def resolve(relative_path)
+        relative_path = normalize_relative_path(relative_path)
+        case_corrections = []
+
+        candidate_paths(relative_path).each do |candidate_path|
+          path_matches(candidate_path).each do |match|
+            return match.path unless match.case_mismatch
+
+            case_corrections << relative_path_for(match.path)
+          end
+        end
+
+        unless case_corrections.empty?
+          raise ResolveError.new(
+            nil,
+            unresolved_path: display_path(relative_path),
+            reason: :incorrect_case,
+            requested_specifier: display_path(relative_path),
+            suggestions: case_corrections.uniq.map { display_path(it) }.first(MAX_CORRECTIONS)
+          )
+        end
+
+        corrections = spelling_corrections(relative_path)
+        raise ResolveError.new(
+          nil,
+          unresolved_path: display_path(relative_path),
+          reason: :not_found,
+          requested_specifier: display_path(relative_path),
+          suggestions: corrections.map { display_path(it) }
+        )
+      end
+
+      private
+
+      attr_reader :root, :extensions
+
+      def normalize_relative_path(path)
+        expanded = root.join(path.to_s).expand_path
+        root_path = root.to_s
+        expanded_path = expanded.to_s
+
+        unless expanded_path == root_path || expanded_path.start_with?("#{root_path}#{File::SEPARATOR}")
+          raise ResolveError.new(
+            "Resolved path escapes root: #{path}",
+            unresolved_path: path.to_s
+          )
+        end
+
+        normalize_path(expanded.relative_path_from(root).to_s)
+      end
+
+      def candidate_paths(relative_path)
+        [relative_path, *extensions.map { |extension| "#{relative_path}#{extension}" }]
+      end
+
+      def path_matches(relative_path)
+        states = [[root, false]]
+
+        relative_path.split("/").each do |part|
+          states =
+            states.flat_map do |directory, case_mismatch|
+              entries = directory_entries(directory)
+              matches = entries.include?(part) ? [part] : entries.select { it.casecmp?(part) }.sort
+
+              matches.map do |entry|
+                [directory.join(entry), case_mismatch || entry != part]
+              end
+            end
+          return [] if states.empty?
+        end
+
+        states.filter_map do |path, case_mismatch|
+          PathMatch.new(path, case_mismatch) if path.file?
+        end
+      end
+
+      def directory_entries(directory)
+        return [] unless directory.directory?
+
+        directory.children.map { it.basename.to_s }
+      rescue SystemCallError
+        []
+      end
+
+      def spelling_corrections(relative_path)
+        aliases = spelling_aliases
+        matches =
+          DidYouMean::TreeSpellChecker
+            .new(dictionary: aliases.keys.sort, separator: "/")
+            .correct(relative_path)
+
+        matches.flat_map { aliases.fetch(it) }.uniq.first(MAX_CORRECTIONS)
+      end
+
+      def spelling_aliases
+        source_files.each_with_object({}) do |path, aliases|
+          aliases[path] = [path]
+          extension = extensions.find { path.end_with?(it) }
+          next unless extension
+
+          alias_path = path.delete_suffix(extension)
+          aliases[alias_path] ||= []
+          aliases[alias_path] << path
+        end
+      end
+
+      def source_files
+        Dir
+          .glob("**/*", File::FNM_DOTMATCH, base: root.to_s)
+          .select { |path| root.join(path).file? }
+          .map { normalize_path(it) }
+          .sort
+      end
+
+      def display_path(relative_path)
+        "#{@path_prefix}#{relative_path}"
+      end
+
+      def relative_path_for(path)
+        normalize_path(path.relative_path_from(root).to_s)
+      end
+
+      def normalize_path(path)
+        path.tr("\\", "/")
+      end
+    end
+  end
+end