klenod-build 0.0.13 → 0.0.15

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

@@ -6,6 +6,7 @@ require_relative "../errors"
 require_relative "../hashing"
 require_relative "../module_id"
 require_relative "../plugin"
+require_relative "../source_error"
 require_relative "../transform_result"
 require_relative "asset_javascript_metadata"
 
@@ -17,6 +18,23 @@ module Klenod
           Plugin.new(...)
         end
 
+        # SVG markup is scraped with a regex rather than parsed, so malformed
+        # markup is tolerated. A file that is not text at all is not.
+        class EncodingError < Klenod::Build::SourceError
+          def kind
+            "SVG encoding error"
+          end
+
+          private
+
+          def location(error)
+            Location.new(
+              detail: error.message,
+              hints: ["An SVG file must be valid UTF-8 text."]
+            )
+          end
+        end
+
         class Plugin < Klenod::Build::Plugin
           EXTENSIONS = [".svg"].freeze
           SVG_RUNTIME_SPECIFIER = "virtual:klenod/svg"
@@ -39,7 +57,7 @@ module Klenod
 
             raise UnsupportedFileError, "SVG imports do not support query options: #{module_id}" if module_id.query
 
-            dimensions = svg_dimensions(code)
+            dimensions = svg_dimensions(code, module_id)
             hash = Hashing.short(code)
             output_path = "/#{asset_name(module_id)}.#{hash}.svg"
             asset =
@@ -146,8 +164,8 @@ module Klenod
             JAVASCRIPT
           end
 
-          def svg_dimensions(code)
-            attributes = svg_attributes(code)
+          def svg_dimensions(code, module_id)
+            attributes = svg_attributes(code, module_id)
             return Dimensions.new(nil, nil) unless attributes
 
             explicit_width = parse_length(attributes["width"])
@@ -157,13 +175,18 @@ module Klenod
             view_box_dimensions(attributes["viewBox"] || attributes["viewbox"])
           end
 
-          def svg_attributes(code)
+          # Malformed markup is tolerated: no <svg> match just means unknown
+          # dimensions. Only a file that is not text at all fails here, and
+          # String#match raises without saying which file it was reading.
+          def svg_attributes(code, module_id)
             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
+          rescue ArgumentError => error
+            raise EncodingError.new(error, source: "", module_id: module_id)
           end
 
           def view_box_dimensions(view_box)

data/lib/klenod/build/resolver.rb

@@ -64,6 +64,7 @@ module Klenod
       def clear_cache
         @resolved_module_ids.clear
         @absolute_paths.clear
+        @filesystem_resolver.clear_cache
       end
 
       private

data/lib/klenod/build/ruby_import_rewriter.rb

