klenod-build 0.0.31 → 0.0.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 138e1ff7f2bde9f495d98443509718767e179b5e0c7c2a95e92edcd40e3e028a
-  data.tar.gz: 927ea94c5136765c21b25e7b95fe9fb59ecbf3e2b9d697a35a0f457297186c51
+  metadata.gz: c8d75c7c0abc58318ff254e605f618ba14399b9df7fab791e2de204c5546774f
+  data.tar.gz: 86117e7ef465f1a39c59eb25d937eaad3ce0d25096f5a569c396b298db9beccf
 SHA512:
-  metadata.gz: 9c0d70321556eef5ed84c1c96da47ce50dc3a0ed8c940b268cdfa58736a47380f511104cd8385398dff4b4da4757582f447058c1b888a4b04e4edfc550668157
-  data.tar.gz: a0ad06933426e2a03814ed459e52c9d0506825f6ba71e0fc8bf8a6b4e39c681df37f8317d25e812cb84f035b4617bb4dde39001bfc7c67be1c5208050eaef103
+  metadata.gz: a4213e39362700cb1a30e741a48f5e26220b7e00ad77f4cd4f52fddb0ed13ccf5e7bf54f9661da232d3da47f831004169e9217a5e2fe4d5bc8bf654198fde4cb
+  data.tar.gz: 8c1377e40417a5bb09eccca2a167c14883054debd8a9cc010726e748fccc77e9e962243bdd36bb30137b219f487a522404a7d2dc1130630d053326734c13875c

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

@@ -6,6 +6,7 @@ require "toml-rb"
 require "yaml"
 
 require_relative "../plugin"
+require_relative "../ruby_literal"
 require_relative "../source_error"
 require_relative "../transform_result"
 
@@ -64,42 +65,9 @@ module Klenod
 
           def module_source(data)
             <<~RUBY
-              Default = #{ruby_literal(data)}
+              Default = #{RubyLiteral.frozen(data)}
             RUBY
           end
-
-          # `inspect` is not Ruby source for every parsed value: dates, times,
-          # and non-finite floats need constructor calls instead.
-          def ruby_literal(value)
-            case value
-            when Hash
-              entries = value.map { |key, entry| "#{ruby_literal(key)} => #{ruby_literal(entry)}" }
-              "{#{entries.join(", ")}}"
-            when Array
-              "[#{value.map { ruby_literal(it) }.join(", ")}]"
-            when Float
-              float_literal(value)
-            when Time
-              zone = value.utc? ? "UTC" : value.utc_offset
-              "::Time.at(#{value.to_i}, #{value.nsec}, :nsec, in: #{zone.inspect})"
-            when Date
-              "::Date.new(#{value.year}, #{value.month}, #{value.day})"
-            when nil, true, false, String, Symbol, Integer
-              value.inspect
-            else
-              raise TypeError, "Cannot write #{value.class} as data module source"
-            end
-          end
-
-          def float_literal(value)
-            if value.nan?
-              "::Float::NAN"
-            elsif value.infinite?
-              value.positive? ? "::Float::INFINITY" : "-::Float::INFINITY"
-            else
-              value.inspect
-            end
-          end
         end
       end
 

data/lib/klenod/build/plugins/google_fonts_plugin/font_metrics.json

@@ -3167,6 +3167,15 @@
     "unitsPerEm": 1000,
     "xWidthAvg": 589
   },
+  "Clarity City": {
+    "familyName": "Clarity City",
+    "category": "sans-serif",
+    "ascent": 994,
+    "descent": -306,
+    "lineGap": 0,
+    "unitsPerEm": 1000,
+    "xWidthAvg": 479
+  },
   "Clicker Script": {
     "familyName": "Clicker Script",
     "category": "handwriting",
@@ -6461,6 +6470,15 @@
     "unitsPerEm": 1000,
     "xWidthAvg": 288
   },
+  "Isometra": {
+    "familyName": "Isometra",
+    "category": "serif",
+    "ascent": 1050,
+    "descent": -250,
+    "lineGap": 0,
+    "unitsPerEm": 1000,
+    "xWidthAvg": 683
+  },
   "Istok Web": {
     "familyName": "Istok Web",
     "category": "sans-serif",
@@ -7307,6 +7325,15 @@
     "unitsPerEm": 1000,
     "xWidthAvg": 412
   },
