klenod-build 0.0.15 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abf589452fadde26fe16d0bbc326e0161e8ed8a719ea516e12e286ef8e1609aa
-  data.tar.gz: 9f54e971b5dc88cd07348be0d96e9885928db10c64b4228bfb64e350b202f669
+  metadata.gz: d24b06569546f0b32ba9aebee8e17b989b9cd67198714952404b818dbae7d425
+  data.tar.gz: c61a9de1db41a5258cf2f9ae742ab9256c69fa06df0ef799035db39df89630f2
 SHA512:
-  metadata.gz: af84591cca45a914ffbf087f308eea54d264cb14a0e03d6e60732a806d5e4cf44b00d291679b1f3dfe1f6d39f58bda043ff6b1de625b9d904667d2db5f8a6c07
-  data.tar.gz: 8f5fbdc8411f73fee7b7f6b86f803d7e04e588db97dc3d4d5019b7bf08cc63a1d73b05d82a97e74135fc2370be072b00524b7df3ac301c0ed2f4eb025c4352d7
+  metadata.gz: cb64e39cf3daedff82d30572bb92c136a3091118a843aa7e9180c40dd83e5e074be8a017867744fb4921a6a092eab366095a510639bacf8aba37a2859c013dd3
+  data.tar.gz: 9d9ad93cbfc302d0db9e4bddca0cb333929fe62480791bfadef0848bc09c4459fd6ed5145fa93f444ed077f1f7e63d172900a7065f81a6e0e24d7f0cf71c9eed

data/lib/klenod/build/graph.rb

@@ -374,6 +374,7 @@ module Klenod
           transform = loaded_source.transform || transform_module_source(module_id, source)
           resolved_dependencies = resolve_transform_dependencies(module_id, transform)
           dependency_records = load_eager_dependency_records(resolved_dependencies)
+          assert_eager_import_names!(module_id, source, resolved_dependencies, dependency_records)
           transform = finalize_transform_result(module_id, transform, resolved_dependencies, dependency_records)
           assert_supported_transform!(module_id, source, transform)
           assert_generated_ruby_parses!(module_id, transform)
@@ -430,6 +431,7 @@ module Klenod
           transform = loaded_source.transform || transform_module_source(module_id, source)
           resolved_dependencies = resolve_transform_dependencies(module_id, transform)
           dependency_records = collect_eager_dependency_records(resolved_dependencies)
+          assert_eager_import_names!(module_id, source, resolved_dependencies, dependency_records)
           transform = finalize_transform_result(module_id, transform, resolved_dependencies, dependency_records)
           assert_supported_transform!(module_id, source, transform)
           assert_generated_ruby_parses!(module_id, transform)
