klenod-build 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 560774e128fafb845afbff51f556e3eb30d3a1b7d280b9fbdc7ac36b48c4b741
-  data.tar.gz: 559ce8134726f2fa31084811a9dcda01987a957c073370f5ac0595c8d7a3f703
+  metadata.gz: 37a480cf40ba06385175cb0156563e300599b888366ea96b5a4c64dc5b7c2af9
+  data.tar.gz: 3aba70e34cb4e0c1c8328cea78682181f2079e28dbded35513f57a135becc405
 SHA512:
-  metadata.gz: 77cb936bd77e35262827d9903124f1b37cec73bb11db28c1a5e497d02a20d9283e989a46524c2f674b7c0f49734632e3da02b324a4988dbccbe3fe244e591921
-  data.tar.gz: eccc054b80b674a4f304fb6ec2abbdaf3bdf244576dc0f9bfd7b0d23b7b35ac77f5a47a061ad013cd9743295606b7ca3526a50e8f2dff48cc86ba13d4dac6fc2
+  metadata.gz: 0a86cb133c6ce093ef722b7f21b7f10402d80e80f3e8cdef85afb853420f0f552b1ccff4d6b42fb6565e0e898ea42ad713e98d385283842d12066b444fd27fbe
+  data.tar.gz: c7e07833d11dd65c47fcf702163157c62a8a670aa44c0017b14018ef658f646088700350b6ffe0e24cfeae475f7e4c5aa6d67b0325a5029904d8765958728a0c

data/README.md

@@ -27,3 +27,6 @@ The CLI can also generate a [Graphviz](https://graphviz.org/) DOT-file from a ge
 ```sh
 bundle exec klenod graph dist/klenod.bundle > graph.dot
 ```
+
+Klenod's internal virtual modules are hidden by default. Pass
+`--internal-virtual-modules` to include them in the graph.

data/lib/klenod/build/asset.rb

@@ -8,8 +8,9 @@ module Klenod
   module Build
     class Asset
       attr_reader :logical_name, :content_hash, :output_path, :source_path, :content_type, :metadata, :queue_kind, :error
+      attr_accessor :url
 
-      def initialize(logical_name, content_hash, output_path, source_path, bytes, content_type, metadata, generator: nil, writer: nil, queue: nil, queue_kind: :cpu)
+      def initialize(logical_name, content_hash, output_path, source_path, bytes, content_type, metadata, url: nil, generator: nil, writer: nil, queue: nil, queue_kind: :cpu)
         @logical_name = logical_name
         @content_hash = content_hash
         @output_path = output_path
@@ -17,6 +18,7 @@ module Klenod
         @bytes = bytes
         @content_type = content_type
         @metadata = metadata
+        @url = url
         @generator = generator
         @writer = writer
         @queue = queue
@@ -28,8 +30,8 @@ module Klenod
         @error = nil
       end
 
-      def self.generated(logical_name, content_hash, output_path, source_path, content_type, metadata, writer: nil, queue: nil, queue_kind: :cpu, &generator)
-        new(logical_name, content_hash, output_path, source_path, nil, content_type, metadata, generator: generator, writer: writer, queue: queue, queue_kind: queue_kind)
+      def self.generated(logical_name, content_hash, output_path, source_path, content_type, metadata, url: nil, writer: nil, queue: nil, queue_kind: :cpu, &generator)
+        new(logical_name, content_hash, output_path, source_path, nil, content_type, metadata, url:, generator: generator, writer: writer, queue: queue, queue_kind: queue_kind)
       end
 
       def bytes

data/lib/klenod/build/cli/application.rb

@@ -68,13 +68,19 @@ module Klenod
 
         options do
           option "--no-assets", "Hide generated asset nodes and edges."
+          option "--internal-virtual-modules", "Include Klenod's internal virtual modules."
         end
 
         one :bundle_path, "Path to a Klenod runtime bundle.", required: true
 
         def call
           bundle = Klenod::Runtime.load_bundle(@bundle_path)
-          dot = Klenod::Build::Graphviz.call(bundle, include_assets: !@options[:no_assets])
+          dot =
+            Klenod::Build::Graphviz.call(
+              bundle,
+              include_assets: !@options[:no_assets],
+              include_internal_virtual_modules: @options[:internal_virtual_modules]
+            )
           output.write(dot)
           dot
         end

data/lib/klenod/build/config.rb

@@ -3,8 +3,8 @@
 module Klenod
   module Build
     Config =
-      Data.define(:source_dir, :entrypoints, :output, :assets_dir, :plugins, :mode, :base_dir) do
-        def initialize(source_dir: "src", entrypoints: [], output: "dist/klenod.bundle", assets_dir: nil, plugins: Context::DEFAULT_PLUGINS, mode: :development, base_dir: Dir.pwd)
+      Data.define(:source_dir, :entrypoints, :output, :assets_dir, :plugins, :mode, :base_dir, :base) do
+        def initialize(source_dir: "src", entrypoints: [], output: "dist/klenod.bundle", assets_dir: nil, plugins: Context::DEFAULT_PLUGINS, mode: :development, base_dir: Dir.pwd, base: Runtime::AssetUrl::DEFAULT_BASE)
           super(
             source_dir: source_dir,
             entrypoints: Array(entrypoints),
@@ -12,7 +12,8 @@ module Klenod
             assets_dir: assets_dir,
             plugins: plugins,
             mode: mode,
-            base_dir: base_dir
+            base_dir: base_dir,
+            base: Runtime::AssetUrl.normalize(base)
           )
         end
 
@@ -25,6 +26,7 @@ module Klenod
             source_dir: source_path,
             plugins: plugins,
             mode: mode,
+            base: base,
             **overrides
           )
         end
