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

data/lib/haml/helpers.rb

@@ -8,7 +8,6 @@ module Haml
     # It's used to raise an error when the return value of a helper is used
     # when it shouldn't be.
     class ErrorReturn
-      # @param message [String] The error message to raise when \{#to\_s} is called
       def initialize(method)
         @message = <<MESSAGE
 #{method} outputs directly to the Haml template.
@@ -71,7 +70,7 @@ MESSAGE
     #     context.haml_tag :p, "Stuff"
     #
     def init_haml_helpers
-      @haml_buffer = Haml::Buffer.new(@haml_buffer, Haml::Engine.new('').send(:options_for_buffer))
+      @haml_buffer = Haml::Buffer.new(haml_buffer, Haml::Engine.new('').send(:options_for_buffer))
       nil
     end
 
@@ -147,7 +146,7 @@ MESSAGE
     #     <li>hello</li>
     #     <li>yall</li>
     #
-    # And
+    # And:
     #
     #     = list_of({:title => 'All the stuff', :description => 'A book about all the stuff.'}) do |key, val|
     #       %h3= key.humanize
@@ -164,10 +163,33 @@ MESSAGE
     #       <p>A book about all the stuff.</p>
     #     </li>
     #
+    # While:
+    #
+    #     = list_of(["Home", "About", "Contact", "FAQ"], {class: "nav", role: "nav"}) do |item|
+    #       %a{ href="#" }= item
+    #
+    # Produces:
+    #
+    #     <li class='nav' role='nav'>
+    #       <a href='#'>Home</a>
+    #     </li>
+    #     <li class='nav' role='nav'>
+    #       <a href='#'>About</a>
+    #     </li>
+    #     <li class='nav' role='nav'>
+    #       <a href='#'>Contact</a>
+    #     </li>
+    #     <li class='nav' role='nav'>
+    #       <a href='#'>FAQ</a>
+    #     </li>
+    #
+    #  `[[class", "nav"], [role", "nav"]]` could have been used instead of `{class: "nav", role: "nav"}` (or any enumerable collection where each pair of items responds to #to_s)
+    #
     # @param enum [Enumerable] The list of objects to iterate over
+    # @param [Enumerable<#to_s,#to_s>] opts Each key/value pair will become an attribute pair for each list item element.
     # @yield [item] A block which contains Haml code that goes within list items
     # @yieldparam item An element of `enum`
-    def list_of(enum, &block)
+    def list_of(enum, opts={}, &block)
       to_return = enum.collect do |i|
         result = capture_haml(i, &block)
 
@@ -178,7 +200,7 @@ MESSAGE
           result = result.strip
         end
 
-        "<li>#{result}</li>"
+        %Q!<li#{opts.empty? ? "" : " ".<<(opts.map{|k,v| "#{k}='#{v}'" }.join(" "))}>#{result}</li>!
       end
       to_return.join("\n")
     end
@@ -346,7 +368,9 @@ MESSAGE
 
         captured = haml_buffer.buffer.slice!(position..-1)
         return captured if haml_buffer.options[:ugly]
-        captured = captured.split(/^/)
+        # Note that the "reject" is needed for rbx 1.2.4, which includes empty
+        # strings in the returned array when splitting by /^/.
+        captured = captured.split(/^/).reject {|x| x == ""}
 
         min_tabs = nil
         captured.each do |line|
@@ -432,24 +456,26 @@ MESSAGE
     #     </table>
     #
     # @param name [#to_s] The name of the tag
-    # @param flags [Array<Symbol>] Haml end-of-tag flags
     #
-    # @overload haml_tag(name, *flags, attributes = {})
+    # @overload haml_tag(name, *rest, attributes = {})
     #   @yield The block of Haml code within the tag
     # @overload haml_tag(name, text, *flags, attributes = {})
     #   @param text [#to_s] The text within the tag
+    #   @param flags [Array<Symbol>] Haml end-of-tag flags
     def haml_tag(name, *rest, &block)
       ret = ErrorReturn.new("haml_tag")
 
       text = rest.shift.to_s unless [Symbol, Hash, NilClass].any? {|t| rest.first.is_a? t}
       flags = []
       flags << rest.shift while rest.first.is_a? Symbol