+  "Kripa": {
+    "familyName": "Kripa",
+    "category": "sans-serif",
+    "ascent": 1080,
+    "descent": -390,
+    "lineGap": 0,
+    "unitsPerEm": 1000,
+    "xWidthAvg": 481
+  },
   "Kristi": {
     "familyName": "Kristi",
     "category": "handwriting",
@@ -7802,6 +7829,15 @@
     "unitsPerEm": 1000,
     "xWidthAvg": 450
   },
+  "Libre Caslon Condensed": {
+    "familyName": "Libre Caslon Condensed",
+    "category": "serif",
+    "ascent": 2061,
+    "descent": -539,
+    "lineGap": 0,
+    "unitsPerEm": 2000,
+    "xWidthAvg": 767
+  },
   "Libre Caslon Display": {
     "familyName": "Libre Caslon Display",
     "category": "serif",

data/lib/klenod/build/plugins/google_fonts_plugin/font_metrics.txt

@@ -5,7 +5,7 @@ Update them to the latest Capsize revision from the Klenod repository root:
     bundle exec rake google_fonts:metrics:update
 
 Project: https://github.com/seek-oss/capsize
-Commit: 8df97f098adc19d8a6d33df301757d7e9670bae6
+Commit: 51946f815deeef7d9d97e0149659abdb50348099
 Source: packages/metrics/src/entireMetricsCollection.json
 
 MIT License

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

@@ -100,7 +100,9 @@ module Klenod
             end
 
             if (old_attributes = attribute_hashes[:old])
-              literal.concat(literal_class_names_from_old_attributes(old_attributes))
+              folded_shorthand, folded_literal = folded_class_names_from_old_attributes(old_attributes)
+              shorthand.concat(folded_shorthand)
+              literal.concat(folded_literal)
             end
 
             {shorthand: shorthand, literal: literal}
@@ -222,20 +224,26 @@ module Klenod
             attribute_sequence?(rest)
           end
 
-          def literal_class_names_from_old_attributes(source)
-            parsed = ::Haml::AttributeParser.parse(source)
-            return [] unless parsed&.key?("class")
+          # Haml folds an old-style hash into the tag's static attributes only
+          # when `parse_static_hash` accepts it (hashrocket pairs of literals),
+          # and then drops the hash source. Any other hash, such as
+          # `{class: "plain"}`, stays a dynamic attribute that the transformer
+          # compiles itself, so only folded classes are recorded here. String
+          # classes stay literal and symbol classes stay scoped, matching how
+          # dynamic class values render.
+          def folded_class_names_from_old_attributes(source)
+            return [[], []] unless parse_static_hash(source)
 
-            value = static_string_literal_value(parsed.fetch("class"))
-            value ? value.split : []
-          end
+            parsed = ::Haml::AttributeParser.parse(source)
+            return [[], []] unless parsed&.key?("class")
 
-          def static_string_literal_value(source)
-            case Ripper.sexp(source)
+            case Ripper.sexp(parsed.fetch("class"))
             in [:program, [[:string_literal, [:string_content, [:@tstring_content, String => value, _location]]]]]
-              value
+              [[], value.split]
+            in [:program, [[:symbol_literal, [:symbol, [_type, String => name, _location]]]]]
+              [[name], []]
             else
-              nil
+              [[], []]
             end
           end
         end

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

@@ -203,10 +203,6 @@ module Klenod
               Fragment.new(literal_source(value))
             end
 
-            def frozen_literal(value)
-              Fragment.new(frozen_literal_source(value))
-            end
-
             def import_call(dependency_id)
               Fragment.new("__klenod_import__(#{literal_source(dependency_id)})")
             end
@@ -443,13 +439,16 @@ module Klenod
             # Whether the script opens a literal block for its Haml children.
             # Calls, `super`, and zsuper can take one; lambdas cannot.
             def block_script?(source)
-              node = parse_expression(fix_syntax_by_adding_missing_pairs(source), context: :block_script)
-
-              node.respond_to?(:block) && node.block.is_a?(Prism::BlockNode)
+              !script_block_node(source).nil?
             end
 
             private
 
+            def script_block_node(source)
+              node = parse_expression(fix_syntax_by_adding_missing_pairs(source), context: :block_script)
+              node.block if node.respond_to?(:block) && node.block.is_a?(Prism::BlockNode)
+            end
+
             def rewrite_ruby_source(source, line_no)
               source = rewrite_line_constant(source, line_no)
               rewrite_variables(source)
@@ -580,7 +579,9 @@ module Klenod
             def block_source(source, body)
               body_source = to_source(body)
 
-              if source.include?("{") && !source.end_with?(" do")
+              # Hash arguments, strings, and parameter defaults can contain
+              # braces without opening the block that owns the Haml children.
+              if script_block_node(source)&.opening_loc&.slice == "{"
                 "#{source} #{body_source} }"
               else
                 [source, indent(body_source, 2), "end"].join("\n")
@@ -630,17 +631,6 @@ module Klenod
               "#{symbol_source(name)} =>"
             end
 
-            def frozen_literal_source(value)
-              case value
-              when Hash
-                "{#{value.map { |key, child| "#{literal_source(key)} => #{frozen_literal_source(child)}" }.join(", ")}}.freeze"
-              when Array
-                "[#{value.map { |child| frozen_literal_source(child) }.join(", ")}].freeze"
-              else
-                literal_source(value)
-              end
-            end
-
             def literal_source(value)
               case value
               when String

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

@@ -6,6 +6,7 @@ require_relative "../plugin"
 require_relative "../dependency"
 require_relative "../module_id"
 require_relative "../ruby_import_rewriter"
+require_relative "../ruby_literal"
 require_relative "../transform_result"
 require_relative "../watched_pattern"
 require_relative "intl_plugin"
@@ -176,7 +177,7 @@ module Klenod
             styles_source = styles_source_for(builder, style_dependencies, class_names_runtime_dependency: class_names_runtime_dependency)
             haml_helper_dependency = haml_helper_dependency(module_id)
             dependencies << haml_helper_dependency
-            translations_source = builder.frozen_literal(translations_for(context, module_id)).source
+            translations_source = RubyLiteral.frozen(translations_for(context, module_id))
             component_class_name = component_class_name(module_id)
             import_rewriter =
               lambda do |source, source_line_offset: 0, source_column_offset: 0|

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

@@ -4,6 +4,7 @@ require_relative "../dependency"
 require_relative "../errors"
 require_relative "../module_id"
 require_relative "../plugin"
+require_relative "../ruby_literal"
 require "klenod/runtime/source_map"
 require_relative "../transform_result"
 require_relative "../watched_pattern"
@@ -376,11 +377,17 @@ module Klenod
           def generate_router_source(manifest)
             imports = import_refs(manifest)
             <<~RUBY
+              require "uri"
+
               Segment = Data.define(:name, :kind, :param_name, :path_part)
               Param = Data.define(:name, :kind)
               #{import_definitions(imports)}
 
               module Default
+                # Raised for a request path with a malformed percent-encoding
+                # or an escape that does not decode to UTF-8.
+                MalformedPathError = Class.new(StandardError)
+
                 Route = Data.define(:path, :page_module_id, :handler_module_id, :segments, :match_parts, :layout_module_ids, :slot_layout_module_id, :page_ref, :handler_ref, :layout_refs) do
                   def params
                     segments
@@ -528,7 +535,7 @@ module Klenod
                 end
 
                 def self.match(path)
-                  parts = normalize_path(path)
+                  parts = request_parts(path)
                   route = main_route_for(parts)
                   return nil unless route
 
@@ -553,6 +560,22 @@ module Klenod
                   normalized.split("/").reject(&:empty?)
                 end
 
+                # Request path segments, each percent-decoded after splitting so
+                # an encoded slash stays inside its segment. `.` and `..` are
+                # kept as ordinary segments; nothing is normalized.
+                def self.request_parts(path)
+                  normalize_path(path).map do |part|
+                    decoded = begin
+                      URI.decode_uri_component(part)
+                    rescue ArgumentError
+                      nil
+                    end
+                    raise MalformedPathError, "Malformed percent-encoding in path segment \#{part.inspect}" unless decoded&.valid_encoding?
+
+                    decoded
+                  end
+                end
+
                 def self.build_tree(routes)
                   root = RouteNode.new(segment: nil, path: "/")
 
@@ -632,7 +655,7 @@ module Klenod
                 end
 
                 def self.special_match(views, path)
-                  parts = normalize_path(path)
+                  parts = request_parts(path)
                   view = special_view_for(views, parts)
                   return nil unless view
 
@@ -742,7 +765,7 @@ module Klenod
                 "      #{route.handler_module_id&.path.inspect},",
                 "      #{segments_source(route.segments)},",
                 "      #{match_parts_source(route.segments)},",
-                "      #{route.layout_module_ids.map(&:path).inspect},",
+                "      #{RubyLiteral.frozen(route.layout_module_ids.map(&:path))},",
                 "      #{route.slot_layout_module_id&.path.inspect},",
                 "      #{route.page_module_id ? imports.fetch(route.page_module_id.to_s) : "nil"},",
                 "      #{route.handler_module_id ? imports.fetch(route.handler_module_id.to_s) : "nil"},",
@@ -763,7 +786,7 @@ module Klenod
                 "      #{view.view_module_id.path.inspect},",
                 "      #{segments_source(view.segments)},",
                 "      #{match_parts_source(view.segments)},",
-                "      #{view.layout_module_ids.map(&:path).inspect},",
+                "      #{RubyLiteral.frozen(view.layout_module_ids.map(&:path))},",
                 "      #{imports.fetch(view.view_module_id.to_s)},",
                 "      #{layouts_source(layouts)}",
                 "    )"
@@ -841,11 +864,11 @@ module Klenod
           end
 
           def segments_source(segments)
-            "[#{segments.map { |segment| segment_source(segment) }.join(", ")}]"
+            "[#{segments.map { |segment| segment_source(segment) }.join(", ")}].freeze"
           end
 
           def match_parts_source(segments)
-            route_match_parts_for(segments).inspect
+            RubyLiteral.frozen(route_match_parts_for(segments))
           end
 
           def segment_source(segment)
@@ -883,7 +906,7 @@ module Klenod
           end
 
           def layouts_source(layouts)
-            "[#{layouts.join(", ")}]"
+            "[#{layouts.join(", ")}].freeze"
           end
 
           def route_handler_module_id?(module_id, context)

data/lib/klenod/build/ruby_literal.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Klenod
+  module Build
+    # Writes parsed data as Ruby source for generated modules. Every hash,
+    # array, time, and date is frozen; string literals are frozen because
+    # modules are evaluated with `frozen_string_literal: true`.
+    module RubyLiteral
+      module_function
+
+      # `inspect` is not Ruby source for every parsed value: dates, times,
+      # and non-finite floats need constructor calls instead.
+      def frozen(value)
+        case value
+        when Hash
+          entries = value.map { |key, entry| "#{frozen(key)} => #{frozen(entry)}" }
+          "{#{entries.join(", ")}}.freeze"
+        when Array
+          "[#{value.map { frozen(it) }.join(", ")}].freeze"
+        when Float
+          float(value)
+        when Time
+          zone = value.utc? ? "UTC" : value.utc_offset
+          "::Time.at(#{value.to_i}, #{value.nsec}, :nsec, in: #{zone.inspect}).freeze"
+        when Date
+          "::Date.new(#{value.year}, #{value.month}, #{value.day}).freeze"
+        when nil, true, false, String, Symbol, Integer
+          value.inspect
+        else
+          raise TypeError, "Cannot write #{value.class} as Ruby literal source"
+        end
+      end
+
+      def float(value)
+        if value.nan?
+          "::Float::NAN"
+        elsif value.infinite?
+          value.positive? ? "::Float::INFINITY" : "-::Float::INFINITY"
+        else
+          value.inspect
+        end
+      end
+    end
+  end
+end

data/lib/klenod/build/version.rb

@@ -2,6 +2,6 @@
 
 module Klenod
   module Build
-    VERSION = "0.0.31"
+    VERSION = "0.0.33"
   end
 end

metadata

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