klenod-build 0.0.20 → 0.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bbeb7b858f12c3e373b4ddfc2a1d1c097048c84a24bf62babdd9b6abfad0903
-  data.tar.gz: 743d7dbbb2850cb175e0ba54dafd2989fd66a2c7ad653338d989f7953a6b50e6
+  metadata.gz: d7873fce94ba35f8420b6aa896bca1866896d5c9f038102f0d13522fb1fa9a16
+  data.tar.gz: 715c13a86148ae750ed6151f05e4fbcb32d1d73bf21d139d1b21d42f7bb405f4
 SHA512:
-  metadata.gz: 39651b21e98ac61f0f4f1e2f014f036a815b317d21107b6422d20767a6e0117227f640ad19c1436251a58b8c4a1e7b7d8c2c52b26776b0ce28e6d9a8a0199332
-  data.tar.gz: 1d4c523e9fff5640b5bf724067c924bfc8f869aca77633e5566388de5365ec6d114cf92972b5737a2067f8ac4d2064911c4df8f9e3d0115bd8839a0829d1a78b
+  metadata.gz: 29157efe18cfdd5982f05ef742f07bb56ee64f54c820b152569be703b76a97dc76f71c166b67ff57e8b5124bed59f16ecbcf39415118dba3672a304854d4fbfa
+  data.tar.gz: 0a0b9e45f353aa70004c01ed9f78d1fe6ef667c7eb4faa5e7c64d038087ed82501c7f77755ed5e67dd26504ac122ee14a7c5414164b36c5933afae86df89df37

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

@@ -23,6 +23,21 @@ module Klenod
               # frozen_string_literal: true
 
               module Default
+                def self.capture
+                  captures = (Thread.current[:__klenod_haml_captures__] ||= [])
+                  output = []
+                  captures << output
+                  yield
+                  output
+                ensure
+                  captures&.pop
+                end
+
+                def self.append_capture(value)
+                  Thread.current.fetch(:__klenod_haml_captures__).last << value
+                  value
+                end
+
                 def self.merge_props(component_class, *sources)
                   result = {}
                   classes = []
@@ -46,12 +61,7 @@ module Klenod
                 end
 
                 def self.normalize_prop_key(key)
-                  return key if key.is_a?(Symbol)
-
-                  name = key.to_s
-                  return key if name.include?("-")
-
-                  name.to_sym
+                  key.to_s.tr("-", "_").to_sym
                 end
 
                 def self.collect_class_values(classes, value)

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

@@ -355,7 +355,9 @@ module Klenod
             def parenthesized_expression(source, line_no: nil)
               source = rewrite_ruby_source(source, line_no)
               node = parse_expression(source, context: :parenthesized_expression)
-              return expression("(#{source})") unless node
+              unless node
+                raise_ruby_parse_error(source, line_no: line_no, context: "Could not parse Haml output script", syntax_error: true)
+              end
 
               fragment(Paren(LParen("("), Statements([node])))
             end
@@ -438,15 +440,18 @@ module Klenod
 
             def silent_script_block(source, body, line_no: nil)
               source = rewrite_ruby_source(source, nil)
-              ast_silent_script_block(source, body) || raise_ruby_parse_error(source, line_no: line_no, context: "Could not build Ruby block from Haml script")
+              ast_silent_script_block(source, body) || raise_ruby_parse_error(source, line_no: line_no, context: "Could not build Ruby block from Haml script", syntax_error: true)
             end
 
-            def silent_script(source)
+            def silent_script(source, line_no: nil)
               source = rewrite_ruby_source(source, nil)
-              ast_silent_script(source) || raise(ArgumentError, "Could not build Ruby begin block from Haml script: #{source.inspect}")
+              fragment = ast_silent_script(source)
+              return fragment if fragment
+
+              raise_ruby_parse_error(source, line_no: line_no, context: "Could not parse Haml silent script", syntax_error: true)
             end
 
