klenod-build 0.0.1

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../plugin"
+require_relative "../ruby_import_rewriter"
+require_relative "../transform_result"
+
+module Klenod
+  module Build
+    module Plugins
+      module RubyPlugin
+        def self.new(...)
+          Plugin.new(...)
+        end
+
+        class Plugin < Klenod::Build::Plugin
+          def transform(module_id, code, context)
+            return TransformResult.identity(code) unless module_id.extname == ".rb"
+
+            result =
+              RubyImportRewriter
+                .new(
+                  module_id: module_id,
+                  kind: :ruby_import,
+                  source_dir: context.source_dir,
+                  profiler: context.profiler
+                )
+                .rewrite(code)
+            TransformResult.new(result.code, result.dependencies, nil, [], result.watched_patterns, {})
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "../asset"
+require_relative "../dependency"
+require_relative "../errors"
+require_relative "../hashing"
+require_relative "../module_id"
+require_relative "../plugin"
+require_relative "../transform_result"
+
+module Klenod
+  module Build
+    module Plugins
+      module SvgPlugin
+        def self.new(...)
+          Plugin.new(...)
+        end
+
+        class Plugin < Klenod::Build::Plugin
+          EXTENSIONS = [".svg"].freeze
+          SVG_RUNTIME_SPECIFIER = "virtual:klenod/svg"
+          SVG_RUNTIME_MODULE_ID = ModuleId.new("#{SVG_RUNTIME_SPECIFIER}.rb", nil)
+
+          def resolve(dependency, _context)
+            return nil unless dependency.specifier == SVG_RUNTIME_SPECIFIER
+
+            ResolvedDependency.new(dependency, SVG_RUNTIME_MODULE_ID, {virtual: true})
+          end
+
+          def load(module_id, _context)
+            return nil unless module_id.scheme == :virtual && module_id == SVG_RUNTIME_MODULE_ID
+
+            svg_runtime_source
+          end
+
+          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"
+            asset =
+              Asset.new(
+                module_id.path,
+                hash,
+                output_path,
+                nil,
+                code,
+                "image/svg+xml",
+                {
+                  type: :svg,
+                  width: dimensions.width,
+                  height: dimensions.height
+                }
+              )
+            javascript_asset = javascript_svg_asset(module_id, asset)
+            svg_runtime_dependency =
+              Dependency
+                .create(
+                  specifier: SVG_RUNTIME_SPECIFIER,
+                  importer_id: module_id,
+                  kind: :svg_runtime
+                )
+                .with(id: "#{module_id}:svg_runtime")
+
+            TransformResult.new(
+              svg_module_source(asset, svg_runtime_dependency),
+              [svg_runtime_dependency],
+              nil,
+              [asset, javascript_asset],
+              [],
+              {asset_bytes: code, svg_javascript_asset_path: javascript_asset.output_path}
+            )
+          end
+
+          def import_value(_resolved_dependency, record, context)
+            return nil unless EXTENSIONS.include?(record.id.extname)
+
+            context.mods.fetch(record.id).const_get(:Exports)::Default
+          end
+
+          def runtime_import_value(_resolved_dependency, record, _context)
+            return Runtime::DefaultImport.new(:Default) if EXTENSIONS.include?(record.id.extname)
+
+            super
+          end
+
+          private
+
+          Dimensions = Data.define(:width, :height)
+
+          def svg_runtime_source
+            <<~RUBY
+              Svg = Data.define(:src, :width, :height, :content_type)
+            RUBY
+          end
+
+          def svg_module_source(asset, svg_runtime_dependency)
+            <<~RUBY
+              SvgRuntime = __klenod_import__(#{svg_runtime_dependency.id.inspect})
+              Default =
+                SvgRuntime::Svg.new(
+                  src: #{asset.output_path.inspect},
+                  width: #{asset.metadata[:width].inspect},
+                  height: #{asset.metadata[:height].inspect},
+                  content_type: #{asset.content_type.inspect}
+                )
+
+            RUBY
+          end
+
+          def javascript_svg_asset(module_id, asset)
+            code = javascript_svg_module_source(asset)
+            hash = Hashing.short(code)
+            Asset.new(
+              module_id.path,
+              hash,
+              "#{asset.output_path}.js",
+              nil,
+              code,
+              "application/javascript",
+              {type: :svg_javascript_metadata, svg_metadata: true, svg_asset_path: asset.output_path}
+            )
+          end
+
+          def javascript_svg_module_source(asset)
+            metadata = {
+              src: asset.output_path,
+              width: asset.metadata[:width],
+              height: asset.metadata[:height],
+              contentType: asset.content_type
+            }
+
+            "export default #{JSON.generate(metadata)};\n"
+          end
+
+          def svg_dimensions(code)
+            attributes = svg_attributes(code)
+            return Dimensions.new(nil, nil) unless attributes
+
+            explicit_width = parse_length(attributes["width"])
+            explicit_height = parse_length(attributes["height"])
+            return Dimensions.new(explicit_width, explicit_height) if explicit_width && explicit_height
+
+            view_box_dimensions(attributes["viewBox"] || attributes["viewbox"])
+          end
+
+          def svg_attributes(code)
+            match = code.match(/<svg(?=[\s>])(?<attributes>[^>]*)>/im)
+            return nil unless match
+
+            match[:attributes].scan(/([:\w.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/).to_h do |name, double_quoted, single_quoted, unquoted|
+              [name, double_quoted || single_quoted || unquoted]
+            end
+          end
+
+          def view_box_dimensions(view_box)
+            values = view_box.to_s.split(/[,\s]+/).filter_map { |value| parse_number(value) }
+            return Dimensions.new(nil, nil) unless values.length == 4
+
+            width = positive_number(values.fetch(2))
+            height = positive_number(values.fetch(3))
+            Dimensions.new(width, height)
+          end
+
+          def parse_length(value)
+            match = value.to_s.strip.match(/\A(?<number>[+-]?(?:\d+(?:\.\d+)?|\.\d+))(?:px)?\z/i)
+            return nil unless match
+
+            positive_number(parse_number(match[:number]))
+          end
+
+          def parse_number(value)
+            number = Float(value, exception: false)
+            return nil unless number&.finite?
+
+            number
+          end
+
+          def positive_number(number)
+            return nil unless number&.positive?
+
+            (number == number.to_i) ? number.to_i : number
+          end
+
+          def asset_name(module_id)
+            File.basename(module_id.path, module_id.extname).gsub(/[^A-Za-z0-9]+/, "_")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/klenod/build/plugins.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Build
+    module Plugins
+      autoload :RubyPlugin, File.expand_path("plugins/ruby_plugin", __dir__)
+      autoload :IntlPlugin, File.expand_path("plugins/intl_plugin", __dir__)
+      autoload :HamlPlugin, File.expand_path("plugins/haml_plugin", __dir__)
+      autoload :MarkdownPlugin, File.expand_path("plugins/markdown_plugin", __dir__)
+      autoload :GemImportPlugin, File.expand_path("plugins/gem_import_plugin", __dir__)
+      autoload :GoogleFontsPlugin, File.expand_path("plugins/google_fonts_plugin", __dir__)
+      autoload :SvgPlugin, File.expand_path("plugins/svg_plugin", __dir__)
+      autoload :ImagePlugin, File.expand_path("plugins/image_plugin", __dir__)
+      autoload :DataPlugin, File.expand_path("plugins/data_plugin", __dir__)
+      autoload :JsonPlugin, File.expand_path("plugins/data_plugin", __dir__)
+      autoload :YamlPlugin, File.expand_path("plugins/data_plugin", __dir__)
+      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__)
+    end
+  end
+end

data/lib/klenod/build/profiler.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Build
+    class Profiler
+      Event = Data.define(:name, :duration, :metadata)
+
+      def initialize(enabled: false, store_events: true, categories: [], progress: nil)
+        @enabled = enabled
+        @events = store_events ? [] : nil
+        @totals = Hash.new(0.0)
+        @totals_by_plugin = Hash.new(0.0)
+        @counts = Hash.new(0)
+        @categories = categories.map(&:to_sym).to_h { |category| [category, true] }
+        @progress = progress
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def events
+        @events || []
+      end
+
+      def measure(name, metadata = nil)
+        return yield unless enabled?
+
+        started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = yield
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+        record(name, duration, metadata || {})
+        result
+      rescue
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at if started_at
+        record(name, duration, (metadata || {}).merge(error: true)) if duration
+        raise
+      end
+
+      def category?(name)
+        @categories.key?(name.to_sym)
+      end
+
+      def count(name, value = 1)
+        return unless enabled?
+
+        @counts[name] += value
+      end
+
+      def progress(name, metadata = {})
+        return unless enabled? && @progress
+
+        @progress.call(name, metadata)
+      end
+
+      def totals
+        @totals.dup
+      end
+
+      def totals_by_plugin
+        @totals_by_plugin.dup
+      end
+
+      def counts
+        @counts.dup
+      end
+
+      private
+
+      def record(name, duration, metadata)
+        @events << Event.new(name, duration, metadata) if @events
+        @totals[name] += duration
+
+        plugin = metadata[:plugin]
+        @totals_by_plugin[[name, plugin]] += duration if plugin
+      end
+    end
+  end
+end

data/lib/klenod/build/resolution_error_formatter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Klenod
+  module Build
+    module ResolutionErrorFormatter
+      ANSI_BACKGROUND = "\e[0;48;5;52m"
+
+      module_function
+
+      def format(error, source_root: nil, source_context: nil, ansi: false)
+        return error.message unless error.resolution_failure?
+
+        lines = [error.title, "", "  Import:      #{error.requested_specifier}"]
+        lines << "  Imported by: #{error.imported_by}" if error.imported_by
+        lines << "  Source root: #{source_root}" if source_root
+        append_suggestions(lines, error)
+        lines.concat(["", source_context]) if source_context
+        text = lines.join("\n")
+        ansi ? format_ansi(text) : text
+      end
+
+      def format_ansi(text)
+        title, separator, body = text.partition("\n")
+        body = body.gsub("\e[0m", ANSI_BACKGROUND)
+        body = "\n#{body}" unless separator.empty?
+
+        "\e[1;31;47m ERROR \e[1;37;41m #{title} #{ANSI_BACKGROUND}#{body}\e[0m"
+      end
+      private_class_method :format_ansi
+
+      def append_suggestions(lines, error)
+        return if error.suggestions.empty?
+
+        lines.concat(["", (error.reason == :incorrect_case) ? "  Use:" : "  Did you mean?"])
+        error.suggestions.each { |suggestion| lines << "    - #{suggestion}" }
+      end
+      private_class_method :append_suggestions
+    end
+  end
+end

data/lib/klenod/build/resolver.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "filesystem_resolver"
+require_relative "module_id"
+require_relative "dependency"
+
+module Klenod
+  module Build
+    class Resolver
+      DEFAULT_EXTENSIONS = [".rb", ".haml"].freeze
+
+      def initialize(source_dir:, extensions: DEFAULT_EXTENSIONS, profiler: nil)
+        @source_dir_path = File.expand_path(source_dir)
+        @source_dir = Pathname.new(@source_dir_path)
+        @extensions = extensions
+        @profiler = profiler
+        @filesystem_resolver = FilesystemResolver.new(root: @source_dir, extensions: @extensions)
+        @resolved_module_ids = {}
+        @absolute_paths = {}
+      end
+
+      attr_reader :source_dir
+
+      def resolve(dependency)
+        module_id = resolve_app_module_id(dependency)
+        raise ResolveError, "Unknown import scheme #{module_id.scheme.inspect} for #{dependency.specifier.inspect}" unless module_id.scheme == :app
+
+        base_path = File.expand_path(module_id.relative_path, @source_dir_path)
+        assert_inside_source_dir!(base_path)
+        key = [base_path, module_id.query]
+        resolved_module_id = @resolved_module_ids[key]
+        if resolved_module_id
+          @profiler&.count(:resolver_cache_hit)
+        else
+          @profiler&.count(:resolver_cache_miss)
+          resolved_path = @filesystem_resolver.resolve(module_id.relative_path)
+          relative = relative_source_path(resolved_path)
+          resolved_module_id = @resolved_module_ids[key] = ModuleId.new("app:/#{relative}", module_id.query)
+        end
+
+        ResolvedDependency.new(dependency, resolved_module_id, {})
+      rescue ResolveError => error
+        raise error.with_path_prefix("app:/").with_resolution_context(dependency: dependency, importer_id: dependency.importer_id)
+      end
+
+      def absolute_path(module_id)
+        path = @absolute_paths[module_id.to_s]
+        if path
+          @profiler&.count(:resolver_absolute_path_cache_hit)
+          return path
+        end
+
+        @profiler&.count(:resolver_absolute_path_cache_miss)
+        @absolute_paths.fetch(module_id.to_s) do |path_key|
+          raise ResolveError, "Cannot map non-app module to source_dir: #{module_id}" unless module_id.scheme == :app
+
+          path = Pathname.new(File.expand_path(module_id.relative_path, @source_dir_path))
+          assert_inside_source_dir!(path)
+          @absolute_paths[path_key] = path
+        end
+      end
+
+      def clear_cache
+        @resolved_module_ids.clear
+        @absolute_paths.clear
+      end
+
+      private
+
+      def resolve_app_module_id(dependency)
+        specifier = dependency.specifier.to_s
+        return ModuleId.parse(specifier) if specifier.match?(ModuleId::SCHEME_PATTERN)
+
+        importer_id = dependency.importer_id
+        if importer_id
+          importer_id.merge(specifier)
+        else
+          ModuleId.new("app:/#{specifier.delete_prefix("/")}")
+        end
+      end
+
+      def assert_inside_source_dir!(path)
+        expanded = File.expand_path(path.to_s)
+        return if expanded == @source_dir_path || expanded.start_with?("#{@source_dir_path}/")
+
+        raise ResolveError, "Resolved path escapes source_dir: #{path}"
+      end
+
+      def relative_source_path(path)
+        Pathname.new(path).relative_path_from(@source_dir).to_s
+      end
+    end
+  end
+end