-      attrs = Haml::Util.map_keys(rest.shift || {}) {|key| key.to_s}
+      attrs = (rest.shift || {})
+      attrs.keys.each {|key| attrs[key.to_s] = attrs.delete(key)} unless attrs.empty?
       name, attrs = merge_name_and_attributes(name.to_s, attrs)
 
       attributes = Haml::Compiler.build_attributes(haml_buffer.html?,
         haml_buffer.options[:attr_wrapper],
         haml_buffer.options[:escape_attrs],
+        haml_buffer.options[:hyphenate_data_attrs],
         attrs)
 
       if text.nil? && block.nil? && (haml_buffer.options[:autoclose].include?(name) || flags.include?(:/))
@@ -574,7 +600,7 @@ MESSAGE
     #
     # @return [Haml::Buffer]
     def haml_buffer
-      @haml_buffer
+      @haml_buffer if defined? @haml_buffer
     end
 
     # Gives a proc the same local `_hamlout` and `_erbout` variables
@@ -585,6 +611,7 @@ MESSAGE
     def haml_bind_proc(&proc)
       _hamlout = haml_buffer
       _erbout = _hamlout.buffer
+      _erbout.to_s #"use" the variable to silence warnings
       proc { |*args| proc.call(*args) }
     end
   end

data/lib/haml/helpers/action_view_extensions.rb

@@ -45,7 +45,8 @@ module Haml
       # @yield A block in which all input to `#haml_concat` is treated as raw.
       # @see Haml::Util#rails_xss_safe?
       def with_raw_haml_concat
-        @_haml_concat_raw, old = true, @_haml_concat_raw
+        @_haml_concat_raw = true
+        old = @_haml_concat_raw
         yield
       ensure
         @_haml_concat_raw = old

data/lib/haml/helpers/action_view_mods.rb

@@ -3,10 +3,9 @@ module ActionView
     def render_with_haml(*args, &block)
       options = args.first
 
-      # If render :layout is used with a block,
-      # it concats rather than returning a string
-      # so we need it to keep thinking it's Haml
-      # until it hits the sub-render
+      # If render :layout is used with a block, it concats rather than returning
+      # a string so we need it to keep thinking it's Haml until it hits the
+      # sub-render.
       if is_haml? && !(options.is_a?(Hash) && options[:layout] && block_given?)
         return non_haml { render_without_haml(*args, &block) }
       end
@@ -15,99 +14,52 @@ module ActionView
     alias_method :render_without_haml, :render
     alias_method :render, :render_with_haml
 
-    # Rails >2.1
-    if Haml::Util.has?(:instance_method, self, :output_buffer)
-      def output_buffer_with_haml
-        return haml_buffer.buffer if is_haml?
-        output_buffer_without_haml
-      end
-      alias_method :output_buffer_without_haml, :output_buffer
-      alias_method :output_buffer, :output_buffer_with_haml
+    def output_buffer_with_haml
+      return haml_buffer.buffer if is_haml?
+      output_buffer_without_haml
+    end
+    alias_method :output_buffer_without_haml, :output_buffer
+    alias_method :output_buffer, :output_buffer_with_haml
 
-      def set_output_buffer_with_haml(new)
-        if is_haml?
-          new = String.new(new) if Haml::Util.rails_xss_safe? &&
-            new.is_a?(Haml::Util.rails_safe_buffer_class)
-          haml_buffer.buffer = new
-        else
-          set_output_buffer_without_haml new
+    def set_output_buffer_with_haml(new_buffer)
+      if is_haml?
+        if Haml::Util.rails_xss_safe? && new_buffer.is_a?(ActiveSupport::SafeBuffer)
+          new_buffer = String.new(new_buffer)
         end
+        haml_buffer.buffer = new_buffer
+      else
+        set_output_buffer_without_haml new_buffer
       end
-      alias_method :set_output_buffer_without_haml, :output_buffer=
-      alias_method :output_buffer=, :set_output_buffer_with_haml
     end
+    alias_method :set_output_buffer_without_haml, :output_buffer=
+    alias_method :output_buffer=, :set_output_buffer_with_haml
   end
 
   module Helpers