-            def silent_script_with_children(source, body)
+            def silent_script_with_children(source, body, line_no: nil)
               source = rewrite_ruby_source(source, nil)
               return_with_children = false
 
@@ -464,7 +469,9 @@ module Klenod
               end
 
               statements = parse_statements(source)
-              return raise(ArgumentError, "Could not parse Haml silent script: #{source.inspect}") unless statements
+              unless statements
+                raise_ruby_parse_error(source, line_no: line_no, context: "Could not parse Haml silent script", syntax_error: true)
+              end
 
               return Fragment.new(source, statements) if return_with_children
 
@@ -472,12 +479,39 @@ module Klenod
               Fragment.new(["begin", indent(source, 2), indent(to_source(body), 2), "end"].join("\n"), node)
             end
 
-            def branches(branches)
-              ast_branches(branches) || raise(ArgumentError, "Could not build Ruby branch from Haml scripts: #{branches.map(&:first).inspect}")
+            def keyword_script?(source)
+              source.start_with?("while ", "until ", "for ")
+            end
+
+            def keyword_script(source, body, line_no: nil)
+              source = rewrite_ruby_source(source, nil)
+              source = block_source(source, body)
+              node = parse_expression(source, context: :keyword_script)
+              return Fragment.new(source, node) if node
+
+              raise_ruby_parse_error(source, line_no: line_no, context: "Could not build Ruby control-flow block from Haml script", syntax_error: true)
             end
 
-            def silent_branches(branches)
-              ast_silent_branches(branches) || raise(ArgumentError, "Could not build Ruby branch from Haml scripts: #{branches.map(&:first).inspect}")
+            def silent_keyword_script(source, body, line_no: nil)
+              captured_script = captured_block_source(source, body)
+              node = parse_expression(captured_script, context: :keyword_script)
+              return Fragment.new(captured_script, node) if node
+
+              raise_ruby_parse_error(captured_script, line_no: line_no, context: "Could not build Ruby control-flow block from Haml script", syntax_error: true)
+            end
+
+            def branches(branches, line_no: nil)
+              fragment = ast_branches(branches)
+              return fragment if fragment
+
+              raise_ruby_parse_error(branch_source(branches), line_no: line_no, context: "Could not parse Haml output branches", syntax_error: true)
+            end
+
+            def silent_branches(branches, line_no: nil)
+              fragment = ast_silent_branches(branches)
+              return fragment if fragment
+
+              raise_ruby_parse_error(branch_source(branches), line_no: line_no, context: "Could not parse Haml silent branches", syntax_error: true)
             end
 
             def ruby_filters(nodes)
@@ -631,7 +665,7 @@ module Klenod
             end
 
             def ast_silent_script(source)
-              statements = parse_statements(source)
+              statements = parse_statements(source) || control_flow_statements(source)
               return nil unless statements
 
               node = ast_begin([*statement_body_for(statements), nil_node])
@@ -639,6 +673,17 @@ module Klenod
               Fragment.new(["begin", indent(source, 2), "  nil", "end"].join("\n"), node)
             end
 
+            # SyntaxTree rejects `next` and `break` at top level even though a
+            # silent script can be nested in an iterator or keyword loop. Parse
+            # those statements inside a harmless temporary loop, then retain
+            # only its body for the surrounding generated block.
+            def control_flow_statements(source)
+              return unless source.match?(/\A(?:next|break)\b/)
+
+              wrapper = parse_expression(["loop do", indent(source, 2), "end"].join("\n"), context: :control_flow_statement)
+              wrapper&.block&.bodystmt&.statements
+            end
+
             def ast_script_block(source, body)
               node = block_script_node(source, body)
               return nil unless node
@@ -647,28 +692,30 @@ module Klenod
             end
 
             def ast_silent_script_block(source, body)
-              node = block_script_node(source, body)
+              source = captured_block_source(source, body)
+              node = parse_expression(source, context: :block_script)
               return nil unless node
 
