haml 5.0.4 → 6.0.0

data/lib/haml/attribute_compiler.rb

@@ -1,223 +1,128 @@
 # frozen_string_literal: true
+require 'haml/attribute_builder'
 require 'haml/attribute_parser'
+require 'haml/ruby_expression'
 
 module Haml
   class AttributeCompiler
-    # @param type [Symbol] :static or :dynamic
-    # @param key [String]
-    # @param value [String] Actual string value for :static type, value's Ruby literal for :dynamic type.
-    class AttributeValue < Struct.new(:type, :key, :value)
-      # @return [String] A Ruby literal of value.
-      def to_literal
-        case type
-        when :static
-          Haml::Util.inspect_obj(value)
-        when :dynamic
-          value
-        end
-      end
-    end
-
-    # Returns a script to render attributes on runtime.
-    #
-    # @param attributes [Hash]
-    # @param object_ref [String,:nil]
-    # @param dynamic_attributes [DynamicAttributes]
-    # @return [String] Attributes rendering code
-    def self.runtime_build(attributes, object_ref, dynamic_attributes)
-      "_hamlout.attributes(#{Haml::Util.inspect_obj(attributes)}, #{object_ref},#{dynamic_attributes.to_literal})"
-    end
-
-    # @param options [Haml::Options]
-    def initialize(options)
-      @is_html = [:html4, :html5].include?(options[:format])
-      @attr_wrapper = options[:attr_wrapper]
+    def initialize(identity, options)
+      @identity = identity
+      @quote  = options[:attr_quote]
+      @format = options[:format]
       @escape_attrs = options[:escape_attrs]
-      @hyphenate_data_attrs = options[:hyphenate_data_attrs]
     end
 
-    # Returns Temple expression to render attributes.
-    #
-    # @param attributes [Hash]
-    # @param object_ref [String,:nil]
-    # @param dynamic_attributes [DynamicAttributes]
-    # @return [Array] Temple expression
-    def compile(attributes, object_ref, dynamic_attributes)
-      if object_ref != :nil || !AttributeParser.available?
-        return [:dynamic, AttributeCompiler.runtime_build(attributes, object_ref, dynamic_attributes)]
+    def compile(node)
+      hashes = []
+      if node.value[:object_ref] != :nil || !Ripper.respond_to?(:lex) # No Ripper.lex in truffleruby
+        return runtime_compile(node)
       end
-
-      parsed_hashes = [dynamic_attributes.new, dynamic_attributes.old].compact.map do |attribute_hash|
-        unless (hash = AttributeParser.parse(attribute_hash))
-          return [:dynamic, AttributeCompiler.runtime_build(attributes, object_ref, dynamic_attributes)]
-        end
-        hash
+      [node.value[:dynamic_attributes].new, node.value[:dynamic_attributes].old].compact.each do |attribute_str|
+        hash = AttributeParser.parse(attribute_str)
+        return runtime_compile(node) unless hash
+        hashes << hash
       end
-      attribute_values = build_attribute_values(attributes, parsed_hashes)
-      AttributeBuilder.verify_attribute_names!(attribute_values.map(&:key))
-
-      [:multi, *group_values_for_sort(attribute_values).map { |value_group|
-        compile_attribute_values(value_group)
-      }]
+      static_compile(node.value[:attributes], hashes)
     end
 
     private
 
