haml 4.1.0.beta.1 → 5.0.0.beta.2

data/Rakefile

@@ -1,19 +1,12 @@
 require "rake/clean"
 require "rake/testtask"
-require "rubygems/package_task"
+require "bundler/gem_tasks"
 
 task :default => :test
 
 CLEAN.replace %w(pkg doc coverage .yardoc test/haml vendor)
 
-def silence_warnings
-  the_real_stderr, $stderr = $stderr, StringIO.new
-  yield
-ensure
-  $stderr = the_real_stderr
-end
-
-desc "Benchmark Haml against ERb. TIMES=n sets the number of runs, default is 1000."
+desc "Benchmark Haml against ERB. TIMES=n sets the number of runs, default is 1000."
 task :benchmark do
   sh "ruby benchmark.rb #{ENV['TIMES']}"
 end
@@ -36,11 +29,6 @@ end
 desc "Run Simplecov"
 task :coverage => [:set_coverage_env, :test]
 
-gemspec = File.expand_path("../haml.gemspec", __FILE__)
-if File.exist? gemspec
-  Gem::PackageTask.new(eval(File.read(gemspec))) { |pkg| }
-end
-
 task :submodules do
   if File.exist?(File.dirname(__FILE__) + "/.git")
     sh %{git submodule sync}
@@ -48,31 +36,32 @@ task :submodules do
   end
 end
 
-begin
-  silence_warnings do
-    require 'yard'
-  end
-
-  namespace :doc do
-    desc "List all undocumented methods and classes."
-    task :undocumented do
-      command = 'yard --list --query '
-      command << '"object.docstring.blank? && '
-      command << '!(object.type == :method && object.is_alias?)"'
-      sh command
+namespace :doc do
+  task :sass do
+    require 'sass'
+    Dir["yard/default/**/*.sass"].each do |sass|
+      File.open(sass.gsub(/sass$/, 'css'), 'w') do |f|
+        f.write(Sass::Engine.new(File.read(sass)).render)
+      end
     end
   end
 
-  desc "Generate documentation"
-  task(:doc) {sh "yard"}
+  desc "List all undocumented methods and classes."
+  task :undocumented do
+    command = 'yard --list --query '
+    command << '"object.docstring.blank? && '
+    command << '!(object.type == :method && object.is_alias?)"'
+    sh command
+  end
+end
 
-  desc "Generate documentation incrementally"
-  task(:redoc) {sh "yard -c"}
+desc "Generate documentation"
+task(:doc => 'doc:sass') {sh "yard"}
 
-rescue LoadError
-end
+desc "Generate documentation incrementally"
+task(:redoc) {sh "yard -c"}
 
-  desc <<END
+desc <<END
 Profile Haml.
   TIMES=n sets the number of runs. Defaults to 1000.
   FILE=str sets the file to profile. Defaults to 'standard'
@@ -86,10 +75,9 @@ task :profile do
   require 'bundler/setup'
   require 'ruby-prof'
   require 'haml'
-  default = 
   file = File.read(File.expand_path("../#{file}", __FILE__))
   obj = Object.new
-  Haml::Engine.new(file, :ugly => true).def_method(obj, :render)
+  Haml::Engine.new(file).def_method(obj, :render)
   result = RubyProf.profile { times.times { obj.render } }
 
   RubyProf.const_get("#{(ENV['OUTPUT'] || 'Flat').capitalize}Printer").new(result).print
@@ -104,14 +92,13 @@ def gemfiles
 end
 
 def with_each_gemfile
-  old_env = ENV['BUNDLE_GEMFILE']
   gemfiles.each do |gemfile|
-    puts "Using gemfile: #{gemfile}"
-    ENV['BUNDLE_GEMFILE'] = gemfile
-    yield
+    Bundler.with_clean_env do
+      puts "Using gemfile: #{gemfile}"
+      ENV['BUNDLE_GEMFILE'] = gemfile
+      yield
+    end
   end
-ensure
-  ENV['BUNDLE_GEMFILE'] = old_env
 end
 
 namespace :test do