-              node = ast_begin([node, nil_node])
-
-              Fragment.new(["begin", indent(block_source(source, body), 2), "  nil", "end"].join("\n"), node)
+              Fragment.new(source, node)
             end
 
             def ast_branches(branches)
-              node = branch_node(branches)
+              source = branch_source(branches)
+              node = parse_expression(source, context: :branches)
               return nil unless node
 
-              Fragment.new(branch_source(branches), node)
+              Fragment.new(source, node)
             end
 
             def ast_silent_branches(branches)
               node = branch_node(branches)
               return nil unless node
 
-              node = ast_begin([node, nil_node])
+              Fragment.new(branch_source(branches), node)
+            end
 
-              Fragment.new(["begin", indent(branch_source(branches), 2), "  nil", "end"].join("\n"), node)
+            def branch_node(branches)
+              parse_expression(branch_source(branches), context: :branches)
             end
 
             def ast_ruby_filters(nodes)
@@ -712,11 +759,24 @@ module Klenod
               end
             end
 
+            # Ruby iterators and keyword loops return their control value rather
+            # than the values produced by their bodies. Capture each compiled
+            # Haml child explicitly, while leaving `return`, `next`, and `break`
+            # in their original Ruby block/loop context.
+            def captured_block_source(source, body)
+              captured_body = "HamlHelper.append_capture(#{argument_source(body)})"
+              script = block_source(source, Fragment.new(captured_body, nil))
+              ["HamlHelper.capture do", indent(script, 2), "end"].join("\n")
+            end
+
             def branch_source(branches)
               body =
                 branches
-                  .map do |source, body|
-                    if source == "else"
+                  .each_with_index
+                  .map do |(source, body), index|
+                    if index.zero? && source.match?(/\Acase\b/)
+                      source
+                    elsif source == "else"
                       ["else", indent(to_source(body), 2)].join("\n")
                     else
                       [source, indent(to_source(body), 2)].join("\n")
@@ -737,78 +797,6 @@ module Klenod
               )
             end
 
-            def branch_node(branches)
-              first_source, first_body = branches.fetch(0)
-              if first_source.match?(/\Acase\b/) && nil_fragment?(first_body)
-                case_node(first_source, branches.drop(1))
-              else
-                if_node(branches)
-              end
-            end
-
-            def if_node(branches)
-              source, body = branches.fetch(0)
-              return else_node(source, body) if source == "else"
-
-              predicate_source =
-                case source
-                when /\Aif\s+(.+)\z/ then $1
-                when /\Aelsif\s+(.+)\z/ then $1
-                when /\Aunless\s+(.+)\z/ then "!(#{$1})"
-                else return nil
-                end
-              predicate = parse_expression(predicate_source, context: :branch_predicate)
-              return nil unless predicate
-
-              consequent =
-                if branches.length > 1
-                  if_node(branches.drop(1))
-                end
-
-              if source.start_with?("elsif")
-                Elsif(predicate, Statements(statement_body_for(body)), consequent)
-              else
-                IfNode(predicate, Statements(statement_body_for(body)), consequent)
-              end
-            end
-
-            def else_node(source, body)
-              return nil unless source == "else"
-
-              Else(Kw("else"), Statements(statement_body_for(body)))
-            end
-
-            def case_node(source, branches)
-              value_source = source[/\Acase\s*(.*)\z/, 1]
-              return nil unless value_source
-
-              value = value_source.empty? ? nil : parse_expression(value_source, context: :case_value)
-              consequent = when_node(branches)
-              return nil unless consequent
-
-              Case(Kw("case"), value, consequent)
-            end
-
-            def when_node(branches)
-              source, body = branches.fetch(0)
-              return else_node(source, body) if source == "else"
-              return nil unless source.start_with?("when ")
-
-              arguments =
-                source
-                  .delete_prefix("when ")
-                  .split(",")
-                  .map { |argument| parse_expression(argument.strip, context: :when_argument) }
-              return nil if arguments.any?(&:nil?)
-
-              consequent =
-                if branches.length > 1
-                  when_node(branches.drop(1))
-                end
-
-              When(Args(arguments), Statements(statement_body_for(body)), consequent)
-            end
-
             def block_script_node(source, body)
               node = parse_expression(fix_syntax_by_adding_missing_pairs(source), context: :block_script)
               return nil unless node.is_a?(SyntaxTree::MethodAddBlock)
