haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/lib/haml/helpers/xss_mods.rb

@@ -63,7 +63,8 @@ module Haml
 
       # Input is escaped
       def haml_concat_with_haml_xss(text = "")
-        haml_concat_without_haml_xss(@_haml_concat_raw ? text : haml_xss_html_escape(text))
+        raw = instance_variable_defined?('@_haml_concat_raw') ? @_haml_concat_raw : false
+        haml_concat_without_haml_xss(raw ? text : haml_xss_html_escape(text))
       end
 
       # Output is always HTML safe
@@ -148,18 +149,15 @@ module ActionView
       alias_method :concat_without_haml_xss, :concat
       alias_method :concat, :concat_with_haml_xss
 
-      # safe_concat was introduced in Rails 3.0
-      if Haml::Util.has?(:instance_method, self, :safe_concat)
-        def safe_concat_with_haml_xss(string)
-          if is_haml?
-            haml_buffer.buffer.concat(string)
-          else
-            safe_concat_without_haml_xss(string)
-          end
+      def safe_concat_with_haml_xss(string)
+        if is_haml?
+          haml_buffer.buffer.concat(string)
+        else
+          safe_concat_without_haml_xss(string)
         end
-        alias_method :safe_concat_without_haml_xss, :safe_concat
-        alias_method :safe_concat, :safe_concat_with_haml_xss
       end
+      alias_method :safe_concat_without_haml_xss, :safe_concat
+      alias_method :safe_concat, :safe_concat_with_haml_xss
     end
   end
 end

data/lib/haml/html.rb

@@ -343,10 +343,10 @@ module Haml
           output + child.to_haml(tabs + 1, options)
         end
       end
-      
+
       def dynamic_attributes
         @dynamic_attributes ||= begin
-          Haml::Util.map_hash(attr_hash) do |name, value|
+          Hash[attr_hash.map do |name, value|
             next if value.empty?
             full_match = nil
             ruby_value = value.gsub(%r{<haml:loud>\s*(.+?)\s*</haml:loud>}) do
@@ -355,7 +355,7 @@ module Haml
             end
             next if ruby_value == value
             [name, full_match ? ruby_value : %("#{ruby_value}")]
-          end
+          end]
         end
       end
 
@@ -366,7 +366,7 @@ module Haml
           else
             CGI.unescapeHTML(self.innerText)
           end
-          
+
         content = erb_to_interpolation(content, options)
         content.gsub!(/\A\s*\n(\s*)/, '\1')
         original_indent = content[/\A(\s*)/, 1]
@@ -380,15 +380,15 @@ module Haml
       def static_attribute?(name, options)
         attr_hash[name] && !dynamic_attribute?(name, options)
       end
-      
+
       def dynamic_attribute?(name, options)
         options[:erb] and dynamic_attributes.key?(name)
       end
-      
+
       def static_id?(options)
         static_attribute?('id', options) && haml_css_attr?(attr_hash['id'])
       end
-      
+
       def static_classname?(options)
         static_attribute?('class', options)
       end
@@ -401,11 +401,24 @@ module Haml
       # that's prettier than that produced by Hash#inspect
       def haml_attributes(options)
         attrs = attr_hash.sort.map do |name, value|
-          value = dynamic_attribute?(name, options) ? dynamic_attributes[name] : value.inspect
+          haml_attribute_pair(name, value, options)
+        end
+        if options[:html_style_attributes]
+          "(#{attrs.join(' ')})"
+        else
+          "{#{attrs.join(', ')}}"
+        end
+      end
+
+      # Returns the string representation of a single attribute key value pair
+      def haml_attribute_pair(name, value, options)
+        value = dynamic_attribute?(name, options) ? dynamic_attributes[name] : value.inspect
+        if options[:html_style_attributes]
+          "#{name}=#{value}"
+        else
           name = name.index(/\W/) ? name.inspect : ":#{name}"
           "#{name} => #{value}"
         end
-        "{#{attrs.join(', ')}}"
       end
     end
   end

data/lib/haml/html/erb.rb

@@ -99,7 +99,7 @@ module Haml
       # @return [Boolean]
       def valid_ruby?(code)
         RubyParser.new.parse(code)