@@ -60,6 +62,7 @@ module Klenod
         @plugins = Context::DEFAULT_PLUGINS
         @mode = :development
         @base_dir = base_dir
+        @base = Runtime::AssetUrl::DEFAULT_BASE
       end
 
       def source_dir(value = nil)
@@ -100,6 +103,12 @@ module Klenod
         @mode = value
       end
 
+      def base(value = nil)
+        return @base unless value
+
+        @base = value
+      end
+
       def config
         Config.new(
           source_dir: @source_dir,
@@ -108,7 +117,8 @@ module Klenod
           assets_dir: @assets_dir,
           plugins: @plugins,
           mode: @mode,
-          base_dir: @base_dir
+          base_dir: @base_dir,
+          base: @base
         )
       end
     end

data/lib/klenod/build/context.rb

@@ -108,6 +108,7 @@ module Klenod
         source_dir:,
         plugins: DEFAULT_PLUGINS,
         mode: :development,
+        base: Runtime::AssetUrl::DEFAULT_BASE,
         asset_generation_concurrency: AssetGenerationQueue::DEFAULT_CONCURRENCY,
         asset_download_concurrency: AssetGenerationQueue::DEFAULT_DOWNLOAD_CONCURRENCY,
         profiler: nil
@@ -116,19 +117,21 @@ module Klenod
         plugins = plugins.to_a if plugins.equal?(DEFAULT_PLUGINS)
         @plugins = plugins
         @mode = mode
+        @base = Runtime::AssetUrl.normalize(base)
         @update_handlers = []
         @graph =
           Graph.new(
             source_dir: source_dir,
             plugins: plugins,
             mode: mode,
+            base: @base,
             asset_generation_concurrency: asset_generation_concurrency,
             asset_download_concurrency: asset_download_concurrency,
             profiler: profiler
           )
       end
 
-      attr_reader :graph, :mode
+      attr_reader :graph, :mode, :base
 
       def evaluate(specifier)
         @graph.load(specifier)
@@ -177,6 +180,10 @@ module Klenod
         @graph.asset(output_path)
       end
 
+      def asset_url(asset_or_output_path)
+        @graph.asset_url(asset_or_output_path)
+      end
+
       def exports(record_or_module_id)
         return record_or_module_id.exports if record_or_module_id.is_a?(LoadedModule)
 

data/lib/klenod/build/errors.rb

@@ -161,7 +161,6 @@ module Klenod
     end
 
     class DynamicImportError < Error; end
-    class TestImportError < ResolveError; end
     class UnsupportedFileError < Error; end
 
     class ImportCycleError < Error

data/lib/klenod/build/graph.rb

@@ -56,13 +56,14 @@ module Klenod
         end
       end
 