@@ -462,7 +464,7 @@ module Klenod
             Runtime::Mod.new(
               module_id.to_s,
               record.transformed_source,
-              imports: imports_for(record.resolved_dependencies, dependency_records),
+              imports: imports_for(module_id, record.source, record.resolved_dependencies, dependency_records),
               source_map: record.source_map,
               version: record.version,
               eval_path: eval_path_for(module_id),
@@ -659,7 +661,7 @@ module Klenod
           Runtime::Mod.new(
             module_id.to_s,
             transform.code,
-            imports: imports_for(resolved_dependencies, dependency_records),
+            imports: imports_for(module_id, source, resolved_dependencies, dependency_records),
             source_map: transform.source_map,
             version: cached ? cached.version + 1 : 0,
             eval_path: eval_path_for(module_id),
@@ -690,7 +692,7 @@ module Klenod
         source_dir.join(module_id.path).to_s
       end
 
-      def imports_for(resolved_dependencies, dependency_records)
+      def imports_for(module_id, source, resolved_dependencies, dependency_records)
         resolved_dependencies.to_h do |resolved_dependency|
           value =
             if resolved_dependency.dependency.eager
@@ -702,6 +704,7 @@ module Klenod
                 evaluate_module(resolved_dependency.module_id)
                 record = @records.fetch(resolved_dependency.module_id)
                 raise_failed_module!(record)
+                assert_import_name!(module_id, source, resolved_dependency, record)
                 import_value(resolved_dependency, record)
               end
             end
@@ -898,10 +901,9 @@ module Klenod
         @records.to_h do |module_id, record|
           imports =
             record.resolved_dependencies.to_h do |resolved_dependency|
-              [
-                resolved_dependency.dependency.id,
-                runtime_import_spec(resolved_dependency, @records.fetch(resolved_dependency.module_id))
-              ]
+              target = @records.fetch(resolved_dependency.module_id)
+              assert_import_name!(module_id, record.source, resolved_dependency, target)
+              [resolved_dependency.dependency.id, runtime_import_spec(resolved_dependency, target)]
             end
 
           [
@@ -990,6 +992,35 @@ module Klenod
         end
       end
 
+      # Lazy targets are not collected until bundle or call time, so only the
+      # eager imports can be checked while the importer is collected.
+      def assert_eager_import_names!(module_id, source, resolved_dependencies, dependency_records)
+        resolved_dependencies.each do |resolved_dependency|
+          next unless resolved_dependency.dependency.eager
+
+          record = dependency_records.fetch(resolved_dependency.dependency.id)
+          assert_import_name!(module_id, source, resolved_dependency, record)
+        end
+      end
+
+      # A named import (`import("./x", :Bar)`) is checked against the constants
+      # the target defines statically, recorded by the Ruby plugin as
+      # metadata[:ruby_constants]. A missing Default is not an error: the
+      # import then returns the Exports module.
+      def assert_import_name!(module_id, source, resolved_dependency, record)
+        name = resolved_dependency.dependency.metadata[:import_name]
+        return unless name
+
+        constants = record.metadata[:ruby_constants]
+        return if constants&.include?(name)
+
+        raise MissingExportError.new(
+          MissingExportError::Report.new(resolved_dependency.dependency, record.id, name, constants),
+          source: source,
+          module_id: module_id
+        )
+      end
+
       def import_value(resolved_dependency, record)
         raise_failed_module!(record)
 

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

@@ -22,7 +22,7 @@ module Klenod
           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, [], [], {}))
+          LoadResult.new(source, nil, TransformResult.new(source, [], nil, [], [], {ruby_constants: [:Default]}))
         end
 
         def class_names_runtime_dependency(module_id)

data/lib/klenod/build/plugins/haml_plugin/helper_source.rb

@@ -12,7 +12,8 @@ module Klenod
               .create(
                 specifier: HAML_HELPER_SPECIFIER,
                 importer_id: module_id,
-                kind: :haml_helper
+                kind: :haml_helper,
+                metadata: {import_name: :Default}
               )
               .with(id: "#{module_id}:haml_helper")
           end

data/lib/klenod/build/plugins/haml_plugin/transformer.rb

@@ -549,6 +549,9 @@ module Klenod
               source_column_offset = source.lines.fetch(node.line, "").match(/\A\s*/).to_s.length
               text = import_rewriter.call(text, source_line_offset: node.line, source_column_offset: source_column_offset)
             end
+            unless builder.statements(text).node?
+              builder.ruby_parse_error(text, line_no: node.line + 1, context: "Could not parse Ruby filter")
+            end
             heredoc_body_lines = ruby_heredoc_body_lines(text)
             source = +""
             text.each_line.with_index(node.line + 1) do |line, line_no|
@@ -625,12 +628,15 @@ module Klenod
 
           def dynamic_attributes(node, builder:, props:)
             dynamic_attributes = node.value.fetch(:dynamic_attributes)
-            sources = [dynamic_attributes.new, dynamic_attributes.old].compact
+            sources = [
+              [dynamic_attributes.new, true],
+              [dynamic_attributes.old, false]
+            ].reject { |source, _parenthesized| source.nil? }
             return {} if sources.empty?
 
             measure_compile(:haml_compile_dynamic_attributes) do
               dynamic = {}
-              sources.each do |source|
+              sources.each do |source, parenthesized|
                 source = builder.line_rewritten_source(source, node.line)
                 simple = simple_dynamic_attributes(source, builder: builder) unless @event_handler
                 if simple
@@ -655,7 +661,7 @@ module Klenod
                   end
 
                   key = attribute_key(assoc.key, builder: builder)
-                  value = event_handler_value(key, assoc.value, builder: builder) || attribute_value(assoc, builder: builder)
+                  value = event_handler_value(key, assoc.value, parenthesized: parenthesized, builder: builder) || attribute_value(assoc, builder: builder)
                   dynamic[key] = value
                   props[key] = value
                 end
@@ -784,14 +790,19 @@ module Klenod
             builder.ruby_parse_error(source, line_no: assoc.key.location&.start_line, context: "Could not parse Haml dynamic attributes")
           end
 
-          def event_handler_value(key, value, builder:)
-            return unless @event_handler && key.to_s.match?(/\Aon[a-z]/)
+          def event_handler_value(key, value, parenthesized:, builder:)
+            normalized_key = key.to_s.tr("-", "_")
+            return unless normalized_key.match?(/\Aon(?:[a-z]|_[a-z])/)
             return unless value
 
             method_name = builder.fragment(value).source
             return unless method_name.match?(/\A[a-zA-Z_]\w*[!?=]?\z/)
 
-            builder.expression("#{@event_handler}.callback(self, :#{method_name})")
+            if @event_handler
+              builder.expression("#{@event_handler}.callback(self, :#{method_name})")
+            elsif parenthesized
+              builder.symbol(method_name)
+            end
           end
 
           def omitted_attribute_value_name(node)

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

@@ -97,7 +97,9 @@ module Klenod
 
             return nil unless module_id.scheme == :virtual && module_id == HAML_HELPER_MODULE_ID
 
-            LoadResult.new(haml_helper_source, nil, TransformResult.new(haml_helper_source, [], nil, [], [], {}))
+            # Loaded with a ready transform, so the Ruby plugin never scans it: declare
+            # the Default export it defines.
+            LoadResult.new(haml_helper_source, nil, TransformResult.new(haml_helper_source, [], nil, [], [], {ruby_constants: [:Default]}))
           end
 
           def transform(module_id, code, context)
@@ -136,7 +138,7 @@ module Klenod
                       specifier: "/markdown-components",
                       importer_id: module_id,
                       kind: :markdown_components,
-                      metadata: {optional: true}
+                      metadata: {optional: true, import_name: :Default}
                     )
                     .with(id: "#{module_id}:markdown_components")
                 dependencies << markdown_components_dependency
