haml2html 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54fab4cd9a6853ba2f3bb3568c17a18f1667b7507a2de432966bea62e6a218e1
-  data.tar.gz: 11e567f5d534e34e2f1a88029f94e20847d13953cdd995e169a65246aaba8ed9
+  metadata.gz: 14f09bc19dfb59cd98fd339e28b7a9a82031ff68a6f9bcb1f09bea25ad5eef24
+  data.tar.gz: 2dd302143f309d861781c904673a986c9525df51538538212194c148eb629929
 SHA512:
-  metadata.gz: e5506405f5757513488fd1771d86adbee964c08d89d5f42f54e1236e6a2e32f1d871ca29c9ee7db83687629325d241416b222e279253f1a464b603ef4c0425af
-  data.tar.gz: bed4c344c88cf6cbd41d89f59398c15ea724a63afb2b91c852f1a1d3402d676dda2be37d6a85414173437fad54064dd4642591e1547d2d38403ba1e38abdb976
+  metadata.gz: f64fb147af2fe01e270f30f5ada9c75776c3434cbd8cf3c724b5f6893edee8ec53462288b3349c0350bd3a90a0e66b5d1f16950849e1671da524abedebe557be
+  data.tar.gz: '04956657bb059627298a8e38502386229a2bdc8ca05f2af5687cf37783b4548ddf52562169c0fab171f1542795d32a1a9159d310cee821234d131b8be7230233'

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.1.4
+
+- Remove the `tag.attributes` fallback and emit literal dynamic attributes directly.
+
 ## 0.1.3
 
 - Fix generated ERB for Haml attributes with mixed static and dynamic classes.

data/README.md

@@ -79,7 +79,7 @@ end
 - Ruby output and control flow: `=`, `!=`, `- if`, `- each do`, and similar blocks.
 - Public comments and silent comments.
 - `:plain`, `:escaped`, `:javascript`, `:css`, `:erb`, and `:ruby` filters.
-- Dynamic Haml attributes through Rails `tag.attributes`.
+- Literal dynamic Haml attribute hashes, including simple `class`, `data`, `aria`, and boolean attributes.
 
 ## Limitations
 

data/lib/haml2html/converter.rb

@@ -9,6 +9,12 @@ require_relative "diagnostic"
 module Haml2html
   class Converter
     VOID_TAGS = %w[area base br col embed hr img input link meta param source track wbr].freeze
+    BOOLEAN_ATTRIBUTES = %w[
+      allowfullscreen async autofocus autoplay checked compact controls declare default defaultchecked defaultmuted
+      defaultselected defer disabled enabled formnovalidate hidden indeterminate inert ismap itemscope loop multiple
+      muted nohref nomodule noresize noshade novalidate nowrap open pauseonexit playsinline readonly required
+      reversed scoped seamless selected sortable truespeed typemustmatch visible
+    ].freeze
     SUPPORTED_FILTERS = %w[plain escaped javascript css erb ruby].freeze
 
     attr_reader :diagnostics
@@ -106,12 +112,14 @@ module Haml2html
       dynamic = dynamic_attributes_expression(value[:dynamic_attributes])
       return static_attributes(attrs) unless dynamic
 
-      if (simple_attrs = simple_dynamic_attributes(dynamic))
-        dynamic_class = simple_attrs.delete("class")
-        return "#{static_attributes(attrs, dynamic_class: dynamic_class)}#{simple_attrs.map { |name, attr_value| dynamic_attribute(name, attr_value) }.join}"
+      simple_attrs = simple_dynamic_attributes(dynamic)
+      unless simple_attrs
+        unsupported(node, "dynamic attributes", "only literal dynamic attribute hashes can be converted safely")
+        return static_attributes(attrs)
       end
 
-      "#{static_attributes(attrs)}#{dynamic_attributes(dynamic)}"
+      dynamic_class = simple_attrs.delete("class")
+      "#{static_attributes(attrs, dynamic_class: dynamic_class&.then { |attr| dynamic_attribute_value(attr) })}#{simple_attrs.values.map { |attr| dynamic_attribute(attr) }.join}"
     end
 
     def emit_script(node, indent)
@@ -195,12 +203,15 @@ module Haml2html
       end.join
     end
 
