haml 5.0.0.beta.2 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 056cc654414c29999474b5115839d33e5ebc9a20
-  data.tar.gz: e56a16b4d053d863af5e9a89200d413d7901f3f7
+  metadata.gz: 7fa1e64aca629e46493a148b6159feb77763ba0d
+  data.tar.gz: 912f3565b782829c0651604333a0d5fd823c45a1
 SHA512:
-  metadata.gz: 7dbf54da5889f0477f6122eb5178310a1e0167f0aaed5f6b495efc6de108183a228bda85ae5a10c46862443e10d30836351d826bdda86d4ebede4b5221ed6b19
-  data.tar.gz: 5d77752a502ab13aaac1e1af68876ff9084913d4a82491c0e790ae851d8975931a478fd59779d5acb92587ebfbff93de4d33411945e0c3a726e5d7fd68902732
+  metadata.gz: d8e860a0fc047d158a7a1d08f349a5555ae9a0afd578327c16cca624c3c0425a323e40cc3185f8ba8fede3ed79d24babb44f634969a69707a46f27d92b925b15
+  data.tar.gz: f3e66b26cf401ac0081721f44322a4fe39c0b0c486d6b4b0dd7e665e483be86f6f1769a0c94ed00b2646e3d76fb7be0ebe2e40c75943c0a5774e38cb3f17a4e2

data/CHANGELOG.md

@@ -1,6 +1,9 @@
 # Haml Changelog
 
-## 5.0.0 (Unreleased)
+## 5.0.0
+
+Released on April 26, 2017
+([diff](https://github.com/haml/haml/compare/4.0.7...5.0.0)).
 
 * Haml now requires Ruby 2.0.0 or above.
 * Rails 3 is no longer supported, matching the official
@@ -18,9 +21,12 @@
   to the source Haml file from which it was generated. Thanks [Alex Babkin](https://github.com/ababkin).
 * Fix #@foo and #$foo style interpolation that was not working in html_safe mode. (Akira Matsuda)
 * Add `haml_tag_if` to render a block, conditionally wrapped in another element (Matt Wildig)
+* Escape Ruby script interpolated in filters. (Matt Wildig)
 * The `haml` command's debug option (`-d`) no longer executes the Haml code, but
   rather checks the generated Ruby syntax for errors.
 * Support Rails 5.1 Erubi template handler.
+* Support Sprockets 3. Thanks [Sam Davies](https://github.com/samphilipd) and [Jeremy Venezia](https://github.com/jvenezia).
+* Allow `@` as tag's class name. Thanks [Joe Bartlett](https://github.com/redoPop).
 * Raise `Haml::InvalidAttributeNameError` when attribute name includes invalid characters. (Takashi Kokubun)
 * Drop dynamic quotes support and always escape `'` for `escape_html`/`escape_attrs` instead.
   Also, escaped results are slightly changed and always unified to the same characters. (Takashi Kokubun)

data/Rakefile

@@ -4,6 +4,21 @@ require "bundler/gem_tasks"
 
 task :default => :test
 
+# FIXME: Redefining :test task to run test/options_test.rb in isolated process since it depends on whether Rails is loaded or not.
+# Remove this task when we finished changing escape_html option to be true by default.
+isolated_test = Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = %w[test/options_test.rb]
+  t.warning = true
+  t.verbose = true
+end
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = Dir['test/*_test.rb'] + Dir['test/haml-spec/*_test.rb'] - isolated_test.file_list
+  t.warning = true
+  t.verbose = true
+end
+
 CLEAN.replace %w(pkg doc coverage .yardoc test/haml vendor)
 
 desc "Benchmark Haml against ERB. TIMES=n sets the number of runs, default is 1000."
@@ -11,17 +26,6 @@ task :benchmark do
   sh "ruby benchmark.rb #{ENV['TIMES']}"
 end
 
-Rake::TestTask.new do |t|
-  t.libs << 'lib' << 'test'
-  # haml-spec tests are explicitly added after other tests so they don't
-  # interfere with the Haml loading process which can cause test failures
-  files = Dir["test/*_test.rb"]
-  files.concat(Dir['test/haml-spec/*_test.rb'])
-  t.test_files = files
-  t.warning = true
-  t.verbose = true
-end
-
 task :set_coverage_env do
   ENV["COVERAGE"] = "true"
 end

data/lib/haml.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'haml/version'
 
 # The module that contains everything Haml-related:

data/lib/haml/attribute_compiler.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'haml/attribute_parser'
 
 module Haml
@@ -27,10 +28,10 @@ module Haml
     #
     # @param attributes [Hash]
     # @param object_ref [String,:nil]
-    # @param attributes_hashes [Array<String>]
+    # @param dynamic_attributes [DynamicAttributes]
     # @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(', ')})"
+    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]
@@ -45,16 +46,16 @@ module Haml
     #
     # @param attributes [Hash]
     # @param object_ref [String,:nil]
-    # @param attributes_hashes [Array<String>]
+    # @param dynamic_attributes [DynamicAttributes]
     # @return [Array] Temple expression
-    def compile(attributes, object_ref, attributes_hashes)
+    def compile(attributes, object_ref, dynamic_attributes)
       if object_ref != :nil || !AttributeParser.available?
-        return [:dynamic, AttributeCompiler.runtime_build(attributes, object_ref, attributes_hashes)]
+        return [:dynamic, AttributeCompiler.runtime_build(attributes, object_ref, dynamic_attributes)]
       end
 
-      parsed_hashes = attributes_hashes.map do |attribute_hash|
+      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, attributes_hashes)]
+          return [:dynamic, AttributeCompiler.runtime_build(attributes, object_ref, dynamic_attributes)]
         end
         hash
       end
@@ -69,7 +70,7 @@ module Haml
 
     private
 
-    # Returns array of AttributeValue instnces from static attributes and dynamic attributes_hashes. For each key,
+    # 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 }]

data/lib/haml/attribute_parser.rb

@@ -1,27 +1,35 @@
+# frozen_string_literal: true
 begin
   require 'ripper'
 rescue LoadError
 end
 
 module Haml
+  # Haml::AttriubuteParser parses Hash literal to { String (key name) => String (value literal) }.
   module AttributeParser
     class UnexpectedTokenError < StandardError; end
     class UnexpectedKeyError < StandardError; end
 
+    # Indices in Ripper tokens
+    TYPE = 1
+    TEXT = 2
+
+    IGNORED_TYPES = %i[on_sp on_ignored_nl]
+
     class << self
+      # @return [Boolean] - return true if AttributeParser.parse can be used.
       def available?
         defined?(Ripper) && Temple::StaticAnalyzer.available?
       end
 
-      def parse(text)
-        exp = wrap_bracket(text)
-        return if Temple::StaticAnalyzer.syntax_error?(exp)
+      # @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)
 
         hash = {}
-        tokens = Ripper.lex(exp)[1..-2] || []
-        each_attr(tokens) do |attr_tokens|
-          key = parse_key!(attr_tokens)
-          hash[key] = attr_tokens.map(&:last).join.strip
+        each_attribute(exp) do |key, value|
+          hash[key] = value
         end
         hash
       rescue UnexpectedTokenError, UnexpectedKeyError
@@ -30,82 +38,106 @@ module Haml
 
       private
 
-      def wrap_bracket(text)
-        text = text.strip
-        return text if text[0] == '{'
-        "{#{text}}"
+      # @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
       end
 
-      def parse_key!(tokens)
-        _, type, str = tokens.shift
+      # @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
+
+        _, type, first_text = 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)
+        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)
+          end
+          shift_hash_rocket!(tokens)
           key