-    # In Rails <=2.1, we've got to override considerable capturing infrastructure.
-    # In Rails >2.1, we can make do with only overriding #capture
-    # (which no longer behaves differently in helper contexts).
-    unless Haml::Util.has?(:instance_method, ActionView::Base, :output_buffer)
-      module CaptureHelper
-        def capture_with_haml(*args, &block)
-          # Rails' #capture helper will just return the value of the block
-          # if it's not actually in the template context,
-          # as detected by the existance of an _erbout variable.
-          # We've got to do the same thing for compatibility.
-
-          if is_haml? && block_is_haml?(block)
-            value = nil
-            buffer = capture_haml(*args) { value = yield(*args) }
-            return buffer unless buffer.empty?
-            return value if value.is_a?(String)
-          else
-            capture_without_haml(*args, &block)
-          end
-        end
-        alias_method :capture_without_haml, :capture
-        alias_method :capture, :capture_with_haml
-
-        def capture_erb_with_buffer_with_haml(buffer, *args, &block)
-          if is_haml?
-            capture_haml(*args, &block)
-          else
-            capture_erb_with_buffer_without_haml(buffer, *args, &block)
-          end
-        end
-        alias_method :capture_erb_with_buffer_without_haml, :capture_erb_with_buffer
-        alias_method :capture_erb_with_buffer, :capture_erb_with_buffer_with_haml
-      end
-
-      module TextHelper
-        def concat_with_haml(string, binding = nil)
-          if is_haml?
-            haml_buffer.buffer.concat(string)
-          else
-            concat_without_haml(string, binding)
-          end
-        end
-        alias_method :concat_without_haml, :concat
-        alias_method :concat, :concat_with_haml
-      end
-    else
-      module CaptureHelper
-        def capture_with_haml(*args, &block)
-          if Haml::Helpers.block_is_haml?(block)
-            _hamlout = eval('_hamlout', block.binding) # Necessary since capture_haml checks _hamlout
-            value = nil
-            buffer = capture_haml(*args) { value = yield(*args) }
-            str =
-              if !buffer.empty?
-                buffer
-              elsif value.is_a?(String)
-                value
-              else
-                ''
-              end
-            return ActionView::NonConcattingString.new(str) if defined?(ActionView::NonConcattingString)
-            return str
-          else
-            capture_without_haml(*args, &block)
-          end
+    module CaptureHelper
+      def capture_with_haml(*args, &block)
+        if Haml::Helpers.block_is_haml?(block)
+          _hamlout = eval('_hamlout', block.binding) # Necessary since capture_haml checks _hamlout
+          value = nil
+          buffer = capture_haml(*args) { value = yield(*args) }
+          str =
+            if !buffer.empty?
+              buffer
+            elsif value.is_a?(String)
+              value
+            else
+              ''
+            end
+          # NonCattingString is present in Rails less than 3.1.0. When support
+          # for 3.0 is dropped, this can be removed.
+          return ActionView::NonConcattingString.new(str) if defined?(ActionView::NonConcattingString)
+          return str
+        else
+          capture_without_haml(*args, &block)
         end
-        alias_method :capture_without_haml, :capture
-        alias_method :capture, :capture_with_haml
       end
+      alias_method :capture_without_haml, :capture
+      alias_method :capture, :capture_with_haml
     end
 
     module TagHelper
@@ -150,109 +102,43 @@ module ActionView
       end
     end
 
-    if Haml::Util.ap_geq_3?
-      module FormTagHelper
-        def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
-          if is_haml?
-            wrap_block = block_given? && block_is_haml?(proc)
-            if wrap_block
-              oldproc = proc
-              proc = haml_bind_proc do |*args|
-                concat "\n"
-                with_tabs(1) {oldproc.call(*args)}
-              end
-            end
-            res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
-            res << "\n" if wrap_block
-            res
-          else
-            form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
-          end
-        end
-        alias_method :form_tag_without_haml, :form_tag
-        alias_method :form_tag, :form_tag_with_haml
-      end
-
-      module FormHelper
-        def form_for_with_haml(object_name, *args, &proc)
-          wrap_block = block_given? && is_haml? && block_is_haml?(proc)
+    module FormTagHelper
+      def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
+        if is_haml?
+          wrap_block = block_given? && block_is_haml?(proc)
           if wrap_block
             oldproc = proc