-    def dynamic_attributes(dynamic)
-      %(<%== (_haml2html_attrs = tag.attributes(**#{dynamic})).empty? ? "" : " \#{_haml2html_attrs}" %>)
-    end
+    def dynamic_attribute(attr)
+      name = attr.fetch(:name)
+      if BOOLEAN_ATTRIBUTES.include?(name)
+        return attr.fetch(:value) ? " #{name}" : "" unless attr.fetch(:dynamic)
+
+        return %(<%= (#{attr.fetch(:value)}) ? " #{name}" : "" %>)
+      end
 
-    def dynamic_attribute(name, value)
-      %( #{name}="#{value}")
+      %( #{name}="#{dynamic_attribute_value(attr)}")
     end
 
     def simple_dynamic_attributes(dynamic)
@@ -212,33 +223,147 @@ module Haml2html
       return nil unless associations.is_a?(Array)
 
       associations.each_with_object({}) do |association, attrs|
-        return nil unless association&.first == :assoc_new
+        name = dynamic_attribute_name(association)
+        return nil unless name
+
+        if name == "data"
+          data_attrs = simple_prefixed_attributes("data", association[2], dynamic)
+          return nil unless data_attrs
+
+          attrs.merge!(data_attrs)
+        elsif name == "aria"
+          aria_attrs = simple_prefixed_attributes("aria", association[2], dynamic)
+          return nil unless aria_attrs
+
+          attrs.merge!(aria_attrs)
+        else
+          value = simple_dynamic_attribute_value(name, association[2], dynamic)
+          return nil unless value
+
+          attrs[name] = value.merge(name: name)
+        end
+      end
+    end
 
-        label = association[1]
-        return nil unless label&.first == :@label
+    def dynamic_attribute_name(association)
+      return nil unless association&.first == :assoc_new
 
-        value = simple_dynamic_attribute_value(association[2])
+      label = association[1]
+      return nil unless label&.first == :@label
+
+      label[1].delete_suffix(":")
+    end
+
+    def simple_prefixed_attributes(prefix, node, source)
+      return nil unless node&.first == :hash
+
+      associations = node.dig(1, 1)
+      return nil unless associations.is_a?(Array)
+
+      associations.each_with_object({}) do |association, attrs|
+        name = dynamic_attribute_name(association)
+        return nil unless name
+
+        value = simple_dynamic_attribute_value(name, association[2], source)
         return nil unless value
+        next if !value.fetch(:dynamic) && [false, nil].include?(value.fetch(:value))
 
-        attrs[label[1].delete_suffix(":")] = value
+        attr_name = "#{prefix}-#{name.tr("_", "-")}"
+        attrs[attr_name] = value.merge(name: attr_name)
       end
     end
 
-    def simple_dynamic_attribute_value(node)
+    def simple_dynamic_attribute_value(name, node, source)
       case node&.first
       when :string_literal
-        escape_attr(string_literal_content(node))
+        string = string_literal_content(node)
+        return nil unless string
+
+        { dynamic: false, value: string }
+      when :symbol_literal
+        { dynamic: false, value: symbol_literal_content(node) }
+      when :var_ref
+        if (keyword = node.dig(1, 1)) && %w[true false nil].include?(keyword)
+          return { dynamic: false, value: literal_keyword_value(keyword) }
+        end
+
+        expression = ruby_expression(node, source)
+        expression && { dynamic: true, value: expression }
       when :vcall
-        ident = node.dig(1, 1)
-        return nil unless ident
+        expression = ruby_expression(node, source)
+        expression && { dynamic: true, value: expression }
+      when :array
+        return nil unless name == "class"
+
+        expression = class_names_expression(node, source)
+        expression && { dynamic: true, value: expression }
+      else
+        expression = ruby_expression(node, source)
+        expression && { dynamic: true, value: expression }
+      end
+    end
+
+    def dynamic_attribute_value(attr)
+      value = attr.fetch(:value)
+      attr.fetch(:dynamic) ? "<%= #{value} %>" : escape_attr(value.to_s)
+    end
+
+    def class_names_expression(node, source)
+      values = node[1]
+      return "class_names" if values.nil? || values.empty?
+
+      args = values.map { |value| ruby_expression(value, source) }
+      return nil if args.any?(&:nil?)
+
+      "class_names(#{args.join(", ")})"
+    end
 
-        "<%= #{ident} %>"
+    def ruby_expression(node, source)
+      case node&.first
+      when :string_literal
+        string = string_literal_content(node)
+        string&.inspect
+      when :symbol_literal
+        ":#{symbol_literal_content(node)}"
+      when :var_ref, :vcall
+        node.dig(1, 1)
+      when :unary
+        expression = ruby_expression(node[2], source)
+        expression && "#{node[1]}#{expression}"
+      when :call
+        receiver = ruby_expression(node[1], source)
+        method = node.dig(3, 1)
+        receiver && method && "#{receiver}.#{method}"
+      when :method_add_arg
+        ruby_expression(node[1], source) if node[2]&.empty?
+      when :fcall
+        node.dig(1, 1)
       end
     end
 
     def string_literal_content(node)
-      content = node.dig(1, 1, 1)
-      content.to_s
+      content = node[1]
+      return nil unless content&.first == :string_content
+
+      parts = content[1..] || []
+      return nil unless parts.all? { |part| part.is_a?(Array) && part.first == :@tstring_content }
+
+      parts.map { |part| part[1] }.join
+    end
+
+    def symbol_literal_content(node)
+      node.dig(1, 1, 1).to_s
+    end
+
+    def literal_keyword_value(keyword)
+      case keyword
+      when "true"
+        true
+      when "false"
+        false
+      when "nil"
+        nil
+      end
     end
 
     def dynamic_attributes_expression(dynamic)

data/lib/haml2html/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Haml2html
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: haml2html
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Kyle
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-08 00:00:00.000000000 Z
+date: 2026-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: haml