radiant 0.6.7 → 0.6.8

data/vendor/plugins/haml/lib/haml/precompiler.rb

@@ -109,28 +109,15 @@ END
       end.join(';') + ';'
     end
 
-    Line = Struct.new("Line", :text, :unstripped, :index, :spaces, :tabs)
+    Line = Struct.new(:text, :unstripped, :index, :spaces, :tabs)
 
     def precompile
-      @precompiled = ''
-      @merged_text = ''
-      @tab_change  = 0
-
       old_line = Line.new
-      (@template + "\n-#\n-#").split(/\n?\r|\r?\n/).each_with_index do |text, index|
-        line = Line.new text.strip, text.lstrip.chomp, index
+      @template.split(/\r\n|\r|\n/).each_with_index do |text, index|
+        @next_line = line = Line.new(text.strip, text.lstrip.chomp, index)
         line.spaces, line.tabs = count_soft_tabs(text)
 
-        if line.text.empty?
-          process_indent(old_line) if flat? && !old_line.text.empty?
-
-          unless flat?
-            newline
-            next
-          end
-
-          push_flat(old_line)
-          old_line.text, old_line.unstripped, old_line.spaces = '', '', 0
+        if line.text.empty? && !flat?
           newline
           next
         end
@@ -154,7 +141,7 @@ END
         end
 
         if old_line.spaces != old_line.tabs * 2
-          raise SyntaxError.new(<<END.strip, 1 + old_line.index - @index)
+          raise SyntaxError.new(<<END.strip, old_line.index)
 #{old_line.spaces} space#{old_line.spaces == 1 ? ' was' : 's were'} used for indentation. Haml must be indented using two spaces.
 END
         end
@@ -165,7 +152,7 @@ END
         resolve_newlines
 
         if !flat? && line.tabs - old_line.tabs > 1
-          raise SyntaxError.new(<<END.strip, 2 + old_line.index - @index)
+          raise SyntaxError.new(<<END.strip, line.index)
 #{line.spaces} spaces were used for indentation. Haml must be indented using two spaces.
 END
         end
@@ -199,12 +186,12 @@ END
       when ELEMENT; render_tag(text)
       when COMMENT; render_comment(text[1..-1].strip)
       when SANITIZE
-        return push_script(unescape_interpolation(text[3..-1].strip), false, nil, false, true) if text[1..2] == "=="
-        return push_script(text[2..-1].strip, false, nil, false, true) if text[1] == SCRIPT
+        return push_script(unescape_interpolation(text[3..-1].strip), false, false, false, true) if text[1..2] == "=="
+        return push_script(text[2..-1].strip, false, false, false, true) if text[1] == SCRIPT
         push_plain text
       when SCRIPT
         return push_script(unescape_interpolation(text[2..-1].strip), false) if text[1] == SCRIPT
-        return push_script(text[1..-1], false, nil, false, true) if options[:escape_html]
+        return push_script(text[1..-1], false, false, false, true) if options[:escape_html]
         push_script(text[1..-1], false)
       when FLAT_SCRIPT; push_flat_script(text[1..-1])
       when SILENT_SCRIPT
@@ -277,8 +264,9 @@ END
 
     # Adds <tt>text</tt> to <tt>@buffer</tt> with appropriate tabulation
     # without parsing it.
-    def push_merged_text(text, tab_change = 0, try_one_liner = false)
-      @merged_text  << (@options[:ugly] ? text : "#{'  ' * @output_tabs}#{text}")
+    def push_merged_text(text, tab_change = 0, indent = true)
+      @merged_text  << (!indent || @dont_indent_next_line || @options[:ugly] ? text : "#{'  ' * @output_tabs}#{text}")
+      @dont_indent_next_line = false
       @tab_change   += tab_change
     end
 
@@ -287,24 +275,29 @@ END
       @merged_text  << text
     end
 
-    def push_text(text, tab_change = 0, try_one_liner = false)
-      push_merged_text("#{text}\n", tab_change, try_one_liner)
+    def push_text(text, tab_change = 0)
+      push_merged_text("#{text}\n", tab_change)
     end
 
     def flush_merged_text
       return if @merged_text.empty?
 
       @precompiled  << "_hamlout.push_text(#{@merged_text.dump}"