-      rescue Racc::ParseError => e
+      rescue Racc::ParseError
         false
       end
 

data/lib/haml/parser.rb

@@ -1,5 +1,4 @@
 require 'strscan'
-require 'haml/shared'
 
 module Haml
   module Parser
@@ -104,8 +103,8 @@ module Haml
           break @template_tabs + 1 if flat? && whitespace =~ /^#{@flat_spaces}/
 
           raise SyntaxError.new(<<END.strip.gsub("\n", ' '), line.index)
-Inconsistent indentation: #{Haml::Shared.human_indentation whitespace, true} used for indentation,
-but the rest of the document was indented using #{Haml::Shared.human_indentation @indentation}.
+Inconsistent indentation: #{Haml::Util.human_indentation whitespace, true} used for indentation,
+but the rest of the document was indented using #{Haml::Util.human_indentation @indentation}.
 END
         end
       end
@@ -151,7 +150,7 @@ END
           @parent = @parent.children.last
         end
 
-        if !flat? && @next_line.tabs - @line.tabs > 1
+        if !@haml_comment && !flat? && @next_line.tabs - @line.tabs > 1
           raise SyntaxError.new("The line was indented #{@next_line.tabs - @line.tabs} levels deeper than the previous line.", @next_line.index)
         end
 
@@ -199,10 +198,10 @@ END
       when FILTER; push filter(text[1..-1].downcase)
       when DOCTYPE
         return push doctype(text) if text[0...3] == '!!!'
-        return push plain(text[3..-1].strip, !:escape_html) if text[1..2] == "=="
-        return push script(text[2..-1].strip, !:escape_html) if text[1] == SCRIPT
-        return push flat_script(text[2..-1].strip, !:escape_html) if text[1] == FLAT_SCRIPT
-        return push plain(text[1..-1].strip, !:escape_html) if text[1] == ?\s
+        return push plain(text[3..-1].strip, false) if text[1..2] == "=="
+        return push script(text[2..-1].strip, false) if text[1] == SCRIPT
+        return push flat_script(text[2..-1].strip, false) if text[1] == FLAT_SCRIPT
+        return push plain(text[1..-1].strip, false) if text[1] == ?\s
         push plain(text)
       when ESCAPE; push plain(text[1..-1])
       else; push plain(text)
@@ -233,7 +232,7 @@ END
       end
 
       escape_html = @options[:escape_html] if escape_html.nil?
-      script(unescape_interpolation(text, escape_html), !:escape_html)
+      script(unescape_interpolation(text, escape_html), false)
     end
 
     def script(text, escape_html = nil, preserve = false)
@@ -530,7 +529,7 @@ END
         break if name.nil?
 
         if name == false
-          text = (Haml::Shared.balance(line, ?(, ?)) || [line]).first
+          text = (Haml::Util.balance(line, ?(, ?)) || [line]).first
           raise Haml::SyntaxError.new("Invalid attribute list: #{text.inspect}.", last_line - 1)
         end
         attributes[name] = value
@@ -613,9 +612,10 @@ END
       # `flat?' here is a little outdated,
       # so we have to manually check if either the previous or current line
       # closes the flat block, as well as whether a new block is opened.
-      @line.tabs if @line
+      line_defined = instance_variable_defined?('@line')
+      @line.tabs if line_defined
       unless (flat? && !closes_flat?(line) && !closes_flat?(@line)) ||
