haml 5.2.2 → 6.3.0

data/lib/haml/cli.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+require 'haml'
+require 'thor'
+
+module Haml
+  class CLI < Thor
+    class_option :escape_html, type: :boolean, default: true
+    class_option :escape_attrs, type: :boolean, default: true
+
+    desc 'render HAML', 'Render haml template'
+    option :load_path, type: :string, aliases: %w[-I]
+    option :require, type: :string, aliases: %w[-r]
+    def render(file)
+      process_load_options
+      code = generate_code(file)
+      puts eval(code, binding, file)
+    end
+
+    desc 'compile HAML', 'Show compile result'
+    option :actionview, type: :boolean, default: false, aliases: %w[-a]
+    option :color, type: :boolean, default: true
+    option :check, type: :boolean, default: false, aliases: %w[-c]
+    def compile(file)
+      code = generate_code(file)
+      if options[:check]
+        if error = validate_ruby(code, file)
+          abort error.message.split("\n").first
+        end
+        puts "Syntax OK"
+        return
+      end
+      puts_code(code, color: options[:color])
+    end
+
+    desc 'temple HAML', 'Show temple intermediate expression'
+    option :color, type: :boolean, default: true
+    def temple(file)
+      pp_object(generate_temple(file), color: options[:color])
+    end
+
+    desc 'parse HAML', 'Show parse result'
+    option :color, type: :boolean, default: true
+    def parse(file)
+      pp_object(generate_ast(file), color: options[:color])
+    end
+
+    desc 'version', 'Show the used haml version'
+    def version
+      puts Haml::VERSION
+    end
+
+    private
+
+    def process_load_options
+      if options[:load_path]
+        options[:load_path].split(':').each do |dir|
+          $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
+        end
+      end
+
+      if options[:require]
+        require options[:require]
+      end
+    end
+
+    def read_file(file)
+      if file == '-'
+        STDIN.read
+      else
+        File.read(file)
+      end
+    end
+
+    def generate_code(file)
+      template = read_file(file)
+      if options[:actionview]
+        require 'action_view'
+        require 'action_view/base'
+        require 'haml/rails_template'
+        handler = Haml::RailsTemplate.new
+        template = ActionView::Template.new(template, 'inline template', handler, { locals: [] })
+        code = handler.call(template)
+        <<-end_src
+          def _inline_template___2144273726781623612_70327218547300(local_assigns, output_buffer)
+            _old_virtual_path, @virtual_path = @virtual_path, nil;_old_output_buffer = @output_buffer;;#{code}
+          ensure
+            @virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
+          end
+        end_src
+      else
+        Haml::Engine.new(engine_options).call(template)
+      end
+    end
+
+    def generate_ast(file)
+      template = read_file(file)
+      Haml::Parser.new(engine_options).call(template)
+    end
+
+    def generate_temple(file)
+      ast = generate_ast(file)
+      Haml::Compiler.new(engine_options).call(ast)
+    end
+
+    def engine_options
+      Haml::Engine.options.to_h.merge(
+        escape_attrs: options[:escape_attrs],
+        escape_html:  options[:escape_html],
+      )
+    end
+
+    # Flexible default_task, compatible with haml's CLI
+    def method_missing(*args)
+      return super(*args) if args.length > 1
+      render(args.first.to_s)
+    end
+
+    def puts_code(code, color: true)
+      begin
+        require 'irb/color'
+      rescue LoadError
+        color = false
+      end
+      if color
+        puts IRB::Color.colorize_code(code)
+      else
+        puts code
+      end
+    end
+
+    # Enable colored pretty printing only for development environment.
+    def pp_object(arg, color: true)
+      begin
+        require 'irb/color_printer'
+      rescue LoadError
+        color = false
+      end
+      if color
+        IRB::ColorPrinter.pp(arg)
+      else
+        require 'pp'
+        pp(arg)
+      end
+    end
+
+    def validate_ruby(code, file)
+      begin
+        eval("BEGIN {return nil}; #{code}", binding, file)
+      rescue ::SyntaxError # Not to be confused with Haml::SyntaxError
+        $!
+      end
+    end
+  end
+end

data/lib/haml/compiler/children_compiler.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+require 'haml/temple_line_counter'
+
+module Haml
+  class Compiler
+    class ChildrenCompiler
+      def initialize
+        @lineno = 1
+        @multi_flattener = Temple::Filters::MultiFlattener.new
+      end
+
+      def compile(node, &block)
+        temple = [:multi]
+        return temple if node.children.empty?
+
+        temple << [:whitespace] if prepend_whitespace?(node)
+        node.children.each do |n|
+          rstrip_whitespace!(temple) if nuke_prev_whitespace?(n)
+          insert_newlines!(temple, n)
+          temple << moving_lineno(n) { block.call(n) }
+          temple << [:whitespace] if insert_whitespace?(n)
+        end
+        rstrip_whitespace!(temple) if nuke_inner_whitespace?(node)
+        temple
+      end
+
+      private
+
+      def insert_newlines!(temple, node)
+        (node.line - @lineno).times do
+          temple << [:newline]
+        end
+
+        @lineno = node.line
+      end
+
+      def moving_lineno(node, &block)
+        # before: As they may have children, we need to increment lineno before compilation.
+        case node.type
+        when :script, :silent_script
+          @lineno += 1
+        when :tag
+          [node.value[:dynamic_attributes].new, node.value[:dynamic_attributes].old].compact.each do |attribute_hash|
+            @lineno += attribute_hash.count("\n")
+          end
+          @lineno += 1 if node.children.empty? && node.value[:parse]
+        end
+
+        temple = block.call # compile
+
+        # after: filter may not have children, and for some dynamic filters we can't predict the number of lines.
+        case node.type
+        when :filter
+          @lineno += TempleLineCounter.count_lines(temple)
+        end
+
+        temple
+      end
+
+      def prepend_whitespace?(node)
+        return false unless %i[comment tag].include?(node.type)
+        !nuke_inner_whitespace?(node)
+      end
+
+      def nuke_inner_whitespace?(node)
+        case
+        when node.type == :tag
+          node.value[:nuke_inner_whitespace]
+        when node.parent.nil?
+          false
+        else
+          nuke_inner_whitespace?(node.parent)
+        end
+      end
+
+      def nuke_prev_whitespace?(node)
+        case node.type
+        when :tag
+          node.value[:nuke_outer_whitespace]
+        when :silent_script
+          !node.children.empty? && nuke_prev_whitespace?(node.children.first)
+        else
+          false
+        end
+      end
+
+      def nuke_outer_whitespace?(node)
+        return false if node.type != :tag
+        node.value[:nuke_outer_whitespace]
+      end
+
+      def rstrip_whitespace!(temple)
+        return if temple.size == 1
+
+        case temple[0]
+        when :multi
+          case temple[-1][0]
+          when :whitespace
+            temple.delete_at(-1)
+          when :multi, :block
+            rstrip_whitespace!(temple[-1])
+          end
+        when :block
+          _block, code, exp = temple
+          if code.start_with?(/\s*if\s/)
+            # Remove [:whitespace] before `end`
+            exp.replace(@multi_flattener.call(exp))
+            rstrip_whitespace!(exp)
+
+            # Remove [:whitespace] before `else` if exists
+            else_index = find_else_index(exp)
+            if else_index
+              whitespace_index = else_index - 1
+              while exp[whitespace_index] == [:newline]
+                whitespace_index -= 1
+              end
+              if exp[whitespace_index] == [:whitespace]
+                exp.delete_at(whitespace_index)
+              end
+            end
+          end
+        end
+      end
+
+      def find_else_index(temple)
+        multi, *args = temple
+        return nil if multi != :multi
+
+        args.each_with_index do |arg, index|
+          if arg[0] == :code && arg[1].match?(/\A\s*else\s*\z/)
+            return index + 1
+          end
+        end
+        nil
+      end
+
+      def insert_whitespace?(node)
+        return false if nuke_outer_whitespace?(node)
+
+        case node.type
+        when :doctype
+          node.value[:type] != 'xml'
+        when :comment, :plain, :tag
+          true
+        when :script
+          node.children.empty? && !nuke_inner_whitespace?(node)
+        when :filter
+          !%w[ruby].include?(node.value[:name])
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/haml/compiler/comment_compiler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module Haml
+  class Compiler
+    class CommentCompiler
+      def compile(node, &block)
+        if node.value[:conditional]
+          compile_conditional_comment(node, &block)
+        else
+          compile_html_comment(node, &block)
+        end
+      end
+
+      private
+
+      def compile_html_comment(node, &block)
+        if node.children.empty?
+          [:html, :comment, compile_text(node)]
+        else
+          [:html, :comment, yield(node)]
+        end
+      end
+
+      def compile_conditional_comment(node, &block)
+        condition = node.value[:conditional]
+        if node.value[:conditional] =~ /\A\[(\[*[^\[\]]+\]*)\]/
+          condition = $1
+        end
+
+        content =
+          if node.children.empty?
+            compile_text(node)
+          else
+            yield(node)
+          end
+        [:html, :condcomment, condition, content, node.value[:revealed]]
+      end
+
+      def compile_text(node)
+        text =
+          if node.value[:parse]
+            # Just always escaping the result for safety. We could respect
+            # escape_html, but I don't see any use case for it.
+            [:escape, true, [:dynamic, node.value[:text]]]
+          else
+            [:static, node.value[:text]]
+          end
+        [:multi, [:static, ' '], text, [:static, ' ']]
+      end
+    end
+  end
+end

data/lib/haml/compiler/doctype_compiler.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module Haml
+  class Compiler
+    class DoctypeCompiler
+      def initialize(options = {})
+        @format = options[:format]
+      end
+
+      def compile(node)
+        case node.value[:type]
+        when ''
+          html_doctype(node)
+        when 'xml'
+          xml_doctype
+        when 'rdfa'
+          rdfa_doctype
+        else
+          [:html, :doctype, node.value[:type]]
+        end
+      end
+
+      private
+
+      def html_doctype(node)
+        version = node.value[:version] || :transitional
+        case @format
+        when :xhtml
+          [:html, :doctype, version]
+        when :html4
+          [:html, :doctype, :transitional]
+        when :html5
+          [:html, :doctype, :html]
+        else
+          [:html, :doctype, @format]
+        end
+      end
+
+      def xml_doctype
+        case @format
+        when :xhtml
+          [:static, "<?xml version='1.0' encoding='utf-8' ?>\n"]
+        else
+          [:multi]
+        end
+      end
+
+      def rdfa_doctype
+        [:static, '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">']
+      end
+    end
+  end
+end

data/lib/haml/compiler/script_compiler.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+require 'temple/static_analyzer'
+require 'haml/ruby_expression'
+require 'haml/string_splitter'
+
+module Haml
+  class Compiler
+    class ScriptCompiler
+      def self.find_and_preserve(input, tags)
+        tags = tags.map { |tag| Regexp.escape(tag) }.join('|')
+        re = /<(#{tags})([^>]*)>(.*?)(<\/\1>)/im
+        input.to_s.gsub(re) do |s|
+          s =~ re # Can't rely on $1, etc. existing since Rails' SafeBuffer#gsub is incompatible
+          "<#{$1}#{$2}>#{Haml::Helpers.preserve($3)}</#{$1}>"
+        end
+      end
+
+      def initialize(identity, options)
+        @identity = identity
+        @disable_capture = options[:disable_capture]
+      end
+
+      def compile(node, &block)
+        unless Ripper.respond_to?(:lex) # No Ripper.lex in truffleruby
+          return dynamic_compile(node, &block)
+        end
+
+        no_children = node.children.empty?
+        case
+        when no_children && node.value[:escape_interpolation]
+          compile_interpolated_plain(node)
+        when no_children && RubyExpression.string_literal?(node.value[:text])
+          delegate_optimization(node)
+        when no_children && Temple::StaticAnalyzer.static?(node.value[:text])
+          static_compile(node)
+        else
+          dynamic_compile(node, &block)
+        end
+      end
+
+      private
+
+      # String-interpolated plain text must be compiled with this method
+      # because we have to escape only interpolated values.
+      def compile_interpolated_plain(node)
+        temple = [:multi]
+        StringSplitter.compile(node.value[:text]).each do |type, value|
+          case type
+          when :static
+            temple << [:static, value]
+          when :dynamic
+            temple << [:escape, node.value[:escape_interpolation], [:dynamic, value]]
+          end
+        end
+        temple << [:newline]
+      end
+
+      # :dynamic is optimized in other filter: StringSplitter
+      def delegate_optimization(node)
+        [:multi,
+         [:escape, node.value[:escape_html], [:dynamic, node.value[:text]]],
+         [:newline],
+        ]
+      end
+
+      def static_compile(node)
+        str = eval(node.value[:text]).to_s
+        if node.value[:escape_html]
+          str = Haml::Util.escape_html(str)
+        elsif node.value[:preserve]
+          str = ScriptCompiler.find_and_preserve(str, %w(textarea pre code))
+        end
+        [:multi, [:static, str], [:newline]]
+      end
+
+      def dynamic_compile(node, &block)
+        var = @identity.generate
+        temple = compile_script_assign(var, node, &block)
+        temple << compile_script_result(var, node)
+      end
+
+      def compile_script_assign(var, node, &block)
+        if node.children.empty?
+          [:multi,
+           [:code, "#{var} = (#{node.value[:text]}"],
+           [:newline],
+           [:code, ')'],
+          ]
+        else
+          [:multi,
+           [:block, "#{var} = #{node.value[:text]}",
+            [:multi, [:newline], @disable_capture ? yield(node) : [:capture, Temple::Utils.unique_name, yield(node)]]
+           ],
+          ]
+        end
+      end
+
+      def compile_script_result(result, node)
+        if !node.value[:escape_html] && node.value[:preserve]
+          result = find_and_preserve(result)
+        end
+        [:escapeany, node.value[:escape_html], [:dynamic, result]]
+      end
+
+      def find_and_preserve(code)
+        %Q[::Haml::Compiler::ScriptCompiler.find_and_preserve(#{code}, %w(textarea pre code))]
+      end
+
+      def escape_html(temple)
+        [:escape, true, temple]
+      end
+    end
+  end
+end

data/lib/haml/compiler/silent_script_compiler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Haml
+  class Compiler
+    class SilentScriptCompiler
+      def compile(node, &block)
+        if node.children.empty?
+          [:multi, [:code, node.value[:text]], [:newline]]
+        else
+          compile_with_children(node, &block)
+        end
+      end
+
+      private
+
+      def compile_with_children(node, &block)
+        [:multi,
+         [:block, node.value[:text],
+          [:multi, [:newline], yield(node)],
+         ],
+        ]
+      end
+    end
+  end
+end

data/lib/haml/compiler/tag_compiler.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+require 'haml/util'
+require 'haml/attribute_compiler'
+require 'haml/string_splitter'
+
+module Haml
+  class Compiler
+    class TagCompiler
+      def initialize(identity, options)
+        @autoclose = options[:autoclose]
+        @identity  = identity
+        @attribute_compiler = AttributeCompiler.new(identity, options)
+      end
+
+      def compile(node, &block)
+        attrs    = @attribute_compiler.compile(node)
+        contents = compile_contents(node, &block)
+        [:html, :tag, node.value[:name], attrs, contents]
+      end
+
+      private
+
+      def compile_contents(node, &block)
+        case
+        when !node.children.empty?
+          yield(node)
+        when node.value[:value].nil? && self_closing?(node)
+          nil
+        when node.value[:parse]
+          return compile_interpolated_plain(node) if node.value[:escape_interpolation]
+          if Ripper.respond_to?(:lex) # No Ripper.lex in truffleruby
+            return delegate_optimization(node) if RubyExpression.string_literal?(node.value[:value])
+            return delegate_optimization(node) if Temple::StaticAnalyzer.static?(node.value[:value])
+          end
+
+          var = @identity.generate
+          [:multi,
+           [:code, "#{var} = (#{node.value[:value]}"],
+           [:newline],
+           [:code, ')'],
+           [:escape, node.value[:escape_html], [:dynamic, var]]
+          ]
+        else
+          [:static, node.value[:value]]
+        end
+      end
+
+      # :dynamic is optimized in other filters: StringSplitter or StaticAnalyzer
+      def delegate_optimization(node)
+        [:multi,
+         [:escape, node.value[:escape_html], [:dynamic, node.value[:value]]],
+         [:newline],
+        ]
+      end
+
+      # We should handle interpolation here to escape only interpolated values.
+      def compile_interpolated_plain(node)
+        temple = [:multi]
+        StringSplitter.compile(node.value[:value]).each do |type, value|
+          case type
+          when :static
+            temple << [:static, value]
+          when :dynamic
+            temple << [:escape, node.value[:escape_interpolation], [:dynamic, value]]
+          end
+        end
+        temple << [:newline]
+      end
+
+      def self_closing?(node)
+        return true if @autoclose && @autoclose.include?(node.value[:name])
+        node.value[:self_closing]
+      end
+    end
+  end
+end