+      @precompiled  << ", #{@dont_tab_up_next_text.inspect}" if @dont_tab_up_next_text || @tab_change != 0
       @precompiled  << ", #{@tab_change}" if @tab_change != 0
       @precompiled  << ");"
       @merged_text   = ''
+      @dont_tab_up_next_text = false
       @tab_change    = 0
     end
 
     # Renders a block of text as plain text.
     # Also checks for an illegally opened block.
     def push_plain(text)
-      raise SyntaxError.new("Illegal nesting: nesting within plain text is illegal.", 1) if @block_opened
+      if @block_opened
+        raise SyntaxError.new("Illegal nesting: nesting within plain text is illegal.", @next_line.index)
+      end
+
       push_text text
     end
 
@@ -324,7 +317,11 @@ END
     #
     # If <tt>preserve_script</tt> is true, Haml::Helpers#find_and_flatten is run on
     # the result before it is added to <tt>@buffer</tt>
-    def push_script(text, preserve_script, close_tag = nil, preserve_tag = false, escape_html = false)
+    def push_script(text, preserve_script, in_tag = false, preserve_tag = false,
+                    escape_html = false, nuke_inner_whitespace = false)
+      # Prerender tabulation unless we're in a tag
+      push_merged_text '' unless in_tag
+
       flush_merged_text
       return if options[:suppress_eval]
 
@@ -332,7 +329,9 @@ END
 
       push_silent "haml_temp = #{text}"
       newline_now
-      out = "haml_temp = _hamlout.push_script(haml_temp, #{preserve_script.inspect}, #{close_tag.inspect}, #{preserve_tag.inspect}, #{escape_html.inspect});"
+      args = [preserve_script, in_tag, preserve_tag,
+              escape_html, nuke_inner_whitespace].map { |a| a.inspect }.join(', ')
+      out = "haml_temp = _hamlout.push_script(haml_temp, #{args});"
       if @block_opened
         push_and_tabulate([:loud, out])
       else
@@ -371,10 +370,14 @@ END
 
     # Puts a line in <tt>@precompiled</tt> that will add the closing tag of
     # the most recently opened tag.
-    def close_tag(tag)
-      @output_tabs -= 1
+    def close_tag(value)
+      tag, nuke_outer_whitespace, nuke_inner_whitespace = value
+      @output_tabs -= 1 unless nuke_inner_whitespace
       @template_tabs -= 1
-      push_text("</#{tag}>", -1)
+      rstrip_buffer! if nuke_inner_whitespace
+      push_merged_text("</#{tag}>" + (nuke_outer_whitespace ? "" : "\n"),
+                       nuke_inner_whitespace ? 0 : -1, !nuke_inner_whitespace)
+      @dont_indent_next_line = nuke_outer_whitespace
     end
 
     # Closes a Ruby block.
