haml 4.0.7 → 4.1.0.alpha.2

data/lib/haml/engine.rb

@@ -69,8 +69,7 @@ module Haml
     # Processes the template and returns the result as a string.
     #
     # `scope` is the context in which the template is evaluated.
-    # If it's a `Binding` or `Proc` object,
-    # Haml uses it as the second argument to `Kernel#eval`;
+    # If it's a `Binding`, Haml uses it as the second argument to `Kernel#eval`;
     # otherwise, Haml just uses its `#instance_eval` context.
     #
     # Note that Haml modifies the evaluation context
@@ -95,14 +94,14 @@ module Haml
     # within the template.
     #
     # Due to some Ruby quirks,
-    # if `scope` is a `Binding` or `Proc` object and a block is given,
+    # if `scope` is a `Binding` object and a block is given,
     # the evaluation context may not be quite what the user expects.
     # In particular, it's equivalent to passing `eval("self", scope)` as `scope`.
     # This won't have an effect in most cases,
     # but if you're relying on local variables defined in the context of `scope`,
     # they won't work.
     #
-    # @param scope [Binding, Proc, Object] The context in which the template is evaluated
+    # @param scope [Binding, Object] The context in which the template is evaluated
     # @param locals [{Symbol => Object}] Local variables that will be made available
     #   to the template
     # @param block [#to_proc] A block that can be yielded to within the template
@@ -111,7 +110,7 @@ module Haml
       parent = scope.instance_variable_defined?('@haml_buffer') ? scope.instance_variable_get('@haml_buffer') : nil
       buffer = Haml::Buffer.new(parent, @options.for_buffer)
 
-      if scope.is_a?(Binding) || scope.is_a?(Proc)
+      if scope.is_a?(Binding)
         scope_object = eval("self", scope)
         scope = scope_object.instance_eval{binding} if block_given?
       else
@@ -121,20 +120,16 @@ module Haml
 
       set_locals(locals.merge(:_hamlout => buffer, :_erbout => buffer.buffer), scope, scope_object)
 
-      scope_object.instance_eval do
-        extend Haml::Helpers
-        @haml_buffer = buffer
-      end
+      scope_object.extend(Haml::Helpers)
+      scope_object.instance_variable_set(:'@haml_buffer', buffer)
       begin
-        eval(@compiler.precompiled_with_return_value, scope, @options[:filename], @options[:line])
+        eval(@compiler.precompiled_with_return_value, scope, @options.filename, @options.line)
       rescue ::SyntaxError => e
         raise SyntaxError, e.message
       end
     ensure
       # Get rid of the current buffer
-      scope_object.instance_eval do
-        @haml_buffer = buffer.upper if buffer
-      end
+      scope_object.instance_variable_set(:'@haml_buffer', buffer.upper) if buffer
     end
     alias_method :to_html, :render
 
@@ -159,11 +154,11 @@ module Haml
     #
     # The proc doesn't take a block; any yields in the template will fail.
     #
-    # @param scope [Binding, Proc, Object] The context in which the template is evaluated
+    # @param scope [Binding, Object] The context in which the template is evaluated
     # @param local_names [Array<Symbol>] The names of the locals that can be passed to the proc
     # @return [Proc] The proc that will run the template
     def render_proc(scope = Object.new, *local_names)
-      if scope.is_a?(Binding) || scope.is_a?(Proc)
+      if scope.is_a?(Binding)
         scope_object = eval("self", scope)
       else
         scope_object = scope
@@ -172,7 +167,7 @@ module Haml
 
       begin
         eval("Proc.new { |*_haml_locals| _haml_locals = _haml_locals[0] || {};" +
-             compiler.precompiled_with_ambles(local_names) + "}\n", scope, @options[:filename], @options[:line])
+             compiler.precompiled_with_ambles(local_names) + "}\n", scope, @options.filename, @options.line)
       rescue ::SyntaxError => e
         raise SyntaxError, e.message
       end