-      attr_reader :records, :mods, :asset_generation_queue, :mode, :profiler
+      attr_reader :records, :mods, :asset_generation_queue, :mode, :profiler, :base
       attr_reader :plugins
 
       def initialize(
         source_dir:,
         plugins:,
         mode: :development,
+        base: Runtime::AssetUrl::DEFAULT_BASE,
         asset_generation_concurrency: AssetGenerationQueue::DEFAULT_CONCURRENCY,
         asset_download_concurrency: AssetGenerationQueue::DEFAULT_DOWNLOAD_CONCURRENCY,
         profiler: nil
@@ -71,6 +72,7 @@ module Klenod
         @resolver = Resolver.new(source_dir: source_dir, profiler: @profiler)
         @plugins = plugins
         @mode = mode
+        @base = Runtime::AssetUrl.normalize(base)
         @asset_generation_queue =
           AssetGenerationQueue.new(
             concurrency: asset_generation_concurrency,
@@ -112,7 +114,8 @@ module Klenod
             loaded_entrypoints,
             runtime_module_specs,
             runtime_asset_specs,
-            source_root: source_dir.to_s
+            source_root: source_dir.to_s,
+            base: base
           )
         end
       end
@@ -125,6 +128,15 @@ module Klenod
         assets.fetch(output_path)
       end
 
+      def asset_url(asset_or_output_path)
+        if asset_or_output_path.respond_to?(:output_path)
+          asset = assets.fetch(asset_or_output_path.output_path, asset_or_output_path)
+          return asset.url || Runtime::AssetUrl.join(base, asset.output_path)
+        end
+
+        Runtime::AssetUrl.join(base, asset_or_output_path)
+      end
+
       def exports(record_or_module_id)
         module_id = module_id_for(record_or_module_id)
         evaluate_module(module_id).const_get(:Exports)
@@ -574,6 +586,7 @@ module Klenod
       end
 
       def build_module_record(module_id, source, source_hash, transformed_hash, transform, resolved_dependencies, cached_or_mod)
+        bind_asset_urls(transform.assets)
         version =
           if cached_or_mod.is_a?(Runtime::Mod)
             cached_or_mod.version
@@ -600,6 +613,10 @@ module Klenod
         )
       end
 
+      def bind_asset_urls(assets)
+        assets.each { |asset| asset.url ||= Runtime::AssetUrl.join(base, asset.output_path) }
+      end
+
       def load_dependency_records(resolved_dependencies)
         return {} if resolved_dependencies.empty?
 
@@ -771,7 +788,8 @@ module Klenod
               asset.content_hash,
               asset.output_path,
               asset.content_type,
-              asset.metadata
+              asset.metadata,
+              asset.url
             )
           ]
         end

data/lib/klenod/build/graphviz.rb

@@ -19,13 +19,18 @@ module Klenod
       ASSET_STYLE = {fillcolor: "#ffe4d6", color: "#e26d39"}.freeze
       DEFAULT_MODULE_STYLE = {fillcolor: "#f7f7f7", color: "#8a8a8a"}.freeze
 
-      def self.call(bundle, include_assets: true)
-        new(bundle, include_assets: include_assets).to_dot
+      def self.call(bundle, include_assets: true, include_internal_virtual_modules: false)
+        new(
+          bundle,
+          include_assets: include_assets,
+          include_internal_virtual_modules: include_internal_virtual_modules
+        ).to_dot
       end
 
-      def initialize(bundle, include_assets: true)
+      def initialize(bundle, include_assets: true, include_internal_virtual_modules: false)
         @bundle = bundle
         @include_assets = include_assets
+        @include_internal_virtual_modules = include_internal_virtual_modules
       end
 
       def to_dot
@@ -46,8 +51,15 @@ module Klenod
 
       private
 
+      def all_module_ids
+        @all_module_ids ||= @bundle.modules.keys.sort
+      end
+
       def module_ids
-        @bundle.modules.keys.sort
+        @module_ids ||=
+          all_module_ids.reject do |id|
+            internal_virtual_module?(id) && !entrypoint?(id) && !@include_internal_virtual_modules
+          end
       end
 
       def module_node(id)
@@ -75,7 +87,7 @@ module Klenod
         module_ids.flat_map do |id|
           @bundle.modules.fetch(id).imports.values.map do |import|
             import = import_spec(import)