-    # Build array of grouped values whose sort order may go back and forth, which is also sorted with key name.
-    # This method needs to group values with the same start because it can be changed in `Haml::AttributeBuidler#build_data_keys`.
-    # @param values [Array<Haml::AttributeCompiler::AttributeValue>]
-    # @return [Array<Array<Haml::AttributeCompiler::AttributeValue>>]
-    def group_values_for_sort(values)
-      sorted_values = values.sort_by(&:key)
-      [].tap do |value_groups|
-        until sorted_values.empty?
-          key = sorted_values.first.key
-          value_group, sorted_values = sorted_values.partition { |v| v.key.start_with?(key) }
-          value_groups << value_group
+    def runtime_compile(node)
+      attrs = []
+      attrs.unshift(node.value[:attributes].inspect) if node.value[:attributes] != {}
+
+      args = [
+        @escape_attrs.inspect, "#{@quote.inspect}.freeze", @format.inspect,
+        '::Haml::AttributeBuilder::BOOLEAN_ATTRIBUTES', node.value[:object_ref],
+      ] + attrs
+      [:html, :attrs, [:dynamic, "::Haml::AttributeBuilder.build(#{args.join(', ')}, #{node.value[:dynamic_attributes].to_literal})"]]
+    end
+
+    def static_compile(static_hash, dynamic_hashes)
+      temple = [:html, :attrs]
+      keys = [*static_hash.keys, *dynamic_hashes.map(&:keys).flatten].uniq.sort
+      keys.each do |key|
+        values = [[:static, static_hash[key]], *dynamic_hashes.map { |h| [:dynamic, h[key]] }]
+        values.select! { |_, exp| exp != nil }
+
+        case key
+        when 'id'
+          compile_id!(temple, key, values)
+        when 'class'
+          compile_class!(temple, key, values)
+        when 'data', 'aria'
+          compile_data!(temple, key, values)
+        when *AttributeBuilder::BOOLEAN_ATTRIBUTES, /\Adata-/, /\Aaria-/
+          compile_boolean!(temple, key, values)
+        else
+          compile_common!(temple, key, values)
         end
       end
+      temple
     end
 
-    # Returns array of AttributeValue instances from static attributes and dynamic_attributes. For each key,
-    # the values' order in returned value is preserved in the same order as Haml::Buffer#attributes's merge order.
-    #
-    # @param attributes [{ String => String }]
-    # @param parsed_hashes [{ String => String }]
-    # @return [Array<AttributeValue>]
-    def build_attribute_values(attributes, parsed_hashes)
-      [].tap do |attribute_values|
-        attributes.each do |key, static_value|
-          attribute_values << AttributeValue.new(:static, key, static_value)
-        end
-        parsed_hashes.each do |parsed_hash|
-          parsed_hash.each do |key, dynamic_value|
-            attribute_values << AttributeValue.new(:dynamic, key, dynamic_value)
-          end
-        end
+    def compile_id!(temple, key, values)
+      build_code = attribute_builder(:id, values)
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:html, :attr, key, [:static, eval(build_code).to_s]]
+      else
+        temple << [:html, :attr, key, [:dynamic, build_code]]
       end
     end
 
-    # Compiles attribute values with the similar key to Temple expression.
-    #
-    # @param values [Array<AttributeValue>] whose `key`s are partially or fully the same from left.
-    # @return [Array] Temple expression
-    def compile_attribute_values(values)
-      if values.map(&:key).uniq.size == 1
-        compile_attribute(values.first.key, values)
+    def compile_class!(temple, key, values)
+      build_code = attribute_builder(:class, values)
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:html, :attr, key, [:static, eval(build_code).to_s]]
       else
-        runtime_build(values)
+        temple << [:html, :attr, key, [:dynamic, build_code]]
       end
     end
 
-    # @param values [Array<AttributeValue>]
-    # @return [Array] Temple expression
-    def runtime_build(values)
-      hash_content = values.group_by(&:key).map do |key, values_for_key|
-        "#{frozen_string(key)} => #{merged_value(key, values_for_key)}"
-      end.join(', ')
-      [:dynamic, "_hamlout.attributes({ #{hash_content} }, nil)"]
-    end
-
-    # Renders attribute values statically.
-    #
-    # @param values [Array<AttributeValue>]
-    # @return [Array] Temple expression
-    def static_build(values)
-      hash_content = values.group_by(&:key).map do |key, values_for_key|
-        "#{frozen_string(key)} => #{merged_value(key, values_for_key)}"
-      end.join(', ')
-
-      arguments = [@is_html, @attr_wrapper, @escape_attrs, @hyphenate_data_attrs]
-      code = "::Haml::AttributeBuilder.build_attributes"\
-        "(#{arguments.map { |a| Haml::Util.inspect_obj(a) }.join(', ')}, { #{hash_content} })"
-      [:static, eval(code).to_s]
-    end
+    def compile_data!(temple, key, values)
+      args = [@escape_attrs.inspect, "#{@quote.inspect}.freeze", values.map { |v| literal_for(v) }]
+      build_code = "::Haml::AttributeBuilder.build_#{key}(#{args.join(', ')})"
 