-        when :on_tstring_beg
-          _, _, key = tokens.shift
+        when :on_tstring_beg # `"key":`, `'key':` or `"key" =>`
+          key = tokens.shift[TEXT]
           next_token = tokens.shift
-          unless next_token[1] == :on_label_end
-            assert_type!(next_token, :on_tstring_end)
-            skip_until_hash_rocket!(tokens)
+          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
+          raise UnexpectedKeyError.new("unexpected token is given!: #{first_text} (#{type})")
         end
       end
 
-      def assert_type!(token, type)
-        raise UnexpectedTokenError if token[1] != type
+      # @param [Array] token - Ripper token
+      def expect_string_end!(token)
+        if token[TYPE] != :on_tstring_end
+          raise UnexpectedTokenError
+        end
       end
 
-      def skip_until_hash_rocket!(tokens)
+      # @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
 
-      def each_attr(tokens)
+      # @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_balaned_tokens(all_tokens) do |tokens|
+          key   = shift_key!(tokens)
+          value = tokens.map(&:last).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_balaned_tokens(tokens, &block)
         attr_tokens = []
-        array_open  = 0
-        brace_open  = 0
-        paren_open  = 0
+        open_tokens = Hash.new { |h, k| h[k] = 0 }
 
         tokens.each do |token|
-          _, type, _ = token
-          case type
+          case token[TYPE]
           when :on_comma
-            if array_open == 0 && brace_open == 0 && paren_open == 0
-              yield(attr_tokens)
+            if open_tokens.values.all?(&:zero?)
+              block.call(attr_tokens)
               attr_tokens = []
               next
             end
           when :on_lbracket
-            array_open += 1
+            open_tokens[:array] += 1
           when :on_rbracket
-            array_open -= 1
+            open_tokens[:array] -= 1
           when :on_lbrace
-            brace_open += 1
+            open_tokens[:block] += 1
           when :on_rbrace
-            brace_open -= 1
+            open_tokens[:block] -= 1
           when :on_lparen
-            paren_open += 1
+            open_tokens[:paren] += 1
           when :on_rparen
-            paren_open -= 1
-          when :on_sp
+            open_tokens[:paren] -= 1
+          when *IGNORED_TYPES
             next if attr_tokens.empty?
           end
 
           attr_tokens << token
         end
-        yield(attr_tokens) unless attr_tokens.empty?
+        block.call(attr_tokens) unless attr_tokens.empty?
       end
     end
   end

data/lib/haml/buffer.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
   # This class is used only internally. It holds the buffer of HTML that
   # is eventually output as the resulting document.
@@ -128,17 +129,6 @@ module Haml
       @real_tabs += tab_change
     end
 
-    # the number of arguments here is insane, but passing in an options hash instead of named arguments
-    # causes a significant performance regression
-    def format_script(result, preserve_script, in_tag, preserve_tag, escape_html, nuke_inner_whitespace, interpolated)
-      result_name = escape_html ? html_escape(result.to_s) : result.to_s
-
-      result = nuke_inner_whitespace ? result_name.strip : result_name
-      result = preserve(result, preserve_script, preserve_tag)
-      fix_textareas!(result) if toplevel? && result.include?('<textarea')
-      result
-    end
-
     def attributes(class_id, obj_ref, *attributes_hashes)
       attributes = class_id
       attributes_hashes.each do |old|
