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

data/lib/haml/{template/plugin.rb → plugin.rb}

@@ -6,13 +6,16 @@ module Haml
 
     def compile(template)
       options = Haml::Template.options.dup
-      if (ActionPack::VERSION::MAJOR >= 4) && template.respond_to?(:type)
+      if template.respond_to?(:type)
         options[:mime_type] = template.type
       elsif template.respond_to? :mime_type
         options[:mime_type] = template.mime_type
       end
       options[:filename] = template.identifier
-      Haml::Engine.new(template.source, options).compiler.precompiled_with_ambles([])
+      Haml::Engine.new(template.source, options).compiler.precompiled_with_ambles(
+        [],
+        after_preamble: '@output_buffer = output_buffer ||= ActionView::OutputBuffer.new if defined?(ActionView::OutputBuffer)',
+      )
     end
 
     def self.call(template)

data/lib/haml/railtie.rb

@@ -7,9 +7,15 @@ if defined?(ActiveSupport)
   end
 
   require 'haml/template/options'
-  ActiveSupport.on_load(:before_initialize) do
-    ActiveSupport.on_load(:action_view) do
-      require "haml/template"
+  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
   end
 end
@@ -21,9 +27,11 @@ module Haml
       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]
+        end
+      end
     end
   end
 end
-
-require "haml/helpers/safe_erubis_template"
-Haml::Filters::Erb.template_class = Haml::SafeErubisTemplate

data/lib/haml/template.rb

@@ -1,12 +1,18 @@
 require 'haml/template/options'
-require 'haml/engine'
-require 'haml/helpers/action_view_mods'
-require 'haml/helpers/action_view_extensions'
+if defined?(ActiveSupport)
+  ActiveSupport.on_load(:action_view) do
+    require 'haml/helpers/action_view_mods'
+    require 'haml/helpers/action_view_extensions'
+  end
+else
+  require 'haml/helpers/action_view_mods'
+  require 'haml/helpers/action_view_extensions'
+end
 require 'haml/helpers/xss_mods'
 require 'haml/helpers/action_view_xss_mods'
 
 module Haml
-  class Compiler
+  class TempleEngine
     def precompiled_method_return_value_with_haml_xss
       "::Haml::Util.html_safe(#{precompiled_method_return_value_without_haml_xss})"
     end
@@ -26,7 +32,6 @@ module Haml
 end
 
 
-Haml::Template.options[:ugly] = defined?(Rails) ? !Rails.env.development? : true
 Haml::Template.options[:escape_html] = true
 
-require 'haml/template/plugin'
+require 'haml/plugin'

data/lib/haml/temple_engine.rb