@@ -205,11 +207,11 @@ module Klenod
                 styles_source: styles_source,
                 translations_source: translations_source,
                 i18n_source: i18n_source_for(builder),
-                haml_helper_source: haml_helper_dependency && builder.constant_assignment("HamlHelper", "#{builder.import_call(haml_helper_dependency.id).source}::Default"),
+                haml_helper_source: haml_helper_dependency && builder.constant_assignment("HamlHelper", builder.import_call(haml_helper_dependency.id).source),
                 styleable: !style_dependencies.empty?,
                 profiler: context.profiler,
                 import_rewriter: import_rewriter,
-                markdown_components_source: markdown_components_dependency ? "__klenod_import__(#{markdown_components_dependency.id.inspect})::Default" : "{}",
+                markdown_components_source: markdown_components_dependency ? "__klenod_import__(#{markdown_components_dependency.id.inspect})" : "{}",
                 variables: @variables,
                 event_handler: @event_handler,
                 cache_static_subtrees: @cache_static_subtrees
@@ -246,19 +248,26 @@ module Klenod
           def import_value(resolved_dependency, record, context)
             styles_import = class_names_runtime_import_value(resolved_dependency, record, context)
             return styles_import if styles_import
-            return nil unless record.id.extname == ".haml"
+            return nil unless default_export?(record)
 
-            context.mods.fetch(record.id).const_get(:Exports)::Default
+            context.mods.fetch(record.id).const_get(:Exports).const_get(:Default, false)
           end
 
           def runtime_import_value(resolved_dependency, record, _context)
             styles_import = class_names_runtime_runtime_import_value(resolved_dependency, record)
             return styles_import if styles_import
-            return Runtime::DefaultImport.new(:Default) if record.id.extname == ".haml"
+            return Runtime::DefaultImport.new(:Default) if default_export?(record)
 
             super
           end
 
+          # Components and the helper module both export Default. The helper is
+          # unwrapped here as well as by the Ruby plugin, so a context built
+          # without the Ruby plugin still renders.
+          def default_export?(record)
+            record.id.extname == ".haml" || record.id == HAML_HELPER_MODULE_ID
+          end
+
           def invalidate_module_ids(paths, context)
             paths
               .filter_map { |path| companion_owner_module_id(path, context) }

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

@@ -22,7 +22,7 @@ module Klenod
 
         def compile(source, interpolate: false)
           source = protect_escaped_interpolation(source) if interpolate
-          document = Kramdown::Document.new(source, input: "GFM")
+          document = Kramdown::Document.new(source, input: "GFM", hard_wrap: false)
           compile_children(document.root.children, interpolate: interpolate)
         end
 

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

@@ -168,13 +168,13 @@ module Klenod
                 specifier: "/markdown-components",
                 importer_id: module_id,
                 kind: :markdown_components,