-          (@line && @line.text[0] == ?: && line.full =~ %r[^#{@line.full[/^\s+/]}\s])
+          (line_defined && @line.text[0] == ?: && line.full =~ %r[^#{@line.full[/^\s+/]}\s])
         return next_line if line.text.empty?
 
         handle_multiline(line)
@@ -664,8 +664,15 @@ END
       text
     end
 
+    # `text' is a Ruby multiline block if it:
+    # - ends with a comma
+    # - but not "?," which is a character literal
+    #   (however, "x?," is a method call and not a literal)
+    # - and not "?\," which is a character literal
+    #
     def is_ruby_multiline?(text)
-      text && text.length > 1 && text[-1] == ?, && text[-2] != ?? && text[-3..-2] != "?\\"
+      text && text.length > 1 && text[-1] == ?, &&
+        !((text[-3..-2] =~ /\W\?/) || text[-3..-2] == "?\\")
     end
 
     def contains_interpolation?(str)
@@ -674,7 +681,7 @@ END
 
     def unescape_interpolation(str, escape_html = nil)
       res = ''
-      rest = Haml::Shared.handle_interpolation str.dump do |scan|
+      rest = Haml::Util.handle_interpolation str.dump do |scan|
         escapes = (scan[2].size - 1) / 2
         res << scan.matched[0...-3 - escapes]
         if escapes % 2 == 1
@@ -689,7 +696,7 @@ END
     end
 
     def balance(*args)
-      res = Haml::Shared.balance(*args)
+      res = Haml::Util.balance(*args)
       return res if res
       raise SyntaxError.new("Unbalanced brackets.")
     end

data/lib/haml/railtie.rb

@@ -1,19 +1,8 @@
-if Haml::Util.ap_geq_3? && !Haml::Util.ap_geq?("3.0.0.beta4")
-  raise <<ERROR
-Haml no longer supports Rails 3 versions before beta 4.
-  Please upgrade to Rails 3.0.0.beta4 or later.
-ERROR
-end
-
-# Rails 3.0.0.beta.2+
-if defined?(ActiveSupport) && Haml::Util.has?(:public_method, ActiveSupport, :on_load)
+if defined?(ActiveSupport)
   require 'haml/template/options'
-  autoload(:Sass, 'sass/rails3_shim')
   ActiveSupport.on_load(:before_initialize) do
-    # resolve autoload if it looks like they're using Sass without options
-    Sass if File.exist?(File.join(Rails.root, 'public/stylesheets/sass'))
     ActiveSupport.on_load(:action_view) do
-      Haml.init_rails(binding)
+      require "haml/template"
     end
   end
 end

data/lib/haml/template.rb

@@ -2,98 +2,31 @@ require 'haml/template/options'
 require 'haml/engine'
 require 'haml/helpers/action_view_mods'
 require 'haml/helpers/action_view_extensions'
-
-if defined?(ActionPack::VERSION::STRING) &&
-    ActionPack::VERSION::STRING == "2.3.6"
-  raise "Haml does not support Rails 2.3.6. Please upgrade to 2.3.7 or later."
-end
+require 'haml/helpers/xss_mods'
 
 module Haml
-  # The class that keeps track of the global options for Haml within Rails.
-  module Template
-    # Enables integration with the Rails 2.2.5+ XSS protection,
-    # if it's available and enabled.
-    #
-    # @return [Boolean] Whether the XSS integration was enabled.
-    def try_enabling_xss_integration
-      return false unless (ActionView::Base.respond_to?(:xss_safe?) && ActionView::Base.xss_safe?) ||
-        # We check for ActiveSupport#on_load here because if we're loading Haml that way, it means:
-        # A) we're in Rails 3 so XSS support is always on, and
-        # B) we might be in Rails 3 beta 3 where the load order is broken and xss_safe? is undefined
-        (defined?(ActiveSupport) && Haml::Util.has?(:public_method, ActiveSupport, :on_load))
-
-      Haml::Template.options[:escape_html] = true
-
-      Haml::Util.module_eval {def rails_xss_safe?; true; end}
-
-      require 'haml/helpers/xss_mods'
-      Haml::Helpers.send(:include, Haml::Helpers::XssMods)
-
-      Haml::Compiler.module_eval do
-        def precompiled_method_return_value_with_haml_xss
-          "::Haml::Util.html_safe(#{precompiled_method_return_value_without_haml_xss})"
-        end
-        alias_method :precompiled_method_return_value_without_haml_xss, :precompiled_method_return_value
-        alias_method :precompiled_method_return_value, :precompiled_method_return_value_with_haml_xss
-      end
-
-      true
+  module Compiler
+    def precompiled_method_return_value_with_haml_xss
+      "::Haml::Util.html_safe(#{precompiled_method_return_value_without_haml_xss})"
     end
+    alias_method :precompiled_method_return_value_without_haml_xss, :precompiled_method_return_value
+    alias_method :precompiled_method_return_value, :precompiled_method_return_value_with_haml_xss
   end
-end
 
-unless Haml::Util.rails_env == "development"
-  Haml::Template.options[:ugly] ||= true
-end
+  module Helpers
+    include Haml::Helpers::XssMods
+  end
 
-if Haml::Util.ap_geq_3?
-  Haml::Template.options[:format] ||= :html5
-end
+  module Util
+    undef :rails_xss_safe? if defined? rails_xss_safe?
+    def rails_xss_safe?; true; end
+  end
 
-# Decide how we want to load Haml into Rails.
-# Patching was necessary for versions <= 2.0.1,
-# but we can make it a normal handler for higher versions.
-if defined?(ActionView::TemplateHandler) ||
-    (defined?(ActionView::Template) && defined?(ActionView::Template::Handler)) ||
-    # Rails >= 3.2.0 uses Handlers instead of Handler
-    (defined?(ActionView::Template) && defined?(ActionView::Template::Handlers))
-  require 'haml/template/plugin'
-else
-  require 'haml/template/patch'
 end
 
-# Enable XSS integration. Use Rails' after_initialize method
-# so that integration will be checked after the rails_xss plugin is loaded
-# (for Rails 2.3.* where it's not enabled by default).
-#
-# If we're running under Rails 3, though, we don't want to use after_intialize,
-# since Haml loading has already been deferred via ActiveSupport.on_load.
-if defined?(Rails.configuration.after_initialize) &&
-    !(defined?(ActiveSupport) && Haml::Util.has?(:public_method, ActiveSupport, :on_load))
-  Rails.configuration.after_initialize {Haml::Template.try_enabling_xss_integration}
-else
-  Haml::Template.try_enabling_xss_integration
-end
 
-if Haml::Util.rails_root
-  # Update init.rb to the current version
-  # if it's out of date.
-  #
-  # We can probably remove this as of v1.9,
-  # because the new init file is sufficiently flexible
-  # to not need updating.
-  rails_init_file = File.join(Haml::Util.rails_root, 'vendor', 'plugins', 'haml', 'init.rb')
-  haml_init_file = Haml::Util.scope('init.rb')
-  begin
-    if File.exists?(rails_init_file)
-      require 'fileutils'
-      FileUtils.cp(haml_init_file, rails_init_file) unless FileUtils.cmp(rails_init_file, haml_init_file)
-    end
-  rescue SystemCallError
-    Haml::Util.haml_warn <<END
-HAML WARNING:
-#{rails_init_file} is out of date and couldn't be automatically updated.
-Please run `haml --rails #{File.expand_path(Haml::Util.rails_root)}' to update it.
-END
-  end
-end
+Haml::Template.options[:ugly] ||= Rails.env.development?
+Haml::Template.options[:escape_html] = true
+Haml::Template.options[:format] ||= :html5
+
+require 'haml/template/plugin'

data/lib/haml/template/options.rb

@@ -8,7 +8,7 @@ module Haml
 
     @options = {}
     # The options hash for Haml when used within Rails.
-    # See {file:HAML_REFERENCE.md#haml_options the Haml options documentation}.
+    # See {file:REFERENCE.md#haml_options the Haml options documentation}.
     #
     # @return [{Symbol => Object}]
     attr_accessor :options

data/lib/haml/template/plugin.rb

@@ -1,37 +1,24 @@
-# This file makes Haml work with Rails
-# using the > 2.0.1 template handler API.
-
 module Haml
-  # In 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.
-  class Plugin < Haml::Util.av_template_class(:Handlers)::ERB.superclass
-    if ((defined?(ActionView::TemplateHandlers) &&
-          defined?(ActionView::TemplateHandlers::Compilable)) ||
-        (defined?(ActionView::Template) &&
-          defined?(ActionView::Template::Handlers) &&
-          defined?(ActionView::Template::Handlers::Compilable))) &&
-        # In Rails 3.1+, we don't need to include Compilable.
-        Haml::Util.av_template_class(:Handlers)::ERB.include?(
-          Haml::Util.av_template_class(:Handlers)::Compilable)
-      include Haml::Util.av_template_class(:Handlers)::Compilable
+
+  # 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 ::Rails.version < "3.1"
+      include ActionView::Template::Handlers::Compilable
     end
 
     def handles_encoding?; true; end
 
     def compile(template)
       options = Haml::Template.options.dup
-
-      # template is a template object in Rails >=2.1.0,
-      # a source string previously
-      if template.respond_to? :source
-        # Template has a generic identifier in Rails >=3.0.0
-        options[:filename] = template.respond_to?(:identifier) ? template.identifier : template.filename
-        source = template.source
-      else
-        source = template
-      end
-
-      Haml::Engine.new(source, options).send(:precompiled_with_ambles, [])
+      options[:mime_type] = template.mime_type if template.respond_to? :mime_type
+      options[:filename] = template.identifier
+      Haml::Engine.new(template.source, options).send(:precompiled_with_ambles, [])
     end
 
     # In Rails 3.1+, #call takes the place of #compile
@@ -45,79 +32,6 @@ module Haml
       end
     end
   end
-
-  # Rails 3.0 prints a deprecation warning when block helpers
-  # return strings that go unused.
-  # We want to print the same deprecation warning,
-  # so we have to compile in a method call to check for it.
-  #
-  # I don't like having this in the compilation pipeline,
-  # and I'd like to get rid of it once Rails 3.1 is well-established.
-  if defined?(ActionView::OutputBuffer) &&
-      Haml::Util.has?(:instance_method, ActionView::OutputBuffer, :append_if_string=)
-    module Compiler
-      def compile_silent_script_with_haml_block_deprecation(&block)
-        unless block && !@node.value[:keyword] &&
-            @node.value[:text] =~ ActionView::Template::Handlers::Erubis::BLOCK_EXPR
-          return compile_silent_script_without_haml_block_deprecation(&block)
-        end
-
-        @node.value[:text] = "_hamlout.append_if_string= #{@node.value[:text]}"
-        compile_silent_script_without_haml_block_deprecation(&block)
-      end
-      alias_method :compile_silent_script_without_haml_block_deprecation, :compile_silent_script
-      alias_method :compile_silent_script, :compile_silent_script_with_haml_block_deprecation
-    end
-
-    class Buffer
-      def append_if_string=(value)
-        if value.is_a?(String) && !value.is_a?(ActionView::NonConcattingString)
-          ActiveSupport::Deprecation.warn("- style block helpers are deprecated. Please use =", caller)
-          buffer << value
-        end
-      end
-    end
-  end
 end
 
-if defined? ActionView::Template and ActionView::Template.respond_to? :register_template_handler
-  ActionView::Template
-else
-  ActionView::Base
-end.register_template_handler(:haml, Haml::Plugin)
-
-# In Rails 2.0.2, ActionView::TemplateError took arguments
-# that we can't fill in from the Haml::Plugin context.
-# Thus, we've got to monkeypatch ActionView::Base to catch the error.
-if defined?(ActionView::TemplateError) &&
-    ActionView::TemplateError.instance_method(:initialize).arity == 5
-  class ActionView::Base
-    def compile_template(handler, template, file_name, local_assigns)
-      render_symbol = assign_method_name(handler, template, file_name)
-
-      # Move begin up two lines so it captures compilation exceptions.
-      begin
-        render_source = create_template_source(handler, template, render_symbol, local_assigns.keys)
-        line_offset = @@template_args[render_symbol].size + handler.line_offset
-      
-        file_name = 'compiled-template' if file_name.blank?
-        CompiledTemplates.module_eval(render_source, file_name, -line_offset)
-      rescue Exception => e # errors from template code
-        if logger
-          logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
-          logger.debug "Function body: #{render_source}"
-          logger.debug "Backtrace: #{e.backtrace.join("\n")}"
-        end
-
-        # There's no way to tell Haml about the filename,
-        # so we've got to insert it ourselves.
-        e.backtrace[0].gsub!('(haml)', file_name) if e.is_a?(Haml::Error)
-        
-        raise ActionView::TemplateError.new(extract_base_path_from(file_name) || view_paths.first, file_name || template, @assigns, template, e)
-      end
-      
-      @@compile_time[render_symbol] = Time.now
-      # logger.debug "Compiled template #{file_name || template}\n ==> #{render_symbol}" if logger
-    end
-  end
-end
+ActionView::Template.register_template_handler(:haml, Haml::Plugin)