@@ -956,10 +944,6 @@ module Klenod
               Comment(value, false)
             end
 
-            def nil_fragment?(value)
-              value.is_a?(Fragment) && value.node.is_a?(SyntaxTree::VarRef) && to_source(value) == "nil"
-            end
-
             def node_for(value)
               return value.node if value.is_a?(Fragment)
 
@@ -1060,7 +1044,7 @@ module Klenod
               [source, *left_right.missing].join("\n")
             end
 
-            def raise_ruby_parse_error(source, line_no:, context:)
+            def raise_ruby_parse_error(source, line_no:, context:, syntax_error: false)
               parse_error = syntax_tree_parse_error(source)
               explain =
                 SyntaxSuggest::ExplainSyntax.new(
@@ -1070,6 +1054,7 @@ module Klenod
               missing = explain.missing.map { |item| explain.why(item) } - errors
 
               message = [context]
+              message[0] += " (Ruby syntax error)" if syntax_error
               message << "Errors:\n  #{errors.join("\n  ")}" unless errors.empty?
               message << "Missing:\n  #{missing.join("\n  ")}" unless missing.empty?
 

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

@@ -352,7 +352,7 @@ module Klenod
             return compile_node(nodes[0], factory: factory, styleable: styleable, builder: builder, markdown_compiler: markdown_compiler) if nodes.length == 1
 
             compile_branches(
-              nodes.map { |node| [script_source(node, builder: builder), node.children] },
+              nodes.map { |node| [script_source(node, builder: builder), node.children, node.line] },
               factory: factory,
               styleable: styleable,
               builder: builder,
@@ -362,7 +362,15 @@ module Klenod
 
           def compile_script(node, factory:, builder:, markdown_compiler:, styleable: false)
             source = script_source(node, builder: builder)
-            return builder.parenthesized_expression(source) if node.children.empty?
+            return builder.parenthesized_expression(source, line_no: node.line) if node.children.empty?
+
+            if builder.keyword_script?(source)
+              return builder.keyword_script(
+                source,
+                compile_nodes(node.children, factory: factory, styleable: styleable, builder: builder, markdown_compiler: markdown_compiler),
+                line_no: node.line
+              )
+            end
 
             builder.script_block(
               source,
@@ -373,7 +381,7 @@ module Klenod
 
           def compile_script_branch(node, factory:, builder:, markdown_compiler:, styleable: false)
             compile_branches(
-              [[script_source(node, builder: builder), node.children]],
+              [[script_source(node, builder: builder), node.children, node.line]],
               factory: factory,
               styleable: styleable,
               builder: builder,
@@ -383,7 +391,7 @@ module Klenod
 
           def compile_silent_script(node, factory:, builder:, markdown_compiler:, styleable: false)
             source = script_source(node, builder: builder)
-            return builder.silent_script(source) if node.children.empty?
+            return builder.silent_script(source, line_no: node.line) if node.children.empty?
             if builder.block_script?(source)
               return builder.silent_script_block(
                 source,
@@ -392,10 +400,19 @@ module Klenod
               )
             end
 
-            unless source.start_with?("if ", "unless ", "case ")
+            if builder.keyword_script?(source)
+              return builder.silent_keyword_script(
+                source,
+                compile_nodes(node.children, factory: factory, styleable: styleable, builder: builder, markdown_compiler: markdown_compiler),
+                line_no: node.line
+              )
+            end
+
+            unless source.start_with?("if ", "unless ", "case ", "begin")
               return builder.silent_script_with_children(
                 source,
-                compile_nodes(node.children, factory: factory, styleable: styleable, builder: builder, markdown_compiler: markdown_compiler)
+                compile_nodes(node.children, factory: factory, styleable: styleable, builder: builder, markdown_compiler: markdown_compiler),
+                line_no: node.line
               )
             end
 
@@ -410,17 +427,19 @@ module Klenod
 
           def compile_branches(branches, factory:, builder:, markdown_compiler:, styleable: false)
             builder.branches(
-              branches.map do |source, children|
+              branches.map do |source, children, _line_no|
                 [source, compile_nodes(children, factory: factory, styleable: styleable, builder: builder, markdown_compiler: markdown_compiler)]
-              end
+              end,
+              line_no: branches.first.fetch(2)
             )
           end
 
           def compile_silent_branches(branches, factory:, builder:, markdown_compiler:, styleable: false)
             builder.silent_branches(
-              branches.map do |source, children|
+              branches.map do |source, children, _line_no|
                 [source, compile_nodes(children, factory: factory, styleable: styleable, builder: builder, markdown_compiler: markdown_compiler)]
-              end
+              end,
+              line_no: branches.first.fetch(2)
             )
           end
 
@@ -428,18 +447,20 @@ module Klenod
             branches = []
             current_source = script_source(node, builder: builder)
             current_children = []
+            current_line = node.line
 
             node.children.each do |child|
               if continuation?(child)
-                branches << [current_source, current_children]
+                branches << [current_source, current_children, current_line]
                 current_source = script_source(child, builder: builder)
                 current_children = child.children.dup
+                current_line = child.line
               else
                 current_children << child
               end
             end
 
-            branches << [current_source, current_children]
+            branches << [current_source, current_children, current_line]
           end
 
           def script_node?(node)

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

@@ -184,6 +184,7 @@ module Klenod
 
           def supported_plus_file?(path)
             basename = path.basename.to_s
+            return true if basename.match?(/\A\+.*\.test\.rb\z/)
             return true if basename == "+route.rb"
 
             ROUTE_FILE_BASENAMES.any? do |route_basename|

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

@@ -126,8 +126,8 @@ module Klenod
               Default =
                 SvgRuntime::SvgMetadata.new(
                   src: #{asset.url.inspect},
-                  width: #{asset.metadata[:width].inspect},
-                  height: #{asset.metadata[:height].inspect},
+                  width: #{rounded_dimension(asset.metadata[:width]).inspect},
+                  height: #{rounded_dimension(asset.metadata[:height]).inspect},
                   content_type: #{asset.content_type.inspect},
                   aspect_ratio: #{AssetJavaScriptMetadata.aspect_ratio(asset.metadata[:width], asset.metadata[:height]).inspect}
                 )
@@ -152,8 +152,8 @@ module Klenod
           def javascript_svg_module_source(asset, context)
             metadata = {
               src: asset.url,
-              width: asset.metadata[:width],
-              height: asset.metadata[:height],
+              width: rounded_dimension(asset.metadata[:width]),
+              height: rounded_dimension(asset.metadata[:height]),
               contentType: asset.content_type,
               aspectRatio: AssetJavaScriptMetadata.aspect_ratio(asset.metadata[:width], asset.metadata[:height])
             }
@@ -175,6 +175,12 @@ module Klenod
             view_box_dimensions(attributes["viewBox"] || attributes["viewbox"])
           end
 
+          # Keep intrinsic dimensions precise in asset metadata so the aspect
+          # ratio is accurate, but expose pixel dimensions as whole numbers.
+          def rounded_dimension(dimension)
+            dimension&.round
+          end
+
           # 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.

data/lib/klenod/build/version.rb

@@ -2,6 +2,6 @@
 
 module Klenod
   module Build
-    VERSION = "0.0.20"
+    VERSION = "0.0.22"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: klenod-build
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.0.22
 platform: ruby
 authors:
 - Andrés Alin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.20
+        version: 0.0.22
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.20
+        version: 0.0.22
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
@@ -327,7 +327,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Build system for Klenod.
 test_files: []