-    # @param key [String]
-    # @param values [Array<AttributeValue>]
-    # @return [String]
-    def merged_value(key, values)
-      if values.size == 1
-        values.first.to_literal
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:static, eval(build_code).to_s]
       else
-        "::Haml::AttributeBuilder.merge_values(#{frozen_string(key)}, #{values.map(&:to_literal).join(', ')})"
+        temple << [:dynamic, build_code]
       end
     end
 
-    # @param str [String]
-    # @return [String]
-    def frozen_string(str)
-      "#{Haml::Util.inspect_obj(str)}.freeze"
-    end
+    def compile_boolean!(temple, key, values)
+      exp = literal_for(values.last)
 
-    # Compiles attribute values for one key to Temple expression that generates ` key='value'`.
-    #
-    # @param key [String]
-    # @param values [Array<AttributeValue>]
-    # @return [Array] Temple expression
-    def compile_attribute(key, values)
-      if values.all? { |v| Temple::StaticAnalyzer.static?(v.to_literal) }
-        return static_build(values)
-      end
-
-      case key
-      when 'id', 'class'
-        compile_id_or_class_attribute(key, values)
+      if Temple::StaticAnalyzer.static?(exp)
+        value = eval(exp)
+        case value
+        when true then temple << [:html, :attr, key, @format == :xhtml ? [:static, key] : [:multi]]
+        when false, nil
+        else temple << [:html, :attr, key, [:fescape, @escape_attrs, [:static, value.to_s]]]
+        end
       else