-            next unless @bundle.modules.key?(import.target_id)
+            next unless visible_module?(import.target_id)
 
             attributes = {
               id: svg_edge_id(id, import.target_id),
@@ -91,25 +103,71 @@ module Klenod
       end
 
       def asset_edges
-        @bundle.assets.values.sort_by(&:output_path).filter_map do |asset|
-          owner = asset_owner(asset)
-          next unless owner
-
-          attributes = {
-            id: svg_edge_id(owner_node_name(owner), asset.output_path),
-            class: "edge edge-asset",
-            color: "#e26d39",
-            style: "dotted",
-            label: "asset"
-          }
-          "  #{owner_node_id(owner)} -> #{asset_node_id(asset)} [#{dot_attributes(attributes)}];"
+        @bundle.assets.values.sort_by(&:output_path).flat_map do |asset|
+          asset_owners(asset).map do |owner|
+            attributes = {
+              id: svg_edge_id(owner_node_name(owner), asset.output_path),
+              class: "edge edge-asset",
+              color: "#e26d39",
+              style: "dotted",
+              label: "asset"
+            }
+            "  #{owner_node_id(owner)} -> #{asset_node_id(asset)} [#{dot_attributes(attributes)}];"
+          end
         end
       end
 
-      def asset_owner(asset)
-        return [:module, asset.logical_name] if @bundle.modules.key?(asset.logical_name)
+      def asset_owners(asset)
+        module_id = module_id_for_asset(asset.logical_name)
+        return visible_module_owners(module_id) if module_id
 
-        google_fonts_css_asset_owner(asset) || query_module_id_for(asset.logical_name)
+        [google_fonts_css_asset_owner(asset), *asset_metadata_owners(asset)].compact
+      end
+
+      def visible_module_owners(module_id)
+        pending = [module_id]
+        seen = Set.new
+        owners = []
+
+        until pending.empty?
+          current_id = pending.shift
+          next unless seen.add?(current_id)
+
+          if visible_module?(current_id)
+            owners << [:module, current_id]
+          else
+            pending.concat(module_importers.fetch(current_id, []))
+          end
+        end
+
+        owners
+      end
+
+      def module_importers
+        @module_importers ||=
+          all_module_ids.each_with_object(Hash.new { |index, id| index[id] = [] }) do |id, index|
+            @bundle.modules.fetch(id).imports.each_value do |import|
+              target_id = import_spec(import).target_id
+              index[target_id] << id if @bundle.modules.key?(target_id)
+            end
+          end
+      end
+
+      def module_id_for_asset(logical_name)
+        return logical_name if @bundle.modules.key?(logical_name)
+
+        module_ids_by_source_path.fetch(logical_name, nil) || query_module_ids_by_path.fetch(logical_name, nil)
+      end
+
+      def module_ids_by_source_path
+        @module_ids_by_source_path ||=
+          all_module_ids.each_with_object({}) do |id, index|
+            source_path = @bundle.modules.fetch(id).source_path
+            next unless source_path
+
+            index[source_path] ||= id
+            index[display_path(source_path)] ||= id
+          end
       end
 
       def google_fonts_css_asset_owner(asset)
@@ -127,14 +185,18 @@ module Klenod
         asset.metadata[:source_url]
       end
 
-      def query_module_id_for(logical_name)
-        module_id = query_module_ids_by_path.fetch(logical_name, nil)
-        [:module, module_id] if module_id
+      def asset_metadata_owners(asset)
+        return [] unless asset.metadata[:javascript_runtime] == :asset_metadata
+
+        @bundle.assets.values
+          .select { it.metadata[:image_metadata] || it.metadata[:svg_metadata] }
+          .sort_by(&:output_path)
+          .map { [:asset, it] }
       end
 
       def query_module_ids_by_path
         @query_module_ids_by_path ||=
-          module_ids.each_with_object({}) do |id, index|
+          all_module_ids.each_with_object({}) do |id, index|
             path, query = id.split("?", 2)
             next unless query
 
@@ -218,6 +280,15 @@ module Klenod
         ["edge", import.eager ? "edge-import" : "edge-import edge-lazy"].join(" ")
       end
 
+      def internal_virtual_module?(id)
+        id.start_with?("virtual:/klenod/", "virtual:klenod/")
+      end
+
+      def visible_module?(id)
+        @visible_module_ids ||= module_ids.to_set
+        @visible_module_ids.include?(id)
+      end
+
       def entrypoint?(id)
         entrypoint_ids.include?(id)
       end

data/lib/klenod/build/plugins/asset_javascript_metadata.rb

@@ -59,7 +59,7 @@ module Klenod
           }
         JAVASCRIPT
         CONTENT_HASH = Hashing.short(SOURCE)
-        OUTPUT_PATH = "/assets/klenod_asset_metadata.#{CONTENT_HASH}.js"
+        OUTPUT_PATH = "/klenod_asset_metadata.#{CONTENT_HASH}.js"
 
         module_function
 

data/lib/klenod/build/plugins/google_fonts_plugin.rb

