klenod-build 0.0.1

data/lib/klenod/build/graphviz.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "klenod/runtime"
+
+module Klenod
+  module Build
+    class Graphviz
+      MODULE_STYLES = {
+        ".rb" => {fillcolor: "#d7ecff", color: "#3a77b5"},
+        ".haml" => {fillcolor: "#f4dcff", color: "#9b52b8"},
+        ".css" => {fillcolor: "#dcfce7", color: "#31a46a"},
+        ".json" => {fillcolor: "#fff3bf", color: "#c28f00"},
+        ".toml" => {fillcolor: "#fff3bf", color: "#c28f00"},
+        ".yaml" => {fillcolor: "#fff3bf", color: "#c28f00"},
+        ".yml" => {fillcolor: "#fff3bf", color: "#c28f00"}
+      }.freeze
+
+      VIRTUAL_STYLE = {fillcolor: "#eceff4", color: "#667085"}.freeze
+      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
+      end
+
+      def initialize(bundle, include_assets: true)
+        @bundle = bundle
+        @include_assets = include_assets
+      end
+
+      def to_dot
+        lines = [
+          "digraph klenod {",
+          "  graph [rankdir=LR, bgcolor=\"transparent\", pad=\"0.4\", nodesep=\"0.45\", ranksep=\"0.8\"];",
+          "  node [shape=box, style=\"rounded,filled\", fontname=\"Menlo\", fontsize=10, margin=\"0.08,0.05\"];",
+          "  edge [fontname=\"Menlo\", fontsize=9, color=\"#667085\", arrowsize=0.7];"
+        ]
+
+        module_ids.each { |id| lines << module_node(id) }
+        lines.concat(asset_nodes) if @include_assets
+        lines.concat(import_edges)
+        lines.concat(asset_edges) if @include_assets
+        lines << "}"
+        "#{lines.join("\n")}\n"
+      end
+
+      private
+
+      def module_ids
+        @bundle.modules.keys.sort
+      end
+
+      def module_node(id)
+        spec = @bundle.modules.fetch(id)
+        style = module_style(id)
+        attributes = {
+          label: module_label(spec),
+          id: svg_node_id(id),
+          class: module_classes(id),
+          fillcolor: style.fetch(:fillcolor),
+          color: style.fetch(:color),
+          penwidth: entrypoint?(id) ? "2.2" : "1.2"
+        }
+
+        "  #{node_id(id)} [#{dot_attributes(attributes)}];"
+      end
+
+      def asset_nodes
+        @bundle.assets.values.sort_by(&:output_path).map do |asset|
+          "  #{asset_node_id(asset)} [#{dot_attributes(asset_attributes(asset))}];"
+        end
+      end
+
+      def import_edges
+        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)
+
+            attributes = {
+              id: svg_edge_id(id, import.target_id),
+              class: edge_classes(import),
+              color: import.eager ? "#475467" : "#7a5af8",
+              style: import.eager ? "solid" : "dashed"
+            }
+            attributes[:label] = "lazy" unless import.eager
+
+            "  #{node_id(id)} -> #{node_id(import.target_id)} [#{dot_attributes(attributes)}];"
+          end
+        end.compact
+      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)}];"
+        end
+      end
+
+      def asset_owner(asset)
+        return [:module, asset.logical_name] if @bundle.modules.key?(asset.logical_name)
+
+        google_fonts_css_asset_owner(asset) || query_module_id_for(asset.logical_name)
+      end
+
+      def google_fonts_css_asset_owner(asset)
+        return nil unless asset.metadata[:google_fonts] && asset.metadata[:type] == :font
+
+        css_asset = @bundle.assets.values.find do |candidate|
+          candidate.metadata[:google_fonts] &&
+            candidate.metadata[:type] == :css &&
+            Array(candidate.metadata[:font_source_urls]).include?(google_fonts_source_url(asset))
+        end
+        [:asset, css_asset] if css_asset
+      end
+
+      def google_fonts_source_url(asset)
+        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
+      end
+
+      def query_module_ids_by_path
+        @query_module_ids_by_path ||=
+          module_ids.each_with_object({}) do |id, index|
+            path, query = id.split("?", 2)
+            next unless query
+
+            index[path] ||= id
+          end
+      end
+
+      def owner_node_id(owner)
+        type, value = owner
+        case type
+        when :module then node_id(value)
+        when :asset then asset_node_id(value)
+        else raise ArgumentError, "unknown graph owner: #{owner.inspect}"
+        end
+      end
+
+      def owner_node_name(owner)
+        type, value = owner
+        case type
+        when :module then value
+        when :asset then value.output_path
+        else raise ArgumentError, "unknown graph owner: #{owner.inspect}"
+        end
+      end
+
+      def import_spec(import)
+        case import
+        when Runtime::ImportSpec
+          import
+        else
+          Runtime::ImportSpec.new(import.to_s, nil, true)
+        end
+      end
+
+      def module_label(spec)
+        label = display_path(spec.source_path || spec.id)
+        type = module_type(spec.id)
+        entrypoint?(spec.id) ? "#{label}\n#{type} entrypoint" : "#{label}\n#{type}"
+      end
+
+      def asset_attributes(asset)
+        ASSET_STYLE.merge(
+          label: "#{display_path(asset.output_path)}\n#{asset.content_type || "asset"}",
+          id: svg_node_id(asset.output_path),
+          class: asset_classes(asset),
+          shape: "note"
+        )
+      end
+
+      def module_style(id)
+        return VIRTUAL_STYLE if id.start_with?("virtual:")
+
+        MODULE_STYLES.fetch(File.extname(id), DEFAULT_MODULE_STYLE)
+      end
+
+      def module_type(id)
+        return "virtual" if id.start_with?("virtual:")
+
+        ext = File.extname(id)
+        ext.empty? ? "module" : ext.delete_prefix(".")
+      end
+
+      def module_classes(id)
+        [
+          "node",
+          "node-module",
+          "module-#{css_identifier(module_type(id))}",
+          ("entrypoint" if entrypoint?(id))
+        ].compact.join(" ")
+      end
+
+      def asset_classes(asset)
+        [
+          "node",
+          "node-asset",
+          "asset-#{css_identifier(asset.metadata[:type] || "asset")}"
+        ].join(" ")
+      end
+
+      def edge_classes(import)
+        ["edge", import.eager ? "edge-import" : "edge-import edge-lazy"].join(" ")
+      end
+
+      def entrypoint?(id)
+        entrypoint_ids.include?(id)
+      end
+
+      def entrypoint_ids
+        @entrypoint_ids ||=
+          if @bundle.entrypoints.respond_to?(:values)
+            @bundle.entrypoints.values
+          else
+            @bundle.entrypoints
+          end
+      end
+
+      def display_path(path)
+        path = path.to_s
+        return path unless @bundle.source_root
+
+        root = File.expand_path(@bundle.source_root)
+        expanded = File.expand_path(path)
+        return expanded.delete_prefix("#{root}/") if expanded.start_with?("#{root}/")
+
+        path
+      end
+
+      def node_id(id)
+        "mod_#{dot_identifier(id)}"
+      end
+
+      def asset_node_id(asset)
+        "asset_#{dot_identifier(asset.output_path)}"
+      end
+
+      def svg_node_id(id)
+        "node-#{dot_identifier(id)}"
+      end
+
+      def svg_edge_id(from, to)
+        "edge-#{dot_identifier(from)}-#{dot_identifier(to)}"
+      end
+
+      def css_identifier(value)
+        value.to_s.gsub(/[^A-Za-z0-9_-]+/, "-").gsub(/\A-+|-+\z/, "")
+      end
+
+      def dot_identifier(value)
+        value.to_s.bytes.map { |byte| byte.to_s(16).rjust(2, "0") }.join
+      end
+
+      def dot_attributes(attributes)
+        attributes.map { |key, value| "#{key}=#{dot_value(value)}" }.join(", ")
+      end
+
+      def dot_value(value)
+        %("#{dot_escape(value)}")
+      end
+
+      def dot_escape(value)
+        value.to_s.gsub(/[\\"]/) { |char| "\\#{char}" }.gsub("\n", "\\n")
+      end
+    end
+  end
+end

data/lib/klenod/build/hashing.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Klenod
+  module Build
+    module Hashing
+      def self.hexdigest(value)
+        Digest::SHA256.hexdigest(value)
+      end
+
+      def self.file_hexdigest(path)
+        Digest::SHA256.file(path.to_s).hexdigest
+      end
+
+      def self.short(value, length: 16)
+        hexdigest(value)[0, length]
+      end
+    end
+  end
+end

data/lib/klenod/build/invalidation_result.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Build
+    AssetUpdate = Data.define(:output_path, :previous_asset, :current_asset) do
+      def added?
+        previous_asset.nil? && !current_asset.nil?
+      end
+
+      def changed?
+        !previous_asset.nil? && !current_asset.nil?
+      end
+
+      def removed?
+        !previous_asset.nil? && current_asset.nil?
+      end
+    end
+
+    AssetChanges = Data.define(:added, :changed, :removed) do
+      def empty?
+        added.empty? && changed.empty? && removed.empty?
+      end
+
+      def paths
+        (added + changed + removed).uniq
+      end
+    end
+
+    InvalidationResult =
+      Data.define(
+        :changed_module_ids,
+        :removed_module_ids,
+        :reloaded_module_ids,
+        :reevaluated_module_ids,
+        :added_assets,
+        :changed_assets,
+        :removed_assets,
+        :asset_updates,
+        :errors
+      ) do
+        def asset_changes
+          AssetChanges.new(added_assets, changed_assets, removed_assets)
+        end
+
+        def empty?
+          changed_module_ids.empty? &&
+            removed_module_ids.empty? &&
+            reloaded_module_ids.empty? &&
+            reevaluated_module_ids.empty? &&
+            asset_changes.empty? &&
+            errors.empty?
+        end
+      end
+  end
+end

data/lib/klenod/build/load_result.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Build
+    LoadResult = Data.define(:source, :source_hash, :transform)
+  end
+end

data/lib/klenod/build/loaded_module.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Build
+    class LoadedModule
+      attr_reader :context, :id
+
+      def initialize(context, id)
+        @context = context
+        @id = id
+      end
+
+      def record
+        context.graph.records.fetch(id)
+      end
+
+      def exports
+        context.exports(id)
+      end
+
+      def evaluated?
+        context.evaluated?(id)
+      end
+
+      def call(...)
+        exports.call(...)
+      end
+
+      def assets(type: nil, content_type: nil, recursive: true)
+        context.assets_for_module(id, type: type, content_type: content_type, recursive: recursive)
+      end
+
+      def to_s
+        id.to_s
+      end
+    end
+  end
+end

data/lib/klenod/build/module_id.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "protocol/url"
+
+module Klenod
+  module Build
+    class ModuleId
+      SCHEME_PATTERN = /\A[A-Za-z][A-Za-z0-9+.-]*:/
+
+      def self.parse(value)
+        new(value)
+      end
+
+      def initialize(value, query = nil)
+        @url = absolute_url_for(value.to_s)
+        @url = @url.with(query: query) if query
+
+        @scheme = @url.scheme.to_sym
+        @host = @url.authority
+        @uri_path = absolute_uri_path(@url.path)
+        @query = @url.query
+      end
+
+      attr_reader :scheme, :host, :uri_path, :query
+
+      def merge(specifier)
+        specifier = specifier.to_s
+        return self.class.parse(specifier) if explicit_scheme?(specifier)
+
+        self.class.parse((@url + Protocol::URL[specifier]).to_s)
+      end
+
+      def to_s
+        @url.to_s
+      end
+
+      def path
+        case scheme
+        when :app
+          relative_path
+        when :virtual
+          "virtual:#{relative_path}"
+        else
+          host ? "#{scheme}://#{host}#{uri_path}" : "#{scheme}:#{relative_path}"
+        end
+      end
+
+      def relative_path
+        uri_path.delete_prefix("/")
+      end
+      alias_method :bare_path, :relative_path
+
+      def dirname
+        File.dirname(relative_path)
+      end
+
+      def extname
+        File.extname(uri_path)
+      end
+
+      def eql?(other)
+        other.is_a?(self.class) && to_s == other.to_s
+      end
+      alias_method :==, :eql?
+
+      def hash
+        to_s.hash
+      end
+
+      private
+
+      def absolute_url_for(value)
+        parsed = Protocol::URL[value]
+        return absolute_url(parsed) if parsed.respond_to?(:scheme) && parsed.scheme
+
+        Protocol::URL::Absolute.new("app", nil, absolute_uri_path(parsed.path), parsed.query, parsed.fragment)
+      end
+
+      def absolute_url(parsed)
+        Protocol::URL::Absolute.new(
+          parsed.scheme,
+          parsed.authority,
+          absolute_uri_path(parsed.path),
+          parsed.query,
+          parsed.fragment
+        )
+      end
+
+      def absolute_uri_path(path)
+        path = path.to_s
+        path = "/#{path}" unless path.start_with?("/")
+        path
+      end
+
+      def explicit_scheme?(value)
+        value.match?(SCHEME_PATTERN)
+      end
+    end
+  end
+end

data/lib/klenod/build/module_record.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Build
+    ModuleRecord =
+      Data.define(
+        :id,
+        :source_hash,
+        :transformed_hash,
+        :dependencies,
+        :resolved_dependencies,
+        :source,
+        :transformed_source,
+        :source_map,
+        :assets,
+        :watched_patterns,
+        :metadata,
+        :version,
+        :status
+      )
+  end
+end

data/lib/klenod/build/plugin.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Build
+    class Plugin
+      def resolve(_dependency, _context)
+        nil
+      end
+
+      def load(_module_id, _context)
+        nil
+      end
+
+      def transform(_module_id, code, _context)
+        TransformResult.identity(code)
+      end
+
+      def finalize(_module_id, result, _resolved_dependencies, _dependency_records, _context)
+        result
+      end
+
+      def import_value(_resolved_dependency, _record, _context)
+        nil
+      end
+
+      def runtime_import_value(_resolved_dependency, _record, _context)
+        nil
+      end
+
+      def invalidate_module_ids(_paths, _context)
+        []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "../dependency"
+require_relative "../load_result"
+require_relative "../module_id"
+require_relative "../transform_result"
+
+module Klenod
+  module Build
+    module Plugins
+      module ClassNamesRuntime
+        CLASS_NAMES_SPECIFIER = "virtual:klenod/class_names"
+        CLASS_NAMES_MODULE_ID = ModuleId.new("virtual:klenod/class_names.rb", nil)
+
+        def resolve_class_names_runtime(dependency)
+          return nil unless dependency.specifier == CLASS_NAMES_SPECIFIER
+
+          ResolvedDependency.new(dependency, CLASS_NAMES_MODULE_ID, {virtual: true})
+        end
+
+        def load_class_names_runtime(module_id)
+          return nil unless module_id.scheme == :virtual && module_id == CLASS_NAMES_MODULE_ID
+
+          source = class_names_runtime_source
+          LoadResult.new(source, nil, TransformResult.new(source, [], nil, [], [], {}))
+        end
+
+        def class_names_runtime_dependency(module_id)
+          Dependency
+            .create(
+              specifier: CLASS_NAMES_SPECIFIER,
+              importer_id: module_id,
+              kind: :class_names_runtime
+            )
+            .with(id: CLASS_NAMES_SPECIFIER)
+        end
+
+        def class_names_runtime_import_value(resolved_dependency, record, context)
+          return nil unless resolved_dependency.dependency.kind == :class_names_runtime
+
+          context.mods.fetch(record.id).const_get(:Exports)::Default
+        end
+
+        def class_names_runtime_runtime_import_value(resolved_dependency, _record)
+          return nil unless resolved_dependency.dependency.kind == :class_names_runtime
+
+          Runtime::DefaultImport.new(:Default)
+        end
+
+        def class_names_runtime_source
+          <<~RUBY
+            # frozen_string_literal: true
+
+            class ClassNames
+              def self.merge(*sources)
+                classes = sources.each_with_object({}) do |source, result|
+                  source.each_pair do |name, class_name|
+                    result[name] = [result[name], class_name].compact.join(" ")
+                  end
+                end
+
+                new(classes.freeze)
+              end
+
+              def initialize(classes)
+                @classes = classes
+              end
+
+              def [](first = nil, *rest)
+                return @classes[first] if rest.empty? && first.is_a?(Symbol)
+
+                class_name(first, *rest)
+              end
+
+              def fetch(...)
+                @classes.fetch(...)
+              end
+
+              def key?(...)
+                @classes.key?(...)
+              end
+
+              def keys
+                @classes.keys
+              end
+
+              def each_pair(...)
+                @classes.each_pair(...)
+              end
+
+              def class_name(*values)
+                classes = []
+                values.each { |value| collect_class_names(classes, value) }
+                return nil if classes.empty?
+
+                classes.join(" ")
+              end
+
+              private
+
+              def collect_class_names(classes, value)
+                case value
+                when nil, false
+                  nil
+                when Symbol
+                  collect_class_names(classes, @classes[value])
+                when String
+                  value.split.each { |class_name| classes << class_name }
+                when Array
+                  value.each { |item| collect_class_names(classes, item) }
+                when Hash
+                  value.each { |class_name, enabled| collect_class_names(classes, class_name) if enabled }
+                else
+                  value.to_s.split.each { |class_name| classes << class_name }
+                end
+              end
+            end
+
+            Default = ClassNames
+          RUBY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Build
+    module Plugins
+      module ComponentDefaults
+        DEFAULT_COMPONENT_BASE_CLASS = "Object"
+        DEFAULT_FACTORY = "Object"
+      end
+    end
+  end
+end