-        compile_common_attribute(key, values)
-      end
-    end
-
-    # @param id_or_class [String] "id" or "class"
-    # @param values [Array<AttributeValue>]
-    # @return [Array] Temple expression
-    def compile_id_or_class_attribute(id_or_class, values)
-      var = unique_name
-      [:multi,
-       [:code, "#{var} = (#{merged_value(id_or_class, values)})"],
-       [:case, var,
-        ['Hash, Array', runtime_build([AttributeValue.new(:dynamic, id_or_class, var)])],
-        ['false, nil', [:multi]],
-        [:else, [:multi,
-                 [:static, " #{id_or_class}=#{@attr_wrapper}"],
-                 [:escape, @escape_attrs, [:dynamic, var]],
-                 [:static, @attr_wrapper]],
+        var = @identity.generate
+        temple << [
+          :case, "(#{var} = (#{exp}))",
+          ['true', [:html, :attr, key, @format == :xhtml ? [:static, key] : [:multi]]],
+          ['false, nil', [:multi]],
+          [:else, [:multi, [:static, " #{key}=#{@quote}"], [:fescape, @escape_attrs, [:dynamic, var]], [:static, @quote]]],
         ]
-       ],
-      ]
+      end
     end
 
-    # @param key [String] Not "id" or "class"
-    # @param values [Array<AttributeValue>]
-    # @return [Array] Temple expression
-    def compile_common_attribute(key, values)
-      var = unique_name
-      [:multi,
-       [:code, "#{var} = (#{merged_value(key, values)})"],
-       [:case, var,
-        ['Hash', runtime_build([AttributeValue.new(:dynamic, key, var)])],
-        ['true', true_value(key)],
-        ['false, nil', [:multi]],
-        [:else, [:multi,
-                 [:static, " #{key}=#{@attr_wrapper}"],
-                 [:escape, @escape_attrs, [:dynamic, var]],
-                 [:static, @attr_wrapper]],
-        ]
-       ],
-      ]
+    def compile_common!(temple, key, values)
+      temple << [:html, :attr, key, [:fescape, @escape_attrs, values.last]]
     end
 
-    def true_value(key)
-      if @is_html
-        [:static, " #{key}"]
-      else
-        [:static, " #{key}=#{@attr_wrapper}#{key}#{@attr_wrapper}"]
-      end
+    def attribute_builder(type, values)
+      args = [@escape_attrs.inspect, *values.map { |v| literal_for(v) }]
+      "::Haml::AttributeBuilder.build_#{type}(#{args.join(', ')})"
     end
 
-    def unique_name
-      @unique_name ||= 0
-      "_haml_attribute_compiler#{@unique_name += 1}"
+    def literal_for(value)
+      type, exp = value
+      type == :static ? "#{exp.inspect}.freeze" : exp
     end
   end
 end

data/lib/haml/attribute_parser.rb

@@ -1,148 +1,110 @@
 # frozen_string_literal: true
-begin
-  require 'ripper'
-rescue LoadError
-end
+require 'haml/ruby_expression'
 
 module Haml
-  # Haml::AttriubuteParser parses Hash literal to { String (key name) => String (value literal) }.
-  module AttributeParser
-    class UnexpectedTokenError < StandardError; end
-    class UnexpectedKeyError < StandardError; end
+  class AttributeParser
+    class ParseSkip < StandardError
+    end
 
-    # Indices in Ripper tokens
-    TYPE = 1
-    TEXT = 2
+    def self.parse(text)
+      self.new.parse(text)
+    end
 
-    IGNORED_TYPES = %i[on_sp on_ignored_nl]
+    def parse(text)
+      exp = wrap_bracket(text)
+      return if RubyExpression.syntax_error?(exp)
 
-    class << self
-      # @return [Boolean] - return true if AttributeParser.parse can be used.
-      def available?
-        defined?(Ripper) && Temple::StaticAnalyzer.available?
+      hash = {}
+      tokens = Ripper.lex(exp)[1..-2] || []
+      each_attr(tokens) do |attr_tokens|
+        key = parse_key!(attr_tokens)
+        hash[key] = attr_tokens.map { |t| t[2] }.join.strip
       end
+      hash
+    rescue ParseSkip
+      nil
+    end
 
-      # @param  [String] exp - Old attributes literal or Hash literal generated from new attributes.
-      # @return [Hash<String, String>,nil] - Return parsed attribute Hash whose values are Ruby literals, or return nil if argument is not a single Hash literal.
-      def parse(exp)
-        return nil unless hash_literal?(exp)
+    private
 
-        hash = {}
-        each_attribute(exp) do |key, value|
-          hash[key] = value
+    def wrap_bracket(text)
+      text = text.strip
+      return text if text[0] == '{'
+      "{#{text}}"
+    end
+
+    def parse_key!(tokens)
+      _, type, str = tokens.shift
+      case type
+      when :on_sp
+        parse_key!(tokens)
+      when :on_label
+        str.tr(':', '')
+      when :on_symbeg
+        _, _, key = tokens.shift
+        assert_type!(tokens.shift, :on_tstring_end) if str != ':'
+        skip_until_hash_rocket!(tokens)
+        key
+      when :on_tstring_beg
+        _, _, key = tokens.shift
+        next_token = tokens.shift
+        unless next_token[1] == :on_label_end
+          assert_type!(next_token, :on_tstring_end)
+          skip_until_hash_rocket!(tokens)
         end
-        hash
-      rescue UnexpectedTokenError, UnexpectedKeyError
-        nil
+        key
+      else
+        raise ParseSkip
       end
+    end
 
-      private
+    def assert_type!(token, type)
+      raise ParseSkip if token[1] != type
+    end
 
-      # @param  [String] exp - Ruby expression
-      # @return [Boolean] - Return true if exp is a single Hash literal
-      def hash_literal?(exp)
-        return false if Temple::StaticAnalyzer.syntax_error?(exp)
-        sym, body = Ripper.sexp(exp)
-        sym == :program && body.is_a?(Array) && body.size == 1 && body[0] && body[0][0] == :hash
+    def skip_until_hash_rocket!(tokens)
+      until tokens.empty?
+        _, type, str = tokens.shift
+        break if type == :on_op && str == '=>'
       end
+    end
 
-      # @param [Array] tokens - Ripper tokens. Scanned tokens will be destructively removed from this argument.
-      # @return [String] - attribute name in String
-      def shift_key!(tokens)
-        while !tokens.empty? && IGNORED_TYPES.include?(tokens.first[TYPE])
-          tokens.shift # ignore spaces
-        end
+    def each_attr(tokens)
+      attr_tokens = []
+      open_tokens = Hash.new { |h, k| h[k] = 0 }
 
-        _, type, first_text = tokens.shift
+      tokens.each do |token|
+        _, type, _ = token
         case type
-        when :on_label # `key:`
-          first_text.tr(':', '')
-        when :on_symbeg # `:key =>`, `:'key' =>` or `:"key" =>`
-          key = tokens.shift[TEXT]
-          if first_text != ':' # `:'key'` or `:"key"`
-            expect_string_end!(tokens.shift)
+        when :on_comma
+          if open_tokens.values.all?(&:zero?)
+            yield(attr_tokens)
+            attr_tokens = []
+            next
           end
-          shift_hash_rocket!(tokens)
-          key
-        when :on_tstring_beg # `"key":`, `'key':` or `"key" =>`
-          key = tokens.shift[TEXT]
-          next_token = tokens.shift
-          if next_token[TYPE] != :on_label_end # on_label_end is `":` or `':`, so `"key" =>`
-            expect_string_end!(next_token)
-            shift_hash_rocket!(tokens)
-          end
-          key
-        else
-          raise UnexpectedKeyError.new("unexpected token is given!: #{first_text} (#{type})")
-        end
-      end
-
-      # @param [Array] token - Ripper token
-      def expect_string_end!(token)
-        if token[TYPE] != :on_tstring_end
-          raise UnexpectedTokenError
+        when :on_lbracket
+          open_tokens[:array] += 1
+        when :on_rbracket
+          open_tokens[:array] -= 1
+        when :on_lbrace
+          open_tokens[:block] += 1
+        when :on_rbrace
+          open_tokens[:block] -= 1
+        when :on_lparen
+          open_tokens[:paren] += 1
+        when :on_rparen
+          open_tokens[:paren] -= 1
+        when :on_embexpr_beg
+          open_tokens[:embexpr] += 1
+        when :on_embexpr_end
+          open_tokens[:embexpr] -= 1
+        when :on_sp
+          next if attr_tokens.empty?
         end
-      end
 
-      # @param [Array] tokens - Ripper tokens
-      def shift_hash_rocket!(tokens)
-        until tokens.empty?
-          _, type, str = tokens.shift
-          break if type == :on_op && str == '=>'
-        end
-      end
-
-      # @param [String] hash_literal
-      # @param [Proc] block - that takes [String, String] as arguments
-      def each_attribute(hash_literal, &block)
-        all_tokens = Ripper.lex(hash_literal.strip)
-        all_tokens = all_tokens[1...-1] || [] # strip tokens for brackets
-
-        each_balanced_tokens(all_tokens) do |tokens|
-          key   = shift_key!(tokens)
-          value = tokens.map {|t| t[2] }.join.strip
-          block.call(key, value)
-        end
-      end
-
-      # @param [Array] tokens - Ripper tokens
-      # @param [Proc] block - that takes balanced Ripper tokens as arguments
-      def each_balanced_tokens(tokens, &block)
-        attr_tokens = []
-        open_tokens = Hash.new { |h, k| h[k] = 0 }
-
-        tokens.each do |token|
-          case token[TYPE]
-          when :on_comma
-            if open_tokens.values.all?(&:zero?)
-              block.call(attr_tokens)
-              attr_tokens = []
-              next
-            end
-          when :on_lbracket
-            open_tokens[:array] += 1
-          when :on_rbracket
-            open_tokens[:array] -= 1
-          when :on_lbrace
-            open_tokens[:block] += 1
-          when :on_rbrace
-            open_tokens[:block] -= 1
-          when :on_lparen
-            open_tokens[:paren] += 1
-          when :on_rparen
-            open_tokens[:paren] -= 1
-          when :on_embexpr_beg
-            open_tokens[:embexpr] += 1
-          when :on_embexpr_end
-            open_tokens[:embexpr] -= 1
-          when *IGNORED_TYPES
-            next if attr_tokens.empty?
-          end
-
-          attr_tokens << token
-        end
-        block.call(attr_tokens) unless attr_tokens.empty?
+        attr_tokens << token
       end
+      yield(attr_tokens) unless attr_tokens.empty?
     end
   end
 end