@@ -502,10 +505,14 @@ END
       if rest
         object_ref, rest = balance(rest, ?[, ?]) if rest[0] == ?[
         attributes_hash, rest = parse_attributes(rest) if rest[0] == ?{ && attributes_hash.nil?
-        action, value = rest.scan(/([=\/\~&!]?)?(.*)?/)[0]
+        nuke_whitespace, action, value = rest.scan(/(<>|><|[><])?([=\/\~&!])?(.*)?/)[0]
+        nuke_whitespace ||= ''
+        nuke_outer_whitespace = nuke_whitespace.include? '>'
+        nuke_inner_whitespace = nuke_whitespace.include? '<'
       end
       value = value.to_s.strip
-      [tag_name, attributes, attributes_hash, object_ref, action, value]
+      [tag_name, attributes, attributes_hash, object_ref, nuke_outer_whitespace,
+       nuke_inner_whitespace, action, value]
     end
 
     def parse_attributes(line)
@@ -518,11 +525,17 @@ END
     # Parses a line that will render as an XHTML tag, and adds the code that will
     # render that tag to <tt>@precompiled</tt>.
     def render_tag(line)
-      tag_name, attributes, attributes_hash, object_ref, action, value = parse_tag(line)
+      tag_name, attributes, attributes_hash, object_ref, nuke_outer_whitespace,
+        nuke_inner_whitespace, action, value = parse_tag(line)
 
       raise SyntaxError.new("Illegal element: classes and ids must have values.") if attributes =~ /[\.#](\.|#|\z)/
 
+      # Get rid of whitespace outside of the tag if we need to
+      rstrip_buffer! if nuke_outer_whitespace
+
       preserve_tag = options[:preserve].include?(tag_name)
+      nuke_inner_whitespace ||= preserve_tag
+      preserve_tag &&= !options[:ugly]
 
       case action
       when '/'; self_closing = xhtml?
@@ -551,41 +564,58 @@ END
       attributes = parse_class_and_id(attributes)
       Buffer.merge_attrs(attributes, static_attributes) if static_attributes
 
-      raise SyntaxError.new("Illegal nesting: nesting within a self-closing tag is illegal.", 1) if @block_opened && self_closing
-      raise SyntaxError.new("Illegal nesting: content can't be both given on the same line as %#{tag_name} and nested within it.", 1) if @block_opened && !value.empty?
+      raise SyntaxError.new("Illegal nesting: nesting within a self-closing tag is illegal.", @next_line.index) if @block_opened && self_closing
+      raise SyntaxError.new("Illegal nesting: content can't be both given on the same line as %#{tag_name} and nested within it.", @next_line.index) if @block_opened && !value.empty?
       raise SyntaxError.new("There's no Ruby code for #{action} to evaluate.") if parse && value.empty?
       raise SyntaxError.new("Self-closing tags can't have content.") if self_closing && !value.empty?
 
       self_closing ||= !!( !@block_opened && value.empty? && @options[:autoclose].include?(tag_name) )
 
+      dont_indent_next_line =
+        (nuke_outer_whitespace && !@block_opened) ||
+        (nuke_inner_whitespace && @block_opened)
+
+      # Check if we can render the tag directly to text and not process it in the buffer
       if object_ref == "nil" && attributes_hash.nil? && !preserve_script
-        # This means that we can render the tag directly to text and not process it in the buffer
-        tag_closed = !value.empty? && !parse
+        tag_closed = !@block_opened && !self_closing && !parse
 
         open_tag  = prerender_tag(tag_name, self_closing, attributes)
-        open_tag << "#{value}</#{tag_name}>" if tag_closed
-        open_tag << "\n" unless parse
+        if tag_closed
+          open_tag << "#{value}</#{tag_name}>"
+          open_tag << "\n" unless nuke_outer_whitespace
+        else
+          open_tag << "\n" unless parse || nuke_inner_whitespace || (self_closing && nuke_outer_whitespace)
+        end
+        
+        push_merged_text(open_tag, tag_closed || self_closing || nuke_inner_whitespace ? 0 : 1,
+                         !nuke_outer_whitespace)
 
-        push_merged_text(open_tag, tag_closed || self_closing ? 0 : 1, parse)
+        @dont_indent_next_line = dont_indent_next_line
         return if tag_closed
       else
         flush_merged_text
         content = value.empty? || parse ? 'nil' : value.dump
         attributes_hash = ', ' + attributes_hash if attributes_hash
-        push_silent "_hamlout.open_tag(#{tag_name.inspect}, #{self_closing.inspect}, #{(!value.empty?).inspect}, #{preserve_tag.inspect}, #{escape_html.inspect}, #{attributes.inspect}, #{object_ref}, #{content}#{attributes_hash})"
+        args = [tag_name, self_closing, !@block_opened, preserve_tag, escape_html,
+                attributes, nuke_outer_whitespace, nuke_inner_whitespace
+               ].map { |v| v.inspect }.join(', ')
+        push_silent "_hamlout.open_tag(#{args}, #{object_ref}, #{content}#{attributes_hash})"
+        @dont_tab_up_next_text = @dont_indent_next_line = dont_indent_next_line
       end
 
       return if self_closing
 
       if value.empty?
-        push_and_tabulate([:element, tag_name])
-        @output_tabs += 1
+        push_and_tabulate([:element, [tag_name, nuke_outer_whitespace, nuke_inner_whitespace]])
+        @output_tabs += 1 unless nuke_inner_whitespace
         return
       end
 
       if parse
         flush_merged_text
-        push_script(value, preserve_script, tag_name, preserve_tag, escape_html)
+        push_script(value, preserve_script, true, preserve_tag, escape_html, nuke_inner_whitespace)
+        @dont_tab_up_next_text = true
+        concat_merged_text("</#{tag_name}>" + (nuke_outer_whitespace ? "" : "\n"))
       end
     end
 
@@ -602,7 +632,7 @@ END
       conditional << ">" if conditional
 
       if @block_opened && !line.empty?
-        raise SyntaxError.new('Illegal nesting: nesting within a tag that already has content is illegal.', 1)
+        raise SyntaxError.new('Illegal nesting: nesting within a tag that already has content is illegal.', @next_line.index)
       end
 
       open = "<!--#{conditional} "
@@ -623,7 +653,7 @@ END
 
     # Renders an XHTML doctype or XML shebang.
     def render_doctype(line)
-      raise SyntaxError.new("Illegal nesting: nesting within a header command is illegal.", 1) if @block_opened
+      raise SyntaxError.new("Illegal nesting: nesting within a header command is illegal.", @next_line.index) if @block_opened
       doctype = text_for_doctype(line)
       push_text doctype if doctype
     end
@@ -666,7 +696,7 @@ END
     def start_filtered(name)
       raise Error.new("Invalid filter name \":#{name}\".") unless name =~ /^\w+$/
 
-      unless filter = options[:filters][name]
+      unless filter = Filters.defined[name]
         if filter == 'redcloth' || filter == 'markdown' || filter == 'textile'
           raise Error.new("You must have the RedCloth gem installed to use \"#{name}\" filter")
         end
@@ -719,8 +749,8 @@ END
     def count_soft_tabs(line)
       spaces = line.index(/([^ ]|$)/)
       if line[spaces] == ?\t
-        return nil if line.strip.empty?
-        raise SyntaxError.new(<<END.strip, 2)
+        return 0, 0 if line.strip.empty?
+        raise SyntaxError.new(<<END.strip, @next_line.index)
 A tab character was used for indentation. Haml must be indented using two spaces.
 Are you sure you have soft tabs enabled in your editor?
 END
@@ -753,5 +783,16 @@ END
       @precompiled << "\n" * @newlines
       @newlines = 0
     end
+
+    # Get rid of and whitespace at the end of the buffer
+    # or the merged text
+    def rstrip_buffer!
+      unless @merged_text.empty?
+        @merged_text.rstrip!
+      else
+        push_silent("_erbout.rstrip!", false)
+        @dont_tab_up_next_text = true
+      end
+    end
   end
 end

data/vendor/plugins/haml/lib/haml/template.rb

@@ -36,8 +36,16 @@ if defined?(RAILS_ROOT)
   # to not need updating.
   rails_init_file = File.join(RAILS_ROOT, 'vendor', 'plugins', 'haml', 'init.rb')
   haml_init_file = Haml.scope('init.rb')
-  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)
+  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
+    warn <<END
+HAML WARNING:
+#{rails_init_file} is out of date and couldn't be automatically updated.
+Please run `haml --rails #{File.expand_path(RAILS_ROOT)}' to update it.
+END
   end
 end

data/vendor/plugins/haml/lib/haml/template/patch.rb

@@ -35,7 +35,7 @@ module ActionView
       options[:filename] = file_name || 'compiled-template'
 
       begin
-        Haml::Engine.new(template, options).def_method(CompiledTemplates, render_symbol, *locals)
+        Haml::Engine.new(template, options).def_method(CompiledTemplates, render_symbol, *locals_keys)
       rescue Exception => e
         if logger
           logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"

data/vendor/plugins/haml/lib/sass.rb

@@ -253,6 +253,22 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #     font-size: 30em;
 #     font-weight: bold; }
 #
+# === Rule Escaping
+#
+# In case, for whatever reason, you need to write a rule
+# that begins with a Sass-meaningful character,
+# you can escape it with a backslash (<tt>\</tt>).
+# For example:
+#
+#  #main
+#    \+div
+#      clear: both
+#
+# is compiled to:
+#
+#  #main +div {
+#    clear: both; }
+#
 # == Constants
 #
 # Sass has support for setting document-wide constants.
@@ -760,9 +776,16 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #
 # == Sass Options
 #
-# Options can be set by setting the hash <tt>Sass::Plugin.options</tt>
-# from <tt>environment.rb</tt> in Rails,
-# or by passing an options hash to Sass::Engine.
+# Options can be set by setting the <tt>Sass::Plugin.options</tt> hash
+# in <tt>environment.rb</tt> in Rails...
+#
+#   Sass::Plugin.options[:style] = :compact
+#
+# ...or by setting the <tt>Merb::Config[:sass]</tt> hash in <tt>init.rb</tt> in Merb...
+#
+#   Merb::Config[:sass][:style] = :compact
+# 
+# ...or by passing an options hash to Sass::Engine.new.
 # Available options are:
 #
 # [<tt>:style</tt>]             Sets the style of the CSS output.

data/vendor/plugins/haml/lib/sass/constant.rb

@@ -119,17 +119,10 @@ module Sass
                 next
               end
 
-              # Is this a constant?
-              if beginning_of_token && symbol == :const
-                beginning_of_token = true
-                to_return << :const
-                next
-              end
-
               # Are we looking at an operator?
               if symbol && (symbol != :mod || str.empty?)
                 str = reset_str.call
-                beginning_of_token = true
+                beginning_of_token = symbol != :close
                 to_return << symbol
                 next
               end
@@ -148,57 +141,30 @@ module Sass
         to_return
       end
 
-      def parenthesize(value)
-        parenthesize_helper(0, value, value.length)[0]
-      end
-
-      def parenthesize_helper(i, value, value_len, return_after_expr = false)
+      def parenthesize(value, return_after_expr = false)
         to_return = []
-        beginning = i
-        token = value[i]
-
-        while i < value_len && token != :close
-          if token == :open
-            to_return.push(*value[beginning...i])
-            sub, i = parenthesize_helper(i + 1, value, value_len)
-            beginning = i
-            to_return << sub
-          elsif token == :neg
-            if value[i + 1].nil?
-              # This is never actually reached, but we'll leave it in just in case.
-              raise Sass::SyntaxError.new("Unterminated unary minus.")
-            elsif value[i + 1] == :open
-              to_return.push(*value[beginning...i])
-              sub, i = parenthesize_helper(i + 2, value, value_len)
-              beginning = i
-              to_return << [:neg, sub]
-            elsif value[i + 1].is_a?(::Symbol)
-              to_return.push(*value[beginning...i])
-              sub, i = parenthesize_helper(i + 1, value, value_len, true)
-              beginning = i
-              to_return << [:neg, sub]
-            else
-              to_return.push(*value[beginning...i])
-              to_return << [:neg, value[i + 1]]
-              beginning = i = i + 2
-            end
-            return to_return[0], i if return_after_expr
-          elsif token == :const
-            raise Sass::SyntaxError.new("Unterminated constant.") if value[i + 1].nil?
-            raise Sass::SyntaxError.new("Invalid constant.") unless value[i + 1].is_a?(::String)
-
-            to_return.push(*value[beginning...i])
-            to_return << [:const, value[i + 1]]
-            beginning = i = i + 2
-            return to_return[0], i if return_after_expr
+
+        while (token = value.shift) && token != :close
+          case token
+          when :open
+            to_return << parenthesize(value)
+          when :neg
+            # This is never actually reached, but we'll leave it in just in case.
+            raise Sass::SyntaxError.new("Unterminated unary minus.") if value.first.nil?
+            to_return << [:neg, parenthesize(value, true)]
+          when :const
+            raise Sass::SyntaxError.new("Unterminated constant.") if value.first.nil?
+            raise Sass::SyntaxError.new("Invalid constant.") unless value.first.is_a?(::String)
+
+            to_return << [:const, value.first]
+            value.shift
           else
-            i += 1
+            to_return << token
           end
 
-          token = value[i]
+          return to_return.first if return_after_expr
         end
-        to_return.push(*value[beginning...i])
-        return to_return, i + 1
+        return to_return
       end
 
       #--
@@ -207,7 +173,10 @@ module Sass
       #++
       def operationalize(value, constants)
         value = [value] unless value.is_a?(Array)
-        if value.length == 1
+        case value.length
+        when 0
+          Sass::Constant::Nil.new
+        when 1
           value = value[0]
           if value.is_a? Array
             operationalize(value, constants)
@@ -216,7 +185,7 @@ module Sass
           else
             Literal.parse(value)
           end
-        elsif value.length == 2
+        when 2
           if value[0] == :neg
             Operation.new(Sass::Constant::Number.new('0'), operationalize(value[1], constants), :minus)
           elsif value[0] == :const
@@ -224,7 +193,7 @@ module Sass
           else
             raise SyntaxError.new("Constant arithmetic error")
           end
-        elsif value.length == 3
+        when 3
           Operation.new(operationalize(value[0], constants), operationalize(value[2], constants), value[1])
         else
           if SECOND_ORDER.include?(value[1]) && FIRST_ORDER.include?(value[3])