-                metadata: {optional: true}
+                metadata: {optional: true, import_name: :Default}
               )
               .with(id: dependency_id(module_id))
           end
 
           def components_source_for(dependency)
-            dependency ? "__klenod_import__(#{dependency.id.inspect})::Default" : "{}"
+            dependency ? "__klenod_import__(#{dependency.id.inspect})" : "{}"
           end
 
           def dependency_id(module_id)

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

@@ -53,7 +53,7 @@ module Klenod
           def transform(module_id, code, context)
             return TransformResult.identity(code) unless module_id.extname == ".rb"
 
-            assert_parses!(module_id, code)
+            program = parse!(module_id, code)
 
             result =
               begin
@@ -68,21 +68,77 @@ module Klenod
               rescue SyntaxTree::Parser::ParseError => error
                 raise ParseError.new(error, source: code, module_id: module_id)
               end
-            TransformResult.new(result.code, result.dependencies, nil, [], result.watched_patterns, {})
+            TransformResult.new(
+              result.code,
+              result.dependencies,
+              nil,
+              [],
+              result.watched_patterns,
+              {ruby_constants: top_level_constants(program)}
+            )
+          end
+
+          # The value an importer receives: the requested constant, or Default
+          # when the module defines one. Nil keeps the Exports module.
+          def import_value(resolved_dependency, record, context)
+            name = import_constant_name(resolved_dependency, record)
+            return nil unless name
+
+            context.mods.fetch(record.id).const_get(:Exports).const_get(name, false)
+          end
+
+          def runtime_import_value(resolved_dependency, record, _context)
+            name = import_constant_name(resolved_dependency, record)
+            return nil unless name
+
+            Runtime::DefaultImport.new(name)
           end
 
           private
 
           # The rewriter only parses a file that contains an import it cannot
-          # rewrite literally, so without this check most syntax errors would
+          # rewrite literally, so without this parse most syntax errors would
           # not surface until the module was evaluated -- and a production build
           # never evaluates application modules, so the bundle would ship
-          # broken. Prism is the parser CRuby itself uses, and validating costs
-          # well under a tenth of a millisecond per file.
-          def assert_parses!(module_id, code)
-            return if Prism.parse_success?(code)
+          # broken. Prism is the parser CRuby itself uses, and parsing costs
+          # well under a millisecond per file. The same tree tells us which
+          # constants the module exports.
+          def parse!(module_id, code)
+            result = Prism.parse(code)
+            raise ParseError.new(result, source: code, module_id: module_id) if result.failure?
+
+            result.value
+          end
+
+          # The constants a module defines at its top level, meaning directly
+          # on its Exports module. Only static definitions count: `const_set`,
+          # constants inside `if` or `begin`, `A::B = 1`, and `class ::A` are
+          # not exports.
+          def top_level_constants(program)
+            program.statements.body.flat_map { |node| defined_constant_names(node) }.uniq
+          end
+
+          def defined_constant_names(node)
+            case node
+            when Prism::ConstantWriteNode
+              [node.name]
+            when Prism::ClassNode, Prism::ModuleNode
+              node.constant_path.is_a?(Prism::ConstantReadNode) ? [node.constant_path.name] : []
+            when Prism::MultiWriteNode
+              [*node.lefts, *node.rights].grep(Prism::ConstantTargetNode).map(&:name)
+            else
+              []
+            end
+          end
+
+          # Records without a constant list were not transformed by this plugin
+          # and keep whatever value other plugins or the graph supply.
+          def import_constant_name(resolved_dependency, record)
+            constants = record.metadata[:ruby_constants]
+            return nil unless constants
 
-            raise ParseError.new(Prism.parse(code), source: code, module_id: module_id)
+            name = resolved_dependency.dependency.metadata.fetch(:import_name, :Default)
+            constants.include?(name) ? name : nil
           end
         end
       end

data/lib/klenod/build/ruby_import_rewriter.rb

@@ -11,7 +11,7 @@ module Klenod
   module Build
     class RubyImportRewriter
       ImportCall =
-        Data.define(:specifier, :location, :dynamic, :method_name, :eager_override) do
+        Data.define(:specifier, :location, :dynamic, :method_name, :eager_override, :import_name) do
           def eager
             eager_override.nil? ? RubyImportRewriter::IMPORT_METHODS.fetch(method_name).fetch(:eager) : eager_override
           end