@@ -220,24 +215,19 @@ module Haml
       method = object.is_a?(Module) ? :module_eval : :instance_eval
 
       object.send(method, "def #{name}(_haml_locals = {}); #{compiler.precompiled_with_ambles(local_names)}; end",
-                  @options[:filename], @options[:line])
+                  @options.filename, @options.line)
     end
 
     private
 
-    if RUBY_VERSION < "1.9"
-      def initialize_encoding(given_value)
-      end
-    else
-      def initialize_encoding(given_value)
-        unless given_value
-          @options.encoding = Encoding.default_internal || @template.encoding
-        end
+    def initialize_encoding(given_value)
+      unless given_value
+        @options.encoding = Encoding.default_internal || @template.encoding
       end
     end
 
     def set_locals(locals, scope, scope_object)
-      scope_object.send(:instance_variable_set, '@_haml_locals', locals)
+      scope_object.instance_variable_set '@_haml_locals', locals
       set_locals = locals.keys.map { |k| "#{k} = @_haml_locals[#{k.inspect}]" }.join("\n")
       eval(set_locals, scope)
     end

data/lib/haml/exec.rb

@@ -1,5 +1,4 @@
 require 'optparse'
-require 'fileutils'
 require 'rbconfig'
 require 'pp'
 
@@ -237,6 +236,11 @@ END
           @options[:for_engine][:attr_wrapper] = '"'
         end
 
+        opts.on('--remove-whitespace',
+                'Remove whitespace surrounding and within tags') do
+          @options[:for_engine][:remove_whitespace] = true
+        end
+
         opts.on('--cdata',
                 'Always add CDATA sections to javascript and css blocks.') do
           @options[:for_engine][:cdata] = true
@@ -260,12 +264,10 @@ END
           @options[:load_paths] << path
         end
 
-        unless RUBY_VERSION < "1.9"
-          opts.on('-E ex[:in]', 'Specify the default external and internal character encodings.') do |encoding|
-            external, internal = encoding.split(':')
-            Encoding.default_external = external if external && !external.empty?
-            Encoding.default_internal = internal if internal && !internal.empty?
-          end
+        opts.on('-E ex[:in]', 'Specify the default external and internal character encodings.') do |encoding|
+          external, internal = encoding.split(':')
+          Encoding.default_external = external if external && !external.empty?
+          Encoding.default_internal = internal if internal && !internal.empty?
         end
 
         opts.on('-d', '--debug', "Print out the precompiled Ruby source.") do

data/lib/haml/filters.rb

@@ -166,7 +166,7 @@ module Haml
             text = unescape_interpolation(text).gsub(/(\\+)n/) do |s|
               escapes = $1.size
               next s if escapes % 2 == 0
-              ("\\" * (escapes - 1)) + "\n"
+              "#{'\\' * (escapes - 1)}\n"
             end
             # We need to add a newline at the beginning to get the
             # filter lines to line up (since the Haml filter contains
@@ -174,7 +174,7 @@ module Haml
             # filter name). Then we need to escape the trailing
             # newline so that the whole filter block doesn't take up
             # too many.
