haml 4.0.0 → 5.0.0

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

@@ -1,31 +1,24 @@
+# frozen_string_literal: true
 module Haml
 
   # This module makes Haml work with Rails using the template handler API.
-  class Plugin < ActionView::Template::Handlers::ERB.superclass
-
-    # Rails 3.1+, template handlers don't inherit from anything. In <= 3.0, they
-    # do. To avoid messy logic figuring this out, we just inherit from whatever
-    # the ERB handler does.
-
-    # In Rails 3.1+, we don't need to include Compilable.
-    if (ActionPack::VERSION::MAJOR == 3) && (ActionPack::VERSION::MINOR < 1)
-      include ActionView::Template::Handlers::Compilable
-    end
-
+  class Plugin
     def handles_encoding?; true; end
 
     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
 
-    # In Rails 3.1+, #call takes the place of #compile
     def self.call(template)
       new.compile(template)
     end
@@ -38,4 +31,4 @@ module Haml
   end
 end
 
-ActionView::Template.register_template_handler(:haml, Haml::Plugin)
+ActionView::Template.register_template_handler(:haml, Haml::Plugin)

data/lib/haml/railtie.rb

@@ -1,21 +1,31 @@
-if defined?(ActiveSupport)
-  require 'haml/template/options'
-  ActiveSupport.on_load(:before_initialize) do
-    ActiveSupport.on_load(:action_view) do
-      require "haml/template"
-    end
+# frozen_string_literal: true
+require 'haml/template/options'
+
+# 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|
-      if defined?(::Sass::Rails) && app.config.assets.enabled
-        require "haml/sass_rails_filter"
+      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
   end
 end
-
-require "haml/helpers/safe_erubis_template"
-Haml::Filters::Erb.template_class = Haml::SafeErubisTemplate

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/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/template.rb

@@ -1,12 +1,19 @@
+# frozen_string_literal: true
 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 +33,6 @@ module Haml
 end
 
 
-Haml::Template.options[:ugly]        = !Rails.env.development?
 Haml::Template.options[:escape_html] = true
 
-require 'haml/template/plugin'
+require 'haml/plugin'

data/lib/haml/temple_engine.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: false
+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,29 @@
+# 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.
+  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