@@ -172,13 +172,14 @@ module Klenod
                 font_url = Regexp.last_match[:url]
                 asset = font_assets[font_url] ||= font_asset(font_url, font_faces[font_url], context)
 
-                %(url(#{quote}#{asset.output_path}#{quote}))
+                %(url(#{quote}#{asset.url}#{quote}))
               end
             rewritten_css = append_fallback_font_faces(rewritten_css, font_faces.values) if @adjust_font_fallback
 
             css_asset = css_asset(module_id, url, rewritten_css, font_assets.keys)
+            css_asset.url = context.asset_url(css_asset.output_path)
             @assets_by_module_id[module_id] = [css_asset, *font_assets.values]
-            ruby_module_source(css_asset.output_path)
+            ruby_module_source(css_asset.url)
           end
 
           def transform(module_id, code, _context)
@@ -242,7 +243,7 @@ module Klenod
 
           def css_asset(module_id, url, css, font_source_urls)
             hash = Hashing.short(css)
-            output_path = "/assets/#{google_fonts_asset_name(url)}.#{hash}.css"
+            output_path = "/#{google_fonts_asset_name(url)}.#{hash}.css"
 
             Asset.new(
               module_id.to_s,
@@ -296,7 +297,7 @@ module Klenod
             hash = Hashing.short(url)
             uri = URI.parse(url)
             extname = File.extname(uri.path)
-            output_path = "/assets/#{font_asset_name(uri, font_face)}.#{hash}#{extname}"
+            output_path = "/#{font_asset_name(uri, font_face)}.#{hash}#{extname}"
 
             Asset.generated(
               url,
@@ -314,6 +315,7 @@ module Klenod
               },
               writer: ->(io) { write_fetch(url, io) },
               queue: context.asset_generation_queue,
+              url: context.asset_url(output_path),
               queue_kind: :io
             ) do
               fetch(url)

data/lib/klenod/build/plugins/image_plugin.rb

@@ -51,7 +51,9 @@ module Klenod
             image_options = image_options_for(module_id)
             asset = default_image_asset(module_id, source_path, source_hash, dimensions, image_options, context.asset_generation_queue)
             variant_assets = generate_variant_assets(module_id, source_path, source_hash, dimensions, image_options, context.asset_generation_queue)
-            javascript_asset = javascript_image_asset(module_id, asset, variant_assets)
+            [asset, *variant_assets].each { |image_asset| image_asset.url = context.asset_url(image_asset.output_path) }
+            javascript_asset = javascript_image_asset(module_id, asset, variant_assets, context)
+            javascript_asset.url = context.asset_url(javascript_asset.output_path)
             assets = [asset, *variant_assets]
             image_runtime_dependency =
               Dependency
@@ -64,7 +66,7 @@ module Klenod
 
             transform =
               TransformResult.new(
-                image_module_source(module_id, assets, image_runtime_dependency),
+                image_module_source(module_id, assets, image_runtime_dependency, context),
                 [image_runtime_dependency],
                 nil,
                 assets,
@@ -126,7 +128,7 @@ module Klenod
             Asset.new(
               module_id.path,
               hash,
-              "/assets/#{asset_name(module_id)}.#{hash}#{module_id.extname}",
+              "/#{asset_name(module_id)}.#{hash}#{module_id.extname}",
               source_path,
               nil,
               content_type(module_id.extname),
@@ -154,7 +156,7 @@ module Klenod
             Asset.generated(
               module_id.path,
               hash,
-              "/assets/#{asset_name(module_id)}.#{hash}#{extname}",
+              "/#{asset_name(module_id)}.#{hash}#{extname}",
               source_path,
               content_type(extname),
               metadata,
@@ -217,15 +219,15 @@ module Klenod
             "# image asset: #{module_id}\n"
           end
 
-          def image_module_source(module_id, assets, image_runtime_dependency)
+          def image_module_source(module_id, assets, image_runtime_dependency, context)
             asset = image_asset(assets)
-            variants = image_variant_assets(assets).map { |variant_asset| image_variant_source(variant_asset) }
+            variants = image_variant_assets(assets).map { |variant_asset| image_variant_source(variant_asset, context) }
 
             <<~RUBY
               ImageRuntime = __klenod_import__(#{image_runtime_dependency.id.inspect})
               Default =
                 ImageRuntime::ImageMetadata.new(
-                  src: #{asset.output_path.inspect},
+                  src: #{asset.url.inspect},
                   width: #{asset.metadata[:width].inspect},
                   height: #{asset.metadata[:height].inspect},
                   content_type: #{asset.content_type.inspect},
@@ -238,10 +240,10 @@ module Klenod
             RUBY
           end
 
-          def image_variant_source(asset)
+          def image_variant_source(asset, context)
             <<~RUBY.chomp
               ImageRuntime::ImageVariant.new(
-                src: #{asset.output_path.inspect},
+                src: #{asset.url.inspect},
                 width: #{asset.metadata[:width].inspect},
                 height: #{asset.metadata[:height].inspect},
                 content_type: #{asset.content_type.inspect},
@@ -253,13 +255,13 @@ module Klenod
             RUBY
           end
 
-          def javascript_image_asset(module_id, asset, variant_assets)
-            code = javascript_image_module_source(asset, variant_assets)
+          def javascript_image_asset(module_id, asset, variant_assets, context)
+            code = javascript_image_module_source(asset, variant_assets, context)
             hash = Hashing.short(code)
             Asset.new(
               module_id.path,
               hash,
-              "/assets/#{asset_name(module_id)}.#{hash}#{module_id.extname}.js",
+              "/#{asset_name(module_id)}.#{hash}#{module_id.extname}.js",
               nil,
               code,
               "application/javascript",
@@ -267,10 +269,10 @@ module Klenod
             )
           end
 
-          def javascript_image_module_source(asset, variant_assets)
-            variants = variant_assets.map { "new ImageVariant(#{AssetJavaScriptMetadata.object_literal(javascript_image_variant(it))})" }
+          def javascript_image_module_source(asset, variant_assets, context)
+            variants = variant_assets.map { "new ImageVariant(#{AssetJavaScriptMetadata.object_literal(javascript_image_variant(it, context))})" }
             properties = {
-              src: asset.output_path,
+              src: asset.url,
               width: asset.metadata[:width],
               height: asset.metadata[:height],
               contentType: asset.content_type,
@@ -279,14 +281,14 @@ module Klenod
             properties << %(variants:[#{variants.join(",")}])
 
             <<~JAVASCRIPT
-              import ImageMetadata, { ImageVariant } from #{AssetJavaScriptMetadata::OUTPUT_PATH.inspect};
+              import ImageMetadata, { ImageVariant } from #{context.asset_url(AssetJavaScriptMetadata::OUTPUT_PATH).inspect};
               export default new ImageMetadata({#{properties.join(",")}});
             JAVASCRIPT
           end
 
-          def javascript_image_variant(asset)
+          def javascript_image_variant(asset, context)
             {
-              src: asset.output_path,
+              src: asset.url,
               width: asset.metadata[:width],
               height: asset.metadata[:height],
               contentType: asset.content_type,
@@ -338,7 +340,7 @@ module Klenod
             extname = ".#{format}"
             descriptor = "#{width}w"
             hash = Hashing.short("#{source_hash}:#{width}:#{format}:#{quality}")
-            output_path = "/assets/#{asset_name(module_id)}.#{width}w.#{hash}#{extname}"
+            output_path = "/#{asset_name(module_id)}.#{width}w.#{hash}#{extname}"
             metadata = {
               type: :image_variant,
               width: width,

data/lib/klenod/build/plugins/svg_plugin.rb

@@ -34,14 +34,14 @@ module Klenod
             svg_runtime_source
           end
 
-          def transform(module_id, code, _context)
+          def transform(module_id, code, context)
             return super unless EXTENSIONS.include?(module_id.extname)
 
             raise UnsupportedFileError, "SVG imports do not support query options: #{module_id}" if module_id.query
 
             dimensions = svg_dimensions(code)
             hash = Hashing.short(code)
-            output_path = "/assets/#{asset_name(module_id)}.#{hash}.svg"
+            output_path = "/#{asset_name(module_id)}.#{hash}.svg"
             asset =
               Asset.new(
                 module_id.path,
@@ -56,7 +56,9 @@ module Klenod
                   height: dimensions.height
                 }
               )
-            javascript_asset = javascript_svg_asset(module_id, asset)
+            asset.url = context.asset_url(asset.output_path)
+            javascript_asset = javascript_svg_asset(module_id, asset, context)
+            javascript_asset.url = context.asset_url(javascript_asset.output_path)
             svg_runtime_dependency =
               Dependency
                 .create(
@@ -67,7 +69,7 @@ module Klenod
                 .with(id: "#{module_id}:svg_runtime")
 
             TransformResult.new(
-              svg_module_source(asset, svg_runtime_dependency),
+              svg_module_source(asset, svg_runtime_dependency, context),
               [svg_runtime_dependency],
               nil,
               [asset],
@@ -100,12 +102,12 @@ module Klenod
             RUBY
           end
 
-          def svg_module_source(asset, svg_runtime_dependency)
+          def svg_module_source(asset, svg_runtime_dependency, context)
             <<~RUBY
               SvgRuntime = __klenod_import__(#{svg_runtime_dependency.id.inspect})
               Default =
                 SvgRuntime::SvgMetadata.new(
-                  src: #{asset.output_path.inspect},
+                  src: #{asset.url.inspect},
                   width: #{asset.metadata[:width].inspect},
                   height: #{asset.metadata[:height].inspect},
                   content_type: #{asset.content_type.inspect},
@@ -115,13 +117,13 @@ module Klenod
             RUBY
           end
 
-          def javascript_svg_asset(module_id, asset)
-            code = javascript_svg_module_source(asset)
+          def javascript_svg_asset(module_id, asset, context)
+            code = javascript_svg_module_source(asset, context)
             hash = Hashing.short(code)
             Asset.new(
               module_id.path,
               hash,
-              "/assets/#{asset_name(module_id)}.#{hash}#{module_id.extname}.js",
+              "/#{asset_name(module_id)}.#{hash}#{module_id.extname}.js",
               nil,
               code,
               "application/javascript",
@@ -129,9 +131,9 @@ module Klenod
             )
           end
 
-          def javascript_svg_module_source(asset)
+          def javascript_svg_module_source(asset, context)
             metadata = {
-              src: asset.output_path,
+              src: asset.url,
               width: asset.metadata[:width],
               height: asset.metadata[:height],
               contentType: asset.content_type,
@@ -139,7 +141,7 @@ module Klenod
             }
 
             <<~JAVASCRIPT
-              import { SvgMetadata } from #{AssetJavaScriptMetadata::OUTPUT_PATH.inspect};
+              import { SvgMetadata } from #{context.asset_url(AssetJavaScriptMetadata::OUTPUT_PATH).inspect};
               export default new SvgMetadata(#{AssetJavaScriptMetadata.object_literal(metadata)});
             JAVASCRIPT
           end

data/lib/klenod/build/plugins.rb

@@ -17,7 +17,6 @@ module Klenod
       autoload :TomlPlugin, File.expand_path("plugins/data_plugin", __dir__)
       autoload :TextPlugin, File.expand_path("plugins/data_plugin", __dir__)
       autoload :RouterPlugin, File.expand_path("plugins/router_plugin", __dir__)
-      autoload :TestPlugin, File.expand_path("plugins/test_plugin", __dir__)
     end
   end
 end

data/lib/klenod/build/version.rb

@@ -2,6 +2,6 @@
 
 module Klenod
   module Build
-    VERSION = "0.0.4"
+    VERSION = "0.0.6"
   end
 end

data/lib/klenod/build.rb

@@ -9,8 +9,6 @@ module Klenod
 
   module Build
     autoload :Graphviz, "klenod/build/graphviz"
-    autoload :TestSelection, "klenod/build/test_suite"
-    autoload :TestSuite, "klenod/build/test_suite"
     autoload :UpdateEvent, "klenod/build/watcher"
     autoload :Watcher, "klenod/build/watcher"
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: klenod-build
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
 platform: ruby
 authors:
 - Andrés Alin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.4
+        version: 0.0.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.4
+        version: 0.0.6
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
@@ -41,16 +41,22 @@ dependencies:
   name: async-http
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.95.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.104.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.95.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.104.0
 - !ruby/object:Gem::Dependency
   name: brotli
   requirement: !ruby/object:Gem::Requirement
@@ -272,7 +278,6 @@ files:
 - lib/klenod/build/plugins/router_plugin.rb
 - lib/klenod/build/plugins/ruby_plugin.rb
 - lib/klenod/build/plugins/svg_plugin.rb
-- lib/klenod/build/plugins/test_plugin.rb
 - lib/klenod/build/profiler.rb
 - lib/klenod/build/resolution_error_formatter.rb
 - lib/klenod/build/resolver.rb
@@ -281,7 +286,6 @@ files:
 - lib/klenod/build/source_map/editor.rb
 - lib/klenod/build/source_map/map.rb
 - lib/klenod/build/source_map/vlq.rb
-- lib/klenod/build/test_suite.rb
 - lib/klenod/build/transform_result.rb
 - lib/klenod/build/version.rb
 - lib/klenod/build/watched_pattern.rb
@@ -299,7 +303,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 4.0.6
+      version: '4.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/klenod/build/plugins/test_plugin.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../errors"
-require_relative "../module_id"
-require_relative "../plugin"
-
-module Klenod
-  module Build
-    module Plugins
-      module TestPlugin
-        def self.new(...)
-          Plugin.new(...)
-        end
-
-        class Plugin < Klenod::Build::Plugin
-          DEFAULT_PATTERN = "**/*.test.rb"
-
-          def initialize(pattern: DEFAULT_PATTERN)
-            @pattern = pattern.to_s
-          end
-
-          attr_reader :pattern
-
-          def discover(source_dir:)
-            root = Pathname.new(source_dir).expand_path
-
-            root
-              .glob(pattern)
-              .select(&:file?)
-              .map { |path| ModuleId.new(path.relative_path_from(root).to_s.tr("\\", "/"), nil) }
-              .sort_by(&:to_s)
-          end
-
-          def test_module_id?(module_id)
-            module_id.scheme == :app && File.fnmatch?(pattern, module_id.relative_path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
-          end
-
-          def finalize(module_id, result, resolved_dependencies, _dependency_records, _context)
-            imported_test = resolved_dependencies.find { |dependency| test_module_id?(dependency.module_id) }
-            return result unless imported_test
-
-            error = TestImportError.new("Test file #{imported_test.module_id.path.inspect} cannot be imported")
-            raise error.with_resolution_context(dependency: imported_test.dependency, importer_id: module_id)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/klenod/build/test_suite.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module Klenod
-  module Build
-    TestSelection = Data.define(:test_paths, :removed_test_paths) do
-      def empty?
-        test_paths.empty? && removed_test_paths.empty?
-      end
-    end
-
-    class TestSuite
-      def initialize(context:, plugin:)
-        @context = context
-        @plugin = plugin
-        @dependency_ids = {}
-        @failed_test_ids = Set.new
-      end
-
-      def collect
-        test_ids = discover
-        test_ids.each { |test_id| index(test_id) }
-        selection(test_ids)
-      end
-
-      def update(event)
-        previous_test_ids = @dependency_ids.keys.to_set
-        current_test_ids = discover.to_set
-        removed_test_ids = previous_test_ids - current_test_ids
-        added_test_ids = current_test_ids - previous_test_ids
-        affected_module_ids = update_module_ids(event)
-        affected_test_ids =
-          @dependency_ids.filter_map do |test_id, dependency_ids|
-            test_id if current_test_ids.include?(test_id) && dependency_ids.intersect?(affected_module_ids)
-          end
-
-        test_ids = (added_test_ids + affected_test_ids + @failed_test_ids).select { |test_id| current_test_ids.include?(test_id) }
-        removed_test_ids.each { |test_id| remove(test_id) }
-        test_ids.each { |test_id| index(test_id) }
-
-        selection(test_ids, removed_test_ids)
-      end
-
-      private
-
-      attr_reader :context, :plugin
-
-      def discover
-        plugin.discover(source_dir: context.graph.source_dir)
-      end
-
-      def index(test_id)
-        dependency_ids = Set[test_id]
-        @dependency_ids[test_id] = dependency_ids
-        collect_dependencies(test_id, dependency_ids)
-        @failed_test_ids.delete(test_id)
-      rescue
-        @failed_test_ids << test_id
-      end
-
-      def collect_dependencies(module_id, dependency_ids)
-        record = context.graph.records[module_id] || context.graph.collect_module(module_id)
-
-        record.resolved_dependencies.each do |dependency|
-          dependency_id = dependency.module_id
-          next unless dependency_ids.add?(dependency_id)
-
-          collect_dependencies(dependency_id, dependency_ids)
-        end
-      end
-
-      def remove(test_id)
-        @dependency_ids.delete(test_id)
-        @failed_test_ids.delete(test_id)
-      end
-
-      def update_module_ids(event)
-        result = event.result
-        Set.new(
-          result.changed_module_ids +
-            result.removed_module_ids +
-            result.reloaded_module_ids +
-            result.reevaluated_module_ids
-        )
-      end
-
-      def selection(test_ids, removed_test_ids = [])
-        TestSelection.new(
-          test_ids.map(&:relative_path).sort.freeze,
-          removed_test_ids.map(&:relative_path).sort.freeze
-        )
-      end
-    end
-  end
-end