@@ -39,6 +39,18 @@ module Klenod
       IMPORT_SOURCE_PATTERN = /(?<![A-Za-z0-9_])(?:import|lazy_import|import_glob)\s*(?:\(|["'])/
       FAST_LITERAL_IMPORT_PATTERN = /(?<![A-Za-z0-9_])(import|lazy_import)\s*\(\s*("(?:\\.|[^"\\#])*")\s*\)/
 
+      # Ruby that does not parse, reported at its line in the enclosing
+      # source. Haml wraps it into its own parse error with a source excerpt.
+      class ParseError < Klenod::Build::Error
+        attr_reader :line, :column
+
+        def initialize(message, line:, column:)
+          @line = line
+          @column = column
+          super(message)
+        end
+      end
+
       def initialize(module_id:, kind:, source_dir: nil, profiler: nil, dependency_id_offset: 0, source_line_offset: 0, source_column_offset: 0)
         @module_id = module_id
         @kind = kind
@@ -54,7 +66,12 @@ module Klenod
         fast_result = rewrite_literal_import_calls(code)
         return fast_result if fast_result
 
-        ast = measure(:ruby_import_parse) { SyntaxTree.parse(code) }
+        ast =
+          begin
+            measure(:ruby_import_parse) { SyntaxTree.parse(code) }
+          rescue SyntaxTree::Parser::ParseError => error
+            raise ParseError.new(error.message, line: error.lineno + @source_line_offset, column: error.column + 1 + @source_column_offset)
+          end
         calls = measure(:ruby_import_scan) { import_calls(ast) }
         expanded = expand_import_calls(calls)
 

data/lib/klenod/build/source_error.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "errors"
+require_relative "source_excerpt"
+
+module Klenod
+  module Build
+    # Base class for a build failure attributable to one source file.
+    #
+    # Plugins parse very different formats with very different libraries, but the
+    # report a developer needs is the same every time: which file, which line and
+    # column, what went wrong, and what to try next. A subclass supplies `kind`
+    # and a `location` that unpacks its library's exception. Everything else --
+    # the message layout, the source excerpt, the synthesized backtrace frame --
+    # is shared, so every format renders identically in the terminal and in the
+    # browser error dialog.
+    #
+    # Being a StandardError matters: a bare Ruby SyntaxError is a ScriptError and
+    # escapes every `rescue => e` in the build, taking the watcher thread down
+    # with it.
+    class SourceError < Error
+      # `hints` is free-form advice, one entry per line, e.g.
+      # "Did you mean hero.jpeg?".
+      Location = Data.define(:line, :column, :detail, :hints) do
+        def initialize(line: nil, column: nil, detail: nil, hints: []) = super
+      end
+
+      attr_reader :module_id, :source, :line, :column, :cause, :detail, :hints
+
+      def initialize(error, source:, module_id:)
+        @cause = error
+        @module_id = module_id
+        @source = source
+
+        found = location_for(error)
+        @line = found.line
+        @column = found.column
+        @detail = found.detail || message_for(error)
+        @hints = Array(found.hints).map(&:to_s).reject(&:empty?).freeze
+
+        super(
+          SourceExcerpt.message(
+            module_id:,
+            line: @line,
+            column: @column,
+            kind:,
+            source:,
+            message: @detail,
+            hints: @hints
+          )
+        )
+
+        set_backtrace(backtrace_for(error))
+      end
+
+      # "JavaScript parse error". Used as the label in the browser error dialog,
+      # so it names the format rather than the plugin.
+      def kind
+        "Parse error"
+      end
+
+      private
+
+      # Re-wrapping is idempotent: a plugin that catches its own SourceError to
+      # attach the source keeps the location the first construction worked out.
+      def location_for(error)
+        return location(error) || Location.new unless error.is_a?(SourceError)
+
+        Location.new(line: error.line, column: error.column, detail: error.detail, hints: error.hints)
+      end
+
+      # Subclasses override to pull line, column, detail and hints out of the
+      # exception their parsing library raised. Returning nil keeps the wrapped
+      # message as the detail and renders no excerpt.
+      def location(_error)
+        nil
+      end
+
+      # Prism reports each failure as data rather than a message to scrape, and
+      # phrases the first as "what is wrong; what was expected".
+      def prism_location(result)
+        first, *rest = result.errors
+        detail, _, expected = first.message.partition("; ")
+
+        Location.new(
+          line: first.location.start_line,
+          column: first.location.start_column + 1,
+          detail: detail,
+          hints: [expected, *rest.map(&:message)].reject(&:empty?).map(&:capitalize)
+        )
+      end
+
+      # A native extension can raise with a bare message rather than an
+      # exception, so do not assume #message exists.
+      def message_for(error)
+        error.respond_to?(:message) ? error.message : error.to_s
+      end
+
+      # The browser dialog highlights source lines by matching backtrace frames
+      # against the filename. A native parser, or one that raises while
+      # evaluating generated source, leaves no Ruby frame pointing at the
+      # module, so synthesize one.
+      def backtrace_for(error)
+        frames = error.respond_to?(:backtrace) ? Array(error.backtrace) : []
+        return frames unless line
+
+        ["#{module_id}:#{[line, column].compact.join(":")}", *frames]
+      end
+    end
+
+    # Ruby generated from another format that does not parse.
+    #
+    # This is a bug in the plugin that generated it rather than in anything the
+    # developer wrote, so the excerpt shows the generated source. It is checked
+    # while collecting, and again as a backstop when a module is evaluated: a
+    # bare SyntaxError there is a ScriptError, which escapes every `rescue => e`
+    # in the build and takes the watcher thread down with it.
+    class GeneratedRubyError < SourceError
+      # "app:/x.rb:3: syntax error found"
+      HEADER = /\A(?<file>.+?):(?<line>\d+): (?<detail>.+?)$/
+      # "    | ^~~ unexpected 'end'; expected a `)` to close the arguments"
+      CARET = /^ *\| (?<pad> *)\^+~* *(?<message>.*)$/
+
+      def kind
+        "Generated Ruby syntax error"
+      end
+
+      private
+
+      # Prism renders its own excerpt into the message it puts on a SyntaxError.
+      # We re-render it from the line and column, and keep the explanation it
+      # prints beside the caret.
+      def location(error)
+        return prism_location(error) if error.is_a?(Prism::ParseResult)
+
+        header = HEADER.match(error.message)
+        return nil unless header
+
+        caret = CARET.match(error.message)
+        detail, _, hint = (caret ? caret[:message] : header[:detail]).partition("; ")
+
+        Location.new(
+          line: header[:line].to_i,
+          column: caret && caret[:pad].length + 1,
+          detail: detail,
+          hints: [hint.empty? ? nil : hint.capitalize].compact
+        )
+      end
+    end
+  end
+end

data/lib/klenod/build/source_excerpt.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Build
+    # Shared formatting for build errors that can point at a line of source.
+    #
+    # Plugins raise errors carrying the original source and a location, and the
+    # resulting message is shown both in the terminal and in the browser error
+    # dialog, so it needs to read well as plain text. The browser passes
+    # `ansi: false` to get the same layout without escape codes.
+    module SourceExcerpt
+      MARKED_LINE = "\e[1;31m"
+      RESET = "\e[0m"
+
+      module_function
+
+      # "app:/pages/thing.tsx:33:9: JavaScript parse error"
+      def title(module_id:, line:, kind:, column: nil)
+        location =
+          if module_id && line
+            "#{module_id}:#{[line, column].compact.join(":")}"
+          elsif module_id
+            module_id.to_s
+          elsif line
+            column ? "line #{line} column #{column}" : "line #{line}"
+          end
+
+        location ? "#{location}: #{kind}" : kind
+      end
+
+      def message(module_id:, line:, kind:, source:, message:, column: nil, hints: [], context: 2, ansi: true)
+        [
+          title(module_id:, line:, column:, kind:),
+          message,
+          excerpt(source:, line:, column:, context:, ansi:),
+          hint_section(hints)
+        ].compact.join("\n\n")
+      end
+
+      def excerpt(source:, line:, column: nil, context: 2, ansi: true)
+        return nil unless line
+
+        lines = source.to_s.lines
+        return nil if lines.empty?
+
+        index = line - 1
+        return nil unless index.between?(0, lines.length - 1)
+
+        first = [index - context, 0].max
+        last = [index + context, lines.length - 1].min
+        width = (last + 1).to_s.length
+
+        rows =
+          (first..last).flat_map do |line_index|
+            marked = line_index == index
+            number = (line_index + 1).to_s.rjust(width)
+            formatted = "#{marked ? ">" : " "} #{number} | #{lines.fetch(line_index).chomp}"
+            formatted = "#{MARKED_LINE}#{formatted}#{RESET}" if marked && ansi
+
+            marked ? [formatted, caret_row(width, column)].compact : [formatted]
+          end
+
+        "Source:\n#{rows.join("\n")}"
+      end
+
+      # "    |       ^", aligned under the offending column of the marked line.
+      def caret_row(width, column)
+        return nil unless column&.positive?
+
+        "#{" " * (width + 3)}| #{" " * (column - 1)}^"
+      end
+
+      # What to try next. Rendered like the "Source:" section so the two read as
+      # one report.
+      def hint_section(hints)
+        hints = Array(hints).map(&:to_s).reject(&:empty?)
+        return nil if hints.empty?
+
+        heading = (hints.length == 1) ? "Hint:" : "Hints:"
+        "#{heading}\n#{hints.map { "  #{it}" }.join("\n")}"
+      end
+    end
+  end
+end

data/lib/klenod/build/version.rb

@@ -2,6 +2,6 @@
 
 module Klenod
   module Build
-    VERSION = "0.0.13"
+    VERSION = "0.0.15"
   end
 end

data/lib/klenod/build/watcher.rb

@@ -129,11 +129,20 @@ module Klenod
 
       def emit_update(changed_paths, removed_paths)
         @graph_version += 1
-        result = @context.invalidate_paths(changed_paths, removed_paths: removed_paths)
+        result = invalidate(changed_paths, removed_paths)
 
         @context.emit_update(UpdateEvent.new(changed_paths, removed_paths, @graph_version, result))
       end
 
+      # Invalidation runs on the worker thread, so anything escaping here
+      # would kill it and take hot reloading down for the rest of the
+      # process. Report the failure as a result instead.
+      def invalidate(changed_paths, removed_paths)
+        @context.invalidate_paths(changed_paths, removed_paths: removed_paths)
+      rescue StandardError, ScriptError => e
+        InvalidationResult.failed(e)
+      end
+
       def monotonic_time
         Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: klenod-build
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.15
 platform: ruby
 authors:
 - Andrés Alin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.13
+        version: 0.0.15
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.13
+        version: 0.0.15
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
@@ -297,6 +297,8 @@ files:
 - lib/klenod/build/resolution_error_formatter.rb
 - lib/klenod/build/resolver.rb
 - lib/klenod/build/ruby_import_rewriter.rb
+- lib/klenod/build/source_error.rb
+- lib/klenod/build/source_excerpt.rb
 - lib/klenod/build/source_map.rb
 - lib/klenod/build/source_map/editor.rb
 - lib/klenod/build/source_map/map.rb