-            text = "\n" + text.sub(/\n"\Z/, "\\n\"")
+            text = %[\n#{text.sub(/\n"\Z/, "\\n\"")}]
             push_script <<RUBY.rstrip, :escape_html => false
 find_and_preserve(#{filter.inspect}.render_with_options(#{text}, _hamlout.options))
 RUBY
@@ -182,12 +182,9 @@ RUBY
           end
 
           rendered = Haml::Helpers::find_and_preserve(filter.render_with_options(text, compiler.options), compiler.options[:preserve])
-
-          if options[:ugly]
-            push_text(rendered.rstrip)
-          else
-            push_text(rendered.rstrip.gsub("\n", "\n#{'  ' * @output_tabs}"))
-          end
+          rendered.rstrip!
+          rendered.gsub!("\n", "\n#{'  ' * @output_tabs}") unless options[:ugly]
+          push_text(rendered)
         end
       end
     end
@@ -216,13 +213,10 @@ RUBY
           type = " type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}"
         end
 
-        str = "<script#{type}>\n"
-        str << "  //<![CDATA[\n" if options[:cdata]
-        str << "#{indent}#{text.rstrip.gsub("\n", "\n#{indent}")}\n"
-        str << "  //]]>\n" if options[:cdata]
-        str << "</script>"
+        text = text.rstrip
+        text.gsub!("\n", "\n#{indent}")
 
-        str
+        %!<script#{type}>\n#{"  //<![CDATA[\n" if options[:cdata]}#{indent}#{text}\n#{"  //]]>\n" if options[:cdata]}</script>!
       end
     end
 
@@ -240,13 +234,10 @@ RUBY
           type = " type=#{options[:attr_wrapper]}text/css#{options[:attr_wrapper]}"
         end
 
-        str = "<style#{type}>\n"
-        str << "  /*<![CDATA[*/\n" if options[:cdata]
-        str << "#{indent}#{text.rstrip.gsub("\n", "\n#{indent}")}\n"
-        str << "  /*]]>*/\n" if options[:cdata]
-        str << "</style>"
+        text = text.rstrip
+        text.gsub!("\n", "\n#{indent}")
 
-        str
+        %(<style#{type}>\n#{"  /*<![CDATA[*/\n" if options[:cdata]}#{indent}#{text}\n#{"  /*]]>*/\n" if options[:cdata]}</style>)
       end
     end
 
@@ -256,7 +247,10 @@ RUBY
 
       # @see Base#render
       def render(text)
-        "<![CDATA[#{("\n" + text).rstrip.gsub("\n", "\n    ")}\n]]>"
+        text = "\n#{text}"
+        text.rstrip!
+        text.gsub!("\n", "\n    ")
+        "<![CDATA[#{text}\n]]>"
       end
     end
 
@@ -288,7 +282,7 @@ RUBY
       def compile(compiler, text)
         return if compiler.options[:suppress_eval]
         compiler.instance_eval do
-          push_silent <<-FIRST.gsub("\n", ';') + text + <<-LAST.gsub("\n", ';')
+          push_silent <<-FIRST.tr("\n", ';') + text + <<-LAST.tr("\n", ';')
             begin
               haml_io = StringIO.new(_hamlout.buffer, 'a')
           FIRST

data/lib/haml/helpers.rb

@@ -117,17 +117,20 @@ MESSAGE
     # HTML entities so they'll render correctly in
     # whitespace-sensitive tags without screwing up the indentation.
     #
-    # @overload perserve(input)
+    # @overload preserve(input)
     #   Escapes newlines within a string.
     #
     #   @param input [String] The string within which to escape all newlines
-    # @overload perserve
+    # @overload preserve
     #   Escapes newlines within a block of Haml code.
     #
     #   @yield The block within which to escape newlines
     def preserve(input = nil, &block)
       return preserve(capture_haml(&block)) if block
-      input.to_s.chomp("\n").gsub(/\n/, '
').gsub(/\r/, '')
+      s = input.to_s.chomp("\n")
+      s.gsub!(/\n/, '
')
+      s.delete!("\r")
+      s
     end
     alias_method :flatten, :preserve
 
@@ -195,7 +198,7 @@ MESSAGE
         result = capture_haml(i, &block)
 
         if result.count("\n") > 1
-          result = result.gsub("\n", "\n  ")
+          result.gsub!("\n", "\n  ")
           result = "\n  #{result.strip}\n"
         else
           result = result.strip
@@ -219,7 +222,11 @@ MESSAGE
     # @param lang [String] The value of `xml:lang` and `lang`
     # @return [{#to_s => String}] The attribute hash
     def html_attrs(lang = 'en-US')
-      {:xmlns => "http://www.w3.org/1999/xhtml", 'xml:lang' => lang, :lang => lang}
+      if haml_buffer.options[:format] == :xhtml
+        {:xmlns => "http://www.w3.org/1999/xhtml", 'xml:lang' => lang, :lang => lang}
+      else
+        {:lang => lang}
+      end
     end
 
     # Increments the number of tabs the buffer automatically adds
@@ -365,17 +372,25 @@ MESSAGE
         position = haml_buffer.buffer.length
 
         haml_buffer.capture_position = position
-        value = block.call(*args)
+        block.call(*args)
 
         captured = haml_buffer.buffer.slice!(position..-1)
-
-        if captured == '' and value != haml_buffer.buffer
-             captured = (value.is_a?(String) ? value : nil)
+        return captured if haml_buffer.options[:ugly]
+        # 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(/^/)
+        captured.delete('')
+
+        min_tabs = nil
+        captured.each do |line|
+          tabs = line.index(/[^ ]/) || line.length
+          min_tabs ||= tabs
+          min_tabs = min_tabs > tabs ? tabs : min_tabs
         end
 
-        return nil if captured.nil?
-        return (haml_buffer.options[:ugly] ? captured : prettify(captured))
-
+        captured.map do |line|
+          line.slice(min_tabs, line.length)
+        end.join
       end
     ensure
       haml_buffer.capture_position = nil
@@ -386,10 +401,9 @@ MESSAGE
     # @param text [#to_s] The text to output
     def haml_concat(text = "")
       unless haml_buffer.options[:ugly] || haml_indent == 0
-        haml_buffer.buffer << haml_indent <<
-          text.to_s.gsub("\n", "\n" + haml_indent) << "\n"
+        haml_buffer.buffer << %[#{haml_indent}#{text.to_s.gsub("\n", "\n#{haml_indent}")}\n]
       else
-        haml_buffer.buffer << text.to_s << "\n"
+        haml_buffer.buffer << "#{text}\n"
       end
       ErrorReturn.new("haml_concat")
     end
@@ -473,7 +487,7 @@ MESSAGE
         attrs)
 
       if text.nil? && block.nil? && (haml_buffer.options[:autoclose].include?(name) || flags.include?(:/))
-        haml_concat "<#{name}#{attributes} />"
+        haml_concat "<#{name}#{attributes}#{' /' if haml_buffer.options[:format] == :xhtml}>"
         return ret
       end
 
@@ -492,7 +506,7 @@ MESSAGE
           tab_down
           haml_concat "</#{name}>"
         else
-          tag << text << "</#{name}>"
+          tag << "#{text}</#{name}>"
           haml_concat tag
         end
         return ret
@@ -503,7 +517,7 @@ MESSAGE
       end
 
       if flags.include?(:<)
-        tag << capture_haml(&block).strip << "</#{name}>"
+        tag << "#{capture_haml(&block).strip}</#{name}>"
         haml_concat tag
         return ret
       end
@@ -517,53 +531,78 @@ MESSAGE
       ret
     end
 
+    # Conditionally wrap a block in an element. If `condition` is `true` then
+    # this method renders the tag described by the argumants in `tag` (using
+    # \{#haml_tag}) with the given block inside, otherwise it just renders the block.
+    #
+    # For example,
+    #
+    #     - haml_tag_if important, '.important' do
+    #       %p
+    #         A (possibly) important paragraph.
+    #
+    # will produce
+    #
+    #     <div class='important'>
+    #       <p>
+    #         A (possibly) important paragraph.
+    #       </p>
+    #     </div>
+    #
+    # if `important` is truthy, and just
+    #
+    #     <p>
+    #       A (possibly) important paragraph.
+    #     </p>
+    #
+    # otherwise.
+    #
+    # Like \{#haml_tag}, `haml_tag_if` outputs directly to the buffer and its
+    # return value should not be used. Use \{#capture_haml} if you need to use
+    # its results as a string.
+    #
+    # @param condition The condition to test to determine whether to render
+    #   the enclosing tag
+    # @param tag Definition of the enclosing tag. See \{#haml_tag} for details
+    #   (specifically the form that takes a block)
+    def haml_tag_if(condition, *tag)
+      if condition
+        haml_tag(*tag){ yield }
+      else
+        yield
+      end
+      ErrorReturn.new("haml_tag_if")
+    end
+
     # Characters that need to be escaped to HTML entities from user input
-    HTML_ESCAPE = { '&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;', '"'=>'&quot;', "'"=>'&#039;', }
+    HTML_ESCAPE = { '&' => '&amp;', '<' => '&lt;', '>' => '&gt;', '"' => '&quot;', "'" => '&#039;' }
 
     HTML_ESCAPE_REGEX = /[\"><&]/
 
-    if RUBY_VERSION >= '1.9'
-      # Include docs here so they are picked up by Yard
-
-      # Returns a copy of `text` with ampersands, angle brackets and quotes
-      # escaped into HTML entities.
-      #
-      # Note that if ActionView is loaded and XSS protection is enabled
-      # (as is the default for Rails 3.0+, and optional for version 2.3.5+),
-      # this won't escape text declared as "safe".
-      #
-      # @param text [String] The string to sanitize
-      # @return [String] The sanitized string
-      def html_escape(text)
-        text = text.to_s
-        text.gsub(HTML_ESCAPE_REGEX, HTML_ESCAPE)
-      end
-    else
-      def html_escape(text)
-        text = text.to_s
-        text.gsub(HTML_ESCAPE_REGEX) {|s| HTML_ESCAPE[s]}
-      end
+    # Returns a copy of `text` with ampersands, angle brackets and quotes
+    # escaped into HTML entities.
+    #
+    # Note that if ActionView is loaded and XSS protection is enabled
+    # (as is the default for Rails 3.0+, and optional for version 2.3.5+),
+    # this won't escape text declared as "safe".
+    #
+    # @param text [String] The string to sanitize
+    # @return [String] The sanitized string
+    def html_escape(text)
+      text = text.to_s
+      text.gsub(HTML_ESCAPE_REGEX, HTML_ESCAPE)
     end
 
-    HTML_ESCAPE_ONCE_REGEX = /[\"><]|&(?!(?:[a-zA-Z]+|(#\d+));)/
-
-    if RUBY_VERSION >= '1.9'
-      # Include docs here so they are picked up by Yard
+    HTML_ESCAPE_ONCE_REGEX = /[\"><]|&(?!(?:[a-zA-Z]+|#(?:\d+|[xX][0-9a-fA-F]+));)/
 
-      # Escapes HTML entities in `text`, but without escaping an ampersand
-      # that is already part of an escaped entity.
-      #
-      # @param text [String] The string to sanitize
-      # @return [String] The sanitized string
-      def escape_once(text)
-        text = text.to_s
-        text.gsub(HTML_ESCAPE_ONCE_REGEX, HTML_ESCAPE)
-      end
-    else
-      def escape_once(text)
-        text = text.to_s
-        text.gsub(HTML_ESCAPE_ONCE_REGEX){|s| HTML_ESCAPE[s]}
-      end
+    # Escapes HTML entities in `text`, but without escaping an ampersand
+    # that is already part of an escaped entity.
+    #
+    # @param text [String] The string to sanitize
+    # @return [String] The sanitized string
+    def escape_once(text)
+      text = text.to_s
+      text.gsub(HTML_ESCAPE_ONCE_REGEX, HTML_ESCAPE)
     end
 
     # Returns whether or not the current template is a Haml template.
@@ -630,22 +669,6 @@ MESSAGE
       _erbout = _erbout = _hamlout.buffer
       proc { |*args| proc.call(*args) }
     end
-
-    def prettify(text)
-      text = text.split(/^/)
-      text.delete('')
-
-      min_tabs = nil
-      text.each do |line|
-        tabs = line.index(/[^ ]/) || line.length
-        min_tabs ||= tabs
-        min_tabs = min_tabs > tabs ? tabs : min_tabs
-      end
-
-      text.map do |line|
-        line.slice(min_tabs, line.length)
-      end.join
-    end
   end
 end