@@ -160,14 +150,6 @@ module Haml
       buffer << buffer.slice!(capture_position..-1).rstrip
     end
 
-    private
-
-    def preserve(result, preserve_script, preserve_tag)
-      return Haml::Helpers.preserve(result) if preserve_tag
-      return Haml::Helpers.find_and_preserve(result, options[:preserve]) if preserve_script
-      result
-    end
-
     # Works like #{find_and_preserve}, but allows the first newline after a
     # preserved opening tag to remain unencoded, and then outdents the content.
     # This change was motivated primarily by the change in Rails 3.2.3 to emit
@@ -177,6 +159,8 @@ module Haml
     # @since Haml 4.0.1
     # @private
     def fix_textareas!(input)
+      return input unless toplevel? && input.include?('<textarea'.freeze)
+
       pattern = /<(textarea)([^>]*)>(\n|&#x000A;)(.*?)<\/textarea>/im
       input.gsub!(pattern) do |s|
         match = pattern.match(s)
@@ -188,10 +172,13 @@ module Haml
         end
         "<#{match[1]}#{match[2]}>\n#{content}</#{match[1]}>"
       end
+      input
     end
 
+    private
+
     def new_encoded_string
-      "".encode(Encoding.find(options[:encoding]))
+      "".encode(options[:encoding])
     end
 
     @@tab_cache = {}

data/lib/haml/compiler.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 require 'haml/attribute_builder'
 require 'haml/attribute_compiler'
 require 'haml/temple_line_counter'
@@ -92,13 +93,13 @@ module Haml
         object_ref = :nil
         parse = false
         value = t[:parse] ? nil : t[:value]
-        attributes_hashes = []
+        dynamic_attributes = Haml::Parser::DynamicAttributes.new
         preserve_script = false
       else
         object_ref = t[:object_ref]
         parse = t[:parse]
         value = t[:value]
-        attributes_hashes = t[:attributes_hashes]
+        dynamic_attributes = t[:dynamic_attributes]
         preserve_script = t[:preserve_script]
       end
 
@@ -107,7 +108,7 @@ module Haml
       end
 
       push_text("<#{t[:name]}")
-      push_temple(@attribute_compiler.compile(t[:attributes], object_ref, attributes_hashes))
+      push_temple(@attribute_compiler.compile(t[:attributes], object_ref, dynamic_attributes))
       push_text(
         if t[:self_closing] && @options.xhtml?
           " />#{"\n" unless t[:nuke_outer_whitespace]}"
@@ -231,8 +232,7 @@ module Haml
 
     def push_temple(temple)
       flush_merged_text
-      newlines = resolve_newlines
-      @temple << [:code, newlines] unless newlines.empty?
+      @temple.concat([[:newline]] * resolve_newlines.count("\n"))
       @temple << temple
       @output_line += TempleLineCounter.count_lines(temple)
     end
@@ -262,15 +262,10 @@ module Haml
     def push_script(text, opts = {})
       return if @options.suppress_eval?
 
-      args = [:preserve_script, :in_tag, :preserve_tag, :escape_html, :nuke_inner_whitespace]
-      args.map! {|name| !!opts[name]}
-      args << !block_given?
-
       no_format = !(opts[:preserve_script] || opts[:preserve_tag] || opts[:escape_html])
 
       unless block_given?
-        format_script_method = "_hamlout.format_script((#{text}\n),#{args.join(',')});"
-        push_generated_script(no_format ? "(#{text}\n).to_s" : format_script_method)
+        push_generated_script(no_format ? "(#{text}\n).to_s" : build_script_formatter("(#{text}\n)", opts))
         push_text("\n") unless opts[:in_tag] || opts[:nuke_inner_whitespace]
         return
       end
@@ -279,8 +274,23 @@ module Haml
       push_silent "haml_temp = #{text}"
       yield
       push_silent('end', :can_suppress) unless @node.value[:dont_push_end]
-      format_script_method = "_hamlout.format_script(haml_temp,#{args.join(',')});"
-      @temple << [:dynamic, no_format ? "haml_temp.to_s;" : format_script_method]
+      @temple << [:dynamic, no_format ? 'haml_temp.to_s;' : build_script_formatter('haml_temp', opts)]
+    end
+
+    def build_script_formatter(text, opts)
+      text = "(#{text}).to_s"
+      if opts[:escape_html]
+        text = "::Haml::Helpers.html_escape(#{text})"
+      end
+      if opts[:nuke_inner_whitespace]
+        text = "(#{text}).strip"
+      end
+      if opts[:preserve_tag]
+        text = "::Haml::Helpers.preserve(#{text})"
+      elsif opts[:preserve_script]
+        text = "::Haml::Helpers.find_and_preserve(#{text}, _hamlout.options[:preserve])"
+      end
+      "_hamlout.fix_textareas!(#{text});"
     end
 
     def push_generated_script(text)

data/lib/haml/engine.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 require 'forwardable'
 
 require 'haml/parser'

data/lib/haml/error.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
   # An exception raised by Haml code.
   class Error < StandardError

data/lib/haml/escapable.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
   # Like Temple::Filters::Escapable, but with support for escaping by
   # Haml::Herlpers.html_escape and Haml::Herlpers.escape_once.

data/lib/haml/exec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'optparse'
 require 'rbconfig'
 require 'pp'
@@ -292,8 +293,8 @@ END
         begin
 
           if @options[:parse]
-            parser = ::Haml::Parser.new(template, ::Haml::Options.new(@options))
-            pp parser.parse
+            parser = ::Haml::Parser.new(::Haml::Options.new(@options))
+            pp parser.call(template)
             return
           end
 

data/lib/haml/filters.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 require "tilt"
 
 module Haml

data/lib/haml/generator.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
   # Ruby code generator, which is a limited version of Temple::Generator.
   # Limit methods since Haml doesn't need most of them.
@@ -27,6 +28,10 @@ module Haml
       exp
     end
 
+    def on_newline
+      "\n"
+    end
+
     private
 
     def concat(str)

data/lib/haml/helpers.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 require 'erb'
 
 module Haml

data/lib/haml/helpers/action_view_extensions.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
   module Helpers
     @@action_view_defined = true

data/lib/haml/helpers/action_view_mods.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
   module Helpers
     module ActionViewMods
@@ -54,7 +55,7 @@ module ActionView
       def content_tag_with_haml(name, *args, &block)
         return content_tag_without_haml(name, *args, &block) unless is_haml?
 
-        preserve = haml_buffer.options[:preserve].include?(name.to_s)
+        preserve = haml_buffer.options.fetch(:preserve, %w[textarea pre code]).include?(name.to_s)
 
         if block_given? && block_is_haml?(block) && preserve
           return content_tag_without_haml(name, *args) {preserve(&block)}

data/lib/haml/helpers/action_view_xss_mods.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActionView
   module Helpers
     module CaptureHelper

data/lib/haml/helpers/safe_erubi_template.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'action_view'
 
 module Haml

data/lib/haml/helpers/safe_erubis_template.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'action_view'
 
 module Haml
@@ -28,4 +29,4 @@ module Haml
       [super, '@output_buffer.to_s'].join("\n")
     end
   end
-end
+end

data/lib/haml/helpers/xss_mods.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
   module Helpers
     # This module overrides Haml helpers to work properly

data/lib/haml/options.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
   # This class encapsulates all of the configuration options that Haml
   # understands. Please see the {file:REFERENCE.md#options Haml Reference} to

data/lib/haml/parser.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 require 'strscan'
 
 module Haml
@@ -204,6 +205,30 @@ module Haml
       end
     end
 
+    # @param [String] new - Hash literal including dynamic values.
+    # @param [String] old - Hash literal including dynamic values or Ruby literal of multiple Hashes which MUST be interpreted as method's last arguments.
+    class DynamicAttributes < Struct.new(:new, :old)
+      def old=(value)
+        unless value =~ /\A{.*}\z/m
+          raise ArgumentError.new('Old attributes must start with "{" and end with "}"')
+        end
+        super
+      end
+
+      # This will be a literal for Haml::Buffer#attributes's last argument, `attributes_hashes`.
+      def to_literal
+        [new, stripped_old].compact.join(', ')
+      end
+
+      private
+
+      # For `%foo{ { foo: 1 }, bar: 2 }`, :old is "{ { foo: 1 }, bar: 2 }" and this method returns " { foo: 1 }, bar: 2 " for last argument.
+      def stripped_old
+        return nil if old.nil?
+        old.sub!(/\A{/, '').sub!(/}\z/m, '')
+      end
+    end
+
     # Processes and deals with lowering indentation.
     def process_indent(line)
       return unless line.tabs <= @template_tabs && @template_tabs > 0
@@ -396,22 +421,20 @@ module Haml
       end
 
       attributes = Parser.parse_class_and_id(attributes)
-      attributes_list = []
+      dynamic_attributes = DynamicAttributes.new
 
       if attributes_hashes[:new]
         static_attributes, attributes_hash = attributes_hashes[:new]
         AttributeBuilder.merge_attributes!(attributes, static_attributes) if static_attributes
-        attributes_list << attributes_hash
+        dynamic_attributes.new = attributes_hash
       end
 
       if attributes_hashes[:old]
         static_attributes = parse_static_hash(attributes_hashes[:old])
         AttributeBuilder.merge_attributes!(attributes, static_attributes) if static_attributes
-        attributes_list << attributes_hashes[:old] unless static_attributes || @options.suppress_eval
+        dynamic_attributes.old = attributes_hashes[:old] unless static_attributes || @options.suppress_eval
       end
 
-      attributes_list.compact!
-
       raise SyntaxError.new(Error.message(:illegal_nesting_self_closing), @next_line.index) if block_opened? && self_closing
       raise SyntaxError.new(Error.message(:no_ruby_code, action), last_line - 1) if parse && value.empty?
       raise SyntaxError.new(Error.message(:self_closing_content), last_line - 1) if self_closing && !value.empty?
@@ -426,7 +449,7 @@ module Haml
       line = handle_ruby_multiline(line) if parse
 
       ParseNode.new(:tag, line.index + 1, :name => tag_name, :attributes => attributes,
-        :attributes_hashes => attributes_list, :self_closing => self_closing,
+        :dynamic_attributes => dynamic_attributes, :self_closing => self_closing,
         :nuke_inner_whitespace => nuke_inner_whitespace,
         :nuke_outer_whitespace => nuke_outer_whitespace, :object_ref => object_ref,
         :escape_html => escape_html, :preserve_tag => preserve_tag,
@@ -532,7 +555,7 @@ module Haml
       attributes = {}
       return attributes if list.empty?
 
-      list.scan(/([#.])([-:_a-zA-Z0-9]+)/) do |type, property|
+      list.scan(/([#.])([-:_a-zA-Z0-9\@]+)/) do |type, property|
         case type
         when '.'
           if attributes[CLASS_KEY]
@@ -547,10 +570,16 @@ module Haml
       attributes
     end
 
+    # This method doesn't use Haml::AttributeParser because currently it depends on Ripper and Rubinius doesn't provide it.
+    # Ideally this logic should be placed in Haml::AttributeParser instead of here and this method should use it.
+    #
+    # @param  [String] text - Hash literal or text inside old attributes
+    # @return [Hash,nil] - Return nil if text is not static Hash literal
     def parse_static_hash(text)
       attributes = {}
       return attributes if text.empty?
 
+      text = text[1...-1] # strip brackets
       scanner = StringScanner.new(text)
       scanner.scan(/\s+/)
       until scanner.eos?
@@ -565,7 +594,7 @@ module Haml
 
     # Parses a line into tag_name, attributes, attributes_hash, object_ref, action, value
     def parse_tag(text)
-      match = text.scan(/%([-:\w]+)([-:\w.#]*)(.+)?/)[0]
+      match = text.scan(/%([-:\w]+)([-:\w.#\@]*)(.+)?/)[0]
       raise SyntaxError.new(Error.message(:invalid_tag, text)) unless match
 
       tag_name, attributes, rest = match
@@ -616,6 +645,9 @@ module Haml
        nuke_inner_whitespace, action, value, last_line || @line.index + 1]
     end
 
+    # @return [String] attributes_hash - Hash literal starting with `{` and ending with `}`
+    # @return [String] rest
+    # @return [Integer] last_line
     def parse_old_attributes(text)
       text = text.dup
       last_line = @line.index + 1
@@ -633,10 +665,12 @@ module Haml
         raise e
       end
 
-      attributes_hash = attributes_hash[1...-1] if attributes_hash
       return attributes_hash, rest, last_line
     end
 
+    # @return [Array<Hash,String,nil>] - [static_attributs (Hash), dynamic_attributes (nil or String starting with `{` and ending with `}`)]
+    # @return [String] rest
+    # @return [Integer] last_line
     def parse_new_attributes(text)
       scanner = StringScanner.new(text)
       last_line = @line.index + 1

data/lib/haml/plugin.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
 
   # This module makes Haml work with Rails using the template handler API.

data/lib/haml/railtie.rb

@@ -1,35 +1,29 @@
-if defined?(ActiveSupport)
-  # check for a compatible Rails version when Haml is loaded
-  if (activesupport_spec = Gem.loaded_specs['activesupport'])
-    if activesupport_spec.version.to_s < '3.2'
-      raise Exception.new("\n\n** Haml now requires Rails 3.2 and later. Use Haml version 4.0.4\n\n")
-    end
-  end
+# frozen_string_literal: true
+require 'haml/template/options'
 
-  require 'haml/template/options'
-  ActiveSupport.on_load(:action_view) do
-    require "haml/template"
-
-    if defined? Erubi
-      require "haml/helpers/safe_erubi_template"
-      Haml::Filters::Erb.template_class = Haml::SafeErubiTemplate
-    else
-      require "haml/helpers/safe_erubis_template"
-      Haml::Filters::Erb.template_class = Haml::SafeErubisTemplate
-    end
+# check for a compatible Rails version when Haml is loaded
+if (activesupport_spec = Gem.loaded_specs['activesupport'])
+  if activesupport_spec.version.to_s < '3.2'
+    raise Exception.new("\n\n** Haml now requires Rails 3.2 and later. Use Haml version 4.0.4\n\n")
   end
 end
 
 module Haml
   class Railtie < ::Rails::Railtie
     initializer :haml do |app|
-      require "haml/template"
-      if defined?(::Sass::Rails::SassTemplate) && app.config.assets.enabled
-        require "haml/sass_rails_filter"
-      end
-      Haml::Options.buffer_defaults.keys.each do |key|
-        if Haml::Template.options.key?(key)
-          Haml::Options.buffer_defaults[key] = Haml::Template.options[key]
+      ActiveSupport.on_load(:action_view) do
+        require "haml/template"
+
+        if defined?(::Sass::Rails::SassTemplate) && app.config.assets.enabled
+          require "haml/sass_rails_filter"
+        end
+
+        if defined? Erubi
+          require "haml/helpers/safe_erubi_template"
+          Haml::Filters::Erb.template_class = Haml::SafeErubiTemplate
+        else
+          require "haml/helpers/safe_erubis_template"
+          Haml::Filters::Erb.template_class = Haml::SafeErubisTemplate
         end
       end
     end

data/lib/haml/sass_rails_filter.rb

@@ -1,11 +1,24 @@
+# frozen_string_literal: true
 module Haml
   module Filters
     # This is an extension of Sass::Rails's SassTemplate class that allows
     # Rails's asset helpers to be used inside Haml Sass filter.
     class SassRailsTemplate < ::Sass::Rails::SassTemplate
-      def render(scope=Object.new, locals={}, &block)
-        scope = ::Rails.application.assets.context_class.new(::Rails.application.assets, "/", "/")
-        super
+      if Gem::Version.new(Sprockets::VERSION) >= Gem::Version.new('3.0.0')
+        def render(scope=Object.new, locals={}, &block)
+          environment = ::Sprockets::Railtie.build_environment(Rails.application)
+          scope = environment.context_class.new(
+            environment: environment,
+            filename: "/",
+            metadata: {}
+          )
+          super
+        end
+      else
+        def render(scope=Object.new, locals={}, &block)
+          scope = ::Rails.application.assets.context_class.new(::Rails.application.assets, "/", "/")
+          super
+        end
       end
 
       def sass_options(scope)
@@ -30,4 +43,4 @@ module Haml
     register_tilt_filter "Sass", :extend => "Css", :template_class => SassRailsTemplate
     register_tilt_filter "Scss", :extend => "Css", :template_class => ScssRailsTemplate
   end
-end
+end

data/lib/haml/template.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'haml/template/options'
 if defined?(ActiveSupport)
   ActiveSupport.on_load(:action_view) do

data/lib/haml/template/options.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # We keep options in its own self-contained file
 # so that we can load it independently in Rails 3,
 # where the full template stuff is lazy-loaded.
@@ -6,11 +7,20 @@ module Haml
   module Template
     extend self
 
-    @options = {}
+    class Options < Hash
+      def []=(key, value)
+        super
+        if Haml::Options.buffer_defaults.key?(key)
+          Haml::Options.buffer_defaults[key] = value
+        end
+      end
+    end
+
+    @options = ::Haml::Template::Options.new
     # The options hash for Haml when used within Rails.
     # See {file:REFERENCE.md#options the Haml options documentation}.
     #
-    # @return [{Symbol => Object}]
+    # @return [Haml::Template::Options<Symbol => Object>]
     attr_accessor :options
   end
 end

data/lib/haml/temple_engine.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 require 'temple'
 require 'haml/escapable'
 require 'haml/generator'

data/lib/haml/temple_line_counter.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
   # A module to count lines of expected code. This would be faster than actual code generation
   # and counting newlines in it.

data/lib/haml/util.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: false
 
 begin
   require 'erubis/tiny'

data/lib/haml/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Haml
-  VERSION = "5.0.0.beta.2"
+  VERSION = "5.0.0"
 end

data/test/attribute_parser_test.rb

@@ -12,93 +12,89 @@ class AttributeParserTeset < Haml::TestCase
     end
 
     if Haml::AttributeParser.available?
-      it { assert_parse({}, '') }
+      it { assert_parse(nil, '') }
       it { assert_parse({}, '{}') }
 
       describe 'invalid hash' do
-        it { assert_parse(nil, ' hash ') }
-        it { assert_parse(nil, 'hash, foo: bar') }
-        it { assert_parse(nil, ' {hash} ') }
-        it { assert_parse(nil, ' { hash, foo: bar } ') }
+        it { assert_parse(nil, '{hash}') }
+        it { assert_parse(nil, '{hash, foo: bar}') }
+        it { assert_parse(nil, '{ {hash} }') }
+        it { assert_parse(nil, '{ { hash, foo: bar } }') }
+        it { assert_parse(nil, '{}.merge({})') }
+      end
+
+      describe 'non single hash' do
+        it { assert_parse(nil, '{ a: 0 };{}') }
+        it { assert_parse(nil, '{ a: 0 }[nil] = {}') }
       end
 
       describe 'dynamic key' do
-        it { assert_parse(nil, 'foo => bar') }
-        it { assert_parse(nil, '[] => bar') }
-        it { assert_parse(nil, '[1,2,3] => bar') }
+        it { assert_parse(nil, '{foo => bar}') }
+        it { assert_parse(nil, '{[] => bar}') }
+        it { assert_parse(nil, '{[1,2,3] => bar}') }
       end
 
       describe 'foo: bar' do
-        it { assert_parse({ '_' => '1' }, '_:1,') }
-        it { assert_parse({ 'foo' => 'bar' }, ' foo:  bar ') }
-        it { assert_parse({ 'a' => 'b', 'c' => ':d' }, 'a: b, c: :d') }
-        it { assert_parse({ 'a' => '[]', 'c' => '"d"' }, 'a: [], c: "d"') }
-        it { assert_parse({ '_' => '1' }, ' { _:1, } ') }
-        it { assert_parse({ 'foo' => 'bar' }, ' {  foo:  bar } ') }
-        it { assert_parse({ 'a' => 'b', 'c' => ':d' }, ' { a: b, c: :d } ') }
-        it { assert_parse({ 'a' => '[]', 'c' => '"d"' }, ' { a: [], c: "d" } ') }
+        it { assert_parse({ '_' => '1' }, '{_:1,}') }
+        it { assert_parse({ 'foo' => 'bar' }, '{ foo:  bar }') }
+        it { assert_parse({ 'a' => 'b', 'c' => ':d' }, '{a: b, c: :d}') }
+        it { assert_parse({ 'a' => '[]', 'c' => '"d"' }, '{a: [], c: "d"}') }
       end
 
       describe ':foo => bar' do
-        it { assert_parse({ 'foo' => ':bar' }, '  :foo   =>  :bar  ') }
-        it { assert_parse({ '_' => '"foo"' }, ':_=>"foo"') }
-        it { assert_parse({ 'a' => '[]', 'c' => '""', 'b' => '"#{3}"' }, ':a => [], c: "", :b => "#{3}"') }
-        it { assert_parse({ 'foo' => ':bar' }, ' {   :foo   =>  :bar } ') }
-        it { assert_parse({ '_' => '"foo"' }, ' { :_=>"foo" } ') }
-        it { assert_parse({ 'a' => '[]', 'c' => '""', 'b' => '"#{3}"' }, ' { :a => [], c: "", :b => "#{3}" } ') }
-        it { assert_parse(nil, ':"f#{o}o" => bar') }
-        it { assert_parse(nil, ':"#{f}oo" => bar') }
-        it { assert_parse(nil, ':"#{foo}" => bar') }
+        it { assert_parse({ 'foo' => ':bar' }, '{  :foo   =>  :bar  }') }
+        it { assert_parse({ '_' => '"foo"' }, '{:_=>"foo"}') }
+        it { assert_parse({ 'a' => '[]', 'c' => '""', 'b' => '"#{3}"' }, '{:a => [], c: "", :b => "#{3}"}') }
+        it { assert_parse(nil, '{:"f#{o}o" => bar}') }
+        it { assert_parse(nil, '{:"#{f}oo" => bar}') }
+        it { assert_parse(nil, '{:"#{foo}" => bar}') }
       end
 
       describe '"foo" => bar' do
-        it { assert_parse({ 'foo' => '[1]' }, '"foo"=>[1]') }
-        it { assert_parse({ 'foo' => 'nya' }, " 'foo' => nya ") }
-        it { assert_parse({ 'foo' => 'bar' }, '%q[foo] => bar ') }
+        it { assert_parse({ 'foo' => '[1]' }, '{"foo"=>[1]}') }
+        it { assert_parse({ 'foo' => 'nya' }, "{ 'foo' => nya }") }
+        it { assert_parse({ 'foo' => 'bar' }, '{%q[foo] => bar }') }
         it { assert_parse({ 'foo' => '[1]' }, ' { "foo"=>[1] } ') }
         it { assert_parse({ 'foo' => 'nya' }, " {  'foo' => nya } ") }
         it { assert_parse({ 'foo' => 'bar' }, ' { %q[foo] => bar } ') }
-        it { assert_parse(nil, '"f#{o}o" => bar') }
-        it { assert_parse(nil, '"#{f}oo" => bar') }
-        it { assert_parse(nil, '"#{foo}" => bar') }
-        it { assert_parse({ 'f#{o}o' => 'bar' }, '%q[f#{o}o] => bar ') }
-        it { assert_parse({ 'f#{o}o' => 'bar' }, ' { %q[f#{o}o] => bar,  } ') }
+        it { assert_parse(nil, '{"f#{o}o" => bar}') }
+        it { assert_parse(nil, '{"#{f}oo" => bar}') }
+        it { assert_parse(nil, '{"#{foo}" => bar}') }
+        it { assert_parse({ 'f#{o}o' => 'bar' }, '{ %q[f#{o}o] => bar }') }
+        it { assert_parse({ 'f#{o}o' => 'bar' }, '{ %q[f#{o}o] => bar,  }') }
         it { assert_parse(nil, '%Q[f#{o}o] => bar ') }
       end
 
+      describe 'multi lines' do
+        it { assert_parse({ 'a' => 'b', 'c' => 'd' }, "{a: b,\nc: d}") }
+      end
+
       if RUBY_VERSION >= '2.2.0'
         describe '"foo": bar' do
-          it { assert_parse({ 'foo' => '()' }, '"foo":()') }
-          it { assert_parse({ 'foo' => 'nya' }, " 'foo': nya ") }
+          it { assert_parse({ 'foo' => '()' }, '{"foo":()}') }
+          it { assert_parse({ 'foo' => 'nya' }, " {'foo': nya} ") }
           it { assert_parse({ 'foo' => '()' }, ' { "foo":() , }') }
           it { assert_parse({ 'foo' => 'nya' }, " {  'foo': nya , }") }
-          it { assert_parse(nil, '"f#{o}o": bar') }
-          it { assert_parse(nil, '"#{f}oo": bar') }
-          it { assert_parse(nil, '"#{foo}": bar') }
+          it { assert_parse(nil, '{"f#{o}o": bar}') }
+          it { assert_parse(nil, '{"#{f}oo": bar}') }
+          it { assert_parse(nil, '{"#{foo}": bar}') }
         end
       end
 
       describe 'nested array' do
-        it { assert_parse({ 'foo' => '[1,2,]' }, 'foo: [1,2,],') }
-        it { assert_parse({ 'foo' => '[1,2,[3,4],5]' }, 'foo: [1,2,[3,4],5],') }
-        it { assert_parse({ 'foo' => '[1,2,[3,4],5]', 'bar' => '[[1,2],]'}, 'foo: [1,2,[3,4],5],bar: [[1,2],],') }
-        it { assert_parse({ 'foo' => '[1,2,]' }, ' { foo: [1,2,], } ') }
-        it { assert_parse({ 'foo' => '[1,2,[3,4],5]' }, ' { foo: [1,2,[3,4],5], } ') }
-        it { assert_parse({ 'foo' => '[1,2,[3,4],5]', 'bar' => '[[1,2],]'}, ' { foo: [1,2,[3,4],5],bar: [[1,2],], } ') }
+        it { assert_parse({ 'foo' => '[1,2,]' }, '{foo: [1,2,],}') }
+        it { assert_parse({ 'foo' => '[1,2,[3,4],5]' }, '{foo: [1,2,[3,4],5],}') }
+        it { assert_parse({ 'foo' => '[1,2,[3,4],5]', 'bar' => '[[1,2],]'}, '{foo: [1,2,[3,4],5],bar: [[1,2],],}') }
       end
 
       describe 'nested hash' do
-        it { assert_parse({ 'foo' => '{ }', 'bar' => '{}' }, 'foo: { }, bar: {}') }
-        it { assert_parse({ 'foo' => '{ bar: baz, hoge: fuga, }' }, 'foo: { bar: baz, hoge: fuga, }, ') }
-        it { assert_parse({ 'data' => '{ confirm: true, disable: false }', 'hello' => '{ world: foo, }' }, 'data: { confirm: true, disable: false }, :hello => { world: foo, },') }
-        it { assert_parse({ 'foo' => '{ }', 'bar' => '{}' }, ' { foo: { }, bar: {} } ') }
-        it { assert_parse({ 'foo' => '{ bar: baz, hoge: fuga, }' }, ' { foo: { bar: baz, hoge: fuga, }, } ') }
-        it { assert_parse({ 'data' => '{ confirm: true, disable: false }', 'hello' => '{ world: foo, }' }, ' { data: { confirm: true, disable: false }, :hello => { world: foo, }, } ') }
+        it { assert_parse({ 'foo' => '{ }', 'bar' => '{}' }, '{foo: { }, bar: {}}') }
+        it { assert_parse({ 'foo' => '{ bar: baz, hoge: fuga, }' }, '{foo: { bar: baz, hoge: fuga, }, }') }
+        it { assert_parse({ 'data' => '{ confirm: true, disable: false }', 'hello' => '{ world: foo, }' }, '{data: { confirm: true, disable: false }, :hello => { world: foo, },}') }
       end
 
       describe 'nested method' do
-        it { assert_parse({ 'foo' => 'bar(a, b)', 'hoge' => 'piyo(a, b,)' }, 'foo: bar(a, b), hoge: piyo(a, b,),') }
-        it { assert_parse({ 'foo' => 'bar(a, b)', 'hoge' => 'piyo(a, b,)' }, ' { foo: bar(a, b), hoge: piyo(a, b,), } ') }
+        it { assert_parse({ 'foo' => 'bar(a, b)', 'hoge' => 'piyo(a, b,)' }, '{ foo: bar(a, b), hoge: piyo(a, b,), }') }
       end
     end
   end

data/test/engine_test.rb

@@ -1555,6 +1555,12 @@ HAML
 HAML
   end
 
+  def test_hash_method_call_in_attributes
+    assert_equal(%Q{<a foo='bar' hoge='fuga'></a>\n}, render(<<-HAML))
+- hash = {:hoge => :fuga}
+%a{{foo: 'bar'}.merge(hash)}
+HAML
+  end
 
   def test_html5_data_attributes_with_nested_hash
     assert_equal("<div data-a-b='c'></div>\n", render(<<-HAML))

data/test/options_test.rb

@@ -9,11 +9,12 @@ module Haml
       )
     end
 
-    def test_buffer_defaults_values_are_default_options
+    def test_buffer_defaults_values_are_the_same_as_rails_defaults
+      rails_defaults = Haml::Options.defaults.merge(Haml::Template.options)
       Haml::Options.buffer_option_keys.each do |key|
         assert_equal(
-          Haml::Options.defaults[key],
-          Haml::Options.buffer_defaults[key],
+          rails_defaults[key],
+          Haml::Options.buffer_defaults[key], "key: #{key}"
         )
       end
     end

data/test/results/bemit.xhtml

@@ -0,0 +1,4 @@
+<div class='o-media@md c-user c-user--premium'>
+<img alt='' class='o-media__img@md c-user__photo c-avatar' src='' />
+<p class='o-media__body@md c-user__bio'>...</p>
+</div>

data/test/template_test.rb

@@ -8,7 +8,7 @@ class TemplateTest < Haml::TestCase
   TEMPLATES = %w{          very_basic        standard    helpers
     whitespace_handling    original_engine   list        helpful
     silent_script          tag_parsing       just_stuff  partials
-    nuke_outer_whitespace  nuke_inner_whitespace
+    nuke_outer_whitespace  nuke_inner_whitespace         bemit
     render_layout partial_layout partial_layout_erb}
 
   def setup

data/test/templates/bemit.haml

@@ -0,0 +1,3 @@
+.o-media@md.c-user.c-user--premium
+  %img.o-media__img@md.c-user__photo.c-avatar{src: '', alt: ''}
+  %p.o-media__body@md.c-user__bio ...

data/test/test_helper.rb

@@ -26,6 +26,7 @@ if defined?(I18n.enforce_available_locales)
 end
 
 class TestApp < Rails::Application
+  config.eager_load = false
   config.root = ""
 end
 Rails.application = TestApp
@@ -39,6 +40,8 @@ $VERBOSE = true
 require 'haml'
 require 'haml/template'
 
+TestApp.initialize!
+
 Haml::Template.options[:format] = :xhtml
 
 BASE_TEST_CLASS = if defined?(Minitest::Test)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haml
 version: !ruby/object:Gem::Version
-  version: 5.0.0.beta.2
+  version: 5.0.0
 platform: ruby
 authors:
 - Natalie Weizenbaum
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-26 00:00:00.000000000 Z
+date: 2017-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: temple
@@ -166,6 +166,7 @@ files:
 - test/mocks/article.rb
 - test/options_test.rb
 - test/parser_test.rb
+- test/results/bemit.xhtml
 - test/results/content_for_layout.xhtml
 - test/results/eval_suppressed.xhtml
 - test/results/helpers.xhtml
@@ -194,6 +195,7 @@ files:
 - test/templates/_text_area.haml
 - test/templates/_text_area_helper.html.haml
 - test/templates/action_view.haml
+- test/templates/bemit.haml
 - test/templates/breakage.haml
 - test/templates/content_for_layout.haml
 - test/templates/eval_suppressed.haml
@@ -234,12 +236,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: An elegant, structured (X)HTML/XML templating engine.