-            proc = proc {|*args| with_tabs(1) {oldproc.call(*args)}}
-          end
-          res = form_for_without_haml(object_name, *args, &proc)
-          res << "\n" if wrap_block
-          res
-        end
-        alias_method :form_for_without_haml, :form_for
-        alias_method :form_for, :form_for_with_haml
-      end
-
-      module CacheHelper
-        # This is a workaround for a Rails 3 bug
-        # that's present at least through beta 3.
-        # Their fragment_for assumes that the block
-        # will return its contents as a string,
-        # which is not always the case.
-        # Luckily, it only makes this assumption if caching is disabled,
-        # so we only override that case.
-        def fragment_for_with_haml(*args, &block)
-          return fragment_for_without_haml(*args, &block) if controller.perform_caching
-          capture(&block)
-        end
-        alias_method :fragment_for_without_haml, :fragment_for
-        alias_method :fragment_for, :fragment_for_with_haml
-      end
-    else
-      module FormTagHelper
-        def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
-          if is_haml?
-            wrap_block = block_given? && block_is_haml?(proc)
-            if wrap_block
-              oldproc = proc
-              proc = haml_bind_proc do |*args|
-                concat "\n"
-                tab_up
-                oldproc.call(*args)
-                tab_down
-                concat haml_indent
-              end
-              concat haml_indent
-            end
-            res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
-            if block_given?
+            proc = haml_bind_proc do |*args|
               concat "\n"
-              return Haml::Helpers::ErrorReturn.new("form_tag")
+              with_tabs(1) {oldproc.call(*args)}
             end
-            res
-          else
-            form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
           end
+          res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
+          res << "\n" if wrap_block
+          res
+        else
+          form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
         end
-        alias_method :form_tag_without_haml, :form_tag
-        alias_method :form_tag, :form_tag_with_haml
       end
+      alias_method :form_tag_without_haml, :form_tag
+      alias_method :form_tag, :form_tag_with_haml
+    end
 
-      module FormHelper
-        def form_for_with_haml(object_name, *args, &proc)
-          wrap_block = block_given? && is_haml? && block_is_haml?(proc)
-          if wrap_block
-            oldproc = proc
-            proc = haml_bind_proc do |*args|
-              tab_up
-              oldproc.call(*args)
-              tab_down
-              concat haml_indent
-            end
-            concat haml_indent
-          end
-          form_for_without_haml(object_name, *args, &proc)
-          concat "\n" if wrap_block
-          Haml::Helpers::ErrorReturn.new("form_for") if is_haml?
+    module FormHelper
+      def form_for_with_haml(object_name, *args, &proc)
+        wrap_block = block_given? && is_haml? && block_is_haml?(proc)
+        if wrap_block
+          oldproc = proc
+          proc = proc {|*subargs| with_tabs(1) {oldproc.call(*subargs)}}
         end
-        alias_method :form_for_without_haml, :form_for
-        alias_method :form_for, :form_for_with_haml
+        res = form_for_without_haml(object_name, *args, &proc)
+        res << "\n" if wrap_block
+        res
       end
+      alias_method :form_for_without_haml, :form_for
+      alias_method :form_for, :form_for_with_haml
     end
   end
 end
+
+require "haml/helpers/rails_323_textarea_fix" if Rails.version >= "3.2.3"

data/lib/haml/helpers/rails_323_textarea_fix.rb

@@ -0,0 +1,39 @@
+# Rails 3.2.3's form helpers add a newline after opening textareas, which can
+# cause problems with newlines being considered content rather than markup.
+# These changes fix the issue by making the helpers emit "<haml:newline/>"
+# rather than the leading newline. The tag is then replaced by a newline after
+# rendering.
+#
+# This should be considered nothing more than an emergency hotfix to ensure
+# compatibility with the latest version of Rails, made at a moment when the Haml
+# project is transitioning to a new maintainer.
+
+# module AbstractController
+#   module Rendering
+#     def render_to_body_with_haml(options = {})
+#       if rendered = render_to_body_without_haml(options)
+#         rendered.gsub('<haml:newline/>', "\n").html_safe
+#       end
+#     end
+#     alias_method_chain :render_to_body, :haml
+#   end
+# end
+
+module ActionView
+  module Helpers
+
+    module FormTagHelper
+      def text_area_tag_with_haml(*args)
+        text_area_tag_without_haml(*args).sub('>&#x000A;', ">\n").html_safe
+      end
+      alias_method_chain :text_area_tag, :haml
+    end
+
+    module FormHelper
+      def text_area_with_haml(*args)
+        text_area_without_haml(*args).sub('>&#x000A;', ">\n").html_safe
+      end
+      alias_method_chain :text_area, :haml
+    end
+  end
+end