klenod-build 0.0.1

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Build
+    module Plugins
+      module HamlPlugin
+        module HelperSource
+          private
+
+          def haml_helper_dependency(module_id)
+            Dependency
+              .create(
+                specifier: HAML_HELPER_SPECIFIER,
+                importer_id: module_id,
+                kind: :haml_helper
+              )
+              .with(id: "#{module_id}:haml_helper")
+          end
+
+          def haml_helper_source
+            <<~RUBY
+              # frozen_string_literal: true
+
+              module Default
+                def self.merge_props(component_class, *sources)
+                  result = {}
+                  classes = []
+
+                  sources.each do |source|
+                    next unless source
+
+                    source.each do |key, value|
+                      key = normalize_prop_key(key)
+                      if key == :class
+                        collect_class_values(classes, value)
+                      else
+                        result[key] = value
+                      end
+                    end
+                  end
+
+                  class_name = class_name(component_class, classes)
+                  result[:class] = class_name if class_name
+                  result
+                end
+
+                def self.normalize_prop_key(key)
+                  return key if key.is_a?(Symbol) && !key.to_s.include?("-")
+
+                  key.to_s.tr("-", "_").to_sym
+                end
+
+                def self.collect_class_values(classes, value)
+                  case value
+                  when nil, false
+                    nil
+                  when Array
+                    value.each { |item| collect_class_values(classes, item) }
+                  else
+                    classes << value
+                  end
+                end
+
+                def self.class_name(component_class, classes)
+                  return nil if classes.empty?
+
+                  styles = component_class.const_defined?(:ClassNames, false) ? component_class::ClassNames : nil
+                  return nil unless styles.respond_to?(:class_name)
+
+                  styles.class_name(*classes)
+                end
+
+                def self.render_slot(component, name = nil, fallback = nil)
+                  children =
+                    if component.respond_to?(:children)
+                      name ? component.children[name] : component.children
+                    elsif component.respond_to?(:__slots)
+                      component.__slots[name&.to_sym]
+                    end
+
+                  return children if children && !children.empty?
+
+                  fallback
+                end
+
+                def self.freeze_static(value, seen = {})
+                  return value if value.nil? || value == true || value == false || value.is_a?(Symbol) || value.is_a?(Numeric)
+
+                  object_id = value.object_id
+                  return value if seen[object_id]
+
+                  seen[object_id] = true
+
+                  case value
+                  when String
+                    nil
+                  when Array
+                    value.each { |child| freeze_static(child, seen) }
+                  when Hash
+                    value.each do |key, child|
+                      freeze_static(key, seen)
+                      freeze_static(child, seen)
+                    end
+                  else
+                    value.deconstruct.each { |child| freeze_static(child, seen) } if value.respond_to?(:deconstruct)
+                  end
+
+                  value.freeze
+                end
+              end
+            RUBY
+          end
+
+          def haml_helper_needed?(source, styleable:)
+            return true if styleable
+
+            source.match?(STATIC_CLASS_SOURCE_PATTERN) || source.match?(/^\s*%slot\b/)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "ripper"
+require "syntax_tree/haml"
+
+module Klenod
+  module Build
+    module Plugins
+      module HamlPlugin
+        def self.parse_haml(source, module_id: nil)
+          parser = ParserWithMetadata.new({})
+          parser.call(source)
+        rescue ::Haml::SyntaxError => error
+          raise ParseError.new(error, source: source, module_id: module_id)
+        end
+
+        class ParserWithMetadata < ::Haml::Parser
+          def initialize(...)
+            @tag_metadata_by_line = Hash.new { |hash, key| hash[key] = [] }
+            super
+          end
+
+          def call(source)
+            root = super
+            annotate_tag_nodes(root)
+            root
+          end
+
+          private
+
+          def parse_tag(text)
+            result = super
+            _, shorthand_attributes, attribute_hashes = result
+            @tag_metadata_by_line[@line.index + 1] << class_metadata(shorthand_attributes, attribute_hashes)
+            result
+          end
+
+          def annotate_tag_nodes(root)
+            queue = root.children.dup
+            until queue.empty?
+              node = queue.shift
+              if node.type == :tag
+                metadata = @tag_metadata_by_line.fetch(node.line, []).shift
+                node.value[:klenod_class_metadata] = metadata if metadata
+              end
+              queue.concat(node.children)
+            end
+          end
+
+          def class_metadata(shorthand_attributes, attribute_hashes)
+            shorthand = ::Haml::Parser.parse_class_and_id(shorthand_attributes).fetch("class", "").split
+            literal = []
+
+            if (new_attributes = attribute_hashes[:new])
+              literal.concat(Array(new_attributes.fetch(0)["class"]).flat_map { it.to_s.split })
+            end
+
+            if (old_attributes = attribute_hashes[:old])
+              literal.concat(literal_class_names_from_old_attributes(old_attributes))
+            end
+
+            {shorthand: shorthand, literal: literal}
+          end
+
+          def literal_class_names_from_old_attributes(source)
+            parsed = ::Haml::AttributeParser.parse(source)
+            return [] unless parsed&.key?("class")
+
+            value = static_string_literal_value(parsed.fetch("class"))
+            value ? value.split : []
+          end
+
+          def static_string_literal_value(source)
+            case Ripper.sexp(source)
+            in [:program, [[:string_literal, [:string_content, [:@tstring_content, String => value, _location]]]]]
+              value
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end