@@ -0,0 +1,119 @@
+require 'temple'
+require 'haml/escapable'
+require 'haml/generator'
+
+module Haml
+  class TempleEngine < Temple::Engine
+    define_options(
+      attr_wrapper:         "'",
+      autoclose:            %w(area base basefont br col command embed frame
+                               hr img input isindex keygen link menuitem meta
+                               param source track wbr),
+      encoding:             nil,
+      escape_attrs:         true,
+      escape_html:          false,
+      filename:             '(haml)',
+      format:               :html5,
+      hyphenate_data_attrs: true,
+      line:                 1,
+      mime_type:            'text/html',
+      preserve:             %w(textarea pre code),
+      remove_whitespace:    false,
+      suppress_eval:        false,
+      cdata:                false,
+      parser_class:         ::Haml::Parser,
+      compiler_class:       ::Haml::Compiler,
+      trace:                false,
+    )
+
+    use :Parser,   -> { options[:parser_class] }
+    use :Compiler, -> { options[:compiler_class] }
+    use Escapable
+    filter :ControlFlow
+    filter :MultiFlattener
+    filter :StaticMerger
+    use Generator
+
+    def compile(template)
+      initialize_encoding(template, options[:encoding])
+      @precompiled = call(template)
+    end
+
+    # The source code that is evaluated to produce the Haml document.
+    #
+    # This is automatically converted to the correct encoding
+    # (see {file:REFERENCE.md#encodings the `:encoding` option}).
+    #
+    # @return [String]
+    def precompiled
+      encoding = Encoding.find(@encoding || '')
+      return @precompiled.force_encoding(encoding) if encoding == Encoding::ASCII_8BIT
+      return @precompiled.encode(encoding)
+    end
+
+    def precompiled_with_return_value
+      "#{precompiled};#{precompiled_method_return_value}"
+    end
+
+    # The source code that is evaluated to produce the Haml document.
+    #
+    # This is automatically converted to the correct encoding
+    # (see {file:REFERENCE.md#encodings the `:encoding` option}).
+    #
+    # @return [String]
+    def precompiled_with_ambles(local_names, after_preamble: '')
+      preamble = <<END.tr!("\n", ';')
+begin
+extend Haml::Helpers
+_hamlout = @haml_buffer = Haml::Buffer.new(haml_buffer, #{Options.new(options).for_buffer.inspect})
+_erbout = _hamlout.buffer
+#{after_preamble}
+END
+      postamble = <<END.tr!("\n", ';')
+#{precompiled_method_return_value}
+ensure
+@haml_buffer = @haml_buffer.upper if @haml_buffer
+end
+END
+      "#{preamble}#{locals_code(local_names)}#{precompiled}#{postamble}"
+    end
+
+    private
+
+    def initialize_encoding(template, given_value)
+      if given_value
+        @encoding = given_value
+      else
+        @encoding = Encoding.default_internal || template.encoding
+      end
+    end
+
+    # Returns the string used as the return value of the precompiled method.
+    # This method exists so it can be monkeypatched to return modified values.
+    def precompiled_method_return_value
+      "_erbout"
+    end
+
+    def locals_code(names)
+      names = names.keys if Hash === names
+
+      names.each_with_object('') do |name, code|
+        # Can't use || because someone might explicitly pass in false with a symbol
+        sym_local = "_haml_locals[#{inspect_obj(name.to_sym)}]"
+        str_local = "_haml_locals[#{inspect_obj(name.to_s)}]"
+        code << "#{name} = #{sym_local}.nil? ? #{str_local} : #{sym_local};"
+      end
+    end
+
+    def inspect_obj(obj)
+      case obj
+      when String
+        %Q!"#{obj.gsub(/[\x00-\x7F]+/) {|s| s.inspect[1...-1]}}"!
+      when Symbol
+        ":#{inspect_obj(obj.to_s)}"
+      else
+        obj.inspect
+      end
+    end
+  end
+end

data/lib/haml/temple_line_counter.rb

@@ -0,0 +1,28 @@
+module Haml
+  # A module to count lines of expected code. This would be faster than actual code generation
+  # and counting newlines in it.
+  module TempleLineCounter
+    class UnexpectedExpression < StandardError; end
+
+    def self.count_lines(exp)
+      type, *args = exp
+      case type
+      when :multi
+        args.map { |a| count_lines(a) }.reduce(:+) || 0
+      when :dynamic, :code
+        args.first.count("\n")
+      when :static
+        0 # It has not real newline "\n" but escaped "\\n".
+      when :case
+        arg, *cases = args
+        arg.count("\n") + cases.map do |cond, e|
+          (cond == :else ? 0 : cond.count("\n")) + count_lines(e)
+        end.reduce(:+)
+      when :escape
+        count_lines(args[1])
+      else
+        raise UnexpectedExpression.new("[HAML BUG] Unexpected Temple expression '#{type}' is given!")
+      end
+    end
+  end
+end

data/lib/haml/util.rb

@@ -14,38 +14,6 @@ module Haml
   module Util
     extend self
 
-    # Computes the powerset of the given array.
-    # This is the set of all subsets of the array.
-    #
-    # @example
-    #   powerset([1, 2, 3]) #=>
-    #     Set[Set[], Set[1], Set[2], Set[3], Set[1, 2], Set[2, 3], Set[1, 3], Set[1, 2, 3]]
-    # @param arr [Enumerable]
-    # @return [Set<Set>] The subsets of `arr`
-    def powerset(arr)
-      arr.inject([Set.new].to_set) do |powerset, el|
-        new_powerset = Set.new
-        powerset.each do |subset|
-          new_powerset << subset
-          new_powerset << subset + [el]
-        end
-        new_powerset
-      end
-    end
-
-    # Returns information about the caller of the previous method.
-    #
-    # @param entry [String] An entry in the `#caller` list, or a similarly formatted string
-    # @return [[String, Fixnum, (String, nil)]] An array containing the filename, line, and method name of the caller.
-    #   The method name may be nil
-    def caller_info(entry = caller[1])
-      info = entry.scan(/^(.*?):(-?.*?)(?::.*`(.+)')?$/).first
-      info[1] = info[1].to_i
-      # This is added by Rubinius to designate a block, but we don't care about it.
-      info[2].sub!(/ \{\}\Z/, '') if info[2]
-      info
-    end
-
     # Silence all output to STDERR within a block.
     #
     # @yield A block in which no output will be printed to STDERR
@@ -71,6 +39,9 @@ module Haml
     # With older versions of the Rails XSS-safety mechanism,
     # this destructively modifies the HTML-safety of `text`.
     #
+    # It only works if you are using ActiveSupport or the parameter `text`
+    # implements the #html_safe method.
+    #
     # @param text [String, nil]
     # @return [String, nil] `text`, marked as HTML-safe
     def html_safe(text)
@@ -81,7 +52,7 @@ module Haml
     # Checks that the encoding of a string is valid
     # and cleans up potential encoding gotchas like the UTF-8 BOM.
     # If it's not, yields an error string describing the invalid character
-    # and the line on which it occurrs.
+    # and the line on which it occurs.
     #
     # @param str [String] The string of which to check the encoding
     # @yield [msg] A block in which an encoding error can be raised.
@@ -163,80 +134,6 @@ MSG
       end
     end
 
-    ## Static Method Stuff
-
-    # The context in which the ERB for \{#def\_static\_method} will be run.
-    class StaticConditionalContext
-      # @param set [#include?] The set of variables that are defined for this context.
-      def initialize(set)
-        @set = set
-      end
-
-      # Checks whether or not a variable is defined for this context.
-      #
-      # @param name [Symbol] The name of the variable
-      # @return [Boolean]
-      def method_missing(name, *args, &block)
-        super unless args.empty? && block.nil?
-        @set.include?(name)
-      end
-    end
-
-    # This is used for methods in {Haml::Buffer} that need to be very fast,
-    # and take a lot of boolean parameters
-    # that are known at compile-time.
-    # Instead of passing the parameters in normally,
-    # a separate method is defined for every possible combination of those parameters;
-    # these are then called using \{#static\_method\_name}.
-    #
-    # To define a static method, an ERB template for the method is provided.
-    # All conditionals based on the static parameters
-    # are done as embedded Ruby within this template.
-    # For example:
-    #
-    #     def_static_method(Foo, :my_static_method, [:foo, :bar], :baz, :bang, <<RUBY)
-    #       <% if baz && bang %>
-    #         return foo + bar
-    #       <% elsif baz || bang %>
-    #         return foo - bar
-    #       <% else %>
-    #         return 17
-    #       <% end %>
-    #     RUBY
-    #
-    # \{#static\_method\_name} can be used to call static methods.
-    #
-    # @overload def_static_method(klass, name, args, *vars, erb)
-    # @param klass [Module] The class on which to define the static method
-    # @param name [#to_s] The (base) name of the static method
-    # @param args [Array<Symbol>] The names of the arguments to the defined methods
-    #   (**not** to the ERB template)
-    # @param vars [Array<Symbol>] The names of the static boolean variables
-    #   to be made available to the ERB template
-    def def_static_method(klass, name, args, *vars)
-      erb = vars.pop
-      info = caller_info
-      powerset(vars).each do |set|
-        context = StaticConditionalContext.new(set).instance_eval {binding}
-        method_content = (defined?(Erubis::TinyEruby) && Erubis::TinyEruby || ERB).new(erb).result(context)
-
-        klass.class_eval(<<METHOD, info[0], info[1])
-          def #{static_method_name(name, *vars.map {|v| set.include?(v)})}(#{args.join(', ')})
-            #{method_content}
-          end
-METHOD
-      end
-    end
-
-    # Computes the name for a method defined via \{#def\_static\_method}.
-    #
-    # @param name [String] The base name of the static method
-    # @param vars [Array<Boolean>] The static variable assignment
-    # @return [String] The real name of the static method
-    def static_method_name(name, *vars)
-      :"#{name}_#{vars.map {|v| !!v}.join('_')}"
-    end
-
     # Scans through a string looking for the interoplation-opening `#{`
     # and, when it's found, yields the scanner to the calling code
     # so it can handle it properly.
@@ -249,7 +146,7 @@ METHOD
     # @return [String] The text remaining in the scanner after all `#{`s have been processed
     def handle_interpolation(str)
       scan = StringScanner.new(str)
-      yield scan while scan.scan(/(.*?)(\\*)\#\{/)
+      yield scan while scan.scan(/(.*?)(\\*)#([\{@$])/)
       scan.rest
     end
 
@@ -298,20 +195,28 @@ METHOD
     end
 
     def contains_interpolation?(str)
-      str.include?('#{')
+      /#[\{$@]/ === str
     end
 
     def unescape_interpolation(str, escape_html = nil)
       res = ''
       rest = Haml::Util.handle_interpolation str.dump do |scan|
         escapes = (scan[2].size - 1) / 2
+        char = scan[3] # '{', '@' or '$'
         res << scan.matched[0...-3 - escapes]
         if escapes % 2 == 1
-          res << '#{'
+          res << "\##{char}"
         else
-          content = eval('"' + balance(scan, ?{, ?}, 1)[0][0...-1] + '"')
+          interpolated = if char == '{'
+            balance(scan, ?{, ?}, 1)[0][0...-1]
+          else
+            scan.scan(/\w+/)
+          end
+          content = eval('"' + interpolated + '"')
+          content.prepend(char) if char == '@' || char == '$'
           content = "Haml::Helpers.html_escape((#{content}))" if escape_html
-          res << '#{' + content + "}"# Use eval to get rid of string escapes
+
+          res << "\#{#{content}}"
         end
       end
       res + rest

data/lib/haml/version.rb

@@ -1,3 +1,3 @@
 module Haml
-  VERSION = "4.1.0.beta.1"
+  VERSION = "5.0.0.beta.2"
 end

data/test/attribute_parser_test.rb

@@ -0,0 +1,105 @@
+require 'test_helper'
+
+class AttributeParserTeset < Haml::TestCase
+  describe '.parse' do
+    def assert_parse(expected, haml)
+      actual = Haml::AttributeParser.parse(haml)
+      if expected.nil?
+        assert_nil actual
+      else
+        assert_equal expected, actual
+      end
+    end
+
+    if Haml::AttributeParser.available?
+      it { assert_parse({}, '') }
+      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 } ') }
+      end
+
+      describe 'dynamic key' do
+        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" } ') }
+      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') }
+      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(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
+
+      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(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],], } ') }
+      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, }, } ') }
+      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,), } ') }
+      end
+    end
+  end
+end