data/lib/haml/attribute_builder.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+module Haml
+  module AttributeBuilder
+    # https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
+    INVALID_ATTRIBUTE_NAME_REGEX = /[ \0"'>\/=]/
+
+    class << self
+      def build_attributes(is_html, attr_wrapper, escape_attrs, hyphenate_data_attrs, attributes = {})
+        # @TODO this is an absolutely ridiculous amount of arguments. At least
+        # some of this needs to be moved into an instance method.
+        join_char = hyphenate_data_attrs ? '-' : '_'
+
+        attributes.each do |key, value|
+          if value.is_a?(Hash)
+            data_attributes = attributes.delete(key)
+            data_attributes = flatten_data_attributes(data_attributes, '', join_char)
+            data_attributes = build_data_keys(data_attributes, hyphenate_data_attrs, key)
+            verify_attribute_names!(data_attributes.keys)
+            attributes = data_attributes.merge(attributes)
+          end
+        end
+
+        result = attributes.collect do |attr, value|
+          next if value.nil?
+
+          value = filter_and_join(value, ' ') if attr == 'class'
+          value = filter_and_join(value, '_') if attr == 'id'
+
+          if value == true
+            next " #{attr}" if is_html
+            next " #{attr}=#{attr_wrapper}#{attr}#{attr_wrapper}"
+          elsif value == false
+            next
+          end
+
+          value =
+            if escape_attrs == :once
+              Haml::Helpers.escape_once(value.to_s)
+            elsif escape_attrs
+              Haml::Helpers.html_escape(value.to_s)
+            else
+              value.to_s
+            end
+          " #{attr}=#{attr_wrapper}#{value}#{attr_wrapper}"
+        end
+        result.compact!
+        result.sort!
+        result.join
+      end
+
+      # @return [String, nil]
+      def filter_and_join(value, separator)
+        return '' if (value.respond_to?(:empty?) && value.empty?)
+
+        if value.is_a?(Array)
+          value = value.flatten
+          value.map! {|item| item ? item.to_s : nil}
+          value.compact!
+          value = value.join(separator)
+        else
+          value = value ? value.to_s : nil
+        end
+        !value.nil? && !value.empty? && value
+      end
+
+      # Merges two attribute hashes.
+      # This is the same as `to.merge!(from)`,
+      # except that it merges id, class, and data attributes.
+      #
+      # ids are concatenated with `"_"`,
+      # and classes are concatenated with `" "`.
+      # data hashes are simply merged.
+      #
+      # Destructively modifies `to`.
+      #
+      # @param to [{String => String,Hash}] The attribute hash to merge into
+      # @param from [{String => Object}] The attribute hash to merge from
+      # @return [{String => String,Hash}] `to`, after being merged
+      def merge_attributes!(to, from)
+        from.keys.each do |key|
+          to[key] = merge_value(key, to[key], from[key])
+        end
+        to
+      end
+
+      # Merge multiple values to one attribute value. No destructive operation.
+      #
+      # @param key [String]
+      # @param values [Array<Object>]
+      # @return [String,Hash]
+      def merge_values(key, *values)
+        values.inject(nil) do |to, from|
+          merge_value(key, to, from)
+        end
+      end
+
+      def verify_attribute_names!(attribute_names)
+        attribute_names.each do |attribute_name|
+          if attribute_name =~ INVALID_ATTRIBUTE_NAME_REGEX
+            raise InvalidAttributeNameError.new("Invalid attribute name '#{attribute_name}' was rendered")
+          end
+        end
+      end
+
+      private
+
+      # Merge a couple of values to one attribute value. No destructive operation.
+      #
+      # @param to [String,Hash,nil]
+      # @param from [Object]
+      # @return [String,Hash]
+      def merge_value(key, to, from)
+        if from.kind_of?(Hash) || to.kind_of?(Hash)
+          from = { nil => from } if !from.is_a?(Hash)
+          to   = { nil => to }   if !to.is_a?(Hash)
+          to.merge(from)
+        elsif key == 'id'
+          merged_id = filter_and_join(from, '_')
+          if to && merged_id
+            merged_id = "#{to}_#{merged_id}"
+          elsif to || merged_id
+            merged_id ||= to
+          end
+          merged_id
+        elsif key == 'class'
+          merged_class = filter_and_join(from, ' ')
+          if to && merged_class
+            merged_class = (merged_class.split(' ') | to.split(' ')).sort.join(' ')
+          elsif to || merged_class
+            merged_class ||= to
+          end
+          merged_class
+        else
+          from
+        end
+      end
+
+      def build_data_keys(data_hash, hyphenate, attr_name="data")
+        Hash[data_hash.map do |name, value|
+          if name == nil
+            [attr_name, value]
+          elsif hyphenate
+            ["#{attr_name}-#{name.to_s.tr('_', '-')}", value]
+          else
+            ["#{attr_name}-#{name}", value]
+          end
+        end]
+      end
+
+      def flatten_data_attributes(data, key, join_char, seen = [])
+        return {key => data} unless data.is_a?(Hash)
+
+        return {key => nil} if seen.include? data.object_id
+        seen << data.object_id
+
+        data.sort {|x, y| x[0].to_s <=> y[0].to_s}.inject({}) do |hash, (k, v)|
+          joined = key == '' ? k : [key, k].join(join_char)
+          hash.merge! flatten_data_attributes(v, joined, join_char, seen)
+        end
+      end
+    end
+  end
+end

data/lib/haml/attribute_compiler.rb

@@ -0,0 +1,214 @@
+require 'haml/attribute_parser'
+
+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
+
+      # Key's substring before a hyphen. This is necessary because values with the same
+      # base_key can conflict by Haml::AttributeBuidler#build_data_keys.
+      def base_key
+        key.split('-', 2).first
+      end
+    end
+
+    # Returns a script to render attributes on runtime.
+    #
+    # @param attributes [Hash]
+    # @param object_ref [String,:nil]
+    # @param attributes_hashes [Array<String>]
+    # @return [String] Attributes rendering code
+    def self.runtime_build(attributes, object_ref, attributes_hashes)
+      "_hamlout.attributes(#{Haml::Util.inspect_obj(attributes)}, #{object_ref},#{attributes_hashes.join(', ')})"
+    end
+
+    # @param options [Haml::Options]
+    def initialize(options)
+      @is_html = [:html4, :html5].include?(options[:format])
+      @attr_wrapper = options[:attr_wrapper]
+      @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 attributes_hashes [Array<String>]
+    # @return [Array] Temple expression
+    def compile(attributes, object_ref, attributes_hashes)
+      if object_ref != :nil || !AttributeParser.available?
+        return [:dynamic, AttributeCompiler.runtime_build(attributes, object_ref, attributes_hashes)]
+      end
+
+      parsed_hashes = attributes_hashes.map do |attribute_hash|
+        unless (hash = AttributeParser.parse(attribute_hash))
+          return [:dynamic, AttributeCompiler.runtime_build(attributes, object_ref, attributes_hashes)]
+        end
+        hash
+      end
+      attribute_values = build_attribute_values(attributes, parsed_hashes)
+      AttributeBuilder.verify_attribute_names!(attribute_values.map(&:key))
+
+      values_by_base_key = attribute_values.group_by(&:base_key)
+      [:multi, *values_by_base_key.keys.sort.map { |base_key|
+        compile_attribute_values(values_by_base_key[base_key])
+      }]
+    end
+
+    private
+
+    # Returns array of AttributeValue instnces from static attributes and dynamic attributes_hashes. 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
+      end
+    end
+
+    # Compiles attribute values with the same base_key to Temple expression.
+    #
+    # @param values [Array<AttributeValue>] `base_key`'s results are the same. `key`'s result may differ.
+    # @return [Array] Temple expression
+    def compile_attribute_values(values)
+      if values.map(&:key).uniq.size == 1
+        compile_attribute(values.first.key, values)
+      else
+        runtime_build(values)
+      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
+
+    # @param key [String]
+    # @param values [Array<AttributeValue>]
+    # @return [String]
+    def merged_value(key, values)
+      if values.size == 1
+        values.first.to_literal
+      else
+        "::Haml::AttributeBuilder.merge_values(#{frozen_string(key)}, #{values.map(&:to_literal).join(', ')})"
+      end
+    end
+
+    # @param str [String]
+    # @return [String]
+    def frozen_string(str)
+      "#{Haml::Util.inspect_obj(str)}.freeze"
+    end
+
+    # 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)
+      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]],
+        ]
+       ],
+      ]
+    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]],
+        ]
+       ],
+      ]
+    end
+
+    def true_value(key)
+      if @is_html
+        [:static, " #{key}"]
+      else
+        [:static, " #{key}=#{@attr_wrapper}#{key}#{@attr_wrapper}"]
+      end
+    end
+
+    def unique_name
+      @unique_name ||= 0
+      "_haml_attribute_compiler#{@unique_name += 1}"
+    end
+  end
+end