@@ -213,21 +213,33 @@ module Klenod
 
         first = unwrap_paren(parts.first)
         string_parts = first&.instance_variable_get(:@parts)
-        literal =
-          (parts.length == 1) &&
+        literal_specifier =
           first&.class&.name == "SyntaxTree::StringLiteral" &&
           string_parts&.length == 1 &&
           string_parts.first.instance_of?(::SyntaxTree::TStringContent)
+        import_name = (parts.length == 2) ? constant_symbol_value(parts.fetch(1)) : nil
+        literal = literal_specifier && (parts.length == 1 || !import_name.nil?)
 
         ImportCall.new(
           literal ? string_parts.first.value : nil,
           node.instance_variable_get(:@location),
           !literal,
           node.instance_variable_get(:@message).value,
-          nil
+          nil,
+          literal ? import_name : nil
         )
       end
 
+      # The optional second argument of `import`: a symbol literal spelled like
+      # a constant, such as `:Bar`. Anything else (`:bar`, `:"Bar"`, a string,
+      # a variable) is reported as a dynamic import.
+      def constant_symbol_value(node)
+        return unless node.instance_of?(::SyntaxTree::SymbolLiteral)
+
+        value = node.instance_variable_get(:@value)
+        value.instance_of?(::SyntaxTree::Const) ? value.value.to_sym : nil
+      end
+
       def build_import_glob_from_parts(node, parts)
         first = unwrap_paren(parts.first)
         string_parts = first&.instance_variable_get(:@parts)
@@ -250,7 +262,8 @@ module Klenod
           node.instance_variable_get(:@location),
           !literal || !valid_options,
           node.instance_variable_get(:@message).value,
-          eager
+          eager,
+          nil
         )
       end
 
@@ -304,20 +317,29 @@ module Klenod
       end
 
       def raise_dynamic_import!(call)
-        expected = (call.method_name == "import_glob") ? "import_glob(\"...\")" : "import(\"...\")"
+        expected =
+          if call.method_name == "import_glob"
+            "import_glob(\"...\")"
+          else
+            "#{call.method_name}(\"...\") or #{call.method_name}(\"...\", :Constant)"
+          end
         raise DynamicImportError, "Only literal #{expected} calls are supported in #{@module_id}"
       end
 
       def build_dependency(call, dependency_index)
-        Dependency
-          .create(
-            specifier: call.specifier,
-            importer_id: @module_id,
-            kind: @kind,
-            loc: source_location(call.location)
-          )
-          .with(eager: call.eager)
-          .with(id: "#{@module_id}:dependency:#{dependency_index}")
+        dependency =
+          Dependency
+            .create(
+              specifier: call.specifier,
+              importer_id: @module_id,
+              kind: @kind,
+              loc: source_location(call.location)
+            )
+            .with(eager: call.eager)
+            .with(id: "#{@module_id}:dependency:#{dependency_index}")
+        return dependency unless call.import_name
+
+        dependency.with(metadata: {import_name: call.import_name}.freeze)
       end
 
       def expand_glob_import(call, dependency_index)

data/lib/klenod/build/source_error.rb

@@ -110,6 +110,43 @@ module Klenod
       end
     end
 
+    # A named import (`import("./x", :Bar)`) of a constant the target module
+    # does not define at its top level.
+    #
+    # The check uses the constants the Ruby plugin recorded statically, so a
+    # typo fails while collecting, with an excerpt of the import, instead of
+    # surfacing as a NameError from inside module evaluation -- or, worse, at
+    # runtime, since a production build never evaluates application modules.
+    class MissingExportError < SourceError
+      Report = Data.define(:dependency, :target_id, :name, :constants)
+
+      def kind
+        "Missing export"
+      end
+
+      private
+
+      def location(report)
+        Location.new(
+          line: report.dependency.loc&.line,
+          column: report.dependency.loc&.column,
+          detail: "#{report.target_id} does not define #{report.name}",
+          hints: [hint_for(report)]
+        )
+      end
+
+      def hint_for(report)
+        case report.constants
+        when nil
+          "Named imports need a Ruby module; #{report.target_id} is not one"
+        when []
+          "#{report.target_id} defines no top-level constants; import it without a name to get its Exports module"
+        else
+          "It defines #{report.constants.join(", ")}"
+        end
+      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

data/lib/klenod/build/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: klenod-build
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.17
 platform: ruby
 authors:
 - Andrés Alin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.15
+        version: 0.0.17
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.15
+        version: 0.0.17
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement