haml 6.0.0.beta.1-java

data/lib/haml/ambles.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module Haml
+  class Ambles < Temple::Filter
+    define_options :preamble, :postamble
+
+    def initialize(*)
+      super
+      @preamble = options[:preamble]
+      @postamble = options[:postamble]
+    end
+
+    def call(ast)
+      ret = [:multi]
+      ret << [:static, @preamble] if @preamble
+      ret << ast
+      ret << [:static, @postamble] if @postamble
+      ret
+    end
+  end
+end

data/lib/haml/attribute_builder.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+require 'haml/object_ref'
+
+module Haml::AttributeBuilder
+  BOOLEAN_ATTRIBUTES = %w[disabled readonly multiple checked autobuffer
+                       autoplay controls loop selected hidden scoped async
+                       defer reversed ismap seamless muted required
+                       autofocus novalidate formnovalidate open pubdate
+                       itemscope allowfullscreen default inert sortable
+                       truespeed typemustmatch download].freeze
+
+  # Java extension is not implemented for JRuby yet.
+  # TruffleRuby does not implement `rb_ary_sort_bang`, etc.
+  if /java/ === RUBY_PLATFORM || RUBY_ENGINE == 'truffleruby'
+    class << self
+      def build(escape_attrs, quote, format, boolean_attributes, object_ref, *hashes)
+        hashes << Haml::ObjectRef.parse(object_ref) if object_ref
+        buf  = []
+        hash = merge_all_attrs(hashes)
+
+        keys = hash.keys.sort!
+        keys.each do |key|
+          case key
+          when 'id'.freeze
+            buf << " id=#{quote}#{build_id(escape_attrs, *hash[key])}#{quote}"
+          when 'class'.freeze
+            buf << " class=#{quote}#{build_class(escape_attrs, *hash[key])}#{quote}"
+          when 'data'.freeze
+            buf << build_data(escape_attrs, quote, *hash[key])
+          when *boolean_attributes, /\Adata-/
+            build_boolean!(escape_attrs, quote, format, buf, key, hash[key])
+          else
+            buf << " #{key}=#{quote}#{escape_html(escape_attrs, hash[key].to_s)}#{quote}"
+          end
+        end
+        buf.join
+      end
+
+      def build_id(escape_attrs, *values)
+        escape_html(escape_attrs, values.flatten.select { |v| v }.join('_'))
+      end
+
+      def build_class(escape_attrs, *values)
+        if values.size == 1
+          value = values.first
+          case
+          when value.is_a?(String)
+            # noop
+          when value.is_a?(Array)
+            value = value.flatten.select { |v| v }.map(&:to_s).uniq.join(' ')
+          when value
+            value = value.to_s
+          else
+            return ''
+          end
+          return escape_html(escape_attrs, value)
+        end
+
+        classes = []
+        values.each do |value|
+          case
+          when value.is_a?(String)
+            classes += value.split(' ')
+          when value.is_a?(Array)
+            classes += value.select { |v| v }
+          when value
+            classes << value.to_s
+          end
+        end
+        escape_html(escape_attrs, classes.map(&:to_s).uniq.join(' '))
+      end
+
+      def build_data(escape_attrs, quote, *hashes)
+        build_data_attribute(:data, escape_attrs, quote, *hashes)
+      end
+
+      def build_aria(escape_attrs, quote, *hashes)
+        build_data_attribute(:aria, escape_attrs, quote, *hashes)
+      end
+
+      private
+
+      def build_data_attribute(key, escape_attrs, quote, *hashes)
+        attrs = []
+        if hashes.size > 1 && hashes.all? { |h| h.is_a?(Hash) }
+          data_value = merge_all_attrs(hashes)
+        else
+          data_value = hashes.last
+        end
+        hash = flatten_attributes(key => data_value)
+
+        hash.sort_by(&:first).each do |key, value|
+          case value
+          when true
+            attrs << " #{key}"
+          when nil, false
+            # noop
+          else
+            attrs << " #{key}=#{quote}#{escape_html(escape_attrs, value.to_s)}#{quote}"
+          end
+        end
+        attrs.join
+      end
+
+      def flatten_attributes(attributes)
+        flattened = {}
+
+        attributes.each do |key, value|
+          case value
+          when attributes
+          when Hash
+            flatten_attributes(value).each do |k, v|
+              if k.nil?
+                flattened[key] = v
+              else
+                flattened["#{key}-#{k.to_s.gsub(/_/, '-')}"] = v
+              end
+            end
+          else
+            flattened[key] = value if value
+          end
+        end
+        flattened
+      end
+
+      def merge_all_attrs(hashes)
+        merged = {}
+        hashes.each do |hash|
+          hash.each do |key, value|
+            key = key.to_s
+            case key
+            when 'id'.freeze, 'class'.freeze, 'data'.freeze
+              merged[key] ||= []
+              merged[key] << value
+            else
+              merged[key] = value
+            end
+          end
+        end
+        merged
+      end
+
+      def build_boolean!(escape_attrs, quote, format, buf, key, value)
+        case value
+        when true
+          case format
+          when :xhtml
+            buf << " #{key}=#{quote}#{key}#{quote}"
+          else
+            buf << " #{key}"
+          end
+        when false, nil
+          # omitted
+        else
+          buf << " #{key}=#{quote}#{escape_html(escape_attrs, value)}#{quote}"
+        end
+      end
+
+      def escape_html(escape_attrs, str)
+        if escape_attrs
+          Haml::Util.escape_html(str)
+        else
+          str
+        end
+      end
+    end
+  else
+    # Haml::AttributeBuilder.build
+    # Haml::AttributeBuilder.build_id
+    # Haml::AttributeBuilder.build_class
+    # Haml::AttributeBuilder.build_data
+    # Haml::AttributeBuilder.build_aria
+    require 'haml/haml'
+  end
+end

data/lib/haml/attribute_compiler.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+require 'haml/attribute_builder'
+require 'haml/attribute_parser'
+require 'haml/ruby_expression'
+
+module Haml
+  class AttributeCompiler
+    def initialize(identity, options)
+      @identity = identity
+      @quote  = options[:attr_quote]
+      @format = options[:format]
+      @escape_attrs = options[:escape_attrs]
+    end
+
+    def compile(node)
+      hashes = []
+      if node.value[:object_ref] != :nil || !Ripper.respond_to?(:lex) # No Ripper.lex in truffleruby
+        return runtime_compile(node)
+      end
+      [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
+      static_compile(node.value[:attributes], hashes)
+    end
+
+    private
+
+    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
+
+    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
+
+    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
+        temple << [:html, :attr, key, [:dynamic, build_code]]
+      end
+    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(', ')})"
+
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:static, eval(build_code).to_s]
+      else
+        temple << [:dynamic, build_code]
+      end
+    end
+
+    def compile_boolean!(temple, key, values)
+      exp = literal_for(values.last)
+
+      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
+        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
+
+    def compile_common!(temple, key, values)
+      temple << [:html, :attr, key, [:fescape, @escape_attrs, values.last]]
+    end
+
+    def attribute_builder(type, values)
+      args = [@escape_attrs.inspect, *values.map { |v| literal_for(v) }]
+      "::Haml::AttributeBuilder.build_#{type}(#{args.join(', ')})"
+    end
+
+    def literal_for(value)
+      type, exp = value
+      type == :static ? "#{exp.inspect}.freeze" : exp
+    end
+  end
+end

data/lib/haml/attribute_parser.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+require 'haml/ruby_expression'
+
+module Haml
+  class AttributeParser
+    class ParseSkip < StandardError
+    end
+
+    def self.parse(text)
+      self.new.parse(text)
+    end
+
+    def parse(text)
+      exp = wrap_bracket(text)
+      return if RubyExpression.syntax_error?(exp)
+
+      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
+
+    private
+
+    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
+        key
+      else
+        raise ParseSkip
+      end
+    end
+
+    def assert_type!(token, type)
+      raise ParseSkip if token[1] != type
+    end
+
+    def skip_until_hash_rocket!(tokens)
+      until tokens.empty?
+        _, type, str = tokens.shift
+        break if type == :on_op && str == '=>'
+      end
+    end
+
+    def each_attr(tokens)
+      attr_tokens = []
+      open_tokens = Hash.new { |h, k| h[k] = 0 }
+
+      tokens.each do |token|
+        _, type, _ = token
+        case type
+        when :on_comma
+          if open_tokens.values.all?(&:zero?)
+            yield(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 :on_sp
+          next if attr_tokens.empty?
+        end
+
+        attr_tokens << token
+      end
+      yield(attr_tokens) unless attr_tokens.empty?
+    end
+  end
+end

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,126 @@
+# frozen_string_literal: true
+require 'haml/temple_line_counter'
+
+module Haml
+  class Compiler
+    class ChildrenCompiler
+      def initialize
+        @lineno = 1
+      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)
+        confirm_whitespace(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 confirm_whitespace(temple)
+        temple.map do |exp|
+          case exp
+          when :whitespace
+            [:static, "\n"]
+          else
+            exp
+          end
+        end
+      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)
+        if temple[-1] == :whitespace
+          temple.delete_at(-1)
+        end
+      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